more changes to the third party lib.

MakeItTalk/thirdparty/AdaptiveWingLoss/.gitignore

@@ -1,8 +1,8 @@
-# Python generated files
-*.pyc
-
-# Project related files
-ckpt/*.pth
-dataset/*
-!dataset/!.py
+# Python generated files
+*.pyc
+
+# Project related files
+ckpt/*.pth
+dataset/*
+!dataset/!.py
 experiments/*

MakeItTalk/thirdparty/AdaptiveWingLoss/LICENSE

@@ -1,201 +1,201 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MakeItTalk/thirdparty/AdaptiveWingLoss/README.md

@@ -1,82 +1,82 @@
-# AdaptiveWingLoss
-## [arXiv](https://arxiv.org/abs/1904.07399)
-Pytorch Implementation of Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression.
-
-<img src='images/wflw.png' width="1000px">
-
-## Update Logs:
-### October 28, 2019
-* Pretrained Model and evaluation code on WFLW dataset is released.
-
-## Installation
-#### Note: Code was originally developed under Python2.X and Pytorch 0.4. This released version was revisioned from original code and was tested on Python3.5.7 and Pytorch 1.3.0.
-
-Install system requirements:
-```
-sudo apt-get install python3-dev python3-pip python3-tk libglib2.0-0
-```
-
-Install python dependencies:
-```
-pip3 install -r requirements.txt
-```
-
-## Run Evaluation on WFLW dataset
-1. Download and process WFLW dataset
-    * Download WFLW dataset and annotation from [Here](https://wywu.github.io/projects/LAB/WFLW.html).
-    * Unzip WFLW dataset and annotations and move files into ```./dataset``` directory. Your directory should look like this:
-        ```
-        AdaptiveWingLoss
-        └───dataset
-           │
-           └───WFLW_annotations
-           │   └───list_98pt_rect_attr_train_test
-           │   │
-           │   └───list_98pt_test
-           │
-           └───WFLW_images
-               └───0--Parade
-               │
-               └───...
-        ```
-    * Inside ```./dataset``` directory, run:
-        ```
-        python convert_WFLW.py
-        ```
-        A new directory ```./dataset/WFLW_test``` should be generated with 2500 processed testing images and corresponding landmarks.
-
-2. Download pretrained model from [Google Drive](https://drive.google.com/file/d/1HZaSjLoorQ4QCEx7PRTxOmg0bBPYSqhH/view?usp=sharing) and put it in ```./ckpt``` directory.
-
-3. Within ```./Scripts``` directory, run following command:
-    ```
-    sh eval_wflw.sh
-    ```
-    
-    <img src='images/wflw_table.png' width="800px">
-    *GTBbox indicates the ground truth landmarks are used as bounding box to crop faces.
-
-## Future Plans
-- [x] Release evaluation code and pretrained model on WFLW dataset.
-
-- [ ] Release training code on WFLW dataset.
- 
-- [ ] Release pretrained model and code on 300W, AFLW and COFW dataset.
-
-- [ ] Replease facial landmark detection API
-
-
-## Citation
-If you find this useful for your research, please cite the following paper.
-
-```
-@InProceedings{Wang_2019_ICCV,
-author = {Wang, Xinyao and Bo, Liefeng and Fuxin, Li},
-title = {Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression},
-booktitle = {The IEEE International Conference on Computer Vision (ICCV)},
-month = {October},
-year = {2019}
-}
-```
-
-## Acknowledgments
-This repository borrows or partially modifies hourglass model and data processing code from [face alignment](https://github.com/1adrianb/face-alignment) and [pose-hg-train](https://github.com/princeton-vl/pose-hg-train).
+# AdaptiveWingLoss
+## [arXiv](https://arxiv.org/abs/1904.07399)
+Pytorch Implementation of Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression.
+
+<img src='images/wflw.png' width="1000px">
+
+## Update Logs:
+### October 28, 2019
+* Pretrained Model and evaluation code on WFLW dataset is released.
+
+## Installation
+#### Note: Code was originally developed under Python2.X and Pytorch 0.4. This released version was revisioned from original code and was tested on Python3.5.7 and Pytorch 1.3.0.
+
+Install system requirements:
+```
+sudo apt-get install python3-dev python3-pip python3-tk libglib2.0-0
+```
+
+Install python dependencies:
+```
+pip3 install -r requirements.txt
+```
+
+## Run Evaluation on WFLW dataset
+1. Download and process WFLW dataset
+    * Download WFLW dataset and annotation from [Here](https://wywu.github.io/projects/LAB/WFLW.html).
+    * Unzip WFLW dataset and annotations and move files into ```./dataset``` directory. Your directory should look like this:
+        ```
+        AdaptiveWingLoss
+        └───dataset
+           │
+           └───WFLW_annotations
+           │   └───list_98pt_rect_attr_train_test
+           │   │
+           │   └───list_98pt_test
+           │
+           └───WFLW_images
+               └───0--Parade
+               │
+               └───...
+        ```
+    * Inside ```./dataset``` directory, run:
+        ```
+        python convert_WFLW.py
+        ```
+        A new directory ```./dataset/WFLW_test``` should be generated with 2500 processed testing images and corresponding landmarks.
+
+2. Download pretrained model from [Google Drive](https://drive.google.com/file/d/1HZaSjLoorQ4QCEx7PRTxOmg0bBPYSqhH/view?usp=sharing) and put it in ```./ckpt``` directory.
+
+3. Within ```./Scripts``` directory, run following command:
+    ```
+    sh eval_wflw.sh
+    ```
+    
+    <img src='images/wflw_table.png' width="800px">
+    *GTBbox indicates the ground truth landmarks are used as bounding box to crop faces.
+
+## Future Plans
+- [x] Release evaluation code and pretrained model on WFLW dataset.
+
+- [ ] Release training code on WFLW dataset.
+ 
+- [ ] Release pretrained model and code on 300W, AFLW and COFW dataset.
+
+- [ ] Replease facial landmark detection API
+
+
+## Citation
+If you find this useful for your research, please cite the following paper.
+
+```
+@InProceedings{Wang_2019_ICCV,
+author = {Wang, Xinyao and Bo, Liefeng and Fuxin, Li},
+title = {Adaptive Wing Loss for Robust Face Alignment via Heatmap Regression},
+booktitle = {The IEEE International Conference on Computer Vision (ICCV)},
+month = {October},
+year = {2019}
+}
+```
+
+## Acknowledgments
+This repository borrows or partially modifies hourglass model and data processing code from [face alignment](https://github.com/1adrianb/face-alignment) and [pose-hg-train](https://github.com/princeton-vl/pose-hg-train).

MakeItTalk/thirdparty/AdaptiveWingLoss/core/coord_conv.py

@@ -1,157 +1,157 @@
-import torch
-import torch.nn as nn
-
-
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-class AddCoordsTh(nn.Module):
-    def __init__(self, x_dim=64, y_dim=64, with_r=False, with_boundary=False):
-        super(AddCoordsTh, self).__init__()
-        self.x_dim = x_dim
-        self.y_dim = y_dim
-        self.with_r = with_r
-        self.with_boundary = with_boundary
-
-    def forward(self, input_tensor, heatmap=None):
-        """
-        input_tensor: (batch, c, x_dim, y_dim)
-        """
-        batch_size_tensor = input_tensor.shape[0]
-
-        xx_ones = torch.ones([1, self.y_dim], dtype=torch.int32).to(device)
-        xx_ones = xx_ones.unsqueeze(-1)
-
-        xx_range = torch.arange(self.x_dim, dtype=torch.int32).unsqueeze(0).to(device)
-        xx_range = xx_range.unsqueeze(1)
-
-        xx_channel = torch.matmul(xx_ones.float(), xx_range.float())
-        xx_channel = xx_channel.unsqueeze(-1)
-
-
-        yy_ones = torch.ones([1, self.x_dim], dtype=torch.int32).to(device)
-        yy_ones = yy_ones.unsqueeze(1)
-
-        yy_range = torch.arange(self.y_dim, dtype=torch.int32).unsqueeze(0).to(device)
-        yy_range = yy_range.unsqueeze(-1)
-
-        yy_channel = torch.matmul(yy_range.float(), yy_ones.float())
-        yy_channel = yy_channel.unsqueeze(-1)
-
-        xx_channel = xx_channel.permute(0, 3, 2, 1)
-        yy_channel = yy_channel.permute(0, 3, 2, 1)
-
-        xx_channel = xx_channel / (self.x_dim - 1)
-        yy_channel = yy_channel / (self.y_dim - 1)
-
-        xx_channel = xx_channel * 2 - 1
-        yy_channel = yy_channel * 2 - 1
-
-        xx_channel = xx_channel.repeat(batch_size_tensor, 1, 1, 1)
-        yy_channel = yy_channel.repeat(batch_size_tensor, 1, 1, 1)
-
-        if self.with_boundary and type(heatmap) != type(None):
-            boundary_channel = torch.clamp(heatmap[:, -1:, :, :],
-                                        0.0, 1.0)
-
-            zero_tensor = torch.zeros_like(xx_channel)
-            xx_boundary_channel = torch.where(boundary_channel>0.05,
-                                              xx_channel, zero_tensor)
-            yy_boundary_channel = torch.where(boundary_channel>0.05,
-                                              yy_channel, zero_tensor)
-        if self.with_boundary and type(heatmap) != type(None):
-            xx_boundary_channel = xx_boundary_channel.to(device)
-            yy_boundary_channel = yy_boundary_channel.to(device)
-
-        ret = torch.cat([input_tensor, xx_channel, yy_channel], dim=1)
-
-
-        if self.with_r:
-            rr = torch.sqrt(torch.pow(xx_channel, 2) + torch.pow(yy_channel, 2))
-            rr = rr / torch.max(rr)
-            ret = torch.cat([ret, rr], dim=1)
-
-        if self.with_boundary and type(heatmap) != type(None):
-            ret = torch.cat([ret, xx_boundary_channel,
-                             yy_boundary_channel], dim=1)
-        return ret
-
-
-class CoordConvTh(nn.Module):
-    """CoordConv layer as in the paper."""
-    def __init__(self, x_dim, y_dim, with_r, with_boundary,
-                 in_channels, first_one=False, *args, **kwargs):
-        super(CoordConvTh, self).__init__()
-        self.addcoords = AddCoordsTh(x_dim=x_dim, y_dim=y_dim, with_r=with_r,
-                                    with_boundary=with_boundary)
-        in_channels += 2
-        if with_r:
-            in_channels += 1
-        if with_boundary and not first_one:
-            in_channels += 2
-        self.conv = nn.Conv2d(in_channels=in_channels, *args, **kwargs)
-
-    def forward(self, input_tensor, heatmap=None):
-        ret = self.addcoords(input_tensor, heatmap)
-        last_channel = ret[:, -2:, :, :]
-        ret = self.conv(ret)
-        return ret, last_channel
-
-
-'''
-An alternative implementation for PyTorch with auto-infering the x-y dimensions.
-'''
-class AddCoords(nn.Module):
-
-    def __init__(self, with_r=False):
-        super().__init__()
-        self.with_r = with_r
-
-    def forward(self, input_tensor):
-        """
-        Args:
-            input_tensor: shape(batch, channel, x_dim, y_dim)
-        """
-        batch_size, _, x_dim, y_dim = input_tensor.size()
-
-        xx_channel = torch.arange(x_dim).repeat(1, y_dim, 1)
-        yy_channel = torch.arange(y_dim).repeat(1, x_dim, 1).transpose(1, 2)
-
-        xx_channel = xx_channel / (x_dim - 1)
-        yy_channel = yy_channel / (y_dim - 1)
-
-        xx_channel = xx_channel * 2 - 1
-        yy_channel = yy_channel * 2 - 1
-
-        xx_channel = xx_channel.repeat(batch_size, 1, 1, 1).transpose(2, 3)
-        yy_channel = yy_channel.repeat(batch_size, 1, 1, 1).transpose(2, 3)
-
-        if input_tensor.is_cuda:
-            xx_channel = xx_channel.to(device)
-            yy_channel = yy_channel.to(device)
-
-        ret = torch.cat([
-            input_tensor,
-            xx_channel.type_as(input_tensor),
-            yy_channel.type_as(input_tensor)], dim=1)
-
-        if self.with_r:
-            rr = torch.sqrt(torch.pow(xx_channel - 0.5, 2) + torch.pow(yy_channel - 0.5, 2))
-            if input_tensor.is_cuda:
-                rr = rr.to(device)
-            ret = torch.cat([ret, rr], dim=1)
-
-        return ret
-
-
-class CoordConv(nn.Module):
-
-    def __init__(self, in_channels, out_channels, with_r=False, **kwargs):
-        super().__init__()
-        self.addcoords = AddCoords(with_r=with_r)
-        self.conv = nn.Conv2d(in_channels + 2, out_channels, **kwargs)
-
-    def forward(self, x):
-        ret = self.addcoords(x)
-        ret = self.conv(ret)
-        return ret
+import torch
+import torch.nn as nn
+
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+class AddCoordsTh(nn.Module):
+    def __init__(self, x_dim=64, y_dim=64, with_r=False, with_boundary=False):
+        super(AddCoordsTh, self).__init__()
+        self.x_dim = x_dim
+        self.y_dim = y_dim
+        self.with_r = with_r
+        self.with_boundary = with_boundary
+
+    def forward(self, input_tensor, heatmap=None):
+        """
+        input_tensor: (batch, c, x_dim, y_dim)
+        """
+        batch_size_tensor = input_tensor.shape[0]
+
+        xx_ones = torch.ones([1, self.y_dim], dtype=torch.int32).to(device)
+        xx_ones = xx_ones.unsqueeze(-1)
+
+        xx_range = torch.arange(self.x_dim, dtype=torch.int32).unsqueeze(0).to(device)
+        xx_range = xx_range.unsqueeze(1)
+
+        xx_channel = torch.matmul(xx_ones.float(), xx_range.float())
+        xx_channel = xx_channel.unsqueeze(-1)
+
+
+        yy_ones = torch.ones([1, self.x_dim], dtype=torch.int32).to(device)
+        yy_ones = yy_ones.unsqueeze(1)
+
+        yy_range = torch.arange(self.y_dim, dtype=torch.int32).unsqueeze(0).to(device)
+        yy_range = yy_range.unsqueeze(-1)
+
+        yy_channel = torch.matmul(yy_range.float(), yy_ones.float())
+        yy_channel = yy_channel.unsqueeze(-1)
+
+        xx_channel = xx_channel.permute(0, 3, 2, 1)
+        yy_channel = yy_channel.permute(0, 3, 2, 1)
+
+        xx_channel = xx_channel / (self.x_dim - 1)
+        yy_channel = yy_channel / (self.y_dim - 1)
+
+        xx_channel = xx_channel * 2 - 1
+        yy_channel = yy_channel * 2 - 1
+
+        xx_channel = xx_channel.repeat(batch_size_tensor, 1, 1, 1)
+        yy_channel = yy_channel.repeat(batch_size_tensor, 1, 1, 1)
+
+        if self.with_boundary and type(heatmap) != type(None):
+            boundary_channel = torch.clamp(heatmap[:, -1:, :, :],
+                                        0.0, 1.0)
+
+            zero_tensor = torch.zeros_like(xx_channel)
+            xx_boundary_channel = torch.where(boundary_channel>0.05,
+                                              xx_channel, zero_tensor)
+            yy_boundary_channel = torch.where(boundary_channel>0.05,
+                                              yy_channel, zero_tensor)
+        if self.with_boundary and type(heatmap) != type(None):
+            xx_boundary_channel = xx_boundary_channel.to(device)
+            yy_boundary_channel = yy_boundary_channel.to(device)
+
+        ret = torch.cat([input_tensor, xx_channel, yy_channel], dim=1)
+
+
+        if self.with_r:
+            rr = torch.sqrt(torch.pow(xx_channel, 2) + torch.pow(yy_channel, 2))
+            rr = rr / torch.max(rr)
+            ret = torch.cat([ret, rr], dim=1)
+
+        if self.with_boundary and type(heatmap) != type(None):
+            ret = torch.cat([ret, xx_boundary_channel,
+                             yy_boundary_channel], dim=1)
+        return ret
+
+
+class CoordConvTh(nn.Module):
+    """CoordConv layer as in the paper."""
+    def __init__(self, x_dim, y_dim, with_r, with_boundary,
+                 in_channels, first_one=False, *args, **kwargs):
+        super(CoordConvTh, self).__init__()
+        self.addcoords = AddCoordsTh(x_dim=x_dim, y_dim=y_dim, with_r=with_r,
+                                    with_boundary=with_boundary)
+        in_channels += 2
+        if with_r:
+            in_channels += 1
+        if with_boundary and not first_one:
+            in_channels += 2
+        self.conv = nn.Conv2d(in_channels=in_channels, *args, **kwargs)
+
+    def forward(self, input_tensor, heatmap=None):
+        ret = self.addcoords(input_tensor, heatmap)
+        last_channel = ret[:, -2:, :, :]
+        ret = self.conv(ret)
+        return ret, last_channel
+
+
+'''
+An alternative implementation for PyTorch with auto-infering the x-y dimensions.
+'''
+class AddCoords(nn.Module):
+
+    def __init__(self, with_r=False):
+        super().__init__()
+        self.with_r = with_r
+
+    def forward(self, input_tensor):
+        """
+        Args:
+            input_tensor: shape(batch, channel, x_dim, y_dim)
+        """
+        batch_size, _, x_dim, y_dim = input_tensor.size()
+
+        xx_channel = torch.arange(x_dim).repeat(1, y_dim, 1)
+        yy_channel = torch.arange(y_dim).repeat(1, x_dim, 1).transpose(1, 2)
+
+        xx_channel = xx_channel / (x_dim - 1)
+        yy_channel = yy_channel / (y_dim - 1)
+
+        xx_channel = xx_channel * 2 - 1
+        yy_channel = yy_channel * 2 - 1
+
+        xx_channel = xx_channel.repeat(batch_size, 1, 1, 1).transpose(2, 3)
+        yy_channel = yy_channel.repeat(batch_size, 1, 1, 1).transpose(2, 3)
+
+        if input_tensor.is_cuda:
+            xx_channel = xx_channel.to(device)
+            yy_channel = yy_channel.to(device)
+
+        ret = torch.cat([
+            input_tensor,
+            xx_channel.type_as(input_tensor),
+            yy_channel.type_as(input_tensor)], dim=1)
+
+        if self.with_r:
+            rr = torch.sqrt(torch.pow(xx_channel - 0.5, 2) + torch.pow(yy_channel - 0.5, 2))
+            if input_tensor.is_cuda:
+                rr = rr.to(device)
+            ret = torch.cat([ret, rr], dim=1)
+
+        return ret
+
+
+class CoordConv(nn.Module):
+
+    def __init__(self, in_channels, out_channels, with_r=False, **kwargs):
+        super().__init__()
+        self.addcoords = AddCoords(with_r=with_r)
+        self.conv = nn.Conv2d(in_channels + 2, out_channels, **kwargs)
+
+    def forward(self, x):
+        ret = self.addcoords(x)
+        ret = self.conv(ret)
+        return ret

MakeItTalk/thirdparty/AdaptiveWingLoss/core/dataloader.py

@@ -1,368 +1,368 @@
-import sys
-import os
-import random
-import glob
-import torch
-from skimage import io
-from skimage import transform as ski_transform
-from skimage.color import rgb2gray
-import scipy.io as sio
-from scipy import interpolate
-import numpy as np
-import matplotlib.pyplot as plt
-from torch.utils.data import Dataset, DataLoader
-from torchvision import transforms, utils
-from torchvision.transforms import Lambda, Compose
-from torchvision.transforms.functional import adjust_brightness, adjust_contrast, adjust_saturation, adjust_hue
-from utils.utils import cv_crop, cv_rotate, draw_gaussian, transform, power_transform, shuffle_lr, fig2data, generate_weight_map
-from PIL import Image
-import cv2
-import copy
-import math
-from imgaug import augmenters as iaa
-
-
-class AddBoundary(object):
-    def __init__(self, num_landmarks=68):
-        self.num_landmarks = num_landmarks
-
-    def __call__(self, sample):
-        landmarks_64 = np.floor(sample['landmarks'] / 4.0)
-        if self.num_landmarks == 68:
-            boundaries = {}
-            boundaries['cheek'] = landmarks_64[0:17]
-            boundaries['left_eyebrow'] = landmarks_64[17:22]
-            boundaries['right_eyebrow'] = landmarks_64[22:27]
-            boundaries['uper_left_eyelid'] = landmarks_64[36:40]
-            boundaries['lower_left_eyelid'] = np.array([landmarks_64[i] for i in [36, 41, 40, 39]])
-            boundaries['upper_right_eyelid'] = landmarks_64[42:46]
-            boundaries['lower_right_eyelid'] = np.array([landmarks_64[i] for i in [42, 47, 46, 45]])
-            boundaries['noise'] = landmarks_64[27:31]
-            boundaries['noise_bot'] = landmarks_64[31:36]
-            boundaries['upper_outer_lip'] = landmarks_64[48:55]
-            boundaries['upper_inner_lip'] = np.array([landmarks_64[i] for i in [60, 61, 62, 63, 64]])
-            boundaries['lower_outer_lip'] = np.array([landmarks_64[i] for i in [48, 59, 58, 57, 56, 55, 54]])
-            boundaries['lower_inner_lip'] = np.array([landmarks_64[i] for i in [60, 67, 66, 65, 64]])
-        elif self.num_landmarks == 98:
-            boundaries = {}
-            boundaries['cheek'] = landmarks_64[0:33]
-            boundaries['left_eyebrow'] = landmarks_64[33:38]
-            boundaries['right_eyebrow'] = landmarks_64[42:47]
-            boundaries['uper_left_eyelid'] = landmarks_64[60:65]
-            boundaries['lower_left_eyelid'] = np.array([landmarks_64[i] for i in [60, 67, 66, 65, 64]])
-            boundaries['upper_right_eyelid'] = landmarks_64[68:73]
-            boundaries['lower_right_eyelid'] = np.array([landmarks_64[i] for i in [68, 75, 74, 73, 72]])
-            boundaries['noise'] = landmarks_64[51:55]
-            boundaries['noise_bot'] = landmarks_64[55:60]
-            boundaries['upper_outer_lip'] = landmarks_64[76:83]
-            boundaries['upper_inner_lip'] = np.array([landmarks_64[i] for i in [88, 89, 90, 91, 92]])
-            boundaries['lower_outer_lip'] = np.array([landmarks_64[i] for i in [76, 87, 86, 85, 84, 83, 82]])
-            boundaries['lower_inner_lip'] = np.array([landmarks_64[i] for i in [88, 95, 94, 93, 92]])
-        elif self.num_landmarks == 19:
-            boundaries = {}
-            boundaries['left_eyebrow'] = landmarks_64[0:3]
-            boundaries['right_eyebrow'] = landmarks_64[3:5]
-            boundaries['left_eye'] = landmarks_64[6:9]
-            boundaries['right_eye'] = landmarks_64[9:12]
-            boundaries['noise'] = landmarks_64[12:15]
-
-        elif self.num_landmarks == 29:
-            boundaries = {}
-            boundaries['upper_left_eyebrow'] = np.stack([
-                landmarks_64[0],
-                landmarks_64[4],
-                landmarks_64[2]
-            ], axis=0)
-            boundaries['lower_left_eyebrow'] = np.stack([
-                landmarks_64[0],
-                landmarks_64[5],
-                landmarks_64[2]
-            ], axis=0)
-            boundaries['upper_right_eyebrow'] = np.stack([
-                landmarks_64[1],
-                landmarks_64[6],
-                landmarks_64[3]
-            ], axis=0)
-            boundaries['lower_right_eyebrow'] = np.stack([
-                landmarks_64[1],
-                landmarks_64[7],
-                landmarks_64[3]
-            ], axis=0)
-            boundaries['upper_left_eye'] = np.stack([
-                landmarks_64[8],
-                landmarks_64[12],
-                landmarks_64[10]
-            ], axis=0)
-            boundaries['lower_left_eye'] = np.stack([
-                landmarks_64[8],
-                landmarks_64[13],
-                landmarks_64[10]
-            ], axis=0)
-            boundaries['upper_right_eye'] = np.stack([
-                landmarks_64[9],
-                landmarks_64[14],
-                landmarks_64[11]
-            ], axis=0)
-            boundaries['lower_right_eye'] = np.stack([
-                landmarks_64[9],
-                landmarks_64[15],
-                landmarks_64[11]
-            ], axis=0)
-            boundaries['noise'] = np.stack([
-                landmarks_64[18],
-                landmarks_64[21],
-                landmarks_64[19]
-            ], axis=0)
-            boundaries['outer_upper_lip'] = np.stack([
-                landmarks_64[22],
-                landmarks_64[24],
-                landmarks_64[23]
-            ], axis=0)
-            boundaries['inner_upper_lip'] = np.stack([
-                landmarks_64[22],
-                landmarks_64[25],
-                landmarks_64[23]
-            ], axis=0)
-            boundaries['outer_lower_lip'] = np.stack([
-                landmarks_64[22],
-                landmarks_64[26],
-                landmarks_64[23]
-            ], axis=0)
-            boundaries['inner_lower_lip'] = np.stack([
-                landmarks_64[22],
-                landmarks_64[27],
-                landmarks_64[23]
-            ], axis=0)
-        functions = {}
-
-        for key, points in boundaries.items():
-            temp = points[0]
-            new_points = points[0:1, :]
-            for point in points[1:]:
-                if point[0] == temp[0] and point[1] == temp[1]:
-                    continue
-                else:
-                    new_points = np.concatenate((new_points, np.expand_dims(point, 0)), axis=0)
-                    temp = point
-            points = new_points
-            if points.shape[0] == 1:
-                points = np.concatenate((points, points+0.001), axis=0)
-            k = min(4, points.shape[0])
-            functions[key] = interpolate.splprep([points[:, 0], points[:, 1]], k=k-1,s=0)
-
-        boundary_map = np.zeros((64, 64))
-
-        fig = plt.figure(figsize=[64/96.0, 64/96.0], dpi=96)
-
-        ax = fig.add_axes([0, 0, 1, 1])
-
-        ax.axis('off')
-
-        ax.imshow(boundary_map, interpolation='nearest', cmap='gray')
-        #ax.scatter(landmarks[:, 0], landmarks[:, 1], s=1, marker=',', c='w')
-
-        for key in functions.keys():
-            xnew = np.arange(0, 1, 0.01)
-            out = interpolate.splev(xnew, functions[key][0], der=0)
-            plt.plot(out[0], out[1], ',', linewidth=1, color='w')
-
-        img = fig2data(fig)
-
-        plt.close()
-
-        sigma = 1
-        temp = 255-img[:,:,1]
-        temp = cv2.distanceTransform(temp, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
-        temp = temp.astype(np.float32)
-        temp = np.where(temp < 3*sigma, np.exp(-(temp*temp)/(2*sigma*sigma)), 0 )
-
-        fig = plt.figure(figsize=[64/96.0, 64/96.0], dpi=96)
-
-        ax = fig.add_axes([0, 0, 1, 1])
-
-        ax.axis('off')
-        ax.imshow(temp, cmap='gray')
-        plt.close()
-
-        boundary_map = fig2data(fig)
-
-        sample['boundary'] = boundary_map[:, :, 0]
-
-        return sample
-
-class AddWeightMap(object):
-    def __call__(self, sample):
-        heatmap= sample['heatmap']
-        boundary = sample['boundary']
-        heatmap = np.concatenate((heatmap, np.expand_dims(boundary, axis=0)), 0)
-        weight_map = np.zeros_like(heatmap)
-        for i in range(heatmap.shape[0]):
-            weight_map[i] = generate_weight_map(weight_map[i],
-                                                heatmap[i])
-        sample['weight_map'] = weight_map
-        return sample
-
-class ToTensor(object):
-    """Convert ndarrays in sample to Tensors."""
-
-    def __call__(self, sample):
-        image, heatmap, landmarks, boundary, weight_map= sample['image'], sample['heatmap'], sample['landmarks'], sample['boundary'], sample['weight_map']
-
-        # swap color axis because
-        # numpy image: H x W x C
-        # torch image: C X H X W
-        if len(image.shape) == 2:
-            image = np.expand_dims(image, axis=2)
-            image_small = np.expand_dims(image_small, axis=2)
-        image = image.transpose((2, 0, 1))
-        boundary = np.expand_dims(boundary, axis=2)
-        boundary = boundary.transpose((2, 0, 1))
-        return {'image': torch.from_numpy(image).float().div(255.0),
-                'heatmap': torch.from_numpy(heatmap).float(),
-                'landmarks': torch.from_numpy(landmarks).float(),
-                'boundary': torch.from_numpy(boundary).float().div(255.0),
-                'weight_map': torch.from_numpy(weight_map).float()}
-
-class FaceLandmarksDataset(Dataset):
-    """Face Landmarks dataset."""
-
-    def __init__(self, img_dir, landmarks_dir, num_landmarks=68, gray_scale=False,
-                 detect_face=False, enhance=False, center_shift=0,
-                 transform=None,):
-        """
-        Args:
-            landmark_dir (string): Path to the mat file with landmarks saved.
-            img_dir (string): Directory with all the images.
-            transform (callable, optional): Optional transform to be applied
-                on a sample.
-        """
-        self.img_dir = img_dir
-        self.landmarks_dir = landmarks_dir
-        self.num_lanmdkars = num_landmarks
-        self.transform = transform
-        self.img_names = glob.glob(self.img_dir+'*.jpg') + \
-                         glob.glob(self.img_dir+'*.png')
-        self.gray_scale = gray_scale
-        self.detect_face = detect_face
-        self.enhance = enhance
-        self.center_shift = center_shift
-        if self.detect_face:
-            self.face_detector = MTCNN(thresh=[0.5, 0.6, 0.7])
-    def __len__(self):
-        return len(self.img_names)
-
-    def __getitem__(self, idx):
-        img_name = self.img_names[idx]
-        pil_image = Image.open(img_name)
-        if pil_image.mode != "RGB":
-            # if input is grayscale image, convert it to 3 channel image
-            if self.enhance:
-                pil_image = power_transform(pil_image, 0.5)
-            temp_image = Image.new('RGB', pil_image.size)
-            temp_image.paste(pil_image)
-            pil_image = temp_image
-        image = np.array(pil_image)
-        if self.gray_scale:
-            image = rgb2gray(image)
-            image = np.expand_dims(image, axis=2)
-            image = np.concatenate((image, image, image), axis=2)
-            image = image * 255.0
-            image = image.astype(np.uint8)
-        if not self.detect_face:
-            center = [450//2, 450//2+0]
-            if self.center_shift != 0:
-                center[0] += int(np.random.uniform(-self.center_shift,
-                                               self.center_shift))
-                center[1] += int(np.random.uniform(-self.center_shift,
-                                               self.center_shift))
-            scale = 1.8
-        else:
-            detected_faces = self.face_detector.detect_image(image)
-            if len(detected_faces) > 0:
-                box = detected_faces[0]
-                left, top, right, bottom, _ = box
-                center = [right - (right - left) / 2.0,
-                        bottom - (bottom - top) / 2.0]
-                center[1] = center[1] - (bottom - top) * 0.12
-                scale = (right - left + bottom - top) / 195.0
-            else:
-                center = [450//2, 450//2+0]
-                scale = 1.8
-            if self.center_shift != 0:
-                shift = self.center * self.center_shift / 450
-                center[0] += int(np.random.uniform(-shift, shift))
-                center[1] += int(np.random.uniform(-shift, shift))
-        base_name = os.path.basename(img_name)
-        landmarks_base_name = base_name[:-4] + '_pts.mat'
-        landmarks_name = os.path.join(self.landmarks_dir, landmarks_base_name)
-        if os.path.isfile(landmarks_name):
-            mat_data = sio.loadmat(landmarks_name)
-            landmarks = mat_data['pts_2d']
-        elif os.path.isfile(landmarks_name[:-8] + '.pts.npy'):
-            landmarks = np.load(landmarks_name[:-8] + '.pts.npy')
-        else:
-            landmarks = []
-            heatmap = []
-
-        if landmarks != []:
-            new_image, new_landmarks = cv_crop(image, landmarks, center,
-                                               scale, 256, self.center_shift)
-            tries = 0
-            while self.center_shift != 0 and tries < 5 and (np.max(new_landmarks) > 240 or np.min(new_landmarks) < 15):
-                center = [450//2, 450//2+0]
-                scale += 0.05
-                center[0] += int(np.random.uniform(-self.center_shift,
-                                            self.center_shift))
-                center[1] += int(np.random.uniform(-self.center_shift,
-                                            self.center_shift))
-
-                new_image, new_landmarks = cv_crop(image, landmarks,
-                                                    center, scale, 256,
-                                                    self.center_shift)
-                tries += 1
-            if np.max(new_landmarks) > 250 or np.min(new_landmarks) < 5:
-                center = [450//2, 450//2+0]
-                scale = 2.25
-                new_image, new_landmarks = cv_crop(image, landmarks,
-                                                    center, scale, 256,
-                                                    100)
-            assert (np.min(new_landmarks) > 0 and np.max(new_landmarks) < 256), \
-                "Landmarks out of boundary!"
-            image = new_image
-            landmarks = new_landmarks
-            heatmap = np.zeros((self.num_lanmdkars, 64, 64))
-            for i in range(self.num_lanmdkars):
-                if landmarks[i][0] > 0:
-                    heatmap[i] = draw_gaussian(heatmap[i], landmarks[i]/4.0+1, 1)
-        sample = {'image': image, 'heatmap': heatmap, 'landmarks': landmarks}
-        if self.transform:
-            sample = self.transform(sample)
-
-        return sample
-
-def get_dataset(val_img_dir, val_landmarks_dir, batch_size,
-                num_landmarks=68, rotation=0, scale=0,
-                center_shift=0, random_flip=False,
-                brightness=0, contrast=0, saturation=0,
-                blur=False, noise=False, jpeg_effect=False,
-                random_occlusion=False, gray_scale=False,
-                detect_face=False, enhance=False):
-    val_transforms = transforms.Compose([AddBoundary(num_landmarks),
-                                         AddWeightMap(),
-                                         ToTensor()])
-
-    val_dataset = FaceLandmarksDataset(val_img_dir, val_landmarks_dir,
-                                       num_landmarks=num_landmarks,
-                                       gray_scale=gray_scale,
-                                       detect_face=detect_face,
-                                       enhance=enhance,
-                                       transform=val_transforms)
-
-    val_dataloader = torch.utils.data.DataLoader(val_dataset,
-                                                   batch_size=batch_size,
-                                                   shuffle=False,
-                                                   num_workers=6)
-    data_loaders = {'val': val_dataloader}
-    dataset_sizes = {}
-    dataset_sizes['val'] = len(val_dataset)
-    return data_loaders, dataset_sizes
+import sys
+import os
+import random
+import glob
+import torch
+from skimage import io
+from skimage import transform as ski_transform
+from skimage.color import rgb2gray
+import scipy.io as sio
+from scipy import interpolate
+import numpy as np
+import matplotlib.pyplot as plt
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms, utils
+from torchvision.transforms import Lambda, Compose
+from torchvision.transforms.functional import adjust_brightness, adjust_contrast, adjust_saturation, adjust_hue
+from utils.utils import cv_crop, cv_rotate, draw_gaussian, transform, power_transform, shuffle_lr, fig2data, generate_weight_map
+from PIL import Image
+import cv2
+import copy
+import math
+from imgaug import augmenters as iaa
+
+
+class AddBoundary(object):
+    def __init__(self, num_landmarks=68):
+        self.num_landmarks = num_landmarks
+
+    def __call__(self, sample):
+        landmarks_64 = np.floor(sample['landmarks'] / 4.0)
+        if self.num_landmarks == 68:
+            boundaries = {}
+            boundaries['cheek'] = landmarks_64[0:17]
+            boundaries['left_eyebrow'] = landmarks_64[17:22]
+            boundaries['right_eyebrow'] = landmarks_64[22:27]
+            boundaries['uper_left_eyelid'] = landmarks_64[36:40]
+            boundaries['lower_left_eyelid'] = np.array([landmarks_64[i] for i in [36, 41, 40, 39]])
+            boundaries['upper_right_eyelid'] = landmarks_64[42:46]
+            boundaries['lower_right_eyelid'] = np.array([landmarks_64[i] for i in [42, 47, 46, 45]])
+            boundaries['noise'] = landmarks_64[27:31]
+            boundaries['noise_bot'] = landmarks_64[31:36]
+            boundaries['upper_outer_lip'] = landmarks_64[48:55]
+            boundaries['upper_inner_lip'] = np.array([landmarks_64[i] for i in [60, 61, 62, 63, 64]])
+            boundaries['lower_outer_lip'] = np.array([landmarks_64[i] for i in [48, 59, 58, 57, 56, 55, 54]])
+            boundaries['lower_inner_lip'] = np.array([landmarks_64[i] for i in [60, 67, 66, 65, 64]])
+        elif self.num_landmarks == 98:
+            boundaries = {}
+            boundaries['cheek'] = landmarks_64[0:33]
+            boundaries['left_eyebrow'] = landmarks_64[33:38]
+            boundaries['right_eyebrow'] = landmarks_64[42:47]
+            boundaries['uper_left_eyelid'] = landmarks_64[60:65]
+            boundaries['lower_left_eyelid'] = np.array([landmarks_64[i] for i in [60, 67, 66, 65, 64]])
+            boundaries['upper_right_eyelid'] = landmarks_64[68:73]
+            boundaries['lower_right_eyelid'] = np.array([landmarks_64[i] for i in [68, 75, 74, 73, 72]])
+            boundaries['noise'] = landmarks_64[51:55]
+            boundaries['noise_bot'] = landmarks_64[55:60]
+            boundaries['upper_outer_lip'] = landmarks_64[76:83]
+            boundaries['upper_inner_lip'] = np.array([landmarks_64[i] for i in [88, 89, 90, 91, 92]])
+            boundaries['lower_outer_lip'] = np.array([landmarks_64[i] for i in [76, 87, 86, 85, 84, 83, 82]])
+            boundaries['lower_inner_lip'] = np.array([landmarks_64[i] for i in [88, 95, 94, 93, 92]])
+        elif self.num_landmarks == 19:
+            boundaries = {}
+            boundaries['left_eyebrow'] = landmarks_64[0:3]
+            boundaries['right_eyebrow'] = landmarks_64[3:5]
+            boundaries['left_eye'] = landmarks_64[6:9]
+            boundaries['right_eye'] = landmarks_64[9:12]
+            boundaries['noise'] = landmarks_64[12:15]
+
+        elif self.num_landmarks == 29:
+            boundaries = {}
+            boundaries['upper_left_eyebrow'] = np.stack([
+                landmarks_64[0],
+                landmarks_64[4],
+                landmarks_64[2]
+            ], axis=0)
+            boundaries['lower_left_eyebrow'] = np.stack([
+                landmarks_64[0],
+                landmarks_64[5],
+                landmarks_64[2]
+            ], axis=0)
+            boundaries['upper_right_eyebrow'] = np.stack([
+                landmarks_64[1],
+                landmarks_64[6],
+                landmarks_64[3]
+            ], axis=0)
+            boundaries['lower_right_eyebrow'] = np.stack([
+                landmarks_64[1],
+                landmarks_64[7],
+                landmarks_64[3]
+            ], axis=0)
+            boundaries['upper_left_eye'] = np.stack([
+                landmarks_64[8],
+                landmarks_64[12],
+                landmarks_64[10]
+            ], axis=0)
+            boundaries['lower_left_eye'] = np.stack([
+                landmarks_64[8],
+                landmarks_64[13],
+                landmarks_64[10]
+            ], axis=0)
+            boundaries['upper_right_eye'] = np.stack([
+                landmarks_64[9],
+                landmarks_64[14],
+                landmarks_64[11]
+            ], axis=0)
+            boundaries['lower_right_eye'] = np.stack([
+                landmarks_64[9],
+                landmarks_64[15],
+                landmarks_64[11]
+            ], axis=0)
+            boundaries['noise'] = np.stack([
+                landmarks_64[18],
+                landmarks_64[21],
+                landmarks_64[19]
+            ], axis=0)
+            boundaries['outer_upper_lip'] = np.stack([
+                landmarks_64[22],
+                landmarks_64[24],
+                landmarks_64[23]
+            ], axis=0)
+            boundaries['inner_upper_lip'] = np.stack([
+                landmarks_64[22],
+                landmarks_64[25],
+                landmarks_64[23]
+            ], axis=0)
+            boundaries['outer_lower_lip'] = np.stack([
+                landmarks_64[22],
+                landmarks_64[26],
+                landmarks_64[23]
+            ], axis=0)
+            boundaries['inner_lower_lip'] = np.stack([
+                landmarks_64[22],
+                landmarks_64[27],
+                landmarks_64[23]
+            ], axis=0)
+        functions = {}
+
+        for key, points in boundaries.items():
+            temp = points[0]
+            new_points = points[0:1, :]
+            for point in points[1:]:
+                if point[0] == temp[0] and point[1] == temp[1]:
+                    continue
+                else:
+                    new_points = np.concatenate((new_points, np.expand_dims(point, 0)), axis=0)
+                    temp = point
+            points = new_points
+            if points.shape[0] == 1:
+                points = np.concatenate((points, points+0.001), axis=0)
+            k = min(4, points.shape[0])
+            functions[key] = interpolate.splprep([points[:, 0], points[:, 1]], k=k-1,s=0)
+
+        boundary_map = np.zeros((64, 64))
+
+        fig = plt.figure(figsize=[64/96.0, 64/96.0], dpi=96)
+
+        ax = fig.add_axes([0, 0, 1, 1])
+
+        ax.axis('off')
+
+        ax.imshow(boundary_map, interpolation='nearest', cmap='gray')
+        #ax.scatter(landmarks[:, 0], landmarks[:, 1], s=1, marker=',', c='w')
+
+        for key in functions.keys():
+            xnew = np.arange(0, 1, 0.01)
+            out = interpolate.splev(xnew, functions[key][0], der=0)
+            plt.plot(out[0], out[1], ',', linewidth=1, color='w')
+
+        img = fig2data(fig)
+
+        plt.close()
+
+        sigma = 1
+        temp = 255-img[:,:,1]
+        temp = cv2.distanceTransform(temp, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+        temp = temp.astype(np.float32)
+        temp = np.where(temp < 3*sigma, np.exp(-(temp*temp)/(2*sigma*sigma)), 0 )
+
+        fig = plt.figure(figsize=[64/96.0, 64/96.0], dpi=96)
+
+        ax = fig.add_axes([0, 0, 1, 1])
+
+        ax.axis('off')
+        ax.imshow(temp, cmap='gray')
+        plt.close()
+
+        boundary_map = fig2data(fig)
+
+        sample['boundary'] = boundary_map[:, :, 0]
+
+        return sample
+
+class AddWeightMap(object):
+    def __call__(self, sample):
+        heatmap= sample['heatmap']
+        boundary = sample['boundary']
+        heatmap = np.concatenate((heatmap, np.expand_dims(boundary, axis=0)), 0)
+        weight_map = np.zeros_like(heatmap)
+        for i in range(heatmap.shape[0]):
+            weight_map[i] = generate_weight_map(weight_map[i],
+                                                heatmap[i])
+        sample['weight_map'] = weight_map
+        return sample
+
+class ToTensor(object):
+    """Convert ndarrays in sample to Tensors."""
+
+    def __call__(self, sample):
+        image, heatmap, landmarks, boundary, weight_map= sample['image'], sample['heatmap'], sample['landmarks'], sample['boundary'], sample['weight_map']
+
+        # swap color axis because
+        # numpy image: H x W x C
+        # torch image: C X H X W
+        if len(image.shape) == 2:
+            image = np.expand_dims(image, axis=2)
+            image_small = np.expand_dims(image_small, axis=2)
+        image = image.transpose((2, 0, 1))
+        boundary = np.expand_dims(boundary, axis=2)
+        boundary = boundary.transpose((2, 0, 1))
+        return {'image': torch.from_numpy(image).float().div(255.0),
+                'heatmap': torch.from_numpy(heatmap).float(),
+                'landmarks': torch.from_numpy(landmarks).float(),
+                'boundary': torch.from_numpy(boundary).float().div(255.0),
+                'weight_map': torch.from_numpy(weight_map).float()}
+
+class FaceLandmarksDataset(Dataset):
+    """Face Landmarks dataset."""
+
+    def __init__(self, img_dir, landmarks_dir, num_landmarks=68, gray_scale=False,
+                 detect_face=False, enhance=False, center_shift=0,
+                 transform=None,):
+        """
+        Args:
+            landmark_dir (string): Path to the mat file with landmarks saved.
+            img_dir (string): Directory with all the images.
+            transform (callable, optional): Optional transform to be applied
+                on a sample.
+        """
+        self.img_dir = img_dir
+        self.landmarks_dir = landmarks_dir
+        self.num_lanmdkars = num_landmarks
+        self.transform = transform
+        self.img_names = glob.glob(self.img_dir+'*.jpg') + \
+                         glob.glob(self.img_dir+'*.png')
+        self.gray_scale = gray_scale
+        self.detect_face = detect_face
+        self.enhance = enhance
+        self.center_shift = center_shift
+        if self.detect_face:
+            self.face_detector = MTCNN(thresh=[0.5, 0.6, 0.7])
+    def __len__(self):
+        return len(self.img_names)
+
+    def __getitem__(self, idx):
+        img_name = self.img_names[idx]
+        pil_image = Image.open(img_name)
+        if pil_image.mode != "RGB":
+            # if input is grayscale image, convert it to 3 channel image
+            if self.enhance:
+                pil_image = power_transform(pil_image, 0.5)
+            temp_image = Image.new('RGB', pil_image.size)
+            temp_image.paste(pil_image)
+            pil_image = temp_image
+        image = np.array(pil_image)
+        if self.gray_scale:
+            image = rgb2gray(image)
+            image = np.expand_dims(image, axis=2)
+            image = np.concatenate((image, image, image), axis=2)
+            image = image * 255.0
+            image = image.astype(np.uint8)
+        if not self.detect_face:
+            center = [450//2, 450//2+0]
+            if self.center_shift != 0:
+                center[0] += int(np.random.uniform(-self.center_shift,
+                                               self.center_shift))
+                center[1] += int(np.random.uniform(-self.center_shift,
+                                               self.center_shift))
+            scale = 1.8
+        else:
+            detected_faces = self.face_detector.detect_image(image)
+            if len(detected_faces) > 0:
+                box = detected_faces[0]
+                left, top, right, bottom, _ = box
+                center = [right - (right - left) / 2.0,
+                        bottom - (bottom - top) / 2.0]
+                center[1] = center[1] - (bottom - top) * 0.12
+                scale = (right - left + bottom - top) / 195.0
+            else:
+                center = [450//2, 450//2+0]
+                scale = 1.8
+            if self.center_shift != 0:
+                shift = self.center * self.center_shift / 450
+                center[0] += int(np.random.uniform(-shift, shift))
+                center[1] += int(np.random.uniform(-shift, shift))
+        base_name = os.path.basename(img_name)
+        landmarks_base_name = base_name[:-4] + '_pts.mat'
+        landmarks_name = os.path.join(self.landmarks_dir, landmarks_base_name)
+        if os.path.isfile(landmarks_name):
+            mat_data = sio.loadmat(landmarks_name)
+            landmarks = mat_data['pts_2d']
+        elif os.path.isfile(landmarks_name[:-8] + '.pts.npy'):
+            landmarks = np.load(landmarks_name[:-8] + '.pts.npy')
+        else:
+            landmarks = []
+            heatmap = []
+
+        if landmarks != []:
+            new_image, new_landmarks = cv_crop(image, landmarks, center,
+                                               scale, 256, self.center_shift)
+            tries = 0
+            while self.center_shift != 0 and tries < 5 and (np.max(new_landmarks) > 240 or np.min(new_landmarks) < 15):
+                center = [450//2, 450//2+0]
+                scale += 0.05
+                center[0] += int(np.random.uniform(-self.center_shift,
+                                            self.center_shift))
+                center[1] += int(np.random.uniform(-self.center_shift,
+                                            self.center_shift))
+
+                new_image, new_landmarks = cv_crop(image, landmarks,
+                                                    center, scale, 256,
+                                                    self.center_shift)
+                tries += 1
+            if np.max(new_landmarks) > 250 or np.min(new_landmarks) < 5:
+                center = [450//2, 450//2+0]
+                scale = 2.25
+                new_image, new_landmarks = cv_crop(image, landmarks,
+                                                    center, scale, 256,
+                                                    100)
+            assert (np.min(new_landmarks) > 0 and np.max(new_landmarks) < 256), \
+                "Landmarks out of boundary!"
+            image = new_image
+            landmarks = new_landmarks
+            heatmap = np.zeros((self.num_lanmdkars, 64, 64))
+            for i in range(self.num_lanmdkars):
+                if landmarks[i][0] > 0:
+                    heatmap[i] = draw_gaussian(heatmap[i], landmarks[i]/4.0+1, 1)
+        sample = {'image': image, 'heatmap': heatmap, 'landmarks': landmarks}
+        if self.transform:
+            sample = self.transform(sample)
+
+        return sample
+
+def get_dataset(val_img_dir, val_landmarks_dir, batch_size,
+                num_landmarks=68, rotation=0, scale=0,
+                center_shift=0, random_flip=False,
+                brightness=0, contrast=0, saturation=0,
+                blur=False, noise=False, jpeg_effect=False,
+                random_occlusion=False, gray_scale=False,
+                detect_face=False, enhance=False):
+    val_transforms = transforms.Compose([AddBoundary(num_landmarks),
+                                         AddWeightMap(),
+                                         ToTensor()])
+
+    val_dataset = FaceLandmarksDataset(val_img_dir, val_landmarks_dir,
+                                       num_landmarks=num_landmarks,
+                                       gray_scale=gray_scale,
+                                       detect_face=detect_face,
+                                       enhance=enhance,
+                                       transform=val_transforms)
+
+    val_dataloader = torch.utils.data.DataLoader(val_dataset,
+                                                   batch_size=batch_size,
+                                                   shuffle=False,
+                                                   num_workers=6)
+    data_loaders = {'val': val_dataloader}
+    dataset_sizes = {}
+    dataset_sizes['val'] = len(val_dataset)
+    return data_loaders, dataset_sizes

MakeItTalk/thirdparty/AdaptiveWingLoss/core/evaler.py

@@ -1,151 +1,151 @@
-import matplotlib
-matplotlib.use('Agg')
-import math
-import torch
-import copy
-import time
-from torch.autograd import Variable
-import shutil
-from skimage import io
-import numpy as np
-from utils.utils import fan_NME, show_landmarks, get_preds_fromhm
-from PIL import Image, ImageDraw
-import os
-import sys
-import cv2
-import matplotlib.pyplot as plt
-
-
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-def eval_model(model, dataloaders, dataset_sizes,
-               writer, use_gpu=True, epoches=5, dataset='val',
-               save_path='./', num_landmarks=68):
-    global_nme = 0
-    model.eval()
-    for epoch in range(epoches):
-        running_loss = 0
-        step = 0
-        total_nme = 0
-        total_count = 0
-        fail_count = 0
-        nmes = []
-        # running_corrects = 0
-
-        # Iterate over data.
-        with torch.no_grad():
-            for data in dataloaders[dataset]:
-                total_runtime = 0
-                run_count = 0
-                step_start = time.time()
-                step += 1
-                # get the inputs
-                inputs = data['image'].type(torch.FloatTensor)
-                labels_heatmap = data['heatmap'].type(torch.FloatTensor)
-                labels_boundary = data['boundary'].type(torch.FloatTensor)
-                landmarks = data['landmarks'].type(torch.FloatTensor)
-                loss_weight_map = data['weight_map'].type(torch.FloatTensor)
-                # wrap them in Variable
-                if use_gpu:
-                    inputs = inputs.to(device)
-                    labels_heatmap = labels_heatmap.to(device)
-                    labels_boundary = labels_boundary.to(device)
-                    loss_weight_map = loss_weight_map.to(device)
-                else:
-                    inputs, labels_heatmap = Variable(inputs), Variable(labels_heatmap)
-                    labels_boundary = Variable(labels_boundary)
-                labels = torch.cat((labels_heatmap, labels_boundary), 1)
-                single_start = time.time()
-                outputs, boundary_channels = model(inputs)
-                single_end = time.time()
-                total_runtime += time.time() - single_start
-                run_count += 1
-                step_end = time.time()
-                for i in range(inputs.shape[0]):
-                    print(inputs.shape)
-                    img = inputs[i]
-                    img = img.cpu().numpy()
-                    img = img.transpose((1, 2, 0)) #*255.0
-                    # img = img.astype(np.uint8)
-                    # img = Image.fromarray(img)
-                    # pred_heatmap = outputs[-1][i].detach().cpu()[:-1, :, :]
-                    pred_heatmap = outputs[-1][:, :-1, :, :][i].detach().cpu()
-                    pred_landmarks, _ = get_preds_fromhm(pred_heatmap.unsqueeze(0))
-                    pred_landmarks = pred_landmarks.squeeze().numpy()
-
-                    gt_landmarks = data['landmarks'][i].numpy()
-                    print(pred_landmarks, gt_landmarks)
-                    import cv2
-                    while(True):
-                        imgshow = vis_landmark_on_img(cv2.UMat(img), pred_landmarks*4)
-                        cv2.imshow('img', imgshow)
-
-                        if(cv2.waitKey(10) == ord('q')):
-                            break
-
-
-                    if num_landmarks == 68:
-                        left_eye = np.average(gt_landmarks[36:42], axis=0)
-                        right_eye = np.average(gt_landmarks[42:48], axis=0)
-                        norm_factor = np.linalg.norm(left_eye - right_eye)
-                        # norm_factor = np.linalg.norm(gt_landmarks[36]- gt_landmarks[45])
-
-                    elif num_landmarks == 98:
-                        norm_factor = np.linalg.norm(gt_landmarks[60]- gt_landmarks[72])
-                    elif num_landmarks == 19:
-                        left, top = gt_landmarks[-2, :]
-                        right, bottom = gt_landmarks[-1, :]
-                        norm_factor = math.sqrt(abs(right - left)*abs(top-bottom))
-                        gt_landmarks = gt_landmarks[:-2, :]
-                    elif num_landmarks == 29:
-                        # norm_factor = np.linalg.norm(gt_landmarks[8]- gt_landmarks[9])
-                        norm_factor = np.linalg.norm(gt_landmarks[16]- gt_landmarks[17])
-                    single_nme = (np.sum(np.linalg.norm(pred_landmarks*4 - gt_landmarks, axis=1)) / pred_landmarks.shape[0]) / norm_factor
-
-                    nmes.append(single_nme)
-                    total_count += 1
-                    if single_nme > 0.1:
-                        fail_count += 1
-                if step % 10 == 0:
-                    print('Step {} Time: {:.6f} Input Mean: {:.6f} Output Mean: {:.6f}'.format(
-                        step, step_end - step_start,
-                        torch.mean(labels),
-                        torch.mean(outputs[0])))
-                # gt_landmarks = landmarks.numpy()
-                # pred_heatmap = outputs[-1].to('cpu').numpy()
-                gt_landmarks = landmarks
-                batch_nme = fan_NME(outputs[-1][:, :-1, :, :].detach().cpu(), gt_landmarks, num_landmarks)
-                # batch_nme = 0
-                total_nme += batch_nme
-        epoch_nme = total_nme / dataset_sizes['val']
-        global_nme += epoch_nme
-        nme_save_path = os.path.join(save_path, 'nme_log.npy')
-        np.save(nme_save_path, np.array(nmes))
-        print('NME: {:.6f} Failure Rate: {:.6f} Total Count: {:.6f} Fail Count: {:.6f}'.format(epoch_nme, fail_count/total_count, total_count, fail_count))
-    print('Evaluation done! Average NME: {:.6f}'.format(global_nme/epoches))
-    print('Everage runtime for a single batch: {:.6f}'.format(total_runtime/run_count))
-    return model
-
-
-def vis_landmark_on_img(img, shape, linewidth=2):
-    '''
-    Visualize landmark on images.
-    '''
-
-    def draw_curve(idx_list, color=(0, 255, 0), loop=False, lineWidth=linewidth):
-        for i in idx_list:
-            cv2.line(img, (shape[i, 0], shape[i, 1]), (shape[i + 1, 0], shape[i + 1, 1]), color, lineWidth)
-        if (loop):
-            cv2.line(img, (shape[idx_list[0], 0], shape[idx_list[0], 1]),
-                     (shape[idx_list[-1] + 1, 0], shape[idx_list[-1] + 1, 1]), color, lineWidth)
-
-    draw_curve(list(range(0, 32)))  # jaw
-    draw_curve(list(range(33, 41)), color=(0, 0, 255), loop=True)  # eye brow
-    draw_curve(list(range(42, 50)), color=(0, 0, 255), loop=True)
-    draw_curve(list(range(51, 59)))  # nose
-    draw_curve(list(range(60, 67)), loop=True)  # eyes
-    draw_curve(list(range(68, 75)), loop=True)
-    draw_curve(list(range(76, 87)), loop=True, color=(0, 255, 255))  # mouth
-    draw_curve(list(range(88, 95)), loop=True, color=(255, 255, 0))
-
+import matplotlib
+matplotlib.use('Agg')
+import math
+import torch
+import copy
+import time
+from torch.autograd import Variable
+import shutil
+from skimage import io
+import numpy as np
+from utils.utils import fan_NME, show_landmarks, get_preds_fromhm
+from PIL import Image, ImageDraw
+import os
+import sys
+import cv2
+import matplotlib.pyplot as plt
+
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+def eval_model(model, dataloaders, dataset_sizes,
+               writer, use_gpu=True, epoches=5, dataset='val',
+               save_path='./', num_landmarks=68):
+    global_nme = 0
+    model.eval()
+    for epoch in range(epoches):
+        running_loss = 0
+        step = 0
+        total_nme = 0
+        total_count = 0
+        fail_count = 0
+        nmes = []
+        # running_corrects = 0
+
+        # Iterate over data.
+        with torch.no_grad():
+            for data in dataloaders[dataset]:
+                total_runtime = 0
+                run_count = 0
+                step_start = time.time()
+                step += 1
+                # get the inputs
+                inputs = data['image'].type(torch.FloatTensor)
+                labels_heatmap = data['heatmap'].type(torch.FloatTensor)
+                labels_boundary = data['boundary'].type(torch.FloatTensor)
+                landmarks = data['landmarks'].type(torch.FloatTensor)
+                loss_weight_map = data['weight_map'].type(torch.FloatTensor)
+                # wrap them in Variable
+                if use_gpu:
+                    inputs = inputs.to(device)
+                    labels_heatmap = labels_heatmap.to(device)
+                    labels_boundary = labels_boundary.to(device)
+                    loss_weight_map = loss_weight_map.to(device)
+                else:
+                    inputs, labels_heatmap = Variable(inputs), Variable(labels_heatmap)
+                    labels_boundary = Variable(labels_boundary)
+                labels = torch.cat((labels_heatmap, labels_boundary), 1)
+                single_start = time.time()
+                outputs, boundary_channels = model(inputs)
+                single_end = time.time()
+                total_runtime += time.time() - single_start
+                run_count += 1
+                step_end = time.time()
+                for i in range(inputs.shape[0]):
+                    print(inputs.shape)
+                    img = inputs[i]
+                    img = img.cpu().numpy()
+                    img = img.transpose((1, 2, 0)) #*255.0
+                    # img = img.astype(np.uint8)
+                    # img = Image.fromarray(img)
+                    # pred_heatmap = outputs[-1][i].detach().cpu()[:-1, :, :]
+                    pred_heatmap = outputs[-1][:, :-1, :, :][i].detach().cpu()
+                    pred_landmarks, _ = get_preds_fromhm(pred_heatmap.unsqueeze(0))
+                    pred_landmarks = pred_landmarks.squeeze().numpy()
+
+                    gt_landmarks = data['landmarks'][i].numpy()
+                    print(pred_landmarks, gt_landmarks)
+                    import cv2
+                    while(True):
+                        imgshow = vis_landmark_on_img(cv2.UMat(img), pred_landmarks*4)
+                        cv2.imshow('img', imgshow)
+
+                        if(cv2.waitKey(10) == ord('q')):
+                            break
+
+
+                    if num_landmarks == 68:
+                        left_eye = np.average(gt_landmarks[36:42], axis=0)
+                        right_eye = np.average(gt_landmarks[42:48], axis=0)
+                        norm_factor = np.linalg.norm(left_eye - right_eye)
+                        # norm_factor = np.linalg.norm(gt_landmarks[36]- gt_landmarks[45])
+
+                    elif num_landmarks == 98:
+                        norm_factor = np.linalg.norm(gt_landmarks[60]- gt_landmarks[72])
+                    elif num_landmarks == 19:
+                        left, top = gt_landmarks[-2, :]
+                        right, bottom = gt_landmarks[-1, :]
+                        norm_factor = math.sqrt(abs(right - left)*abs(top-bottom))
+                        gt_landmarks = gt_landmarks[:-2, :]
+                    elif num_landmarks == 29:
+                        # norm_factor = np.linalg.norm(gt_landmarks[8]- gt_landmarks[9])
+                        norm_factor = np.linalg.norm(gt_landmarks[16]- gt_landmarks[17])
+                    single_nme = (np.sum(np.linalg.norm(pred_landmarks*4 - gt_landmarks, axis=1)) / pred_landmarks.shape[0]) / norm_factor
+
+                    nmes.append(single_nme)
+                    total_count += 1
+                    if single_nme > 0.1:
+                        fail_count += 1
+                if step % 10 == 0:
+                    print('Step {} Time: {:.6f} Input Mean: {:.6f} Output Mean: {:.6f}'.format(
+                        step, step_end - step_start,
+                        torch.mean(labels),
+                        torch.mean(outputs[0])))
+                # gt_landmarks = landmarks.numpy()
+                # pred_heatmap = outputs[-1].to('cpu').numpy()
+                gt_landmarks = landmarks
+                batch_nme = fan_NME(outputs[-1][:, :-1, :, :].detach().cpu(), gt_landmarks, num_landmarks)
+                # batch_nme = 0
+                total_nme += batch_nme
+        epoch_nme = total_nme / dataset_sizes['val']
+        global_nme += epoch_nme
+        nme_save_path = os.path.join(save_path, 'nme_log.npy')
+        np.save(nme_save_path, np.array(nmes))
+        print('NME: {:.6f} Failure Rate: {:.6f} Total Count: {:.6f} Fail Count: {:.6f}'.format(epoch_nme, fail_count/total_count, total_count, fail_count))
+    print('Evaluation done! Average NME: {:.6f}'.format(global_nme/epoches))
+    print('Everage runtime for a single batch: {:.6f}'.format(total_runtime/run_count))
+    return model
+
+
+def vis_landmark_on_img(img, shape, linewidth=2):
+    '''
+    Visualize landmark on images.
+    '''
+
+    def draw_curve(idx_list, color=(0, 255, 0), loop=False, lineWidth=linewidth):
+        for i in idx_list:
+            cv2.line(img, (shape[i, 0], shape[i, 1]), (shape[i + 1, 0], shape[i + 1, 1]), color, lineWidth)
+        if (loop):
+            cv2.line(img, (shape[idx_list[0], 0], shape[idx_list[0], 1]),
+                     (shape[idx_list[-1] + 1, 0], shape[idx_list[-1] + 1, 1]), color, lineWidth)
+
+    draw_curve(list(range(0, 32)))  # jaw
+    draw_curve(list(range(33, 41)), color=(0, 0, 255), loop=True)  # eye brow
+    draw_curve(list(range(42, 50)), color=(0, 0, 255), loop=True)
+    draw_curve(list(range(51, 59)))  # nose
+    draw_curve(list(range(60, 67)), loop=True)  # eyes
+    draw_curve(list(range(68, 75)), loop=True)
+    draw_curve(list(range(76, 87)), loop=True, color=(0, 255, 255))  # mouth
+    draw_curve(list(range(88, 95)), loop=True, color=(255, 255, 0))
+
     return img

MakeItTalk/thirdparty/AdaptiveWingLoss/core/models.py

@@ -1,228 +1,228 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import math
-from core.coord_conv import CoordConvTh
-
-
-def conv3x3(in_planes, out_planes, strd=1, padding=1,
-            bias=False,dilation=1):
-    "3x3 convolution with padding"
-    return nn.Conv2d(in_planes, out_planes, kernel_size=3,
-                     stride=strd, padding=padding, bias=bias,
-                     dilation=dilation)
-
-class BasicBlock(nn.Module):
-    expansion = 1
-
-    def __init__(self, inplanes, planes, stride=1, downsample=None):
-        super(BasicBlock, self).__init__()
-        self.conv1 = conv3x3(inplanes, planes, stride)
-        # self.bn1 = nn.BatchNorm2d(planes)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = conv3x3(planes, planes)
-        # self.bn2 = nn.BatchNorm2d(planes)
-        self.downsample = downsample
-        self.stride = stride
-
-    def forward(self, x):
-        residual = x
-
-        out = self.conv1(x)
-        # out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        # out = self.bn2(out)
-
-        if self.downsample is not None:
-            residual = self.downsample(x)
-
-        out += residual
-        out = self.relu(out)
-
-        return out
-
-class ConvBlock(nn.Module):
-    def __init__(self, in_planes, out_planes):
-        super(ConvBlock, self).__init__()
-        self.bn1 = nn.BatchNorm2d(in_planes)
-        self.conv1 = conv3x3(in_planes, int(out_planes / 2))
-        self.bn2 = nn.BatchNorm2d(int(out_planes / 2))
-        self.conv2 = conv3x3(int(out_planes / 2), int(out_planes / 4),
-                             padding=1, dilation=1)
-        self.bn3 = nn.BatchNorm2d(int(out_planes / 4))
-        self.conv3 = conv3x3(int(out_planes / 4), int(out_planes / 4),
-                             padding=1, dilation=1)
-
-        if in_planes != out_planes:
-            self.downsample = nn.Sequential(
-                nn.BatchNorm2d(in_planes),
-                nn.ReLU(True),
-                nn.Conv2d(in_planes, out_planes,
-                          kernel_size=1, stride=1, bias=False),
-            )
-        else:
-            self.downsample = None
-
-    def forward(self, x):
-        residual = x
-
-        out1 = self.bn1(x)
-        out1 = F.relu(out1, True)
-        out1 = self.conv1(out1)
-
-        out2 = self.bn2(out1)
-        out2 = F.relu(out2, True)
-        out2 = self.conv2(out2)
-
-        out3 = self.bn3(out2)
-        out3 = F.relu(out3, True)
-        out3 = self.conv3(out3)
-
-        out3 = torch.cat((out1, out2, out3), 1)
-
-        if self.downsample is not None:
-            residual = self.downsample(residual)
-
-        out3 += residual
-
-        return out3
-
-class HourGlass(nn.Module):
-    def __init__(self, num_modules, depth, num_features, first_one=False):
-        super(HourGlass, self).__init__()
-        self.num_modules = num_modules
-        self.depth = depth
-        self.features = num_features
-        self.coordconv = CoordConvTh(x_dim=64, y_dim=64,
-                                     with_r=True, with_boundary=True,
-                                     in_channels=256, first_one=first_one,
-                                     out_channels=256,
-                                     kernel_size=1,
-                                     stride=1, padding=0)
-        self._generate_network(self.depth)
-
-    def _generate_network(self, level):
-        self.add_module('b1_' + str(level), ConvBlock(256, 256))
-
-        self.add_module('b2_' + str(level), ConvBlock(256, 256))
-
-        if level > 1:
-            self._generate_network(level - 1)
-        else:
-            self.add_module('b2_plus_' + str(level), ConvBlock(256, 256))
-
-        self.add_module('b3_' + str(level), ConvBlock(256, 256))
-
-    def _forward(self, level, inp):
-        # Upper branch
-        up1 = inp
-        up1 = self._modules['b1_' + str(level)](up1)
-
-        # Lower branch
-        low1 = F.avg_pool2d(inp, 2, stride=2)
-        low1 = self._modules['b2_' + str(level)](low1)
-
-        if level > 1:
-            low2 = self._forward(level - 1, low1)
-        else:
-            low2 = low1
-            low2 = self._modules['b2_plus_' + str(level)](low2)
-
-        low3 = low2
-        low3 = self._modules['b3_' + str(level)](low3)
-
-        up2 = F.upsample(low3, scale_factor=2, mode='nearest')
-
-        return up1 + up2
-
-    def forward(self, x, heatmap):
-        x, last_channel = self.coordconv(x, heatmap)
-        return self._forward(self.depth, x), last_channel
-
-class FAN(nn.Module):
-
-    def __init__(self, num_modules=1, end_relu=False, gray_scale=False,
-                 num_landmarks=68):
-        super(FAN, self).__init__()
-        self.num_modules = num_modules
-        self.gray_scale = gray_scale
-        self.end_relu = end_relu
-        self.num_landmarks = num_landmarks
-
-        # Base part
-        if self.gray_scale:
-            self.conv1 = CoordConvTh(x_dim=256, y_dim=256,
-                                     with_r=True, with_boundary=False,
-                                     in_channels=3, out_channels=64,
-                                     kernel_size=7,
-                                     stride=2, padding=3)
-        else:
-            self.conv1 = CoordConvTh(x_dim=256, y_dim=256,
-                                     with_r=True, with_boundary=False,
-                                     in_channels=3, out_channels=64,
-                                     kernel_size=7,
-                                     stride=2, padding=3)
-        self.bn1 = nn.BatchNorm2d(64)
-        self.conv2 = ConvBlock(64, 128)
-        self.conv3 = ConvBlock(128, 128)
-        self.conv4 = ConvBlock(128, 256)
-
-        # Stacking part
-        for hg_module in range(self.num_modules):
-            if hg_module == 0:
-                first_one = True
-            else:
-                first_one = False
-            self.add_module('m' + str(hg_module), HourGlass(1, 4, 256,
-                                                            first_one))
-            self.add_module('top_m_' + str(hg_module), ConvBlock(256, 256))
-            self.add_module('conv_last' + str(hg_module),
-                            nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0))
-            self.add_module('bn_end' + str(hg_module), nn.BatchNorm2d(256))
-            self.add_module('l' + str(hg_module), nn.Conv2d(256,
-                                                            num_landmarks+1, kernel_size=1, stride=1, padding=0))
-
-            if hg_module < self.num_modules - 1:
-                self.add_module(
-                    'bl' + str(hg_module), nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0))
-                self.add_module('al' + str(hg_module), nn.Conv2d(num_landmarks+1,
-                                                                 256, kernel_size=1, stride=1, padding=0))
-
-    def forward(self, x):
-        x, _ = self.conv1(x)
-        x = F.relu(self.bn1(x), True)
-        # x = F.relu(self.bn1(self.conv1(x)), True)
-        x = F.avg_pool2d(self.conv2(x), 2, stride=2)
-        x = self.conv3(x)
-        x = self.conv4(x)
-
-        previous = x
-
-        outputs = []
-        boundary_channels = []
-        tmp_out = None
-        for i in range(self.num_modules):
-            hg, boundary_channel = self._modules['m' + str(i)](previous,
-                                                               tmp_out)
-
-            ll = hg
-            ll = self._modules['top_m_' + str(i)](ll)
-
-            ll = F.relu(self._modules['bn_end' + str(i)]
-                        (self._modules['conv_last' + str(i)](ll)), True)
-
-            # Predict heatmaps
-            tmp_out = self._modules['l' + str(i)](ll)
-            if self.end_relu:
-                tmp_out = F.relu(tmp_out) # HACK: Added relu
-            outputs.append(tmp_out)
-            boundary_channels.append(boundary_channel)
-
-            if i < self.num_modules - 1:
-                ll = self._modules['bl' + str(i)](ll)
-                tmp_out_ = self._modules['al' + str(i)](tmp_out)
-                previous = previous + ll + tmp_out_
-
-        return outputs, boundary_channels
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+from core.coord_conv import CoordConvTh
+
+
+def conv3x3(in_planes, out_planes, strd=1, padding=1,
+            bias=False,dilation=1):
+    "3x3 convolution with padding"
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3,
+                     stride=strd, padding=padding, bias=bias,
+                     dilation=dilation)
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        # self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        # self.bn2 = nn.BatchNorm2d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        # out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        # out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_planes, out_planes):
+        super(ConvBlock, self).__init__()
+        self.bn1 = nn.BatchNorm2d(in_planes)
+        self.conv1 = conv3x3(in_planes, int(out_planes / 2))
+        self.bn2 = nn.BatchNorm2d(int(out_planes / 2))
+        self.conv2 = conv3x3(int(out_planes / 2), int(out_planes / 4),
+                             padding=1, dilation=1)
+        self.bn3 = nn.BatchNorm2d(int(out_planes / 4))
+        self.conv3 = conv3x3(int(out_planes / 4), int(out_planes / 4),
+                             padding=1, dilation=1)
+
+        if in_planes != out_planes:
+            self.downsample = nn.Sequential(
+                nn.BatchNorm2d(in_planes),
+                nn.ReLU(True),
+                nn.Conv2d(in_planes, out_planes,
+                          kernel_size=1, stride=1, bias=False),
+            )
+        else:
+            self.downsample = None
+
+    def forward(self, x):
+        residual = x
+
+        out1 = self.bn1(x)
+        out1 = F.relu(out1, True)
+        out1 = self.conv1(out1)
+
+        out2 = self.bn2(out1)
+        out2 = F.relu(out2, True)
+        out2 = self.conv2(out2)
+
+        out3 = self.bn3(out2)
+        out3 = F.relu(out3, True)
+        out3 = self.conv3(out3)
+
+        out3 = torch.cat((out1, out2, out3), 1)
+
+        if self.downsample is not None:
+            residual = self.downsample(residual)
+
+        out3 += residual
+
+        return out3
+
+class HourGlass(nn.Module):
+    def __init__(self, num_modules, depth, num_features, first_one=False):
+        super(HourGlass, self).__init__()
+        self.num_modules = num_modules
+        self.depth = depth
+        self.features = num_features
+        self.coordconv = CoordConvTh(x_dim=64, y_dim=64,
+                                     with_r=True, with_boundary=True,
+                                     in_channels=256, first_one=first_one,
+                                     out_channels=256,
+                                     kernel_size=1,
+                                     stride=1, padding=0)
+        self._generate_network(self.depth)
+
+    def _generate_network(self, level):
+        self.add_module('b1_' + str(level), ConvBlock(256, 256))
+
+        self.add_module('b2_' + str(level), ConvBlock(256, 256))
+
+        if level > 1:
+            self._generate_network(level - 1)
+        else:
+            self.add_module('b2_plus_' + str(level), ConvBlock(256, 256))
+
+        self.add_module('b3_' + str(level), ConvBlock(256, 256))
+
+    def _forward(self, level, inp):
+        # Upper branch
+        up1 = inp
+        up1 = self._modules['b1_' + str(level)](up1)
+
+        # Lower branch
+        low1 = F.avg_pool2d(inp, 2, stride=2)
+        low1 = self._modules['b2_' + str(level)](low1)
+
+        if level > 1:
+            low2 = self._forward(level - 1, low1)
+        else:
+            low2 = low1
+            low2 = self._modules['b2_plus_' + str(level)](low2)
+
+        low3 = low2
+        low3 = self._modules['b3_' + str(level)](low3)
+
+        up2 = F.upsample(low3, scale_factor=2, mode='nearest')
+
+        return up1 + up2
+
+    def forward(self, x, heatmap):
+        x, last_channel = self.coordconv(x, heatmap)
+        return self._forward(self.depth, x), last_channel
+
+class FAN(nn.Module):
+
+    def __init__(self, num_modules=1, end_relu=False, gray_scale=False,
+                 num_landmarks=68):
+        super(FAN, self).__init__()
+        self.num_modules = num_modules
+        self.gray_scale = gray_scale
+        self.end_relu = end_relu
+        self.num_landmarks = num_landmarks
+
+        # Base part
+        if self.gray_scale:
+            self.conv1 = CoordConvTh(x_dim=256, y_dim=256,
+                                     with_r=True, with_boundary=False,
+                                     in_channels=3, out_channels=64,
+                                     kernel_size=7,
+                                     stride=2, padding=3)
+        else:
+            self.conv1 = CoordConvTh(x_dim=256, y_dim=256,
+                                     with_r=True, with_boundary=False,
+                                     in_channels=3, out_channels=64,
+                                     kernel_size=7,
+                                     stride=2, padding=3)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.conv2 = ConvBlock(64, 128)
+        self.conv3 = ConvBlock(128, 128)
+        self.conv4 = ConvBlock(128, 256)
+
+        # Stacking part
+        for hg_module in range(self.num_modules):
+            if hg_module == 0:
+                first_one = True
+            else:
+                first_one = False
+            self.add_module('m' + str(hg_module), HourGlass(1, 4, 256,
+                                                            first_one))
+            self.add_module('top_m_' + str(hg_module), ConvBlock(256, 256))
+            self.add_module('conv_last' + str(hg_module),
+                            nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0))
+            self.add_module('bn_end' + str(hg_module), nn.BatchNorm2d(256))
+            self.add_module('l' + str(hg_module), nn.Conv2d(256,
+                                                            num_landmarks+1, kernel_size=1, stride=1, padding=0))
+
+            if hg_module < self.num_modules - 1:
+                self.add_module(
+                    'bl' + str(hg_module), nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0))
+                self.add_module('al' + str(hg_module), nn.Conv2d(num_landmarks+1,
+                                                                 256, kernel_size=1, stride=1, padding=0))
+
+    def forward(self, x):
+        x, _ = self.conv1(x)
+        x = F.relu(self.bn1(x), True)
+        # x = F.relu(self.bn1(self.conv1(x)), True)
+        x = F.avg_pool2d(self.conv2(x), 2, stride=2)
+        x = self.conv3(x)
+        x = self.conv4(x)
+
+        previous = x
+
+        outputs = []
+        boundary_channels = []
+        tmp_out = None
+        for i in range(self.num_modules):
+            hg, boundary_channel = self._modules['m' + str(i)](previous,
+                                                               tmp_out)
+
+            ll = hg
+            ll = self._modules['top_m_' + str(i)](ll)
+
+            ll = F.relu(self._modules['bn_end' + str(i)]
+                        (self._modules['conv_last' + str(i)](ll)), True)
+
+            # Predict heatmaps
+            tmp_out = self._modules['l' + str(i)](ll)
+            if self.end_relu:
+                tmp_out = F.relu(tmp_out) # HACK: Added relu
+            outputs.append(tmp_out)
+            boundary_channels.append(boundary_channel)
+
+            if i < self.num_modules - 1:
+                ll = self._modules['bl' + str(i)](ll)
+                tmp_out_ = self._modules['al' + str(i)](tmp_out)
+                previous = previous + ll + tmp_out_
+
+        return outputs, boundary_channels

MakeItTalk/thirdparty/AdaptiveWingLoss/eval.py

@@ -1,77 +1,77 @@
-from __future__ import print_function, division
-import torch
-import argparse
-import numpy as np
-import torch.nn as nn
-import time
-import os
-from core.evaler import eval_model
-from core.dataloader import get_dataset
-from core import models
-from tensorboardX import SummaryWriter
-
-# Parse arguments
-parser = argparse.ArgumentParser()
-# Dataset paths
-parser.add_argument('--val_img_dir', type=str,
-                    help='Validation image directory')
-parser.add_argument('--val_landmarks_dir', type=str,
-                    help='Validation landmarks directory')
-parser.add_argument('--num_landmarks', type=int, default=68,
-                    help='Number of landmarks')
-
-# Checkpoint and pretrained weights
-parser.add_argument('--ckpt_save_path', type=str,
-                    help='a directory to save checkpoint file')
-parser.add_argument('--pretrained_weights', type=str,
-                    help='a directory to save pretrained_weights')
-
-# Eval options
-parser.add_argument('--batch_size', type=int, default=25,
-                    help='learning rate decay after each epoch')
-
-# Network parameters
-parser.add_argument('--hg_blocks', type=int, default=4,
-                    help='Number of HG blocks to stack')
-parser.add_argument('--gray_scale', type=str, default="False",
-                    help='Whether to convert RGB image into gray scale during training')
-parser.add_argument('--end_relu', type=str, default="False",
-                    help='Whether to add relu at the end of each HG module')
-
-args = parser.parse_args()
-
-VAL_IMG_DIR = args.val_img_dir
-VAL_LANDMARKS_DIR = args.val_landmarks_dir
-CKPT_SAVE_PATH = args.ckpt_save_path
-BATCH_SIZE = args.batch_size
-PRETRAINED_WEIGHTS = args.pretrained_weights
-GRAY_SCALE = False if args.gray_scale == 'False' else True
-HG_BLOCKS = args.hg_blocks
-END_RELU = False if args.end_relu == 'False' else True
-NUM_LANDMARKS = args.num_landmarks
-
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-writer = SummaryWriter(CKPT_SAVE_PATH)
-
-dataloaders, dataset_sizes = get_dataset(VAL_IMG_DIR, VAL_LANDMARKS_DIR,
-                                         BATCH_SIZE, NUM_LANDMARKS)
-use_gpu = torch.cuda.is_available()
-model_ft = models.FAN(HG_BLOCKS, END_RELU, GRAY_SCALE, NUM_LANDMARKS)
-
-if PRETRAINED_WEIGHTS != "None":
-    checkpoint = torch.load(PRETRAINED_WEIGHTS)
-    if 'state_dict' not in checkpoint:
-        model_ft.load_state_dict(checkpoint)
-    else:
-        pretrained_weights = checkpoint['state_dict']
-        model_weights = model_ft.state_dict()
-        pretrained_weights = {k: v for k, v in pretrained_weights.items() \
-                              if k in model_weights}
-        model_weights.update(pretrained_weights)
-        model_ft.load_state_dict(model_weights)
-
-model_ft = model_ft.to(device)
-
-model_ft = eval_model(model_ft, dataloaders, dataset_sizes, writer, use_gpu, 1, 'val', CKPT_SAVE_PATH, NUM_LANDMARKS)
-
+from __future__ import print_function, division
+import torch
+import argparse
+import numpy as np
+import torch.nn as nn
+import time
+import os
+from core.evaler import eval_model
+from core.dataloader import get_dataset
+from core import models
+from tensorboardX import SummaryWriter
+
+# Parse arguments
+parser = argparse.ArgumentParser()
+# Dataset paths
+parser.add_argument('--val_img_dir', type=str,
+                    help='Validation image directory')
+parser.add_argument('--val_landmarks_dir', type=str,
+                    help='Validation landmarks directory')
+parser.add_argument('--num_landmarks', type=int, default=68,
+                    help='Number of landmarks')
+
+# Checkpoint and pretrained weights
+parser.add_argument('--ckpt_save_path', type=str,
+                    help='a directory to save checkpoint file')
+parser.add_argument('--pretrained_weights', type=str,
+                    help='a directory to save pretrained_weights')
+
+# Eval options
+parser.add_argument('--batch_size', type=int, default=25,
+                    help='learning rate decay after each epoch')
+
+# Network parameters
+parser.add_argument('--hg_blocks', type=int, default=4,
+                    help='Number of HG blocks to stack')
+parser.add_argument('--gray_scale', type=str, default="False",
+                    help='Whether to convert RGB image into gray scale during training')
+parser.add_argument('--end_relu', type=str, default="False",
+                    help='Whether to add relu at the end of each HG module')
+
+args = parser.parse_args()
+
+VAL_IMG_DIR = args.val_img_dir
+VAL_LANDMARKS_DIR = args.val_landmarks_dir
+CKPT_SAVE_PATH = args.ckpt_save_path
+BATCH_SIZE = args.batch_size
+PRETRAINED_WEIGHTS = args.pretrained_weights
+GRAY_SCALE = False if args.gray_scale == 'False' else True
+HG_BLOCKS = args.hg_blocks
+END_RELU = False if args.end_relu == 'False' else True
+NUM_LANDMARKS = args.num_landmarks
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+writer = SummaryWriter(CKPT_SAVE_PATH)
+
+dataloaders, dataset_sizes = get_dataset(VAL_IMG_DIR, VAL_LANDMARKS_DIR,
+                                         BATCH_SIZE, NUM_LANDMARKS)
+use_gpu = torch.cuda.is_available()
+model_ft = models.FAN(HG_BLOCKS, END_RELU, GRAY_SCALE, NUM_LANDMARKS)
+
+if PRETRAINED_WEIGHTS != "None":
+    checkpoint = torch.load(PRETRAINED_WEIGHTS)
+    if 'state_dict' not in checkpoint:
+        model_ft.load_state_dict(checkpoint)
+    else:
+        pretrained_weights = checkpoint['state_dict']
+        model_weights = model_ft.state_dict()
+        pretrained_weights = {k: v for k, v in pretrained_weights.items() \
+                              if k in model_weights}
+        model_weights.update(pretrained_weights)
+        model_ft.load_state_dict(model_weights)
+
+model_ft = model_ft.to(device)
+
+model_ft = eval_model(model_ft, dataloaders, dataset_sizes, writer, use_gpu, 1, 'val', CKPT_SAVE_PATH, NUM_LANDMARKS)
+

MakeItTalk/thirdparty/AdaptiveWingLoss/requirements.txt

@@ -1,12 +1,12 @@
-opencv-python
-scipy>=0.17.0
-scikit-image
-numpy
-matplotlib
-Pillow>=4.3.0
-imgaug
-tensorflow
-git+https://github.com/lanpa/tensorboardX
-joblib
-torch==1.3.0
-torchvision==0.4.1
+opencv-python
+scipy>=0.17.0
+scikit-image
+numpy
+matplotlib
+Pillow>=4.3.0
+imgaug
+tensorflow
+git+https://github.com/lanpa/tensorboardX
+joblib
+torch==1.3.0
+torchvision==0.4.1

MakeItTalk/thirdparty/AdaptiveWingLoss/scripts/eval_wflw.sh

@@ -1,10 +1,10 @@
-CUDA_VISIBLE_DEVICES=1 python ../eval.py \
-                    --val_img_dir='../dataset/WFLW_test/images/' \
-                    --val_landmarks_dir='../dataset/WFLW_test/landmarks/' \
-                    --ckpt_save_path='../experiments/eval_iccv_0620' \
-                    --hg_blocks=4 \
-                    --pretrained_weights='../ckpt/WFLW_4HG.pth' \
-                    --num_landmarks=98 \
-                    --end_relu='False' \
-                    --batch_size=20 \
-
+CUDA_VISIBLE_DEVICES=1 python ../eval.py \
+                    --val_img_dir='../dataset/WFLW_test/images/' \
+                    --val_landmarks_dir='../dataset/WFLW_test/landmarks/' \
+                    --ckpt_save_path='../experiments/eval_iccv_0620' \
+                    --hg_blocks=4 \
+                    --pretrained_weights='../ckpt/WFLW_4HG.pth' \
+                    --num_landmarks=98 \
+                    --end_relu='False' \
+                    --batch_size=20 \
+

MakeItTalk/thirdparty/AdaptiveWingLoss/utils/utils.py

@@ -1,354 +1,354 @@
-from __future__ import print_function, division
-import os
-import sys
-import math
-import torch
-import cv2
-from PIL import Image
-from skimage import io
-from skimage import transform as ski_transform
-from scipy import ndimage
-import numpy as np
-import matplotlib
-import matplotlib.pyplot as plt
-from torch.utils.data import Dataset, DataLoader
-from torchvision import transforms, utils
-
-def _gaussian(
-        size=3, sigma=0.25, amplitude=1, normalize=False, width=None,
-        height=None, sigma_horz=None, sigma_vert=None, mean_horz=0.5,
-        mean_vert=0.5):
-    # handle some defaults
-    if width is None:
-        width = size
-    if height is None:
-        height = size
-    if sigma_horz is None:
-        sigma_horz = sigma
-    if sigma_vert is None:
-        sigma_vert = sigma
-    center_x = mean_horz * width + 0.5
-    center_y = mean_vert * height + 0.5
-    gauss = np.empty((height, width), dtype=np.float32)
-    # generate kernel
-    for i in range(height):
-        for j in range(width):
-            gauss[i][j] = amplitude * math.exp(-(math.pow((j + 1 - center_x) / (
-                sigma_horz * width), 2) / 2.0 + math.pow((i + 1 - center_y) / (sigma_vert * height), 2) / 2.0))
-    if normalize:
-        gauss = gauss / np.sum(gauss)
-    return gauss
-
-def draw_gaussian(image, point, sigma):
-    # Check if the gaussian is inside
-    ul = [np.floor(np.floor(point[0]) - 3 * sigma),
-          np.floor(np.floor(point[1]) - 3 * sigma)]
-    br = [np.floor(np.floor(point[0]) + 3 * sigma),
-          np.floor(np.floor(point[1]) + 3 * sigma)]
-    if (ul[0] > image.shape[1] or ul[1] >
-            image.shape[0] or br[0] < 1 or br[1] < 1):
-        return image
-    size = 6 * sigma + 1
-    g = _gaussian(size)
-    g_x = [int(max(1, -ul[0])), int(min(br[0], image.shape[1])) -
-           int(max(1, ul[0])) + int(max(1, -ul[0]))]
-    g_y = [int(max(1, -ul[1])), int(min(br[1], image.shape[0])) -
-           int(max(1, ul[1])) + int(max(1, -ul[1]))]
-    img_x = [int(max(1, ul[0])), int(min(br[0], image.shape[1]))]
-    img_y = [int(max(1, ul[1])), int(min(br[1], image.shape[0]))]
-    assert (g_x[0] > 0 and g_y[1] > 0)
-    correct = False
-    while not correct:
-        try:
-            image[img_y[0] - 1:img_y[1], img_x[0] - 1:img_x[1]
-            ] = image[img_y[0] - 1:img_y[1], img_x[0] - 1:img_x[1]] + g[g_y[0] - 1:g_y[1], g_x[0] - 1:g_x[1]]
-            correct = True
-        except:
-            print('img_x: {}, img_y: {}, g_x:{}, g_y:{}, point:{}, g_shape:{}, ul:{}, br:{}'.format(img_x, img_y, g_x, g_y, point, g.shape, ul, br))
-            ul = [np.floor(np.floor(point[0]) - 3 * sigma),
-                np.floor(np.floor(point[1]) - 3 * sigma)]
-            br = [np.floor(np.floor(point[0]) + 3 * sigma),
-                np.floor(np.floor(point[1]) + 3 * sigma)]
-            g_x = [int(max(1, -ul[0])), int(min(br[0], image.shape[1])) -
-                int(max(1, ul[0])) + int(max(1, -ul[0]))]
-            g_y = [int(max(1, -ul[1])), int(min(br[1], image.shape[0])) -
-                int(max(1, ul[1])) + int(max(1, -ul[1]))]
-            img_x = [int(max(1, ul[0])), int(min(br[0], image.shape[1]))]
-            img_y = [int(max(1, ul[1])), int(min(br[1], image.shape[0]))]
-            pass
-    image[image > 1] = 1
-    return image
-
-def transform(point, center, scale, resolution, rotation=0, invert=False):
-    _pt = np.ones(3)
-    _pt[0] = point[0]
-    _pt[1] = point[1]
-
-    h = 200.0 * scale
-    t = np.eye(3)
-    t[0, 0] = resolution / h
-    t[1, 1] = resolution / h
-    t[0, 2] = resolution * (-center[0] / h + 0.5)
-    t[1, 2] = resolution * (-center[1] / h + 0.5)
-
-    if rotation != 0:
-        rotation = -rotation
-        r = np.eye(3)
-        ang = rotation * math.pi / 180.0
-        s = math.sin(ang)
-        c = math.cos(ang)
-        r[0][0] = c
-        r[0][1] = -s
-        r[1][0] = s
-        r[1][1] = c
-
-        t_ = np.eye(3)
-        t_[0][2] = -resolution / 2.0
-        t_[1][2] = -resolution / 2.0
-        t_inv = torch.eye(3)
-        t_inv[0][2] = resolution / 2.0
-        t_inv[1][2] = resolution / 2.0
-        t = reduce(np.matmul, [t_inv, r, t_, t])
-
-    if invert:
-        t = np.linalg.inv(t)
-    new_point = (np.matmul(t, _pt))[0:2]
-
-    return new_point.astype(int)
-
-def cv_crop(image, landmarks, center, scale, resolution=256, center_shift=0):
-    new_image = cv2.copyMakeBorder(image, center_shift,
-                                   center_shift,
-                                   center_shift,
-                                   center_shift,
-                                   cv2.BORDER_CONSTANT, value=[0,0,0])
-    new_landmarks = landmarks.copy()
-    if center_shift != 0:
-        center[0] += center_shift
-        center[1] += center_shift
-        new_landmarks = new_landmarks + center_shift
-    length = 200 * scale
-    top = int(center[1] - length // 2)
-    bottom = int(center[1] + length // 2)
-    left = int(center[0] - length // 2)
-    right = int(center[0] + length // 2)
-    y_pad = abs(min(top, new_image.shape[0] - bottom, 0))
-    x_pad = abs(min(left, new_image.shape[1] - right, 0))
-    top, bottom, left, right = top + y_pad, bottom + y_pad, left + x_pad, right + x_pad
-    new_image = cv2.copyMakeBorder(new_image, y_pad,
-                                   y_pad,
-                                   x_pad,
-                                   x_pad,
-                                   cv2.BORDER_CONSTANT, value=[0,0,0])
-    new_image = new_image[top:bottom, left:right]
-    new_image = cv2.resize(new_image, dsize=(int(resolution), int(resolution)),
-                           interpolation=cv2.INTER_LINEAR)
-    new_landmarks[:, 0] = (new_landmarks[:, 0] + x_pad - left) * resolution / length
-    new_landmarks[:, 1] = (new_landmarks[:, 1] + y_pad - top) * resolution / length
-    return new_image, new_landmarks
-
-def cv_rotate(image, landmarks, heatmap, rot, scale, resolution=256):
-    img_mat = cv2.getRotationMatrix2D((resolution//2, resolution//2), rot, scale)
-    ones = np.ones(shape=(landmarks.shape[0], 1))
-    stacked_landmarks = np.hstack([landmarks, ones])
-    new_landmarks = img_mat.dot(stacked_landmarks.T).T
-    if np.max(new_landmarks) > 255 or np.min(new_landmarks) < 0:
-        return image, landmarks, heatmap
-    else:
-        new_image = cv2.warpAffine(image, img_mat, (resolution, resolution))
-        if heatmap is not None:
-            new_heatmap = np.zeros((heatmap.shape[0], 64, 64))
-            for i in range(heatmap.shape[0]):
-                if new_landmarks[i][0] > 0:
-                    new_heatmap[i] = draw_gaussian(new_heatmap[i],
-                                                   new_landmarks[i]/4.0+1, 1)
-        return new_image, new_landmarks, new_heatmap
-
-def show_landmarks(image, heatmap, gt_landmarks, gt_heatmap):
-    """Show image with pred_landmarks"""
-    pred_landmarks = []
-    pred_landmarks, _ = get_preds_fromhm(torch.from_numpy(heatmap).unsqueeze(0))
-    pred_landmarks = pred_landmarks.squeeze()*4
-
-    # pred_landmarks2 = get_preds_fromhm2(heatmap)
-    heatmap = np.max(gt_heatmap, axis=0)
-    heatmap = heatmap / np.max(heatmap)
-    # image = ski_transform.resize(image, (64, 64))*255
-    image = image.astype(np.uint8)
-    heatmap = np.max(gt_heatmap, axis=0)
-    heatmap = ski_transform.resize(heatmap, (image.shape[0], image.shape[1]))
-    heatmap *= 255
-    heatmap = heatmap.astype(np.uint8)
-    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
-    plt.imshow(image)
-    plt.scatter(gt_landmarks[:, 0], gt_landmarks[:, 1], s=0.5, marker='.', c='g')
-    plt.scatter(pred_landmarks[:, 0], pred_landmarks[:, 1], s=0.5, marker='.', c='r')
-    plt.pause(0.001)  # pause a bit so that plots are updated
-
-def fan_NME(pred_heatmaps, gt_landmarks, num_landmarks=68):
-    '''
-       Calculate total NME for a batch of data
-
-       Args:
-           pred_heatmaps: torch tensor of size [batch, points, height, width]
-           gt_landmarks: torch tesnsor of size [batch, points, x, y]
-
-       Returns:
-           nme: sum of nme for this batch
-    '''
-    nme = 0
-    pred_landmarks, _ = get_preds_fromhm(pred_heatmaps)
-    pred_landmarks = pred_landmarks.numpy()
-    gt_landmarks = gt_landmarks.numpy()
-    for i in range(pred_landmarks.shape[0]):
-        pred_landmark = pred_landmarks[i] * 4.0
-        gt_landmark = gt_landmarks[i]
-
-        if num_landmarks == 68:
-            left_eye = np.average(gt_landmark[36:42], axis=0)
-            right_eye = np.average(gt_landmark[42:48], axis=0)
-            norm_factor = np.linalg.norm(left_eye - right_eye)
-            # norm_factor = np.linalg.norm(gt_landmark[36]- gt_landmark[45])
-        elif num_landmarks == 98:
-            norm_factor = np.linalg.norm(gt_landmark[60]- gt_landmark[72])
-        elif num_landmarks == 19:
-            left, top = gt_landmark[-2, :]
-            right, bottom = gt_landmark[-1, :]
-            norm_factor = math.sqrt(abs(right - left)*abs(top-bottom))
-            gt_landmark = gt_landmark[:-2, :]
-        elif num_landmarks == 29:
-            # norm_factor = np.linalg.norm(gt_landmark[8]- gt_landmark[9])
-            norm_factor = np.linalg.norm(gt_landmark[16]- gt_landmark[17])
-        nme += (np.sum(np.linalg.norm(pred_landmark - gt_landmark, axis=1)) / pred_landmark.shape[0]) / norm_factor
-    return nme
-
-def fan_NME_hm(pred_heatmaps, gt_heatmaps, num_landmarks=68):
-    '''
-       Calculate total NME for a batch of data
-
-       Args:
-           pred_heatmaps: torch tensor of size [batch, points, height, width]
-           gt_landmarks: torch tesnsor of size [batch, points, x, y]
-
-       Returns:
-           nme: sum of nme for this batch
-    '''
-    nme = 0
-    pred_landmarks, _ = get_index_fromhm(pred_heatmaps)
-    pred_landmarks = pred_landmarks.numpy()
-    gt_landmarks = gt_landmarks.numpy()
-    for i in range(pred_landmarks.shape[0]):
-        pred_landmark = pred_landmarks[i] * 4.0
-        gt_landmark = gt_landmarks[i]
-        if num_landmarks == 68:
-            left_eye = np.average(gt_landmark[36:42], axis=0)
-            right_eye = np.average(gt_landmark[42:48], axis=0)
-            norm_factor = np.linalg.norm(left_eye - right_eye)
-        else:
-            norm_factor = np.linalg.norm(gt_landmark[60]- gt_landmark[72])
-        nme += (np.sum(np.linalg.norm(pred_landmark - gt_landmark, axis=1)) / pred_landmark.shape[0]) / norm_factor
-    return nme
-
-def power_transform(img, power):
-    img = np.array(img)
-    img_new = np.power((img/255.0), power) * 255.0
-    img_new = img_new.astype(np.uint8)
-    img_new = Image.fromarray(img_new)
-    return img_new
-
-def get_preds_fromhm(hm, center=None, scale=None, rot=None):
-    max, idx = torch.max(
-        hm.view(hm.size(0), hm.size(1), hm.size(2) * hm.size(3)), 2)
-    idx += 1
-    preds = idx.view(idx.size(0), idx.size(1), 1).repeat(1, 1, 2).float()
-    preds[..., 0].apply_(lambda x: (x - 1) % hm.size(3) + 1)
-    preds[..., 1].add_(-1).div_(hm.size(2)).floor_().add_(1)
-
-    for i in range(preds.size(0)):
-        for j in range(preds.size(1)):
-            hm_ = hm[i, j, :]
-            pX, pY = int(preds[i, j, 0]) - 1, int(preds[i, j, 1]) - 1
-            if pX > 0 and pX < 63 and pY > 0 and pY < 63:
-                diff = torch.FloatTensor(
-                    [hm_[pY, pX + 1] - hm_[pY, pX - 1],
-                     hm_[pY + 1, pX] - hm_[pY - 1, pX]])
-                preds[i, j].add_(diff.sign_().mul_(.25))
-
-    preds.add_(-0.5)
-
-    preds_orig = torch.zeros(preds.size())
-    if center is not None and scale is not None:
-        for i in range(hm.size(0)):
-            for j in range(hm.size(1)):
-                preds_orig[i, j] = transform(
-                    preds[i, j], center, scale, hm.size(2), rot, True)
-
-    return preds, preds_orig
-
-def get_index_fromhm(hm):
-    max, idx = torch.max(
-        hm.view(hm.size(0), hm.size(1), hm.size(2) * hm.size(3)), 2)
-    preds = idx.view(idx.size(0), idx.size(1), 1).repeat(1, 1, 2).float()
-    preds[..., 0].remainder_(hm.size(3))
-    preds[..., 1].div_(hm.size(2)).floor_()
-
-    for i in range(preds.size(0)):
-        for j in range(preds.size(1)):
-            hm_ = hm[i, j, :]
-            pX, pY = int(preds[i, j, 0]), int(preds[i, j, 1])
-            if pX > 0 and pX < 63 and pY > 0 and pY < 63:
-                diff = torch.FloatTensor(
-                    [hm_[pY, pX + 1] - hm_[pY, pX - 1],
-                     hm_[pY + 1, pX] - hm_[pY - 1, pX]])
-                preds[i, j].add_(diff.sign_().mul_(.25))
-
-    return preds
-
-def shuffle_lr(parts, num_landmarks=68, pairs=None):
-    if num_landmarks == 68:
-        if pairs is None:
-            pairs = [[0, 16], [1, 15], [2, 14], [3, 13], [4, 12], [5, 11], [6, 10],
-                    [7, 9], [17, 26], [18, 25], [19, 24], [20, 23], [21, 22], [36, 45],
-                    [37, 44], [38, 43], [39, 42], [41, 46], [40, 47], [31, 35], [32, 34],
-                    [50, 52], [49, 53], [48, 54], [61, 63], [60, 64], [67, 65], [59, 55], [58, 56]]
-    elif num_landmarks == 98:
-        if pairs is None:
-            pairs = [[0, 32], [1,31], [2, 30], [3, 29], [4, 28], [5, 27], [6, 26], [7, 25], [8, 24], [9, 23], [10, 22], [11, 21], [12, 20], [13, 19], [14, 18], [15, 17], [33, 46], [34, 45], [35, 44], [36, 43], [37, 42], [38, 50], [39, 49], [40, 48], [41, 47], [60, 72], [61, 71], [62, 70], [63, 69], [64, 68], [65, 75], [66, 74], [67, 73], [96, 97], [55, 59], [56, 58], [76, 82], [77, 81], [78, 80], [88, 92], [89, 91], [95, 93], [87, 83], [86, 84]]
-    elif num_landmarks == 19:
-        if pairs is None:
-            pairs = [[0, 5], [1, 4], [2, 3], [6, 11], [7, 10], [8, 9], [12, 14], [15, 17]]
-    elif num_landmarks == 29:
-        if pairs is None:
-            pairs = [[0, 1], [4, 6], [5, 7], [2, 3], [8, 9], [12, 14], [16, 17], [13, 15], [10, 11], [18, 19], [22, 23]]
-    for matched_p in pairs:
-        idx1, idx2 = matched_p[0], matched_p[1]
-        tmp = np.copy(parts[idx1])
-        np.copyto(parts[idx1], parts[idx2])
-        np.copyto(parts[idx2], tmp)
-    return parts
-
-
-def generate_weight_map(weight_map,heatmap):
-
-    k_size = 3
-    dilate = ndimage.grey_dilation(heatmap ,size=(k_size,k_size))
-    weight_map[np.where(dilate>0.2)] = 1
-    return weight_map
-
-def fig2data(fig):
-    """
-    @brief Convert a Matplotlib figure to a 4D numpy array with RGBA channels and return it
-    @param fig a matplotlib figure
-    @return a numpy 3D array of RGBA values
-    """
-    # draw the renderer
-    fig.canvas.draw ( )
-
-    # Get the RGB buffer from the figure
-    w,h = fig.canvas.get_width_height()
-    buf = np.fromstring (fig.canvas.tostring_rgb(), dtype=np.uint8)
-    buf.shape = (w, h, 3)
-
-    # canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode
-    buf = np.roll (buf, 3, axis=2)
-    return buf
+from __future__ import print_function, division
+import os
+import sys
+import math
+import torch
+import cv2
+from PIL import Image
+from skimage import io
+from skimage import transform as ski_transform
+from scipy import ndimage
+import numpy as np
+import matplotlib
+import matplotlib.pyplot as plt
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms, utils
+
+def _gaussian(
+        size=3, sigma=0.25, amplitude=1, normalize=False, width=None,
+        height=None, sigma_horz=None, sigma_vert=None, mean_horz=0.5,
+        mean_vert=0.5):
+    # handle some defaults
+    if width is None:
+        width = size
+    if height is None:
+        height = size
+    if sigma_horz is None:
+        sigma_horz = sigma
+    if sigma_vert is None:
+        sigma_vert = sigma
+    center_x = mean_horz * width + 0.5
+    center_y = mean_vert * height + 0.5
+    gauss = np.empty((height, width), dtype=np.float32)
+    # generate kernel
+    for i in range(height):
+        for j in range(width):
+            gauss[i][j] = amplitude * math.exp(-(math.pow((j + 1 - center_x) / (
+                sigma_horz * width), 2) / 2.0 + math.pow((i + 1 - center_y) / (sigma_vert * height), 2) / 2.0))
+    if normalize:
+        gauss = gauss / np.sum(gauss)
+    return gauss
+
+def draw_gaussian(image, point, sigma):
+    # Check if the gaussian is inside
+    ul = [np.floor(np.floor(point[0]) - 3 * sigma),
+          np.floor(np.floor(point[1]) - 3 * sigma)]
+    br = [np.floor(np.floor(point[0]) + 3 * sigma),
+          np.floor(np.floor(point[1]) + 3 * sigma)]
+    if (ul[0] > image.shape[1] or ul[1] >
+            image.shape[0] or br[0] < 1 or br[1] < 1):
+        return image
+    size = 6 * sigma + 1
+    g = _gaussian(size)
+    g_x = [int(max(1, -ul[0])), int(min(br[0], image.shape[1])) -
+           int(max(1, ul[0])) + int(max(1, -ul[0]))]
+    g_y = [int(max(1, -ul[1])), int(min(br[1], image.shape[0])) -
+           int(max(1, ul[1])) + int(max(1, -ul[1]))]
+    img_x = [int(max(1, ul[0])), int(min(br[0], image.shape[1]))]
+    img_y = [int(max(1, ul[1])), int(min(br[1], image.shape[0]))]
+    assert (g_x[0] > 0 and g_y[1] > 0)
+    correct = False
+    while not correct:
+        try:
+            image[img_y[0] - 1:img_y[1], img_x[0] - 1:img_x[1]
+            ] = image[img_y[0] - 1:img_y[1], img_x[0] - 1:img_x[1]] + g[g_y[0] - 1:g_y[1], g_x[0] - 1:g_x[1]]
+            correct = True
+        except:
+            print('img_x: {}, img_y: {}, g_x:{}, g_y:{}, point:{}, g_shape:{}, ul:{}, br:{}'.format(img_x, img_y, g_x, g_y, point, g.shape, ul, br))
+            ul = [np.floor(np.floor(point[0]) - 3 * sigma),
+                np.floor(np.floor(point[1]) - 3 * sigma)]
+            br = [np.floor(np.floor(point[0]) + 3 * sigma),
+                np.floor(np.floor(point[1]) + 3 * sigma)]
+            g_x = [int(max(1, -ul[0])), int(min(br[0], image.shape[1])) -
+                int(max(1, ul[0])) + int(max(1, -ul[0]))]
+            g_y = [int(max(1, -ul[1])), int(min(br[1], image.shape[0])) -
+                int(max(1, ul[1])) + int(max(1, -ul[1]))]
+            img_x = [int(max(1, ul[0])), int(min(br[0], image.shape[1]))]
+            img_y = [int(max(1, ul[1])), int(min(br[1], image.shape[0]))]
+            pass
+    image[image > 1] = 1
+    return image
+
+def transform(point, center, scale, resolution, rotation=0, invert=False):
+    _pt = np.ones(3)
+    _pt[0] = point[0]
+    _pt[1] = point[1]
+
+    h = 200.0 * scale
+    t = np.eye(3)
+    t[0, 0] = resolution / h
+    t[1, 1] = resolution / h
+    t[0, 2] = resolution * (-center[0] / h + 0.5)
+    t[1, 2] = resolution * (-center[1] / h + 0.5)
+
+    if rotation != 0:
+        rotation = -rotation
+        r = np.eye(3)
+        ang = rotation * math.pi / 180.0
+        s = math.sin(ang)
+        c = math.cos(ang)
+        r[0][0] = c
+        r[0][1] = -s
+        r[1][0] = s
+        r[1][1] = c
+
+        t_ = np.eye(3)
+        t_[0][2] = -resolution / 2.0
+        t_[1][2] = -resolution / 2.0
+        t_inv = torch.eye(3)
+        t_inv[0][2] = resolution / 2.0
+        t_inv[1][2] = resolution / 2.0
+        t = reduce(np.matmul, [t_inv, r, t_, t])
+
+    if invert:
+        t = np.linalg.inv(t)
+    new_point = (np.matmul(t, _pt))[0:2]
+
+    return new_point.astype(int)
+
+def cv_crop(image, landmarks, center, scale, resolution=256, center_shift=0):
+    new_image = cv2.copyMakeBorder(image, center_shift,
+                                   center_shift,
+                                   center_shift,
+                                   center_shift,
+                                   cv2.BORDER_CONSTANT, value=[0,0,0])
+    new_landmarks = landmarks.copy()
+    if center_shift != 0:
+        center[0] += center_shift
+        center[1] += center_shift
+        new_landmarks = new_landmarks + center_shift
+    length = 200 * scale
+    top = int(center[1] - length // 2)
+    bottom = int(center[1] + length // 2)
+    left = int(center[0] - length // 2)
+    right = int(center[0] + length // 2)
+    y_pad = abs(min(top, new_image.shape[0] - bottom, 0))
+    x_pad = abs(min(left, new_image.shape[1] - right, 0))
+    top, bottom, left, right = top + y_pad, bottom + y_pad, left + x_pad, right + x_pad
+    new_image = cv2.copyMakeBorder(new_image, y_pad,
+                                   y_pad,
+                                   x_pad,
+                                   x_pad,
+                                   cv2.BORDER_CONSTANT, value=[0,0,0])
+    new_image = new_image[top:bottom, left:right]
+    new_image = cv2.resize(new_image, dsize=(int(resolution), int(resolution)),
+                           interpolation=cv2.INTER_LINEAR)
+    new_landmarks[:, 0] = (new_landmarks[:, 0] + x_pad - left) * resolution / length
+    new_landmarks[:, 1] = (new_landmarks[:, 1] + y_pad - top) * resolution / length
+    return new_image, new_landmarks
+
+def cv_rotate(image, landmarks, heatmap, rot, scale, resolution=256):
+    img_mat = cv2.getRotationMatrix2D((resolution//2, resolution//2), rot, scale)
+    ones = np.ones(shape=(landmarks.shape[0], 1))
+    stacked_landmarks = np.hstack([landmarks, ones])
+    new_landmarks = img_mat.dot(stacked_landmarks.T).T
+    if np.max(new_landmarks) > 255 or np.min(new_landmarks) < 0:
+        return image, landmarks, heatmap
+    else:
+        new_image = cv2.warpAffine(image, img_mat, (resolution, resolution))
+        if heatmap is not None:
+            new_heatmap = np.zeros((heatmap.shape[0], 64, 64))
+            for i in range(heatmap.shape[0]):
+                if new_landmarks[i][0] > 0:
+                    new_heatmap[i] = draw_gaussian(new_heatmap[i],
+                                                   new_landmarks[i]/4.0+1, 1)
+        return new_image, new_landmarks, new_heatmap
+
+def show_landmarks(image, heatmap, gt_landmarks, gt_heatmap):
+    """Show image with pred_landmarks"""
+    pred_landmarks = []
+    pred_landmarks, _ = get_preds_fromhm(torch.from_numpy(heatmap).unsqueeze(0))
+    pred_landmarks = pred_landmarks.squeeze()*4
+
+    # pred_landmarks2 = get_preds_fromhm2(heatmap)
+    heatmap = np.max(gt_heatmap, axis=0)
+    heatmap = heatmap / np.max(heatmap)
+    # image = ski_transform.resize(image, (64, 64))*255
+    image = image.astype(np.uint8)
+    heatmap = np.max(gt_heatmap, axis=0)
+    heatmap = ski_transform.resize(heatmap, (image.shape[0], image.shape[1]))
+    heatmap *= 255
+    heatmap = heatmap.astype(np.uint8)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+    plt.imshow(image)
+    plt.scatter(gt_landmarks[:, 0], gt_landmarks[:, 1], s=0.5, marker='.', c='g')
+    plt.scatter(pred_landmarks[:, 0], pred_landmarks[:, 1], s=0.5, marker='.', c='r')
+    plt.pause(0.001)  # pause a bit so that plots are updated
+
+def fan_NME(pred_heatmaps, gt_landmarks, num_landmarks=68):
+    '''
+       Calculate total NME for a batch of data
+
+       Args:
+           pred_heatmaps: torch tensor of size [batch, points, height, width]
+           gt_landmarks: torch tesnsor of size [batch, points, x, y]
+
+       Returns:
+           nme: sum of nme for this batch
+    '''
+    nme = 0
+    pred_landmarks, _ = get_preds_fromhm(pred_heatmaps)
+    pred_landmarks = pred_landmarks.numpy()
+    gt_landmarks = gt_landmarks.numpy()
+    for i in range(pred_landmarks.shape[0]):
+        pred_landmark = pred_landmarks[i] * 4.0
+        gt_landmark = gt_landmarks[i]
+
+        if num_landmarks == 68:
+            left_eye = np.average(gt_landmark[36:42], axis=0)
+            right_eye = np.average(gt_landmark[42:48], axis=0)
+            norm_factor = np.linalg.norm(left_eye - right_eye)
+            # norm_factor = np.linalg.norm(gt_landmark[36]- gt_landmark[45])
+        elif num_landmarks == 98:
+            norm_factor = np.linalg.norm(gt_landmark[60]- gt_landmark[72])
+        elif num_landmarks == 19:
+            left, top = gt_landmark[-2, :]
+            right, bottom = gt_landmark[-1, :]
+            norm_factor = math.sqrt(abs(right - left)*abs(top-bottom))
+            gt_landmark = gt_landmark[:-2, :]
+        elif num_landmarks == 29:
+            # norm_factor = np.linalg.norm(gt_landmark[8]- gt_landmark[9])
+            norm_factor = np.linalg.norm(gt_landmark[16]- gt_landmark[17])
+        nme += (np.sum(np.linalg.norm(pred_landmark - gt_landmark, axis=1)) / pred_landmark.shape[0]) / norm_factor
+    return nme
+
+def fan_NME_hm(pred_heatmaps, gt_heatmaps, num_landmarks=68):
+    '''
+       Calculate total NME for a batch of data
+
+       Args:
+           pred_heatmaps: torch tensor of size [batch, points, height, width]
+           gt_landmarks: torch tesnsor of size [batch, points, x, y]
+
+       Returns:
+           nme: sum of nme for this batch
+    '''
+    nme = 0
+    pred_landmarks, _ = get_index_fromhm(pred_heatmaps)
+    pred_landmarks = pred_landmarks.numpy()
+    gt_landmarks = gt_landmarks.numpy()
+    for i in range(pred_landmarks.shape[0]):
+        pred_landmark = pred_landmarks[i] * 4.0
+        gt_landmark = gt_landmarks[i]
+        if num_landmarks == 68:
+            left_eye = np.average(gt_landmark[36:42], axis=0)
+            right_eye = np.average(gt_landmark[42:48], axis=0)
+            norm_factor = np.linalg.norm(left_eye - right_eye)
+        else:
+            norm_factor = np.linalg.norm(gt_landmark[60]- gt_landmark[72])
+        nme += (np.sum(np.linalg.norm(pred_landmark - gt_landmark, axis=1)) / pred_landmark.shape[0]) / norm_factor
+    return nme
+
+def power_transform(img, power):
+    img = np.array(img)
+    img_new = np.power((img/255.0), power) * 255.0
+    img_new = img_new.astype(np.uint8)
+    img_new = Image.fromarray(img_new)
+    return img_new
+
+def get_preds_fromhm(hm, center=None, scale=None, rot=None):
+    max, idx = torch.max(
+        hm.view(hm.size(0), hm.size(1), hm.size(2) * hm.size(3)), 2)
+    idx += 1
+    preds = idx.view(idx.size(0), idx.size(1), 1).repeat(1, 1, 2).float()
+    preds[..., 0].apply_(lambda x: (x - 1) % hm.size(3) + 1)
+    preds[..., 1].add_(-1).div_(hm.size(2)).floor_().add_(1)
+
+    for i in range(preds.size(0)):
+        for j in range(preds.size(1)):
+            hm_ = hm[i, j, :]
+            pX, pY = int(preds[i, j, 0]) - 1, int(preds[i, j, 1]) - 1
+            if pX > 0 and pX < 63 and pY > 0 and pY < 63:
+                diff = torch.FloatTensor(
+                    [hm_[pY, pX + 1] - hm_[pY, pX - 1],
+                     hm_[pY + 1, pX] - hm_[pY - 1, pX]])
+                preds[i, j].add_(diff.sign_().mul_(.25))
+
+    preds.add_(-0.5)
+
+    preds_orig = torch.zeros(preds.size())
+    if center is not None and scale is not None:
+        for i in range(hm.size(0)):
+            for j in range(hm.size(1)):
+                preds_orig[i, j] = transform(
+                    preds[i, j], center, scale, hm.size(2), rot, True)
+
+    return preds, preds_orig
+
+def get_index_fromhm(hm):
+    max, idx = torch.max(
+        hm.view(hm.size(0), hm.size(1), hm.size(2) * hm.size(3)), 2)
+    preds = idx.view(idx.size(0), idx.size(1), 1).repeat(1, 1, 2).float()
+    preds[..., 0].remainder_(hm.size(3))
+    preds[..., 1].div_(hm.size(2)).floor_()
+
+    for i in range(preds.size(0)):
+        for j in range(preds.size(1)):
+            hm_ = hm[i, j, :]
+            pX, pY = int(preds[i, j, 0]), int(preds[i, j, 1])
+            if pX > 0 and pX < 63 and pY > 0 and pY < 63:
+                diff = torch.FloatTensor(
+                    [hm_[pY, pX + 1] - hm_[pY, pX - 1],
+                     hm_[pY + 1, pX] - hm_[pY - 1, pX]])
+                preds[i, j].add_(diff.sign_().mul_(.25))
+
+    return preds
+
+def shuffle_lr(parts, num_landmarks=68, pairs=None):
+    if num_landmarks == 68:
+        if pairs is None:
+            pairs = [[0, 16], [1, 15], [2, 14], [3, 13], [4, 12], [5, 11], [6, 10],
+                    [7, 9], [17, 26], [18, 25], [19, 24], [20, 23], [21, 22], [36, 45],
+                    [37, 44], [38, 43], [39, 42], [41, 46], [40, 47], [31, 35], [32, 34],
+                    [50, 52], [49, 53], [48, 54], [61, 63], [60, 64], [67, 65], [59, 55], [58, 56]]
+    elif num_landmarks == 98:
+        if pairs is None:
+            pairs = [[0, 32], [1,31], [2, 30], [3, 29], [4, 28], [5, 27], [6, 26], [7, 25], [8, 24], [9, 23], [10, 22], [11, 21], [12, 20], [13, 19], [14, 18], [15, 17], [33, 46], [34, 45], [35, 44], [36, 43], [37, 42], [38, 50], [39, 49], [40, 48], [41, 47], [60, 72], [61, 71], [62, 70], [63, 69], [64, 68], [65, 75], [66, 74], [67, 73], [96, 97], [55, 59], [56, 58], [76, 82], [77, 81], [78, 80], [88, 92], [89, 91], [95, 93], [87, 83], [86, 84]]
+    elif num_landmarks == 19:
+        if pairs is None:
+            pairs = [[0, 5], [1, 4], [2, 3], [6, 11], [7, 10], [8, 9], [12, 14], [15, 17]]
+    elif num_landmarks == 29:
+        if pairs is None:
+            pairs = [[0, 1], [4, 6], [5, 7], [2, 3], [8, 9], [12, 14], [16, 17], [13, 15], [10, 11], [18, 19], [22, 23]]
+    for matched_p in pairs:
+        idx1, idx2 = matched_p[0], matched_p[1]
+        tmp = np.copy(parts[idx1])
+        np.copyto(parts[idx1], parts[idx2])
+        np.copyto(parts[idx2], tmp)
+    return parts
+
+
+def generate_weight_map(weight_map,heatmap):
+
+    k_size = 3
+    dilate = ndimage.grey_dilation(heatmap ,size=(k_size,k_size))
+    weight_map[np.where(dilate>0.2)] = 1
+    return weight_map
+
+def fig2data(fig):
+    """
+    @brief Convert a Matplotlib figure to a 4D numpy array with RGBA channels and return it
+    @param fig a matplotlib figure
+    @return a numpy 3D array of RGBA values
+    """
+    # draw the renderer
+    fig.canvas.draw ( )
+
+    # Get the RGB buffer from the figure
+    w,h = fig.canvas.get_width_height()
+    buf = np.fromstring (fig.canvas.tostring_rgb(), dtype=np.uint8)
+    buf.shape = (w, h, 3)
+
+    # canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode
+    buf = np.roll (buf, 3, axis=2)
+    return buf

MakeItTalk/thirdparty/face_of_art/CODEOWNERS

@@ -1 +1 @@
-* @papulke
+* @papulke

MakeItTalk/thirdparty/face_of_art/LICENCE.txt

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2019 Jordan Yaniv
-
-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.
+MIT License
+
+Copyright (c) 2019 Jordan Yaniv
+
+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.

MakeItTalk/thirdparty/face_of_art/README.md

@@ -1,98 +1,98 @@
-# The Face of Art: Landmark Detection and Geometric Style in Portraits
-
-Code for the landmark detection framework described in [The Face of Art: Landmark Detection and Geometric Style in Portraits](http://www.faculty.idc.ac.il/arik/site/foa/face-of-art.asp) (SIGGRAPH 2019)
-
-![](old/teaser.png)
-<sub><sup>Top: landmark detection results on artistic portraits with different styles allows to define the geometric style of an artist. Bottom: results of the style transfer of portraits using various artists' geometric style, including Amedeo Modigliani, Pablo Picasso, Margaret Keane, Fernand Léger, and Tsuguharu Foujita. Top right portrait is from 'Woman with Peanuts,' ©1962, Estate of Roy Lichtenstein.</sup></sub>
-
-## Getting Started
-
-### Requirements
-
-* python
-* anaconda
-
-### Download
-
-#### Model
-download model weights from [here](https://www.dropbox.com/sh/hrxcyug1bmbj6cs/AAAxq_zI5eawcLjM8zvUwaXha?dl=0).
-
-#### Datasets
-* The datasets used for training and evaluating our model can be found [here](https://ibug.doc.ic.ac.uk/resources/facial-point-annotations/).
-
-* The Artistic-Faces dataset can be found [here](http://www.faculty.idc.ac.il/arik/site/foa/artistic-faces-dataset.asp).
-
-* Training images with texture augmentation can be found [here](https://www.dropbox.com/sh/av2k1i1082z0nie/AAC5qV1E2UkqpDLVsv7TazMta?dl=0).
-  before applying texture style transfer, the training images were cropped to the ground-truth face bounding-box with 25% margin. To crop training images, run the script `crop_training_set.py`.
-
-* our model expects the following directory structure of landmark detection datasets: 
-```
-landmark_detection_datasets
-    ├── training
-    ├── test
-    ├── challenging
-    ├── common
-    ├── full
-    ├── crop_gt_margin_0.25 (cropped images of training set)
-    └── crop_gt_margin_0.25_ns (cropped images of training set + texture style transfer)
-```    
-### Install
-
-Create a virtual environment and install the following:
-* opencv
-* menpo
-* menpofit
-* tensorflow-gpu
-
-for python 2:
-```
-conda create -n foa_env python=2.7 anaconda
-source activate foa_env
-conda install -c menpo opencv
-conda install -c menpo menpo
-conda install -c menpo menpofit
-pip install tensorflow-gpu
-
-```
-
-for python 3:
-```
-conda create -n foa_env python=3.5 anaconda
-source activate foa_env
-conda install -c menpo opencv
-conda install -c menpo menpo
-conda install -c menpo menpofit
-pip3 install tensorflow-gpu
-
-```
-
-Clone repository:
-
-```
-git clone https://github.com/papulke/deep_face_heatmaps
-```
-
-## Instructions
-
-### Training
-
-To train the network you need to run `train_heatmaps_network.py`
-
-example for training a model with texture augmentation (100% of images) and geometric augmentation (~70% of images):
-```
-python train_heatmaps_network.py --output_dir='test_artistic_aug' --augment_geom=True \
---augment_texture=True --p_texture=1. --p_geom=0.7
-```
-
-### Testing 
-
-For using the detection framework to predict landmarks, run the script `predict_landmarks.py`
-
-## Acknowledgments
-
-* [ect](https://github.com/HongwenZhang/ECT-FaceAlignment)
-* [menpo](https://github.com/menpo/menpo)
-* [menpofit](https://github.com/menpo/menpofit)
-* [mdm](https://github.com/trigeorgis/mdm)
-* [style transfer implementation](https://github.com/woodrush/neural-art-tf)
-* [painter-by-numbers dataset](https://www.kaggle.com/c/painter-by-numbers/data)
+# The Face of Art: Landmark Detection and Geometric Style in Portraits
+
+Code for the landmark detection framework described in [The Face of Art: Landmark Detection and Geometric Style in Portraits](http://www.faculty.idc.ac.il/arik/site/foa/face-of-art.asp) (SIGGRAPH 2019)
+
+![](old/teaser.png)
+<sub><sup>Top: landmark detection results on artistic portraits with different styles allows to define the geometric style of an artist. Bottom: results of the style transfer of portraits using various artists' geometric style, including Amedeo Modigliani, Pablo Picasso, Margaret Keane, Fernand Léger, and Tsuguharu Foujita. Top right portrait is from 'Woman with Peanuts,' ©1962, Estate of Roy Lichtenstein.</sup></sub>
+
+## Getting Started
+
+### Requirements
+
+* python
+* anaconda
+
+### Download
+
+#### Model
+download model weights from [here](https://www.dropbox.com/sh/hrxcyug1bmbj6cs/AAAxq_zI5eawcLjM8zvUwaXha?dl=0).
+
+#### Datasets
+* The datasets used for training and evaluating our model can be found [here](https://ibug.doc.ic.ac.uk/resources/facial-point-annotations/).
+
+* The Artistic-Faces dataset can be found [here](http://www.faculty.idc.ac.il/arik/site/foa/artistic-faces-dataset.asp).
+
+* Training images with texture augmentation can be found [here](https://www.dropbox.com/sh/av2k1i1082z0nie/AAC5qV1E2UkqpDLVsv7TazMta?dl=0).
+  before applying texture style transfer, the training images were cropped to the ground-truth face bounding-box with 25% margin. To crop training images, run the script `crop_training_set.py`.
+
+* our model expects the following directory structure of landmark detection datasets: 
+```
+landmark_detection_datasets
+    ├── training
+    ├── test
+    ├── challenging
+    ├── common
+    ├── full
+    ├── crop_gt_margin_0.25 (cropped images of training set)
+    └── crop_gt_margin_0.25_ns (cropped images of training set + texture style transfer)
+```    
+### Install
+
+Create a virtual environment and install the following:
+* opencv
+* menpo
+* menpofit
+* tensorflow-gpu
+
+for python 2:
+```
+conda create -n foa_env python=2.7 anaconda
+source activate foa_env
+conda install -c menpo opencv
+conda install -c menpo menpo
+conda install -c menpo menpofit
+pip install tensorflow-gpu
+
+```
+
+for python 3:
+```
+conda create -n foa_env python=3.5 anaconda
+source activate foa_env
+conda install -c menpo opencv
+conda install -c menpo menpo
+conda install -c menpo menpofit
+pip3 install tensorflow-gpu
+
+```
+
+Clone repository:
+
+```
+git clone https://github.com/papulke/deep_face_heatmaps
+```
+
+## Instructions
+
+### Training
+
+To train the network you need to run `train_heatmaps_network.py`
+
+example for training a model with texture augmentation (100% of images) and geometric augmentation (~70% of images):
+```
+python train_heatmaps_network.py --output_dir='test_artistic_aug' --augment_geom=True \
+--augment_texture=True --p_texture=1. --p_geom=0.7
+```
+
+### Testing 
+
+For using the detection framework to predict landmarks, run the script `predict_landmarks.py`
+
+## Acknowledgments
+
+* [ect](https://github.com/HongwenZhang/ECT-FaceAlignment)
+* [menpo](https://github.com/menpo/menpo)
+* [menpofit](https://github.com/menpo/menpofit)
+* [mdm](https://github.com/trigeorgis/mdm)
+* [style transfer implementation](https://github.com/woodrush/neural-art-tf)
+* [painter-by-numbers dataset](https://www.kaggle.com/c/painter-by-numbers/data)

MakeItTalk/thirdparty/face_of_art/crop_training_set.py

@@ -1,38 +1,38 @@
-from scipy.misc import imsave
-from menpo_functions import *
-from data_loading_functions import *
-
-
-# define paths & parameters for cropping dataset
-img_dir = '~/landmark_detection_datasets/'
-dataset = 'training'
-bb_type = 'gt'
-margin = 0.25
-image_size = 256
-
-# load bounding boxes
-bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
-bb_dictionary = load_bb_dictionary(bb_dir, mode='TRAIN', test_data=dataset)
-
-# directory for saving face crops
-outdir = os.path.join(img_dir, 'crop_'+bb_type+'_margin_'+str(margin))
-if not os.path.exists(outdir):
-    os.mkdir(outdir)
-
-# load images
-imgs_to_crop = load_menpo_image_list(
-    img_dir=img_dir, train_crop_dir=None, img_dir_ns=None, mode='TRAIN', bb_dictionary=bb_dictionary,
-    image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=False)
-
-# save cropped images with matching landmarks
-print ("\ncropping dataset from: "+os.path.join(img_dir, dataset))
-print ("\nsaving cropped dataset to: "+outdir)
-for im in imgs_to_crop:
-    if im.pixels.shape[0] == 1:
-        im_pixels = gray2rgb(np.squeeze(im.pixels))
-    else:
-        im_pixels = np.rollaxis(im.pixels, 0, 3)
-    imsave(os.path.join(outdir, im.path.name.split('.')[0]+'.png'), im_pixels)
-    mio.export_landmark_file(im.landmarks['PTS'], os.path.join(outdir, im.path.name.split('.')[0]+'.pts'))
-
-print ("\ncropping dataset completed!")
+from scipy.misc import imsave
+from menpo_functions import *
+from data_loading_functions import *
+
+
+# define paths & parameters for cropping dataset
+img_dir = '~/landmark_detection_datasets/'
+dataset = 'training'
+bb_type = 'gt'
+margin = 0.25
+image_size = 256
+
+# load bounding boxes
+bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
+bb_dictionary = load_bb_dictionary(bb_dir, mode='TRAIN', test_data=dataset)
+
+# directory for saving face crops
+outdir = os.path.join(img_dir, 'crop_'+bb_type+'_margin_'+str(margin))
+if not os.path.exists(outdir):
+    os.mkdir(outdir)
+
+# load images
+imgs_to_crop = load_menpo_image_list(
+    img_dir=img_dir, train_crop_dir=None, img_dir_ns=None, mode='TRAIN', bb_dictionary=bb_dictionary,
+    image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=False)
+
+# save cropped images with matching landmarks
+print ("\ncropping dataset from: "+os.path.join(img_dir, dataset))
+print ("\nsaving cropped dataset to: "+outdir)
+for im in imgs_to_crop:
+    if im.pixels.shape[0] == 1:
+        im_pixels = gray2rgb(np.squeeze(im.pixels))
+    else:
+        im_pixels = np.rollaxis(im.pixels, 0, 3)
+    imsave(os.path.join(outdir, im.path.name.split('.')[0]+'.png'), im_pixels)
+    mio.export_landmark_file(im.landmarks['PTS'], os.path.join(outdir, im.path.name.split('.')[0]+'.pts'))
+
+print ("\ncropping dataset completed!")

MakeItTalk/thirdparty/face_of_art/data_loading_functions.py

@@ -1,161 +1,161 @@
-import numpy as np
-import os
-from skimage.color import gray2rgb
-
-
-def train_val_shuffle_inds_per_epoch(valid_inds, train_inds, train_iter, batch_size, log_path, save_log=True):
-    """shuffle image indices for each training epoch and save to log"""
-    
-    np.random.seed(0)
-    num_train_images = len(train_inds)
-    num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
-    epoch_inds_shuffle = np.zeros((num_epochs, num_train_images)).astype(int)
-    img_inds = np.arange(num_train_images)
-    for i in range(num_epochs):
-        np.random.shuffle(img_inds)
-        epoch_inds_shuffle[i, :] = img_inds
-
-    if save_log:
-        with open(os.path.join(log_path, "train_val_shuffle_inds.csv"), "wb") as f:
-            if valid_inds is not None:
-                f.write(b'valid inds\n')
-                np.savetxt(f, valid_inds.reshape(1, -1), fmt='%i', delimiter=",")
-            f.write(b'train inds\n')
-            np.savetxt(f, train_inds.reshape(1, -1), fmt='%i', delimiter=",")
-            f.write(b'shuffle inds\n')
-            np.savetxt(f, epoch_inds_shuffle, fmt='%i', delimiter=",")
-
-    return epoch_inds_shuffle
-
-
-def gaussian(x, y, x0, y0, sigma=6):
-    return 1./(np.sqrt(2*np.pi)*sigma) * np.exp(-0.5 * ((x-x0)**2 + (y-y0)**2) / sigma**2)
-
-
-def create_gaussian_filter(sigma=6, win_mult=3.5):
-    win_size = int(win_mult * sigma)
-    x, y = np.mgrid[0:2*win_size+1, 0:2*win_size+1]
-    gauss_filt = (8./3)*sigma*gaussian(x, y, win_size, win_size, sigma=sigma)  # same as in ECT
-    return gauss_filt
-
-
-def load_images(img_list, batch_inds, image_size=256, c_dim=3, scale=255):
-
-        """ load images as a numpy array from menpo image list """
-
-        num_inputs = len(batch_inds)
-        batch_menpo_images = img_list[batch_inds]
-
-        images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
-
-        for ind, img in enumerate(batch_menpo_images):
-            if img.n_channels < 3 and c_dim == 3:
-                images[ind, :, :, :] = gray2rgb(img.pixels_with_channels_at_back())
-            else:
-                images[ind, :, :, :] = img.pixels_with_channels_at_back()
-
-        if scale is 255:
-            images *= 255
-        elif scale is 0:
-            images = 2 * images - 1
-
-        return images
-
-
-# loading functions with pre-allocation and approx heat-map generation
-
-
-def create_approx_heat_maps_alloc_once(landmarks, maps, gauss_filt=None, win_mult=3.5, num_landmarks=68, image_size=256,
-                                       sigma=6):
-    """ create heatmaps from input landmarks"""
-    maps.fill(0.)
-
-    win_size = int(win_mult * sigma)
-    filt_size = 2 * win_size + 1
-    landmarks = landmarks.astype(int)
-
-    if gauss_filt is None:
-        x_small, y_small = np.mgrid[0:2 * win_size + 1, 0:2 * win_size + 1]
-        gauss_filt = (8. / 3) * sigma * gaussian(x_small, y_small, win_size, win_size, sigma=sigma)  # same as in ECT
-
-    for i in range(num_landmarks):
-
-        min_row = landmarks[i, 0] - win_size
-        max_row = landmarks[i, 0] + win_size + 1
-        min_col = landmarks[i, 1] - win_size
-        max_col = landmarks[i, 1] + win_size + 1
-
-        if min_row < 0:
-            min_row_gap = -1 * min_row
-            min_row = 0
-        else:
-            min_row_gap = 0
-
-        if min_col < 0:
-            min_col_gap = -1 * min_col
-            min_col = 0
-        else:
-            min_col_gap = 0
-
-        if max_row > image_size:
-            max_row_gap = max_row - image_size
-            max_row = image_size
-        else:
-            max_row_gap = 0
-
-        if max_col > image_size:
-            max_col_gap = max_col - image_size
-            max_col = image_size
-        else:
-            max_col_gap = 0
-
-        maps[min_row:max_row, min_col:max_col, i] =\
-            gauss_filt[min_row_gap:filt_size - 1 * max_row_gap, min_col_gap:filt_size - 1 * max_col_gap]
-
-
-def load_images_landmarks_approx_maps_alloc_once(
-        img_list, batch_inds, images, maps_small, maps, landmarks, image_size=256, num_landmarks=68,
-        scale=255, gauss_filt_large=None, gauss_filt_small=None, win_mult=3.5, sigma=6, save_landmarks=False):
-
-    """ load images and gt landmarks from menpo image list, and create matching heatmaps """
-
-    batch_menpo_images = img_list[batch_inds]
-    c_dim = images.shape[-1]
-    grp_name = batch_menpo_images[0].landmarks.group_labels[0]
-
-    win_size_large = int(win_mult * sigma)
-    win_size_small = int(win_mult * (1.*sigma/4))
-
-    if gauss_filt_small is None:
-        x_small, y_small = np.mgrid[0:2 * win_size_small + 1, 0:2 * win_size_small + 1]
-        gauss_filt_small = (8. / 3) * (1.*sigma/4) * gaussian(
-            x_small, y_small, win_size_small, win_size_small, sigma=1.*sigma/4)  # same as in ECT
-    if gauss_filt_large is None:
-        x_large, y_large = np.mgrid[0:2 * win_size_large + 1, 0:2 * win_size_large + 1]
-        gauss_filt_large = (8. / 3) * sigma * gaussian(x_large, y_large, win_size_large, win_size_large, sigma=sigma)  # same as in ECT
-
-    for ind, img in enumerate(batch_menpo_images):
-        if img.n_channels < 3 and c_dim == 3:
-            images[ind, :, :, :] = gray2rgb(img.pixels_with_channels_at_back())
-        else:
-            images[ind, :, :, :] = img.pixels_with_channels_at_back()
-
-        lms = img.landmarks[grp_name].points
-        lms = np.minimum(lms, image_size - 1)
-        create_approx_heat_maps_alloc_once(
-            landmarks=lms, maps=maps[ind, :, :, :], gauss_filt=gauss_filt_large, win_mult=win_mult,
-            num_landmarks=num_landmarks, image_size=image_size, sigma=sigma)
-
-        lms_small = img.resize([image_size / 4, image_size / 4]).landmarks[grp_name].points
-        lms_small = np.minimum(lms_small, image_size / 4 - 1)
-        create_approx_heat_maps_alloc_once(
-            landmarks=lms_small, maps=maps_small[ind, :, :, :], gauss_filt=gauss_filt_small, win_mult=win_mult,
-            num_landmarks=num_landmarks, image_size=image_size / 4, sigma=1. * sigma / 4)
-
-        if save_landmarks:
-            landmarks[ind, :, :] = lms
-
-    if scale is 255:
-        images *= 255
-    elif scale is 0:
-        images = 2 * images - 1
+import numpy as np
+import os
+from skimage.color import gray2rgb
+
+
+def train_val_shuffle_inds_per_epoch(valid_inds, train_inds, train_iter, batch_size, log_path, save_log=True):
+    """shuffle image indices for each training epoch and save to log"""
+    
+    np.random.seed(0)
+    num_train_images = len(train_inds)
+    num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
+    epoch_inds_shuffle = np.zeros((num_epochs, num_train_images)).astype(int)
+    img_inds = np.arange(num_train_images)
+    for i in range(num_epochs):
+        np.random.shuffle(img_inds)
+        epoch_inds_shuffle[i, :] = img_inds
+
+    if save_log:
+        with open(os.path.join(log_path, "train_val_shuffle_inds.csv"), "wb") as f:
+            if valid_inds is not None:
+                f.write(b'valid inds\n')
+                np.savetxt(f, valid_inds.reshape(1, -1), fmt='%i', delimiter=",")
+            f.write(b'train inds\n')
+            np.savetxt(f, train_inds.reshape(1, -1), fmt='%i', delimiter=",")
+            f.write(b'shuffle inds\n')
+            np.savetxt(f, epoch_inds_shuffle, fmt='%i', delimiter=",")
+
+    return epoch_inds_shuffle
+
+
+def gaussian(x, y, x0, y0, sigma=6):
+    return 1./(np.sqrt(2*np.pi)*sigma) * np.exp(-0.5 * ((x-x0)**2 + (y-y0)**2) / sigma**2)
+
+
+def create_gaussian_filter(sigma=6, win_mult=3.5):
+    win_size = int(win_mult * sigma)
+    x, y = np.mgrid[0:2*win_size+1, 0:2*win_size+1]
+    gauss_filt = (8./3)*sigma*gaussian(x, y, win_size, win_size, sigma=sigma)  # same as in ECT
+    return gauss_filt
+
+
+def load_images(img_list, batch_inds, image_size=256, c_dim=3, scale=255):
+
+        """ load images as a numpy array from menpo image list """
+
+        num_inputs = len(batch_inds)
+        batch_menpo_images = img_list[batch_inds]
+
+        images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
+
+        for ind, img in enumerate(batch_menpo_images):
+            if img.n_channels < 3 and c_dim == 3:
+                images[ind, :, :, :] = gray2rgb(img.pixels_with_channels_at_back())
+            else:
+                images[ind, :, :, :] = img.pixels_with_channels_at_back()
+
+        if scale is 255:
+            images *= 255
+        elif scale is 0:
+            images = 2 * images - 1
+
+        return images
+
+
+# loading functions with pre-allocation and approx heat-map generation
+
+
+def create_approx_heat_maps_alloc_once(landmarks, maps, gauss_filt=None, win_mult=3.5, num_landmarks=68, image_size=256,
+                                       sigma=6):
+    """ create heatmaps from input landmarks"""
+    maps.fill(0.)
+
+    win_size = int(win_mult * sigma)
+    filt_size = 2 * win_size + 1
+    landmarks = landmarks.astype(int)
+
+    if gauss_filt is None:
+        x_small, y_small = np.mgrid[0:2 * win_size + 1, 0:2 * win_size + 1]
+        gauss_filt = (8. / 3) * sigma * gaussian(x_small, y_small, win_size, win_size, sigma=sigma)  # same as in ECT
+
+    for i in range(num_landmarks):
+
+        min_row = landmarks[i, 0] - win_size
+        max_row = landmarks[i, 0] + win_size + 1
+        min_col = landmarks[i, 1] - win_size
+        max_col = landmarks[i, 1] + win_size + 1
+
+        if min_row < 0:
+            min_row_gap = -1 * min_row
+            min_row = 0
+        else:
+            min_row_gap = 0
+
+        if min_col < 0:
+            min_col_gap = -1 * min_col
+            min_col = 0
+        else:
+            min_col_gap = 0
+
+        if max_row > image_size:
+            max_row_gap = max_row - image_size
+            max_row = image_size
+        else:
+            max_row_gap = 0
+
+        if max_col > image_size:
+            max_col_gap = max_col - image_size
+            max_col = image_size
+        else:
+            max_col_gap = 0
+
+        maps[min_row:max_row, min_col:max_col, i] =\
+            gauss_filt[min_row_gap:filt_size - 1 * max_row_gap, min_col_gap:filt_size - 1 * max_col_gap]
+
+
+def load_images_landmarks_approx_maps_alloc_once(
+        img_list, batch_inds, images, maps_small, maps, landmarks, image_size=256, num_landmarks=68,
+        scale=255, gauss_filt_large=None, gauss_filt_small=None, win_mult=3.5, sigma=6, save_landmarks=False):
+
+    """ load images and gt landmarks from menpo image list, and create matching heatmaps """
+
+    batch_menpo_images = img_list[batch_inds]
+    c_dim = images.shape[-1]
+    grp_name = batch_menpo_images[0].landmarks.group_labels[0]
+
+    win_size_large = int(win_mult * sigma)
+    win_size_small = int(win_mult * (1.*sigma/4))
+
+    if gauss_filt_small is None:
+        x_small, y_small = np.mgrid[0:2 * win_size_small + 1, 0:2 * win_size_small + 1]
+        gauss_filt_small = (8. / 3) * (1.*sigma/4) * gaussian(
+            x_small, y_small, win_size_small, win_size_small, sigma=1.*sigma/4)  # same as in ECT
+    if gauss_filt_large is None:
+        x_large, y_large = np.mgrid[0:2 * win_size_large + 1, 0:2 * win_size_large + 1]
+        gauss_filt_large = (8. / 3) * sigma * gaussian(x_large, y_large, win_size_large, win_size_large, sigma=sigma)  # same as in ECT
+
+    for ind, img in enumerate(batch_menpo_images):
+        if img.n_channels < 3 and c_dim == 3:
+            images[ind, :, :, :] = gray2rgb(img.pixels_with_channels_at_back())
+        else:
+            images[ind, :, :, :] = img.pixels_with_channels_at_back()
+
+        lms = img.landmarks[grp_name].points
+        lms = np.minimum(lms, image_size - 1)
+        create_approx_heat_maps_alloc_once(
+            landmarks=lms, maps=maps[ind, :, :, :], gauss_filt=gauss_filt_large, win_mult=win_mult,
+            num_landmarks=num_landmarks, image_size=image_size, sigma=sigma)
+
+        lms_small = img.resize([image_size / 4, image_size / 4]).landmarks[grp_name].points
+        lms_small = np.minimum(lms_small, image_size / 4 - 1)
+        create_approx_heat_maps_alloc_once(
+            landmarks=lms_small, maps=maps_small[ind, :, :, :], gauss_filt=gauss_filt_small, win_mult=win_mult,
+            num_landmarks=num_landmarks, image_size=image_size / 4, sigma=1. * sigma / 4)
+
+        if save_landmarks:
+            landmarks[ind, :, :] = lms
+
+    if scale is 255:
+        images *= 255
+    elif scale is 0:
+        images = 2 * images - 1

MakeItTalk/thirdparty/face_of_art/deformation_functions.py

@@ -1,386 +1,386 @@
-import numpy as np
-
-
-def deform_part(landmarks, part_inds, scale_y=1., scale_x=1., shift_ver=0., shift_horiz=0.):
-    """ deform facial part landmarks - matching ibug annotations of 68 landmarks """
-
-    landmarks_part = landmarks[part_inds, :].copy()
-    part_mean = np.mean(landmarks_part, 0)
-
-    landmarks_norm = landmarks_part - part_mean
-    landmarks_deform = landmarks_norm.copy()
-    landmarks_deform[:, 1] = scale_x * landmarks_deform[:, 1]
-    landmarks_deform[:, 0] = scale_y * landmarks_deform[:, 0]
-
-    landmarks_deform = landmarks_deform + part_mean
-    landmarks_deform = landmarks_deform + shift_ver * np.array([1, 0]) + shift_horiz * np.array([0, 1])
-
-    deform_shape = landmarks.copy()
-    deform_shape[part_inds] = landmarks_deform
-    return deform_shape
-
-
-def deform_mouth(lms, p_scale=0, p_shift=0, pad=5):
-    """ deform mouth landmarks - matching ibug annotations of 68 landmarks """
-
-    jaw_line_inds = np.arange(0, 17)
-    nose_inds = np.arange(27, 36)
-    mouth_inds = np.arange(48, 68)
-
-    part_inds = mouth_inds.copy()
-
-    # find part spatial limitations
-    jaw_pad = 4
-    x_max = np.max(lms[part_inds, 1]) + (np.max(lms[jaw_line_inds[jaw_pad:-jaw_pad], 1]) - np.max(
-        lms[part_inds, 1])) * 0.5 - pad
-    x_min = np.min(lms[jaw_line_inds[jaw_pad:-jaw_pad], 1]) + (np.min(lms[part_inds, 1]) - np.min(
-        lms[jaw_line_inds[jaw_pad:-jaw_pad], 1])) * 0.5 + pad
-    y_min = np.max(lms[nose_inds, 0]) + (np.min(lms[part_inds, 0]) - np.max(lms[nose_inds, 0])) * 0.5
-    max_jaw = np.minimum(np.max(lms[jaw_line_inds, 0]), lms[8, 0])
-    y_max = max_jaw - (max_jaw - np.max(lms[part_inds, 0])) * 0.5 - pad
-
-    # scale facial feature
-    scale = np.random.rand()
-    if p_scale > 0.5 and scale > 0.5:
-
-        part_mean = np.mean(lms[part_inds, :], 0)
-        lms_part_norm = lms[part_inds, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        scale_max_y = np.minimum(
-            (y_min - part_mean[0]) / part_y_bound_min,
-            (y_max - part_mean[0]) / part_y_bound_max)
-        scale_max_y = np.minimum(scale_max_y, 1.2)
-
-        scale_max_x = np.minimum(
-            (x_min - part_mean[1]) / part_x_bound_min,
-            (x_max - part_mean[1]) / part_x_bound_max)
-        scale_max_x = np.minimum(scale_max_x, 1.2)
-
-        scale_y = np.random.uniform(0.7, scale_max_y)
-        scale_x = np.random.uniform(0.7, scale_max_x)
-
-        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
-
-        # check for spatial errors
-        error = check_deformation_spatial_errors(lms_def_scale, part_inds, pad=pad)
-        if error:
-            lms_def_scale = lms.copy()
-    else:
-        lms_def_scale = lms.copy()
-
-    # shift facial feature
-    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
-
-        part_mean = np.mean(lms_def_scale[part_inds, :], 0)
-        lms_part_norm = lms_def_scale[part_inds, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        shift_x = np.random.uniform(x_min - (part_mean[1] + part_x_bound_min),
-                                    x_max - (part_mean[1] + part_x_bound_max))
-        shift_y = np.random.uniform(y_min - (part_mean[0] + part_y_bound_min),
-                                    y_max - (part_mean[0] + part_y_bound_max))
-
-        lms_def = deform_part(lms_def_scale, part_inds, scale_y=1., scale_x=1., shift_ver=shift_y, shift_horiz=shift_x)
-        error = check_deformation_spatial_errors(lms_def, part_inds, pad=pad)
-        if error:
-            lms_def = lms_def_scale.copy()
-    else:
-        lms_def = lms_def_scale.copy()
-
-    return lms_def
-
-
-def deform_nose(lms, p_scale=0, p_shift=0, pad=5):
-    """ deform nose landmarks - matching ibug annotations of 68 landmarks """
-
-    nose_inds = np.arange(27, 36)
-    left_eye_inds = np.arange(36, 42)
-    right_eye_inds = np.arange(42, 48)
-    mouth_inds = np.arange(48, 68)
-
-    part_inds = nose_inds.copy()
-
-    # find part spatial limitations
-    x_max = np.max(lms[part_inds[:4], 1]) + (np.min(lms[right_eye_inds, 1]) - np.max(lms[part_inds[:4], 1])) * 0.5 - pad
-    x_min = np.max(lms[left_eye_inds, 1]) + (np.min(lms[part_inds[:4], 1]) - np.max(lms[left_eye_inds, 1])) * 0.5 + pad
-
-    max_brows = np.max(lms[21:23, 0])
-    y_min = np.min(lms[part_inds, 0]) + (max_brows - np.min(lms[part_inds, 0])) * 0.5
-    min_mouth = np.min(lms[mouth_inds, 0])
-    y_max = np.max(lms[part_inds, 0]) + (np.max(lms[part_inds, 0]) - min_mouth) * 0 - pad
-
-    # scale facial feature
-    scale = np.random.rand()
-    if p_scale > 0.5 and scale > 0.5:
-
-        part_mean = np.mean(lms[part_inds, :], 0)
-        lms_part_norm = lms[part_inds, :] - part_mean
-
-        part_y_bound_min = np.min(lms_part_norm[:, 0])
-        part_y_bound_max = np.max(lms_part_norm[:, 0])
-
-        scale_max_y = np.minimum(
-            (y_min - part_mean[0]) / part_y_bound_min,
-            (y_max - part_mean[0]) / part_y_bound_max)
-        scale_y = np.random.uniform(0.7, scale_max_y)
-        scale_x = np.random.uniform(0.7, 1.5)
-
-        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
-
-        error1 = check_deformation_spatial_errors(lms_def_scale, part_inds[:4], pad=pad)
-        error2 = check_deformation_spatial_errors(lms_def_scale, part_inds[4:], pad=pad)
-        error = error1 + error2
-        if error:
-            lms_def_scale = lms.copy()
-    else:
-        lms_def_scale = lms.copy()
-
-    # shift facial feature
-    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
-
-        part_mean = np.mean(lms_def_scale[part_inds, :], 0)
-        lms_part_norm = lms_def_scale[part_inds, :] - part_mean
-
-        part_x_bound_min = np.min(lms_part_norm[:4], 0)
-        part_x_bound_max = np.max(lms_part_norm[:4], 0)
-        part_y_bound_min = np.min(lms_part_norm[:, 0])
-        part_y_bound_max = np.max(lms_part_norm[:, 0])
-
-        shift_x = np.random.uniform(x_min - (part_mean[1] + part_x_bound_min),
-                                    x_max - (part_mean[1] + part_x_bound_max))
-        shift_y = np.random.uniform(y_min - (part_mean[0] + part_y_bound_min),
-                                    y_max - (part_mean[0] + part_y_bound_max))
-
-        lms_def = deform_part(lms_def_scale, part_inds, scale_y=1., scale_x=1., shift_ver=shift_y, shift_horiz=shift_x)
-
-        error1 = check_deformation_spatial_errors(lms_def, part_inds[:4], pad=pad)
-        error2 = check_deformation_spatial_errors(lms_def, part_inds[4:], pad=pad)
-        error = error1 + error2
-        if error:
-            lms_def = lms_def_scale.copy()
-    else:
-        lms_def = lms_def_scale.copy()
-
-    return lms_def
-
-
-def deform_eyes(lms, p_scale=0, p_shift=0, pad=10):
-    """ deform eyes + eyebrows landmarks - matching ibug annotations of 68 landmarks """
-
-    nose_inds = np.arange(27, 36)
-    left_eye_inds = np.arange(36, 42)
-    right_eye_inds = np.arange(42, 48)
-    left_brow_inds = np.arange(17, 22)
-    right_brow_inds = np.arange(22, 27)
-
-    part_inds_right = np.hstack((right_brow_inds, right_eye_inds))
-    part_inds_left = np.hstack((left_brow_inds, left_eye_inds))
-
-    # find part spatial limitations
-
-    # right eye+eyebrow
-    x_max_right = np.max(lms[part_inds_right, 1]) + (lms[16, 1] - np.max(lms[part_inds_right, 1])) * 0.5 - pad
-    x_min_right = np.max(lms[nose_inds[:4], 1]) + (np.min(lms[part_inds_right, 1]) - np.max(
-        lms[nose_inds[:4], 1])) * 0.5 + pad
-    y_max_right = np.max(lms[part_inds_right, 0]) + (lms[33, 0] - np.max(lms[part_inds_right, 0])) * 0.25 - pad
-    y_min_right = 2 * pad
-
-    # left eye+eyebrow
-    x_max_left = np.max(lms[part_inds_left, 1]) + (np.min(lms[nose_inds[:4], 1]) - np.max(
-        lms[part_inds_left, 1])) * 0.5 - pad
-    x_min_left = lms[0, 1] + (np.min(lms[part_inds_left, 1]) - lms[0, 1]) * 0.5 + pad
-
-    y_max_left = np.max(lms[part_inds_left, 0]) + (lms[33, 0] - np.max(lms[part_inds_left, 0])) * 0.25 - pad
-    y_min_left = 2 * pad
-
-    # scale facial feature
-    scale = np.random.rand()
-    if p_scale > 0.5 and scale > 0.5:
-
-        # right eye+eyebrow
-        part_mean = np.mean(lms[part_inds_right, :], 0)
-        lms_part_norm = lms[part_inds_right, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        scale_max_y = np.minimum(
-            (y_min_right - part_mean[0]) / part_y_bound_min,
-            (y_max_right - part_mean[0]) / part_y_bound_max)
-        scale_max_y_right = np.minimum(scale_max_y, 1.5)
-
-        scale_max_x = np.minimum(
-            (x_min_right - part_mean[1]) / part_x_bound_min,
-            (x_max_right - part_mean[1]) / part_x_bound_max)
-        scale_max_x_right = np.minimum(scale_max_x, 1.5)
-
-        # left eye+eyebrow
-        part_mean = np.mean(lms[part_inds_left, :], 0)
-        lms_part_norm = lms[part_inds_left, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        scale_max_y = np.minimum(
-            (y_min_left - part_mean[0]) / part_y_bound_min,
-            (y_max_left - part_mean[0]) / part_y_bound_max)
-        scale_max_y_left = np.minimum(scale_max_y, 1.5)
-
-        scale_max_x = np.minimum(
-            (x_min_left - part_mean[1]) / part_x_bound_min,
-            (x_max_left - part_mean[1]) / part_x_bound_max)
-        scale_max_x_left = np.minimum(scale_max_x, 1.5)
-
-        scale_max_x = np.minimum(scale_max_x_left, scale_max_x_right)
-        scale_max_y = np.minimum(scale_max_y_left, scale_max_y_right)
-        scale_y = np.random.uniform(0.8, scale_max_y)
-        scale_x = np.random.uniform(0.8, scale_max_x)
-
-        lms_def_scale = deform_part(lms, part_inds_right, scale_y=scale_y, scale_x=scale_x, shift_ver=0.,
-                                    shift_horiz=0.)
-        lms_def_scale = deform_part(lms_def_scale.copy(), part_inds_left, scale_y=scale_y, scale_x=scale_x,
-                                    shift_ver=0., shift_horiz=0.)
-
-        error1 = check_deformation_spatial_errors(lms_def_scale, part_inds_right, pad=pad)
-        error2 = check_deformation_spatial_errors(lms_def_scale, part_inds_left, pad=pad)
-        error = error1 + error2
-        if error:
-            lms_def_scale = lms.copy()
-    else:
-        lms_def_scale = lms.copy()
-
-    # shift facial feature
-    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
-
-        y_min_right = np.maximum(0.8 * np.min(lms_def_scale[part_inds_right, 0]), pad)
-        y_min_left = np.maximum(0.8 * np.min(lms_def_scale[part_inds_left, 0]), pad)
-
-        # right eye
-        part_mean = np.mean(lms_def_scale[part_inds_right, :], 0)
-        lms_part_norm = lms_def_scale[part_inds_right, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        shift_x = np.random.uniform(x_min_right - (part_mean[1] + part_x_bound_min),
-                                    x_max_right - (part_mean[1] + part_x_bound_max))
-        shift_y = np.random.uniform(y_min_right - (part_mean[0] + part_y_bound_min),
-                                    y_max_right - (part_mean[0] + part_y_bound_max))
-
-        lms_def_right = deform_part(lms_def_scale, part_inds_right, scale_y=1., scale_x=1., shift_ver=shift_y,
-                               shift_horiz=shift_x)
-
-        error1 = check_deformation_spatial_errors(lms_def_right, part_inds_right, pad=pad)
-        if error1:
-            lms_def_right = lms_def_scale.copy()
-
-        # left eye
-        part_mean = np.mean(lms_def_scale[part_inds_left, :], 0)
-        lms_part_norm = lms_def_scale[part_inds_left, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        shift_x = np.random.uniform(x_min_left - (part_mean[1] + part_x_bound_min),
-                                    x_max_left - (part_mean[1] + part_x_bound_max))
-        shift_y = np.random.uniform(y_min_left - (part_mean[0] + part_y_bound_min),
-                                    y_max_left - (part_mean[0] + part_y_bound_max))
-
-        lms_def = deform_part(lms_def_right.copy(), part_inds_left, scale_y=1., scale_x=1., shift_ver=shift_y,
-                              shift_horiz=shift_x)
-
-        error2 = check_deformation_spatial_errors(lms_def, part_inds_left, pad=pad)
-        if error2:
-            lms_def = lms_def_right.copy()
-    else:
-        lms_def = lms_def_scale.copy()
-
-    return lms_def
-
-
-def deform_scale_face(lms, p_scale=0, pad=5, image_size=256):
-    """ change face landmarks scale & aspect ratio - matching ibug annotations of 68 landmarks """
-
-    part_inds = np.arange(68)
-
-    # find spatial limitations
-    x_max = np.max(lms[part_inds, 1]) + (image_size - np.max(lms[part_inds, 1])) * 0.5 - pad
-    x_min = np.min(lms[part_inds, 1]) * 0.5 + pad
-
-    y_min = 2 * pad
-    y_max = np.max(lms[part_inds, 0]) + (image_size - np.max(lms[part_inds, 0])) * 0.5 - pad
-
-    if p_scale > 0.5:
-
-        part_mean = np.mean(lms[part_inds, :], 0)
-        lms_part_norm = lms[part_inds, :] - part_mean
-
-        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
-        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
-
-        scale_max_y = np.minimum(
-            (y_min - part_mean[0]) / part_y_bound_min,
-            (y_max - part_mean[0]) / part_y_bound_max)
-        scale_max_y = np.minimum(scale_max_y, 1.2)
-
-        scale_max_x = np.minimum(
-            (x_min - part_mean[1]) / part_x_bound_min,
-            (x_max - part_mean[1]) / part_x_bound_max)
-        scale_max_x = np.minimum(scale_max_x, 1.2)
-
-        scale_y = np.random.uniform(0.6, scale_max_y)
-        scale_x = np.random.uniform(0.6, scale_max_x)
-
-        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
-
-        # check for spatial errors
-        error2 = np.sum(lms_def_scale >= image_size) + np.sum(lms_def_scale < 0)
-        error1 = len(np.unique((lms_def_scale).astype('int'), axis=0)) != len(lms_def_scale)
-        error = error1 + error2
-        if error:
-            lms_def_scale = lms.copy()
-    else:
-        lms_def_scale = lms.copy()
-
-    return lms_def_scale
-
-
-def deform_face_geometric_style(lms, p_scale=0, p_shift=0):
-    """ deform facial landmarks - matching ibug annotations of 68 landmarks """
-
-    lms = deform_scale_face(lms.copy(), p_scale=p_scale, pad=0)
-    lms = deform_nose(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
-    lms = deform_mouth(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
-    lms = deform_eyes(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
-    return lms
-
-
-def get_bounds(lms):
-    part_y_bound_min, part_x_bound_min = np.min(lms,0)
-    part_y_bound_max, part_x_bound_max = np.max(lms,0)
-    return np.array([[part_x_bound_min, part_x_bound_max], [part_y_bound_min, part_y_bound_max]])
-
-
-def part_intersection(part_to_check, points_to_compare, pad=0):
-    points_to_compare = np.round(points_to_compare.copy())
-    check_bounds = np.round(get_bounds(part_to_check))
-    check_bounds[:, 0] += pad
-    check_bounds[:, 1] -= pad
-    inds_y = np.where(np.logical_and(points_to_compare[:,0] > check_bounds[1,0], points_to_compare[:,0]<check_bounds[1,1]))
-    inds_x = np.where(np.logical_and(points_to_compare[:,1] > check_bounds[0,0], points_to_compare[:,1]<check_bounds[0,1]))
-    return np.intersect1d(inds_y, inds_x)
-
-
-def check_deformation_spatial_errors(def_landmarks, part_inds,pad=0):
-    """ check for spatial errors in deformed landmarks"""
-
-    part_to_check = def_landmarks[part_inds, :].copy()
-    points_to_compare = np.delete(def_landmarks, part_inds,axis=0).reshape(-1,2)
-    inter_inds = part_intersection(part_to_check,points_to_compare, pad=pad)
-    out = len(inter_inds) > 0
-    return out
+import numpy as np
+
+
+def deform_part(landmarks, part_inds, scale_y=1., scale_x=1., shift_ver=0., shift_horiz=0.):
+    """ deform facial part landmarks - matching ibug annotations of 68 landmarks """
+
+    landmarks_part = landmarks[part_inds, :].copy()
+    part_mean = np.mean(landmarks_part, 0)
+
+    landmarks_norm = landmarks_part - part_mean
+    landmarks_deform = landmarks_norm.copy()
+    landmarks_deform[:, 1] = scale_x * landmarks_deform[:, 1]
+    landmarks_deform[:, 0] = scale_y * landmarks_deform[:, 0]
+
+    landmarks_deform = landmarks_deform + part_mean
+    landmarks_deform = landmarks_deform + shift_ver * np.array([1, 0]) + shift_horiz * np.array([0, 1])
+
+    deform_shape = landmarks.copy()
+    deform_shape[part_inds] = landmarks_deform
+    return deform_shape
+
+
+def deform_mouth(lms, p_scale=0, p_shift=0, pad=5):
+    """ deform mouth landmarks - matching ibug annotations of 68 landmarks """
+
+    jaw_line_inds = np.arange(0, 17)
+    nose_inds = np.arange(27, 36)
+    mouth_inds = np.arange(48, 68)
+
+    part_inds = mouth_inds.copy()
+
+    # find part spatial limitations
+    jaw_pad = 4
+    x_max = np.max(lms[part_inds, 1]) + (np.max(lms[jaw_line_inds[jaw_pad:-jaw_pad], 1]) - np.max(
+        lms[part_inds, 1])) * 0.5 - pad
+    x_min = np.min(lms[jaw_line_inds[jaw_pad:-jaw_pad], 1]) + (np.min(lms[part_inds, 1]) - np.min(
+        lms[jaw_line_inds[jaw_pad:-jaw_pad], 1])) * 0.5 + pad
+    y_min = np.max(lms[nose_inds, 0]) + (np.min(lms[part_inds, 0]) - np.max(lms[nose_inds, 0])) * 0.5
+    max_jaw = np.minimum(np.max(lms[jaw_line_inds, 0]), lms[8, 0])
+    y_max = max_jaw - (max_jaw - np.max(lms[part_inds, 0])) * 0.5 - pad
+
+    # scale facial feature
+    scale = np.random.rand()
+    if p_scale > 0.5 and scale > 0.5:
+
+        part_mean = np.mean(lms[part_inds, :], 0)
+        lms_part_norm = lms[part_inds, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        scale_max_y = np.minimum(
+            (y_min - part_mean[0]) / part_y_bound_min,
+            (y_max - part_mean[0]) / part_y_bound_max)
+        scale_max_y = np.minimum(scale_max_y, 1.2)
+
+        scale_max_x = np.minimum(
+            (x_min - part_mean[1]) / part_x_bound_min,
+            (x_max - part_mean[1]) / part_x_bound_max)
+        scale_max_x = np.minimum(scale_max_x, 1.2)
+
+        scale_y = np.random.uniform(0.7, scale_max_y)
+        scale_x = np.random.uniform(0.7, scale_max_x)
+
+        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
+
+        # check for spatial errors
+        error = check_deformation_spatial_errors(lms_def_scale, part_inds, pad=pad)
+        if error:
+            lms_def_scale = lms.copy()
+    else:
+        lms_def_scale = lms.copy()
+
+    # shift facial feature
+    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
+
+        part_mean = np.mean(lms_def_scale[part_inds, :], 0)
+        lms_part_norm = lms_def_scale[part_inds, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        shift_x = np.random.uniform(x_min - (part_mean[1] + part_x_bound_min),
+                                    x_max - (part_mean[1] + part_x_bound_max))
+        shift_y = np.random.uniform(y_min - (part_mean[0] + part_y_bound_min),
+                                    y_max - (part_mean[0] + part_y_bound_max))
+
+        lms_def = deform_part(lms_def_scale, part_inds, scale_y=1., scale_x=1., shift_ver=shift_y, shift_horiz=shift_x)
+        error = check_deformation_spatial_errors(lms_def, part_inds, pad=pad)
+        if error:
+            lms_def = lms_def_scale.copy()
+    else:
+        lms_def = lms_def_scale.copy()
+
+    return lms_def
+
+
+def deform_nose(lms, p_scale=0, p_shift=0, pad=5):
+    """ deform nose landmarks - matching ibug annotations of 68 landmarks """
+
+    nose_inds = np.arange(27, 36)
+    left_eye_inds = np.arange(36, 42)
+    right_eye_inds = np.arange(42, 48)
+    mouth_inds = np.arange(48, 68)
+
+    part_inds = nose_inds.copy()
+
+    # find part spatial limitations
+    x_max = np.max(lms[part_inds[:4], 1]) + (np.min(lms[right_eye_inds, 1]) - np.max(lms[part_inds[:4], 1])) * 0.5 - pad
+    x_min = np.max(lms[left_eye_inds, 1]) + (np.min(lms[part_inds[:4], 1]) - np.max(lms[left_eye_inds, 1])) * 0.5 + pad
+
+    max_brows = np.max(lms[21:23, 0])
+    y_min = np.min(lms[part_inds, 0]) + (max_brows - np.min(lms[part_inds, 0])) * 0.5
+    min_mouth = np.min(lms[mouth_inds, 0])
+    y_max = np.max(lms[part_inds, 0]) + (np.max(lms[part_inds, 0]) - min_mouth) * 0 - pad
+
+    # scale facial feature
+    scale = np.random.rand()
+    if p_scale > 0.5 and scale > 0.5:
+
+        part_mean = np.mean(lms[part_inds, :], 0)
+        lms_part_norm = lms[part_inds, :] - part_mean
+
+        part_y_bound_min = np.min(lms_part_norm[:, 0])
+        part_y_bound_max = np.max(lms_part_norm[:, 0])
+
+        scale_max_y = np.minimum(
+            (y_min - part_mean[0]) / part_y_bound_min,
+            (y_max - part_mean[0]) / part_y_bound_max)
+        scale_y = np.random.uniform(0.7, scale_max_y)
+        scale_x = np.random.uniform(0.7, 1.5)
+
+        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
+
+        error1 = check_deformation_spatial_errors(lms_def_scale, part_inds[:4], pad=pad)
+        error2 = check_deformation_spatial_errors(lms_def_scale, part_inds[4:], pad=pad)
+        error = error1 + error2
+        if error:
+            lms_def_scale = lms.copy()
+    else:
+        lms_def_scale = lms.copy()
+
+    # shift facial feature
+    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
+
+        part_mean = np.mean(lms_def_scale[part_inds, :], 0)
+        lms_part_norm = lms_def_scale[part_inds, :] - part_mean
+
+        part_x_bound_min = np.min(lms_part_norm[:4], 0)
+        part_x_bound_max = np.max(lms_part_norm[:4], 0)
+        part_y_bound_min = np.min(lms_part_norm[:, 0])
+        part_y_bound_max = np.max(lms_part_norm[:, 0])
+
+        shift_x = np.random.uniform(x_min - (part_mean[1] + part_x_bound_min),
+                                    x_max - (part_mean[1] + part_x_bound_max))
+        shift_y = np.random.uniform(y_min - (part_mean[0] + part_y_bound_min),
+                                    y_max - (part_mean[0] + part_y_bound_max))
+
+        lms_def = deform_part(lms_def_scale, part_inds, scale_y=1., scale_x=1., shift_ver=shift_y, shift_horiz=shift_x)
+
+        error1 = check_deformation_spatial_errors(lms_def, part_inds[:4], pad=pad)
+        error2 = check_deformation_spatial_errors(lms_def, part_inds[4:], pad=pad)
+        error = error1 + error2
+        if error:
+            lms_def = lms_def_scale.copy()
+    else:
+        lms_def = lms_def_scale.copy()
+
+    return lms_def
+
+
+def deform_eyes(lms, p_scale=0, p_shift=0, pad=10):
+    """ deform eyes + eyebrows landmarks - matching ibug annotations of 68 landmarks """
+
+    nose_inds = np.arange(27, 36)
+    left_eye_inds = np.arange(36, 42)
+    right_eye_inds = np.arange(42, 48)
+    left_brow_inds = np.arange(17, 22)
+    right_brow_inds = np.arange(22, 27)
+
+    part_inds_right = np.hstack((right_brow_inds, right_eye_inds))
+    part_inds_left = np.hstack((left_brow_inds, left_eye_inds))
+
+    # find part spatial limitations
+
+    # right eye+eyebrow
+    x_max_right = np.max(lms[part_inds_right, 1]) + (lms[16, 1] - np.max(lms[part_inds_right, 1])) * 0.5 - pad
+    x_min_right = np.max(lms[nose_inds[:4], 1]) + (np.min(lms[part_inds_right, 1]) - np.max(
+        lms[nose_inds[:4], 1])) * 0.5 + pad
+    y_max_right = np.max(lms[part_inds_right, 0]) + (lms[33, 0] - np.max(lms[part_inds_right, 0])) * 0.25 - pad
+    y_min_right = 2 * pad
+
+    # left eye+eyebrow
+    x_max_left = np.max(lms[part_inds_left, 1]) + (np.min(lms[nose_inds[:4], 1]) - np.max(
+        lms[part_inds_left, 1])) * 0.5 - pad
+    x_min_left = lms[0, 1] + (np.min(lms[part_inds_left, 1]) - lms[0, 1]) * 0.5 + pad
+
+    y_max_left = np.max(lms[part_inds_left, 0]) + (lms[33, 0] - np.max(lms[part_inds_left, 0])) * 0.25 - pad
+    y_min_left = 2 * pad
+
+    # scale facial feature
+    scale = np.random.rand()
+    if p_scale > 0.5 and scale > 0.5:
+
+        # right eye+eyebrow
+        part_mean = np.mean(lms[part_inds_right, :], 0)
+        lms_part_norm = lms[part_inds_right, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        scale_max_y = np.minimum(
+            (y_min_right - part_mean[0]) / part_y_bound_min,
+            (y_max_right - part_mean[0]) / part_y_bound_max)
+        scale_max_y_right = np.minimum(scale_max_y, 1.5)
+
+        scale_max_x = np.minimum(
+            (x_min_right - part_mean[1]) / part_x_bound_min,
+            (x_max_right - part_mean[1]) / part_x_bound_max)
+        scale_max_x_right = np.minimum(scale_max_x, 1.5)
+
+        # left eye+eyebrow
+        part_mean = np.mean(lms[part_inds_left, :], 0)
+        lms_part_norm = lms[part_inds_left, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        scale_max_y = np.minimum(
+            (y_min_left - part_mean[0]) / part_y_bound_min,
+            (y_max_left - part_mean[0]) / part_y_bound_max)
+        scale_max_y_left = np.minimum(scale_max_y, 1.5)
+
+        scale_max_x = np.minimum(
+            (x_min_left - part_mean[1]) / part_x_bound_min,
+            (x_max_left - part_mean[1]) / part_x_bound_max)
+        scale_max_x_left = np.minimum(scale_max_x, 1.5)
+
+        scale_max_x = np.minimum(scale_max_x_left, scale_max_x_right)
+        scale_max_y = np.minimum(scale_max_y_left, scale_max_y_right)
+        scale_y = np.random.uniform(0.8, scale_max_y)
+        scale_x = np.random.uniform(0.8, scale_max_x)
+
+        lms_def_scale = deform_part(lms, part_inds_right, scale_y=scale_y, scale_x=scale_x, shift_ver=0.,
+                                    shift_horiz=0.)
+        lms_def_scale = deform_part(lms_def_scale.copy(), part_inds_left, scale_y=scale_y, scale_x=scale_x,
+                                    shift_ver=0., shift_horiz=0.)
+
+        error1 = check_deformation_spatial_errors(lms_def_scale, part_inds_right, pad=pad)
+        error2 = check_deformation_spatial_errors(lms_def_scale, part_inds_left, pad=pad)
+        error = error1 + error2
+        if error:
+            lms_def_scale = lms.copy()
+    else:
+        lms_def_scale = lms.copy()
+
+    # shift facial feature
+    if p_shift > 0.5 and (np.random.rand() > 0.5 or not scale):
+
+        y_min_right = np.maximum(0.8 * np.min(lms_def_scale[part_inds_right, 0]), pad)
+        y_min_left = np.maximum(0.8 * np.min(lms_def_scale[part_inds_left, 0]), pad)
+
+        # right eye
+        part_mean = np.mean(lms_def_scale[part_inds_right, :], 0)
+        lms_part_norm = lms_def_scale[part_inds_right, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        shift_x = np.random.uniform(x_min_right - (part_mean[1] + part_x_bound_min),
+                                    x_max_right - (part_mean[1] + part_x_bound_max))
+        shift_y = np.random.uniform(y_min_right - (part_mean[0] + part_y_bound_min),
+                                    y_max_right - (part_mean[0] + part_y_bound_max))
+
+        lms_def_right = deform_part(lms_def_scale, part_inds_right, scale_y=1., scale_x=1., shift_ver=shift_y,
+                               shift_horiz=shift_x)
+
+        error1 = check_deformation_spatial_errors(lms_def_right, part_inds_right, pad=pad)
+        if error1:
+            lms_def_right = lms_def_scale.copy()
+
+        # left eye
+        part_mean = np.mean(lms_def_scale[part_inds_left, :], 0)
+        lms_part_norm = lms_def_scale[part_inds_left, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        shift_x = np.random.uniform(x_min_left - (part_mean[1] + part_x_bound_min),
+                                    x_max_left - (part_mean[1] + part_x_bound_max))
+        shift_y = np.random.uniform(y_min_left - (part_mean[0] + part_y_bound_min),
+                                    y_max_left - (part_mean[0] + part_y_bound_max))
+
+        lms_def = deform_part(lms_def_right.copy(), part_inds_left, scale_y=1., scale_x=1., shift_ver=shift_y,
+                              shift_horiz=shift_x)
+
+        error2 = check_deformation_spatial_errors(lms_def, part_inds_left, pad=pad)
+        if error2:
+            lms_def = lms_def_right.copy()
+    else:
+        lms_def = lms_def_scale.copy()
+
+    return lms_def
+
+
+def deform_scale_face(lms, p_scale=0, pad=5, image_size=256):
+    """ change face landmarks scale & aspect ratio - matching ibug annotations of 68 landmarks """
+
+    part_inds = np.arange(68)
+
+    # find spatial limitations
+    x_max = np.max(lms[part_inds, 1]) + (image_size - np.max(lms[part_inds, 1])) * 0.5 - pad
+    x_min = np.min(lms[part_inds, 1]) * 0.5 + pad
+
+    y_min = 2 * pad
+    y_max = np.max(lms[part_inds, 0]) + (image_size - np.max(lms[part_inds, 0])) * 0.5 - pad
+
+    if p_scale > 0.5:
+
+        part_mean = np.mean(lms[part_inds, :], 0)
+        lms_part_norm = lms[part_inds, :] - part_mean
+
+        part_y_bound_min, part_x_bound_min = np.min(lms_part_norm, 0)
+        part_y_bound_max, part_x_bound_max = np.max(lms_part_norm, 0)
+
+        scale_max_y = np.minimum(
+            (y_min - part_mean[0]) / part_y_bound_min,
+            (y_max - part_mean[0]) / part_y_bound_max)
+        scale_max_y = np.minimum(scale_max_y, 1.2)
+
+        scale_max_x = np.minimum(
+            (x_min - part_mean[1]) / part_x_bound_min,
+            (x_max - part_mean[1]) / part_x_bound_max)
+        scale_max_x = np.minimum(scale_max_x, 1.2)
+
+        scale_y = np.random.uniform(0.6, scale_max_y)
+        scale_x = np.random.uniform(0.6, scale_max_x)
+
+        lms_def_scale = deform_part(lms, part_inds, scale_y=scale_y, scale_x=scale_x, shift_ver=0., shift_horiz=0.)
+
+        # check for spatial errors
+        error2 = np.sum(lms_def_scale >= image_size) + np.sum(lms_def_scale < 0)
+        error1 = len(np.unique((lms_def_scale).astype('int'), axis=0)) != len(lms_def_scale)
+        error = error1 + error2
+        if error:
+            lms_def_scale = lms.copy()
+    else:
+        lms_def_scale = lms.copy()
+
+    return lms_def_scale
+
+
+def deform_face_geometric_style(lms, p_scale=0, p_shift=0):
+    """ deform facial landmarks - matching ibug annotations of 68 landmarks """
+
+    lms = deform_scale_face(lms.copy(), p_scale=p_scale, pad=0)
+    lms = deform_nose(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
+    lms = deform_mouth(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
+    lms = deform_eyes(lms.copy(), p_scale=p_scale, p_shift=p_shift, pad=0)
+    return lms
+
+
+def get_bounds(lms):
+    part_y_bound_min, part_x_bound_min = np.min(lms,0)
+    part_y_bound_max, part_x_bound_max = np.max(lms,0)
+    return np.array([[part_x_bound_min, part_x_bound_max], [part_y_bound_min, part_y_bound_max]])
+
+
+def part_intersection(part_to_check, points_to_compare, pad=0):
+    points_to_compare = np.round(points_to_compare.copy())
+    check_bounds = np.round(get_bounds(part_to_check))
+    check_bounds[:, 0] += pad
+    check_bounds[:, 1] -= pad
+    inds_y = np.where(np.logical_and(points_to_compare[:,0] > check_bounds[1,0], points_to_compare[:,0]<check_bounds[1,1]))
+    inds_x = np.where(np.logical_and(points_to_compare[:,1] > check_bounds[0,0], points_to_compare[:,1]<check_bounds[0,1]))
+    return np.intersect1d(inds_y, inds_x)
+
+
+def check_deformation_spatial_errors(def_landmarks, part_inds,pad=0):
+    """ check for spatial errors in deformed landmarks"""
+
+    part_to_check = def_landmarks[part_inds, :].copy()
+    points_to_compare = np.delete(def_landmarks, part_inds,axis=0).reshape(-1,2)
+    inter_inds = part_intersection(part_to_check,points_to_compare, pad=pad)
+    out = len(inter_inds) > 0
+    return out

MakeItTalk/thirdparty/face_of_art/logging_functions.py

@@ -1,200 +1,200 @@
-import numpy as np
-import os
-import cv2
-import matplotlib.pyplot as plt
-from scipy.ndimage import zoom
-
-
-def print_training_params_to_file(init_locals):
-    """save param log file"""
-
-    del init_locals['self']
-    with open(os.path.join(init_locals['save_log_path'], 'Training_Parameters.txt'), 'w') as f:
-        f.write('Training Parameters:\n\n')
-        for key, value in init_locals.items():
-            f.write('* %s: %s\n' % (key, value))
-
-
-def heat_maps_to_landmarks(maps, image_size=256, num_landmarks=68):
-    """find landmarks from heatmaps (arg max on each map)"""
-
-    landmarks = np.zeros((num_landmarks,2)).astype('float32')
-
-    for m_ind in range(num_landmarks):
-        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
-
-    return landmarks
-
-
-def heat_maps_to_landmarks_alloc_once(maps, landmarks, image_size=256, num_landmarks=68):
-    """find landmarks from heatmaps (arg max on each map) with pre-allocation"""
-
-    for m_ind in range(num_landmarks):
-        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
-
-
-def batch_heat_maps_to_landmarks_alloc_once(batch_maps, batch_landmarks, batch_size, image_size=256, num_landmarks=68):
-    """find landmarks from heatmaps (arg max on each map) - for multiple images"""
-
-    for i in range(batch_size):
-        heat_maps_to_landmarks_alloc_once(
-            maps=batch_maps[i, :, :, :], landmarks=batch_landmarks[i, :, :], image_size=image_size,
-            num_landmarks=num_landmarks)
-
-
-def normalize_map(map_in):
-    map_min = map_in.min()
-    return (map_in - map_min) / (map_in.max() - map_min)
-
-
-def map_to_rgb(map_gray):
-    cmap = plt.get_cmap('jet')
-    rgba_map_image = cmap(map_gray)
-    map_rgb = np.delete(rgba_map_image, 3, 2) * 255
-    return map_rgb
-
-
-def create_img_with_landmarks(image, landmarks, image_size=256, num_landmarks=68, scale=255, circle_size=2):
-    """add landmarks to a face image"""
-    image = image.reshape(image_size, image_size, -1)
-
-    if scale is 0:
-        image = 127.5 * (image + 1)
-    elif scale is 1:
-        image *= 255
-
-    landmarks = landmarks.reshape(num_landmarks, 2)
-    landmarks = np.clip(landmarks, 0, image_size-1)
-
-    for (y, x) in landmarks.astype('int'):
-        cv2.circle(image, (x, y), circle_size, (255, 0, 0), -1)
-
-    return image
-
-
-def heat_maps_to_image(maps, landmarks=None, image_size=256, num_landmarks=68):
-    """create one image from multiple heatmaps"""
-
-    if landmarks is None:
-        landmarks = heat_maps_to_landmarks(maps, image_size=image_size, num_landmarks=num_landmarks)
-
-    x, y = np.mgrid[0:image_size, 0:image_size]
-
-    pixel_dist = np.sqrt(
-        np.square(np.expand_dims(x, 2) - landmarks[:, 0]) + np.square(np.expand_dims(y, 2) - landmarks[:, 1]))
-
-    nn_landmark = np.argmin(pixel_dist, 2)
-
-    map_image = maps[x, y, nn_landmark]
-    map_image = (map_image-map_image.min())/(map_image.max()-map_image.min())  # normalize for visualization
-
-    return map_image
-
-
-def merge_images_landmarks_maps_gt(images, maps, maps_gt, landmarks=None, image_size=256, num_landmarks=68,
-                                   num_samples=9, scale=255, circle_size=2, fast=False):
-    """create image for log - containing input face images, predicted heatmaps and GT heatmaps (if exists)"""
-
-    images = images[:num_samples]
-    if maps.shape[1] is not image_size:
-        images = zoom(images, (1, 0.25, 0.25, 1))
-        image_size /= 4
-        image_size=int(image_size)
-    if maps_gt is not None:
-        if maps_gt.shape[1] is not image_size:
-            maps_gt = zoom(maps_gt, (1, 0.25, 0.25, 1))
-
-    cmap = plt.get_cmap('jet')
-
-    row = int(np.sqrt(num_samples))
-    if maps_gt is None:
-        merged = np.zeros([row * image_size, row * image_size * 2, 3])
-    else:
-        merged = np.zeros([row * image_size, row * image_size * 3, 3])
-
-    for idx, img in enumerate(images):
-        i = idx // row
-        j = idx % row
-
-        if landmarks is None:
-            img_landmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size,
-                                                   num_landmarks=num_landmarks)
-        else:
-            img_landmarks = landmarks[idx]
-
-        if fast:
-            map_image = np.amax(maps[idx, :, :, :], 2)
-            map_image = (map_image - map_image.min()) / (map_image.max() - map_image.min())
-        else:
-            map_image = heat_maps_to_image(maps[idx, :, :, :], img_landmarks, image_size=image_size,
-                                           num_landmarks=num_landmarks)
-        rgba_map_image = cmap(map_image)
-        map_image = np.delete(rgba_map_image, 3, 2) * 255
-
-        img = create_img_with_landmarks(img, img_landmarks, image_size, num_landmarks, scale=scale,
-                                        circle_size=circle_size)
-
-        if maps_gt is not None:
-            if fast:
-                map_gt_image = np.amax(maps_gt[idx, :, :, :], 2)
-                map_gt_image = (map_gt_image - map_gt_image.min()) / (map_gt_image.max() - map_gt_image.min())
-            else:
-                map_gt_image = heat_maps_to_image(maps_gt[idx, :, :, :], image_size=image_size,
-                                                  num_landmarks=num_landmarks)
-            rgba_map_gt_image = cmap(map_gt_image)
-            map_gt_image = np.delete(rgba_map_gt_image, 3, 2) * 255
-
-            merged[i * image_size:(i + 1) * image_size, (j * 3) * image_size:(j * 3 + 1) * image_size, :] = img
-            merged[i * image_size:(i + 1) * image_size, (j * 3 + 1) * image_size:(j * 3 + 2) * image_size,
-            :] = map_image
-            merged[i * image_size:(i + 1) * image_size, (j * 3 + 2) * image_size:(j * 3 + 3) * image_size,
-            :] = map_gt_image
-        else:
-            merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = img
-            merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size,:] = map_image
-
-    return merged
-
-
-def map_comapre_channels(images, maps1, maps2, image_size=64, num_landmarks=68, scale=255):
-    """create image for log - present one face image, along with all its heatmaps (one for each landmark)"""
-
-    map1 = maps1[0]
-    if maps2 is not None:
-        map2 = maps2[0]
-    image = images[0]
-
-    if image.shape[0] is not image_size:
-        image = zoom(image, (0.25, 0.25, 1))
-    if scale is 1:
-        image *= 255
-    elif scale is 0:
-        image = 127.5 * (image + 1)
-
-    row = np.ceil(np.sqrt(num_landmarks)).astype(np.int64)
-    if maps2 is not None:
-        merged = np.zeros([row * image_size, row * image_size * 2, 3])
-    else:
-        merged = np.zeros([row * image_size, row * image_size, 3])
-
-    for idx in range(num_landmarks):
-        i = idx // row
-        j = idx % row
-        channel_map = map_to_rgb(normalize_map(map1[:, :, idx]))
-        if maps2 is not None:
-            channel_map2 = map_to_rgb(normalize_map(map2[:, :, idx]))
-            merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] =\
-                channel_map
-            merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] =\
-                channel_map2
-        else:
-            merged[i * image_size:(i + 1) * image_size, j * image_size:(j + 1) * image_size, :] = channel_map
-
-    i = (idx + 1) // row
-    j = (idx + 1) % row
-    if maps2 is not None:
-        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = image
-    else:
-        merged[i * image_size:(i + 1) * image_size, j * image_size:(j + 1) * image_size, :] = image
-    return merged
-
+import numpy as np
+import os
+import cv2
+import matplotlib.pyplot as plt
+from scipy.ndimage import zoom
+
+
+def print_training_params_to_file(init_locals):
+    """save param log file"""
+
+    del init_locals['self']
+    with open(os.path.join(init_locals['save_log_path'], 'Training_Parameters.txt'), 'w') as f:
+        f.write('Training Parameters:\n\n')
+        for key, value in init_locals.items():
+            f.write('* %s: %s\n' % (key, value))
+
+
+def heat_maps_to_landmarks(maps, image_size=256, num_landmarks=68):
+    """find landmarks from heatmaps (arg max on each map)"""
+
+    landmarks = np.zeros((num_landmarks,2)).astype('float32')
+
+    for m_ind in range(num_landmarks):
+        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
+
+    return landmarks
+
+
+def heat_maps_to_landmarks_alloc_once(maps, landmarks, image_size=256, num_landmarks=68):
+    """find landmarks from heatmaps (arg max on each map) with pre-allocation"""
+
+    for m_ind in range(num_landmarks):
+        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
+
+
+def batch_heat_maps_to_landmarks_alloc_once(batch_maps, batch_landmarks, batch_size, image_size=256, num_landmarks=68):
+    """find landmarks from heatmaps (arg max on each map) - for multiple images"""
+
+    for i in range(batch_size):
+        heat_maps_to_landmarks_alloc_once(
+            maps=batch_maps[i, :, :, :], landmarks=batch_landmarks[i, :, :], image_size=image_size,
+            num_landmarks=num_landmarks)
+
+
+def normalize_map(map_in):
+    map_min = map_in.min()
+    return (map_in - map_min) / (map_in.max() - map_min)
+
+
+def map_to_rgb(map_gray):
+    cmap = plt.get_cmap('jet')
+    rgba_map_image = cmap(map_gray)
+    map_rgb = np.delete(rgba_map_image, 3, 2) * 255
+    return map_rgb
+
+
+def create_img_with_landmarks(image, landmarks, image_size=256, num_landmarks=68, scale=255, circle_size=2):
+    """add landmarks to a face image"""
+    image = image.reshape(image_size, image_size, -1)
+
+    if scale is 0:
+        image = 127.5 * (image + 1)
+    elif scale is 1:
+        image *= 255
+
+    landmarks = landmarks.reshape(num_landmarks, 2)
+    landmarks = np.clip(landmarks, 0, image_size-1)
+
+    for (y, x) in landmarks.astype('int'):
+        cv2.circle(image, (x, y), circle_size, (255, 0, 0), -1)
+
+    return image
+
+
+def heat_maps_to_image(maps, landmarks=None, image_size=256, num_landmarks=68):
+    """create one image from multiple heatmaps"""
+
+    if landmarks is None:
+        landmarks = heat_maps_to_landmarks(maps, image_size=image_size, num_landmarks=num_landmarks)
+
+    x, y = np.mgrid[0:image_size, 0:image_size]
+
+    pixel_dist = np.sqrt(
+        np.square(np.expand_dims(x, 2) - landmarks[:, 0]) + np.square(np.expand_dims(y, 2) - landmarks[:, 1]))
+
+    nn_landmark = np.argmin(pixel_dist, 2)
+
+    map_image = maps[x, y, nn_landmark]
+    map_image = (map_image-map_image.min())/(map_image.max()-map_image.min())  # normalize for visualization
+
+    return map_image
+
+
+def merge_images_landmarks_maps_gt(images, maps, maps_gt, landmarks=None, image_size=256, num_landmarks=68,
+                                   num_samples=9, scale=255, circle_size=2, fast=False):
+    """create image for log - containing input face images, predicted heatmaps and GT heatmaps (if exists)"""
+
+    images = images[:num_samples]
+    if maps.shape[1] is not image_size:
+        images = zoom(images, (1, 0.25, 0.25, 1))
+        image_size /= 4
+        image_size=int(image_size)
+    if maps_gt is not None:
+        if maps_gt.shape[1] is not image_size:
+            maps_gt = zoom(maps_gt, (1, 0.25, 0.25, 1))
+
+    cmap = plt.get_cmap('jet')
+
+    row = int(np.sqrt(num_samples))
+    if maps_gt is None:
+        merged = np.zeros([row * image_size, row * image_size * 2, 3])
+    else:
+        merged = np.zeros([row * image_size, row * image_size * 3, 3])
+
+    for idx, img in enumerate(images):
+        i = idx // row
+        j = idx % row
+
+        if landmarks is None:
+            img_landmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size,
+                                                   num_landmarks=num_landmarks)
+        else:
+            img_landmarks = landmarks[idx]
+
+        if fast:
+            map_image = np.amax(maps[idx, :, :, :], 2)
+            map_image = (map_image - map_image.min()) / (map_image.max() - map_image.min())
+        else:
+            map_image = heat_maps_to_image(maps[idx, :, :, :], img_landmarks, image_size=image_size,
+                                           num_landmarks=num_landmarks)
+        rgba_map_image = cmap(map_image)
+        map_image = np.delete(rgba_map_image, 3, 2) * 255
+
+        img = create_img_with_landmarks(img, img_landmarks, image_size, num_landmarks, scale=scale,
+                                        circle_size=circle_size)
+
+        if maps_gt is not None:
+            if fast:
+                map_gt_image = np.amax(maps_gt[idx, :, :, :], 2)
+                map_gt_image = (map_gt_image - map_gt_image.min()) / (map_gt_image.max() - map_gt_image.min())
+            else:
+                map_gt_image = heat_maps_to_image(maps_gt[idx, :, :, :], image_size=image_size,
+                                                  num_landmarks=num_landmarks)
+            rgba_map_gt_image = cmap(map_gt_image)
+            map_gt_image = np.delete(rgba_map_gt_image, 3, 2) * 255
+
+            merged[i * image_size:(i + 1) * image_size, (j * 3) * image_size:(j * 3 + 1) * image_size, :] = img
+            merged[i * image_size:(i + 1) * image_size, (j * 3 + 1) * image_size:(j * 3 + 2) * image_size,
+            :] = map_image
+            merged[i * image_size:(i + 1) * image_size, (j * 3 + 2) * image_size:(j * 3 + 3) * image_size,
+            :] = map_gt_image
+        else:
+            merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = img
+            merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size,:] = map_image
+
+    return merged
+
+
+def map_comapre_channels(images, maps1, maps2, image_size=64, num_landmarks=68, scale=255):
+    """create image for log - present one face image, along with all its heatmaps (one for each landmark)"""
+
+    map1 = maps1[0]
+    if maps2 is not None:
+        map2 = maps2[0]
+    image = images[0]
+
+    if image.shape[0] is not image_size:
+        image = zoom(image, (0.25, 0.25, 1))
+    if scale is 1:
+        image *= 255
+    elif scale is 0:
+        image = 127.5 * (image + 1)
+
+    row = np.ceil(np.sqrt(num_landmarks)).astype(np.int64)
+    if maps2 is not None:
+        merged = np.zeros([row * image_size, row * image_size * 2, 3])
+    else:
+        merged = np.zeros([row * image_size, row * image_size, 3])
+
+    for idx in range(num_landmarks):
+        i = idx // row
+        j = idx % row
+        channel_map = map_to_rgb(normalize_map(map1[:, :, idx]))
+        if maps2 is not None:
+            channel_map2 = map_to_rgb(normalize_map(map2[:, :, idx]))
+            merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] =\
+                channel_map
+            merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] =\
+                channel_map2
+        else:
+            merged[i * image_size:(i + 1) * image_size, j * image_size:(j + 1) * image_size, :] = channel_map
+
+    i = (idx + 1) // row
+    j = (idx + 1) % row
+    if maps2 is not None:
+        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = image
+    else:
+        merged[i * image_size:(i + 1) * image_size, j * image_size:(j + 1) * image_size, :] = image
+    return merged
+

MakeItTalk/thirdparty/face_of_art/menpo_functions.py

@@ -1,299 +1,299 @@
-import os
-from scipy.io import loadmat
-from menpo.shape.pointcloud import PointCloud
-from menpo.transform import ThinPlateSplines
-import menpo.transform as mt
-
-import menpo.io as mio
-from glob import glob
-from thirdparty.face_of_art.deformation_functions import *
-
-# landmark indices by facial feature
-jaw_indices = np.arange(0, 17)
-lbrow_indices = np.arange(17, 22)
-rbrow_indices = np.arange(22, 27)
-upper_nose_indices = np.arange(27, 31)
-lower_nose_indices = np.arange(31, 36)
-leye_indices = np.arange(36, 42)
-reye_indices = np.arange(42, 48)
-outer_mouth_indices = np.arange(48, 60)
-inner_mouth_indices = np.arange(60, 68)
-
-# flipped landmark indices
-mirrored_parts_68 = np.hstack([
-    jaw_indices[::-1], rbrow_indices[::-1], lbrow_indices[::-1],
-    upper_nose_indices, lower_nose_indices[::-1],
-    np.roll(reye_indices[::-1], 4), np.roll(leye_indices[::-1], 4),
-    np.roll(outer_mouth_indices[::-1], 7),
-    np.roll(inner_mouth_indices[::-1], 5)
-])
-
-
-def load_bb_files(bb_file_dirs):
-    """load bounding box mat file for challenging, common, full & training datasets"""
-
-    bb_files_dict = {}
-    for bb_file in bb_file_dirs:
-        bb_mat = loadmat(bb_file)['bounding_boxes']
-        num_imgs = np.max(bb_mat.shape)
-        for i in range(num_imgs):
-            name = bb_mat[0][i][0][0][0][0]
-            bb_init = bb_mat[0][i][0][0][1] - 1  # matlab indicies
-            bb_gt = bb_mat[0][i][0][0][2] - 1  # matlab indicies
-            if str(name) in bb_files_dict.keys():
-                print (str(name) + ' already exists')
-            else:
-                bb_files_dict[str(name)] = (bb_init, bb_gt)
-    return bb_files_dict
-
-
-def load_bb_dictionary(bb_dir, mode, test_data='full'):
-    """create bounding box dictionary of input dataset: train/common/full/challenging"""
-
-    if mode == 'TRAIN':
-        bb_dirs = \
-            ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
-    else:
-        if test_data == 'common':
-            bb_dirs = \
-                ['bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
-        elif test_data == 'challenging':
-            bb_dirs = ['bounding_boxes_ibug.mat']
-        elif test_data == 'full':
-            bb_dirs = \
-                ['bounding_boxes_ibug.mat', 'bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
-        elif test_data == 'training':
-            bb_dirs = \
-                ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
-        else:
-            bb_dirs = None
-
-    if mode == 'TEST' and test_data not in ['full', 'challenging', 'common', 'training']:
-        bb_files_dict = None
-    else:
-        bb_dirs = [os.path.join(bb_dir, dataset) for dataset in bb_dirs]
-        bb_files_dict = load_bb_files(bb_dirs)
-
-    return bb_files_dict
-
-
-def center_margin_bb(bb, img_bounds, margin=0.25):
-    """create new bounding box with input margin"""
-
-    bb_size = ([bb[0, 2] - bb[0, 0], bb[0, 3] - bb[0, 1]])
-    margins = (np.max(bb_size) * (1 + margin) - bb_size) / 2
-    bb_new = np.zeros_like(bb)
-    bb_new[0, 0] = np.maximum(bb[0, 0] - margins[0], 0)
-    bb_new[0, 2] = np.minimum(bb[0, 2] + margins[0], img_bounds[1])
-    bb_new[0, 1] = np.maximum(bb[0, 1] - margins[1], 0)
-    bb_new[0, 3] = np.minimum(bb[0, 3] + margins[1], img_bounds[0])
-    return bb_new
-
-
-def crop_to_face_image(img, bb_dictionary=None, gt=True, margin=0.25, image_size=256, normalize=True,
-                       return_transform=False):
-    """crop face image using bounding box dictionary, or GT landmarks"""
-
-    name = img.path.name
-    img_bounds = img.bounds()[1]
-
-    # if there is no bounding-box dict and GT landmarks are available, use it to determine the bounding box
-    if bb_dictionary is None and img.has_landmarks:
-        grp_name = img.landmarks.group_labels[0]
-        bb_menpo = img.landmarks[grp_name].bounding_box().points
-        bb = np.array([[bb_menpo[0, 1], bb_menpo[0, 0], bb_menpo[2, 1], bb_menpo[2, 0]]])
-    elif bb_dictionary is not None:
-        if gt:
-            bb = bb_dictionary[name][1]  # ground truth
-        else:
-            bb = bb_dictionary[name][0]  # init from face detector
-    else:
-        bb = None
-
-    if bb is not None:
-        # add margin to bounding box
-        bb = center_margin_bb(bb, img_bounds, margin=margin)
-        bb_pointcloud = PointCloud(np.array([[bb[0, 1], bb[0, 0]],
-                                             [bb[0, 3], bb[0, 0]],
-                                             [bb[0, 3], bb[0, 2]],
-                                             [bb[0, 1], bb[0, 2]]]))
-        if return_transform:
-            face_crop, bb_transform = img.crop_to_pointcloud(bb_pointcloud, return_transform=True)
-        else:
-            face_crop = img.crop_to_pointcloud(bb_pointcloud)
-    else:
-        # if there is no bounding box/gt landmarks, use entire image
-        face_crop = img.copy()
-        bb_transform = None
-
-    # if face crop is not a square - pad borders with mean pixel value
-    h, w = face_crop.shape
-    diff = h - w
-    if diff < 0:
-        face_crop.pixels = np.pad(face_crop.pixels, ((0, 0), (0, -1 * diff), (0, 0)), 'mean')
-    elif diff > 0:
-        face_crop.pixels = np.pad(face_crop.pixels, ((0, 0), (0, 0), (0, diff)), 'mean')
-
-    if return_transform:
-        face_crop, rescale_transform = face_crop.resize([image_size, image_size], return_transform=True)
-        if bb_transform is None:
-            transform_chain = rescale_transform
-        else:
-            transform_chain = mt.TransformChain(transforms=(rescale_transform, bb_transform))
-    else:
-        face_crop = face_crop.resize([image_size, image_size])
-
-    if face_crop.n_channels == 4:
-        face_crop.pixels = face_crop.pixels[:3, :, :]
-
-    if normalize:
-        face_crop.pixels = face_crop.rescale_pixels(0., 1.).pixels
-
-    if return_transform:
-        return face_crop, transform_chain
-    else:
-        return face_crop
-
-
-def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True):
-    """basic image augmentation: random crop, rotation and horizontal flip"""
-
-    # taken from MDM: https://github.com/trigeorgis/mdm
-    def mirror_landmarks_68(lms, im_size):
-        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
-        ).reshape(-1, 2))[mirrored_parts_68])
-
-    # taken from MDM: https://github.com/trigeorgis/mdm
-    def mirror_image(im):
-        im = im.copy()
-        im.pixels = im.pixels[..., ::-1].copy()
-
-        for group in im.landmarks:
-            lms = im.landmarks[group]
-            if lms.points.shape[0] == 68:
-                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
-
-        return im
-
-    flip_rand = np.random.random() > 0.5
-    #     rot_rand = np.random.random() > 0.5
-    #     crop_rand = np.random.random() > 0.5
-    rot_rand = True  # like ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-    crop_rand = True  # like ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-
-    if crop_rand:
-        lim = image_size - crop_size
-        min_crop_inds = np.random.randint(0, lim, 2)
-        max_crop_inds = min_crop_inds + crop_size
-        img = img.crop(min_crop_inds, max_crop_inds)
-
-    if flip and flip_rand:
-        img = mirror_image(img)
-
-    if rot_rand:
-        rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
-        img = img.rotate_ccw_about_centre(rot_angle)
-
-    img = img.resize([image_size, image_size])
-
-    return img
-
-
-def augment_menpo_img_ns(img, img_dir_ns, p_ns=0.):
-    """texture style image augmentation using stylized copies in *img_dir_ns*"""
-
-    img = img.copy()
-    if p_ns > 0.5:
-        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
-        num_augs = len(ns_augs)
-        if num_augs > 0:
-            ns_ind = np.random.randint(0, num_augs)
-            ns_aug = mio.import_image(ns_augs[ns_ind])
-            ns_pixels = ns_aug.pixels
-            img.pixels = ns_pixels
-    return img
-
-
-def augment_menpo_img_geom(img, p_geom=0.):
-    """geometric style image augmentation using random face deformations"""
-
-    img = img.copy()
-    if p_geom > 0.5:
-        grp_name = img.landmarks.group_labels[0]
-        lms_geom_warp = deform_face_geometric_style(img.landmarks[grp_name].points.copy(), p_scale=p_geom, p_shift=p_geom)
-        img = warp_face_image_tps(img, PointCloud(lms_geom_warp), grp_name)
-    return img
-
-
-def warp_face_image_tps(img, new_shape, lms_grp_name='PTS', warp_mode='constant'):
-    """warp image to new landmarks using TPS interpolation"""
-
-    tps = ThinPlateSplines(new_shape, img.landmarks[lms_grp_name])
-    try:
-        img_warp = img.warp_to_shape(img.shape, tps, mode=warp_mode)
-        img_warp.landmarks[lms_grp_name] = new_shape
-        return img_warp
-    except np.linalg.linalg.LinAlgError as err:
-        print ('Error:'+str(err)+'\nUsing original landmarks for:\n'+str(img.path))
-        return img
-
-
-def load_menpo_image_list(
-    img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-    bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
-    augment_geom=False, p_geom=0, verbose=False, return_transform=False):
-
-    """load images from image dir to create menpo-type image list"""
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size,
-                                  return_transform=return_transform)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size,
-                                  return_transform=return_transform)
-
-    def crop_to_face_image_test(img):
-        return crop_to_face_image(img, bb_dictionary=None, margin=margin, image_size=image_size,
-                                  return_transform=return_transform)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture)[0])
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom)[0])
-
-    if mode is 'TRAIN':
-        if train_crop_dir is None:
-            img_set_dir = os.path.join(img_dir, 'training')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, train_crop_dir)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-        # perform image augmentation
-        if augment_texture and p_texture > 0:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom and p_geom > 0:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:  # if mode is 'TEST', load test data
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            img_set_dir = os.path.join(img_dir, test_data)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, test_data+'*')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            out_image_list = out_image_list.map(crop_to_face_image_test)
-
-    return out_image_list
+import os
+from scipy.io import loadmat
+from menpo.shape.pointcloud import PointCloud
+from menpo.transform import ThinPlateSplines
+import menpo.transform as mt
+
+import menpo.io as mio
+from glob import glob
+from thirdparty.face_of_art.deformation_functions import *
+
+# landmark indices by facial feature
+jaw_indices = np.arange(0, 17)
+lbrow_indices = np.arange(17, 22)
+rbrow_indices = np.arange(22, 27)
+upper_nose_indices = np.arange(27, 31)
+lower_nose_indices = np.arange(31, 36)
+leye_indices = np.arange(36, 42)
+reye_indices = np.arange(42, 48)
+outer_mouth_indices = np.arange(48, 60)
+inner_mouth_indices = np.arange(60, 68)
+
+# flipped landmark indices
+mirrored_parts_68 = np.hstack([
+    jaw_indices[::-1], rbrow_indices[::-1], lbrow_indices[::-1],
+    upper_nose_indices, lower_nose_indices[::-1],
+    np.roll(reye_indices[::-1], 4), np.roll(leye_indices[::-1], 4),
+    np.roll(outer_mouth_indices[::-1], 7),
+    np.roll(inner_mouth_indices[::-1], 5)
+])
+
+
+def load_bb_files(bb_file_dirs):
+    """load bounding box mat file for challenging, common, full & training datasets"""
+
+    bb_files_dict = {}
+    for bb_file in bb_file_dirs:
+        bb_mat = loadmat(bb_file)['bounding_boxes']
+        num_imgs = np.max(bb_mat.shape)
+        for i in range(num_imgs):
+            name = bb_mat[0][i][0][0][0][0]
+            bb_init = bb_mat[0][i][0][0][1] - 1  # matlab indicies
+            bb_gt = bb_mat[0][i][0][0][2] - 1  # matlab indicies
+            if str(name) in bb_files_dict.keys():
+                print (str(name) + ' already exists')
+            else:
+                bb_files_dict[str(name)] = (bb_init, bb_gt)
+    return bb_files_dict
+
+
+def load_bb_dictionary(bb_dir, mode, test_data='full'):
+    """create bounding box dictionary of input dataset: train/common/full/challenging"""
+
+    if mode == 'TRAIN':
+        bb_dirs = \
+            ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
+    else:
+        if test_data == 'common':
+            bb_dirs = \
+                ['bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
+        elif test_data == 'challenging':
+            bb_dirs = ['bounding_boxes_ibug.mat']
+        elif test_data == 'full':
+            bb_dirs = \
+                ['bounding_boxes_ibug.mat', 'bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
+        elif test_data == 'training':
+            bb_dirs = \
+                ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
+        else:
+            bb_dirs = None
+
+    if mode == 'TEST' and test_data not in ['full', 'challenging', 'common', 'training']:
+        bb_files_dict = None
+    else:
+        bb_dirs = [os.path.join(bb_dir, dataset) for dataset in bb_dirs]
+        bb_files_dict = load_bb_files(bb_dirs)
+
+    return bb_files_dict
+
+
+def center_margin_bb(bb, img_bounds, margin=0.25):
+    """create new bounding box with input margin"""
+
+    bb_size = ([bb[0, 2] - bb[0, 0], bb[0, 3] - bb[0, 1]])
+    margins = (np.max(bb_size) * (1 + margin) - bb_size) / 2
+    bb_new = np.zeros_like(bb)
+    bb_new[0, 0] = np.maximum(bb[0, 0] - margins[0], 0)
+    bb_new[0, 2] = np.minimum(bb[0, 2] + margins[0], img_bounds[1])
+    bb_new[0, 1] = np.maximum(bb[0, 1] - margins[1], 0)
+    bb_new[0, 3] = np.minimum(bb[0, 3] + margins[1], img_bounds[0])
+    return bb_new
+
+
+def crop_to_face_image(img, bb_dictionary=None, gt=True, margin=0.25, image_size=256, normalize=True,
+                       return_transform=False):
+    """crop face image using bounding box dictionary, or GT landmarks"""
+
+    name = img.path.name
+    img_bounds = img.bounds()[1]
+
+    # if there is no bounding-box dict and GT landmarks are available, use it to determine the bounding box
+    if bb_dictionary is None and img.has_landmarks:
+        grp_name = img.landmarks.group_labels[0]
+        bb_menpo = img.landmarks[grp_name].bounding_box().points
+        bb = np.array([[bb_menpo[0, 1], bb_menpo[0, 0], bb_menpo[2, 1], bb_menpo[2, 0]]])
+    elif bb_dictionary is not None:
+        if gt:
+            bb = bb_dictionary[name][1]  # ground truth
+        else:
+            bb = bb_dictionary[name][0]  # init from face detector
+    else:
+        bb = None
+
+    if bb is not None:
+        # add margin to bounding box
+        bb = center_margin_bb(bb, img_bounds, margin=margin)
+        bb_pointcloud = PointCloud(np.array([[bb[0, 1], bb[0, 0]],
+                                             [bb[0, 3], bb[0, 0]],
+                                             [bb[0, 3], bb[0, 2]],
+                                             [bb[0, 1], bb[0, 2]]]))
+        if return_transform:
+            face_crop, bb_transform = img.crop_to_pointcloud(bb_pointcloud, return_transform=True)
+        else:
+            face_crop = img.crop_to_pointcloud(bb_pointcloud)
+    else:
+        # if there is no bounding box/gt landmarks, use entire image
+        face_crop = img.copy()
+        bb_transform = None
+
+    # if face crop is not a square - pad borders with mean pixel value
+    h, w = face_crop.shape
+    diff = h - w
+    if diff < 0:
+        face_crop.pixels = np.pad(face_crop.pixels, ((0, 0), (0, -1 * diff), (0, 0)), 'mean')
+    elif diff > 0:
+        face_crop.pixels = np.pad(face_crop.pixels, ((0, 0), (0, 0), (0, diff)), 'mean')
+
+    if return_transform:
+        face_crop, rescale_transform = face_crop.resize([image_size, image_size], return_transform=True)
+        if bb_transform is None:
+            transform_chain = rescale_transform
+        else:
+            transform_chain = mt.TransformChain(transforms=(rescale_transform, bb_transform))
+    else:
+        face_crop = face_crop.resize([image_size, image_size])
+
+    if face_crop.n_channels == 4:
+        face_crop.pixels = face_crop.pixels[:3, :, :]
+
+    if normalize:
+        face_crop.pixels = face_crop.rescale_pixels(0., 1.).pixels
+
+    if return_transform:
+        return face_crop, transform_chain
+    else:
+        return face_crop
+
+
+def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True):
+    """basic image augmentation: random crop, rotation and horizontal flip"""
+
+    # taken from MDM: https://github.com/trigeorgis/mdm
+    def mirror_landmarks_68(lms, im_size):
+        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
+        ).reshape(-1, 2))[mirrored_parts_68])
+
+    # taken from MDM: https://github.com/trigeorgis/mdm
+    def mirror_image(im):
+        im = im.copy()
+        im.pixels = im.pixels[..., ::-1].copy()
+
+        for group in im.landmarks:
+            lms = im.landmarks[group]
+            if lms.points.shape[0] == 68:
+                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
+
+        return im
+
+    flip_rand = np.random.random() > 0.5
+    #     rot_rand = np.random.random() > 0.5
+    #     crop_rand = np.random.random() > 0.5
+    rot_rand = True  # like ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+    crop_rand = True  # like ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+
+    if crop_rand:
+        lim = image_size - crop_size
+        min_crop_inds = np.random.randint(0, lim, 2)
+        max_crop_inds = min_crop_inds + crop_size
+        img = img.crop(min_crop_inds, max_crop_inds)
+
+    if flip and flip_rand:
+        img = mirror_image(img)
+
+    if rot_rand:
+        rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
+        img = img.rotate_ccw_about_centre(rot_angle)
+
+    img = img.resize([image_size, image_size])
+
+    return img
+
+
+def augment_menpo_img_ns(img, img_dir_ns, p_ns=0.):
+    """texture style image augmentation using stylized copies in *img_dir_ns*"""
+
+    img = img.copy()
+    if p_ns > 0.5:
+        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
+        num_augs = len(ns_augs)
+        if num_augs > 0:
+            ns_ind = np.random.randint(0, num_augs)
+            ns_aug = mio.import_image(ns_augs[ns_ind])
+            ns_pixels = ns_aug.pixels
+            img.pixels = ns_pixels
+    return img
+
+
+def augment_menpo_img_geom(img, p_geom=0.):
+    """geometric style image augmentation using random face deformations"""
+
+    img = img.copy()
+    if p_geom > 0.5:
+        grp_name = img.landmarks.group_labels[0]
+        lms_geom_warp = deform_face_geometric_style(img.landmarks[grp_name].points.copy(), p_scale=p_geom, p_shift=p_geom)
+        img = warp_face_image_tps(img, PointCloud(lms_geom_warp), grp_name)
+    return img
+
+
+def warp_face_image_tps(img, new_shape, lms_grp_name='PTS', warp_mode='constant'):
+    """warp image to new landmarks using TPS interpolation"""
+
+    tps = ThinPlateSplines(new_shape, img.landmarks[lms_grp_name])
+    try:
+        img_warp = img.warp_to_shape(img.shape, tps, mode=warp_mode)
+        img_warp.landmarks[lms_grp_name] = new_shape
+        return img_warp
+    except np.linalg.linalg.LinAlgError as err:
+        print ('Error:'+str(err)+'\nUsing original landmarks for:\n'+str(img.path))
+        return img
+
+
+def load_menpo_image_list(
+    img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+    bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
+    augment_geom=False, p_geom=0, verbose=False, return_transform=False):
+
+    """load images from image dir to create menpo-type image list"""
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size,
+                                  return_transform=return_transform)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size,
+                                  return_transform=return_transform)
+
+    def crop_to_face_image_test(img):
+        return crop_to_face_image(img, bb_dictionary=None, margin=margin, image_size=image_size,
+                                  return_transform=return_transform)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture)[0])
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom)[0])
+
+    if mode is 'TRAIN':
+        if train_crop_dir is None:
+            img_set_dir = os.path.join(img_dir, 'training')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, train_crop_dir)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+        # perform image augmentation
+        if augment_texture and p_texture > 0:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom and p_geom > 0:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:  # if mode is 'TEST', load test data
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            img_set_dir = os.path.join(img_dir, test_data)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, test_data+'*')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            out_image_list = out_image_list.map(crop_to_face_image_test)
+
+    return out_image_list

MakeItTalk/thirdparty/face_of_art/old/deep_heatmaps_model_ect.py

@@ -1,544 +1,544 @@
-import scipy.io
-import scipy.misc
-from glob import glob
-import os
-import numpy as np
-from image_utils import *
-from ops import *
-from sklearn.model_selection import train_test_split
-import tensorflow as tf
-from tensorflow import contrib
-
-
-class DeepHeatmapsModel(object):
-
-    """facial landmark localization Network"""
-
-    def __init__(self, mode='TRAIN', train_iter=500000, learning_rate=0.000001, image_size=256, c_dim=3, batch_size=10,
-                 num_landmarks=68, img_path='data', save_log_path='logs', save_sample_path='sample',
-                 save_model_path='model',test_model_path='model/deep_heatmaps-1000'):
-
-        self.mode = mode
-        self.train_iter=train_iter
-        self.learning_rate=learning_rate
-
-        self.image_size = image_size
-        self.c_dim = c_dim
-        self.batch_size = batch_size
-
-        self.num_landmarks = num_landmarks
-
-        self.save_log_path=save_log_path
-        self.save_sample_path=save_sample_path
-        self.save_model_path=save_model_path
-        self.test_model_path=test_model_path
-        self.img_path=img_path
-
-        self.momentum = 0.95
-        self.step = 20000  # for lr decay
-        self.gamma = 0.05  # for lr decay
-
-        self.weight_initializer = 'random_normal'  # random_normal or xavier
-        self.weight_initializer_std = 0.01
-        self.bias_initializer = 0.0
-
-        self.l_weight_primary = 100.
-        self.l_weight_fusion = 3.*self.l_weight_primary
-
-        self.sigma = 6  # sigma for heatmap generation
-        self.scale = 'zero_center'  # scale for image normalization '255' / '1' / 'zero_center'
-
-        self.print_every=2
-        self.save_every=100
-        self.sample_every_epoch = False
-        self.sample_every=10
-        self.sample_grid=4
-        self.log_every_epoch=1
-        self.log_histograms = True
-
-        self.config = tf.ConfigProto()
-        self.config.gpu_options.allow_growth = True
-
-        bb_dir = '/Users/arik/Desktop/DATA/face_data/300W/Bounding_Boxes/'
-        test_data='full'  # if mode is TEST, this choose the set to use full/common/challenging/test
-        margin = 0.25  # for face crops
-        bb_type = 'gt'  # gt/init
-
-        self.bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=test_data)
-
-        self.img_menpo_list = load_menpo_image_list(img_path, mode, self.bb_dictionary, image_size,
-                                                    margin=margin, bb_type=bb_type, test_data=test_data)
-
-        if mode is 'TRAIN':
-            train_params = locals()
-            print_training_params_to_file(train_params)
-
-    def add_placeholders(self):
-
-        if self.mode == 'TEST':
-                self.test_images = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'images')
-                # self.test_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks * 2], 'landmarks')
-
-                self.test_heatmaps = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'heatmaps')
-
-                self.test_heatmaps_small = tf.placeholder(
-                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'heatmaps_small')
-
-        elif self.mode == 'TRAIN':
-                self.train_images = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'train_images')
-                # self.train_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks*2], 'train_landmarks')
-
-                self.train_heatmaps = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'train_heatmaps')
-
-                self.train_heatmaps_small = tf.placeholder(
-                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'train_heatmaps_small')
-
-                # self.valid_images = tf.placeholder(
-                #     tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'valid_images')
-                # # self.valid_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks * 2], 'valid_landmarks')
-                #
-                # self.valid_heatmaps = tf.placeholder(
-                #     tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'valid_heatmaps')
-                #
-                # self.valid_heatmaps_small = tf.placeholder(
-                #     tf.float32,[None, self.image_size / 4, self.image_size / 4, self.num_landmarks], 'valid_heatmaps_small')
-
-    def heatmaps_network(self, input_images, reuse=None, name='pred_heatmaps'):
-
-        with tf.name_scope(name):
-
-            # if training is None:
-            #     if self.mode == 'train':
-            #         training = True
-            #     else:
-            #         training = False
-
-            if self.weight_initializer == 'xavier':
-                weight_initializer = contrib.layers.xavier_initializer()
-            else:
-                weight_initializer = tf.random_normal_initializer(stddev=self.weight_initializer_std)
-
-            bias_init = tf.constant_initializer(self.bias_initializer)
-
-            with tf.variable_scope('heatmaps_network'):
-                with tf.name_scope('primary_net'):
-
-                    l1 = conv_relu_pool(input_images, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                        reuse=reuse, var_scope='conv_1')
-                    l2 = conv_relu_pool(l1, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                        reuse=reuse, var_scope='conv_2')
-                    l3 = conv_relu(l2, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                   reuse=reuse, var_scope='conv_3')
-
-                    l4_1 = conv_relu(l3, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_1')
-                    l4_2 = conv_relu(l3, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_2')
-                    l4_3 = conv_relu(l3, 3, 128, conv_dilation=3, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_3')
-                    l4_4 = conv_relu(l3, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_4')
-
-                    l4 = tf.concat([l4_1, l4_2, l4_3, l4_4], 3, name='conv_4')
-
-                    l5_1 = conv_relu(l4, 3, 256, conv_dilation=1, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_1')
-                    l5_2 = conv_relu(l4, 3, 256, conv_dilation=2, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_2')
-                    l5_3 = conv_relu(l4, 3, 256, conv_dilation=3, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_3')
-                    l5_4 = conv_relu(l4, 3, 256, conv_dilation=4, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_4')
-
-                    l5 = tf.concat([l5_1, l5_2, l5_3, l5_4], 3, name='conv_5')
-
-                    l6 = conv_relu(l5, 1, 512, conv_ker_init=weight_initializer,
-                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_6')
-                    l7 = conv_relu(l6, 1, 256, conv_ker_init=weight_initializer,
-                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_7')
-                    primary_out = conv(l7, 1, self.num_landmarks, conv_ker_init=weight_initializer,
-                                            conv_bias_init=bias_init, reuse=reuse, var_scope='conv_8')
-
-                with tf.name_scope('fusion_net'):
-
-                    l_fsn_0 = tf.concat([l3, l7], 3, name='conv_3_7_fsn')
-
-                    l_fsn_1_1 = conv_relu(l_fsn_0, 3, 64, conv_dilation=1, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_1')
-                    l_fsn_1_2 = conv_relu(l_fsn_0, 3, 64, conv_dilation=2, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_2')
-                    l_fsn_1_3 = conv_relu(l_fsn_0, 3, 64, conv_dilation=3, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_3')
-
-                    l_fsn_1 = tf.concat([l_fsn_1_1, l_fsn_1_2, l_fsn_1_3], 3, name='conv_fsn_1')
-
-                    l_fsn_2_1 = conv_relu(l_fsn_1, 3, 64, conv_dilation=1, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_1')
-                    l_fsn_2_2 = conv_relu(l_fsn_1, 3, 64, conv_dilation=2, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_2')
-                    l_fsn_2_3 = conv_relu(l_fsn_1, 3, 64, conv_dilation=4, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_3')
-                    l_fsn_2_4 = conv_relu(l_fsn_1, 5, 64, conv_dilation=3, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_4')
-
-                    l_fsn_2 = tf.concat([l_fsn_2_1, l_fsn_2_2, l_fsn_2_3, l_fsn_2_4], 3, name='conv_fsn_2')
-
-                    l_fsn_3_1 = conv_relu(l_fsn_2, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_1')
-                    l_fsn_3_2 = conv_relu(l_fsn_2, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_2')
-                    l_fsn_3_3 = conv_relu(l_fsn_2, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_3')
-                    l_fsn_3_4 = conv_relu(l_fsn_2, 5, 128, conv_dilation=3, conv_ker_init=weight_initializer,
-                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_4')
-
-                    l_fsn_3 = tf.concat([l_fsn_3_1, l_fsn_3_2, l_fsn_3_3, l_fsn_3_4], 3, name='conv_fsn_3')
-
-                    l_fsn_4 = conv_relu(l_fsn_3, 1, 256, conv_ker_init=weight_initializer,
-                                        conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_4')
-                    l_fsn_5 = conv(l_fsn_4, 1, self.num_landmarks, conv_ker_init=weight_initializer,
-                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_5')
-
-                with tf.name_scope('upsample_net'):
-
-                    out = deconv(l_fsn_5, 8, self.num_landmarks, conv_stride=4,
-                                 conv_ker_init=deconv2d_bilinear_upsampling_initializer(
-                                     [8, 8, self.num_landmarks, self.num_landmarks]), conv_bias_init=bias_init,
-                                 reuse=reuse, var_scope='deconv_1')
-
-                self.all_layers = [l1, l2, l3, l4, l5, l6, l7, primary_out, l_fsn_1, l_fsn_2, l_fsn_3, l_fsn_4,
-                                   l_fsn_5, out]
-
-                return primary_out, out
-
-    def build_model(self):
-        if self.mode == 'TEST':
-            self.pred_hm_p, self.pred_hm_f = self.heatmaps_network(self.test_images)
-        elif self.mode == 'TRAIN':
-            self.pred_hm_p,self.pred_hm_f = self.heatmaps_network(self.train_images,name='pred_heatmaps_train')
-            # self.pred_landmarks_valid = self.landmarks_network(self.valid_images,name='pred_landmarks_valid')
-            # self.pred_landmarks_eval = self.landmarks_network(self.test_images,training=False,reuse=True,name='pred_landmarks_eval')
-            # self.pred_landmarks_train = self.landmarks_network(self.train_images, reuse=True, name='pred_landmarks_train')
-
-    def create_loss_ops(self):
-
-        def l2_loss_norm_eyes(pred_landmarks, real_landmarks, normalize=True, name='l2_loss'):
-
-            with tf.name_scope(name):
-                with tf.name_scope('real_pred_landmarks_diff'):
-                    landmarks_diff = pred_landmarks - real_landmarks
-
-                if normalize:
-                    with tf.name_scope('real_landmarks_eye_dist'):
-                        with tf.name_scope('left_eye'):
-                            p1_out = tf.slice(real_landmarks, [0, 72], [-1, 2])
-                            p1_in = tf.slice(real_landmarks, [0, 78], [-1, 2])
-                            p1 = (p1_in + p1_out) / 2
-                        with tf.name_scope('right_eye'):
-                            p2_out = tf.slice(real_landmarks, [0, 90], [-1, 2])
-                            p2_in = tf.slice(real_landmarks, [0, 84], [-1, 2])
-                            p2 = (p2_in + p2_out) / 2
-                        eps = 1e-6
-                        eye_dist = tf.expand_dims(tf.sqrt(tf.reduce_sum(tf.square(p1 - p2), axis=1)) + eps, axis=1)
-                    norm_landmarks_diff = landmarks_diff / eye_dist
-                    l2_landmarks_norm = tf.reduce_mean(tf.square(norm_landmarks_diff))
-
-                    out = l2_landmarks_norm
-                else:
-                    l2_landmarks = tf.reduce_mean(tf.square(landmarks_diff))
-                    out = l2_landmarks
-
-                return out
-
-        if self.mode is 'TRAIN':
-            primary_maps_diff = self.pred_hm_p-self.train_heatmaps_small
-            fusion_maps_diff = self.pred_hm_f - self.train_heatmaps
-
-            self.l2_primary = tf.reduce_mean(tf.square(primary_maps_diff))
-            self.l2_fusion = tf.reduce_mean(tf.square(fusion_maps_diff))
-
-            self.total_loss = self.l_weight_primary * self.l2_primary + self.l_weight_fusion * self.l2_fusion
-
-            # self.l2_loss_batch_train = l2_loss_norm_eyes(self.pred_landmarks_train, self.train_landmarks,
-            #                                      self.normalize_loss_by_eyes, name='loss_train_batch')
-            # with tf.name_scope('losses_not_for_train_step'):
-            #     self.l2_loss_train = l2_loss_norm_eyes(self.pred_landmarks_train, self.train_landmarks,
-            #                                            self.normalize_loss_by_eyes, name='train')
-            #
-            #     self.l2_loss_valid = l2_loss_norm_eyes(self.pred_landmarks_valid, self.valid_landmarks,
-            #                                            self.normalize_loss_by_eyes, name='valid')
-        # else:
-            # self.l2_loss_test = l2_loss_norm_eyes(self.pred_landmarks_eval, self.test_landmarks,
-            #                                       self.normalize_loss_by_eyes)
-
-    # def predict_landmarks_in_batches(self,image_paths,session):
-    #
-    #     num_batches = int(1.*len(image_paths)/self.batch_size)
-    #     if num_batches == 0:
-    #         batch_size = len(image_paths)
-    #         num_batches = 1
-    #     else:
-    #         batch_size = self.batch_size
-    #
-    #     for i in range(num_batches):
-    #         batch_image_paths = image_paths[i * batch_size:(i + 1) * batch_size]
-    #         batch_images, _ = \
-    #             load_data(batch_image_paths, None, self.image_size, self.num_landmarks, conv=True)
-    #         if i == 0:
-    #             all_pred_landmarks = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
-    #         else:
-    #             batch_pred = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
-    #             all_pred_landmarks = np.concatenate((all_pred_landmarks,batch_pred),0)
-    #
-    #     reminder = len(image_paths)-num_batches*batch_size
-    #     if reminder >0:
-    #         reminder_paths = image_paths[-reminder:]
-    #         batch_images, _ = \
-    #             load_data(reminder_paths, None, self.image_size, self.num_landmarks, conv=True)
-    #         batch_pred = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
-    #         all_pred_landmarks = np.concatenate((all_pred_landmarks, batch_pred), 0)
-    #
-    #     return all_pred_landmarks
-
-    def create_summary_ops(self):
-
-            var_summary = [tf.summary.histogram(var.name,var) for var in tf.trainable_variables()]
-            grads = tf.gradients(self.total_loss, tf.trainable_variables())
-            grads = list(zip(grads, tf.trainable_variables()))
-            grad_summary = [tf.summary.histogram(var.name+'/grads',grad) for grad,var in grads]
-            activ_summary = [tf.summary.histogram(layer.name, layer) for layer in self.all_layers]
-            l2_primary = tf.summary.scalar('l2_primary', self.l2_primary)
-            l2_fusion = tf.summary.scalar('l2_fusion', self.l2_fusion)
-            l_total = tf.summary.scalar('l_total', self.total_loss)
-
-            if self.log_histograms:
-                self.batch_summary_op = tf.summary.merge([l2_primary, l2_fusion, l_total, var_summary, grad_summary,
-                                                          activ_summary])
-            else:
-                self.batch_summary_op = tf.summary.merge([l2_primary, l2_fusion, l_total])
-
-            # l2_train_loss_summary = tf.summary.scalar('l2_loss_train', self.l2_loss_train)
-            # l2_valid_loss_summary = tf.summary.scalar('l2_loss_valid', self.l2_loss_valid)
-            #
-            # self.epoch_summary_op = tf.summary.merge([l2_train_loss_summary, l2_valid_loss_summary])
-
-    def eval(self):
-
-        self.add_placeholders()
-        # build model
-        self.build_model()
-
-        num_images = len(self.img_menpo_list)
-        img_inds = np.arange(num_images)
-
-        sample_iter = int(1. * len(num_images) / self.sample_grid)
-
-        if self.max_test_sample is not None:
-            if self.max_test_sample < sample_iter:
-                sample_iter = self.max_test_sample
-
-        with tf.Session(config=self.config) as sess:
-
-            # load trained parameters
-            print ('loading test model...')
-            saver = tf.train.Saver()
-            saver.restore(sess, self.test_model_path)
-
-            _, model_name = os.path.split(self.test_model_path)
-
-            # if self.new_test_data is False:
-            #     # create loss ops
-            #     self.create_loss_ops()
-            #
-            #     all_test_pred_landmarks = self.predict_landmarks_in_batches(test_data_paths, session=sess)
-            #     _, all_test_real_landmarks = load_data(None, test_landmarks_paths, self.image_size,
-            #                                            self.num_landmarks, conv=True)
-            #     all_test_loss = sess.run(self.l2_loss_test, {self.pred_landmarks_eval: all_test_pred_landmarks,
-            #                                                  self.test_landmarks: all_test_real_landmarks})
-            #     with open(os.path.join(self.save_log_path, model_name+'-test_loss.txt'), 'w') as f:
-            #         f.write(str(all_test_loss))
-
-            for i in range(sample_iter):
-
-                batch_inds = img_inds[i * self.sample_grid:(i + 1) * self.sample_grid]
-
-                batch_images, _, _, _ = \
-                    load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
-                              num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
-                              save_landmarks=False)
-
-                batch_maps_pred, batch_maps_small_pred = sess.run([self.pred_hm_f, self.pred_hm_p],
-                                                                  {self.test_images: batch_images})
-
-                sample_path_imgs = os.path.join(self.save_sample_path, model_name + '-sample-%d-to-%d-1.png' % (
-                                        i * self.sample_grid, (i + 1) * self.sample_grid))
-
-                sample_path_maps = os.path.join(self.save_sample_path, model_name + '-sample-%d-to-%d-2.png' % (
-                                        i * self.sample_grid, (i + 1) * self.sample_grid))
-
-                merged_img = merge_images_landmarks_maps(
-                    batch_images, batch_maps_pred, image_size=self.image_size,
-                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale)
-
-                merged_map = merge_compare_maps(
-                    batch_maps_small_pred, batch_maps_pred, image_size=self.image_size/4,
-                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
-
-                scipy.misc.imsave(sample_path_imgs, merged_img)
-                scipy.misc.imsave(sample_path_maps, merged_map)
-
-                print ('saved %s' % sample_path_imgs)
-
-    def train(self):
-            tf.set_random_seed(1234)
-            # build a graph
-            # add placeholders
-            self.add_placeholders()
-            # build model
-            self.build_model()
-            # create loss ops
-            self.create_loss_ops()
-            # create summary ops
-            self.create_summary_ops()
-
-            # create optimizer and training op
-            global_step = tf.Variable(0, trainable=False)
-            lr = tf.train.exponential_decay(self.learning_rate,global_step, self.step, self.gamma, staircase=True)
-            optimizer = tf.train.MomentumOptimizer(lr,self.momentum)
-
-            train_op = optimizer.minimize(self.total_loss,global_step=global_step)
-
-            with tf.Session(config=self.config) as sess:
-
-                tf.global_variables_initializer().run()
-
-                # create model saver and file writer
-                summary_writer = tf.summary.FileWriter(logdir=self.save_log_path, graph=tf.get_default_graph())
-                saver = tf.train.Saver()
-
-                print
-                print('*** Start Training ***')
-
-                # set random seed
-                epoch = 0
-                print_epoch=True
-
-                num_train_images = len(self.img_menpo_list)
-                num_train_images=10
-                img_inds = np.arange(num_train_images)
-                np.random.shuffle(img_inds)
-
-                for step in range(self.train_iter + 1):
-
-                    # get batch images
-                    j = step % int(float(num_train_images) / float(self.batch_size))
-
-                    if step > 0 and j == 0:
-                        np.random.shuffle(img_inds)  # shuffle data if finished epoch
-                        epoch += 1
-                        print_epoch=True
-
-                    batch_inds = img_inds[j * self.batch_size:(j + 1) * self.batch_size]
-
-                    batch_images, batch_maps, batch_maps_small, _ =\
-                        load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
-                                  num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale, save_landmarks=False)
-
-                    feed_dict_train = {self.train_images: batch_images, self.train_heatmaps: batch_maps,
-                                       self.train_heatmaps_small: batch_maps_small}
-
-                    sess.run(train_op, feed_dict_train)
-
-                    # print loss every *log_every_epoch* epoch
-                    # if step == 0 or (step+1) == self.train_iter or (epoch % self.log_every_epoch ==0 and print_epoch):
-                    #     if self.sample_every_epoch is not True:
-                    #         print_epoch=False
-                    #     all_train_pred_landmarks=self.predict_landmarks_in_batches(train_data_paths,session=sess)
-                    #     _,all_train_real_landmarks = load_data(None,train_landmarks_paths,self.image_size,
-                    #                                          self.num_landmarks, conv=True)
-                    #     all_train_loss = sess.run(self.l2_loss_train,{self.pred_landmarks_train:all_train_pred_landmarks,
-                    #                               self.train_landmarks:all_train_real_landmarks})
-                    #
-                    #     all_valid_pred_landmarks = self.predict_landmarks_in_batches(valid_data_paths,session=sess)
-                    #     _, all_valid_real_landmarks = load_data(None, valid_landmarks_paths, self.image_size,
-                    #                                             self.num_landmarks, conv=True)
-                    #     all_valid_loss = sess.run(self.l2_loss_valid, {self.pred_landmarks_valid: all_valid_pred_landmarks,
-                    #                                                    self.valid_landmarks: all_valid_real_landmarks})
-                    #     print("--------- EPOCH %d ---------" % (epoch))
-                    #     print ('step: [%d/%d] train loss: [%.6f] valid loss: [%.6f]'
-                    #            % (step + 1, self.train_iter, all_train_loss, all_valid_loss))
-                    #     print("----------------------------")
-                    #     summary= sess.run(self.epoch_summary_op,{self.l2_loss_valid:all_valid_loss,self.l2_loss_train:all_train_loss})
-                    #     summary_writer.add_summary(summary, epoch)
-
-                    # save to log and print status
-                    if step == 0 or (step + 1) % self.print_every == 0:
-
-                        summary, l_p, l_f, l_t = sess.run(
-                            [self.batch_summary_op, self.l2_primary,self.l2_fusion,self.total_loss],
-                            feed_dict_train)
-
-                        summary_writer.add_summary(summary, step)
-
-                        print ('epoch: [%d] step: [%d/%d] primary loss: [%.6f] fusion loss: [%.6f] total loss: [%.6f]'
-                               % (epoch, step + 1, self.train_iter, l_p, l_f, l_t))
-
-                    # save model
-                    if (step + 1) % self.save_every == 0:
-                        saver.save(sess, os.path.join(self.save_model_path, 'deep_heatmaps'), global_step=step + 1)
-                        print ('model/deep-heatmaps-%d saved' % (step + 1))
-
-                    # save images with landmarks
-                    if self.sample_every_epoch and (epoch % self.log_every_epoch ==0 and print_epoch):
-                        print_epoch = False
-
-                        # train_pred = sess.run(self.pred_landmarks_eval, {self.test_images: batch_images})
-                        # valid_pred = sess.run(self.pred_landmarks_eval, {self.test_images: valid_images_sample})
-                        #
-                        # train_sample_path = os.path.join(self.save_sample_path, 'train-epoch-%d.png' % (epoch))
-                        # valid_sample_path = os.path.join(self.save_sample_path, 'valid-epoch-%d.png' % (epoch))
-                        #
-                        # merge_images_train = merge_images_with_landmarks(batch_images, train_pred, self.image_size,
-                        #                                                  self.num_landmarks, self.sample_grid)
-                        # merge_images_valid = merge_images_with_landmarks(valid_images_sample, valid_pred,
-                        #                                                  self.image_size, self.num_landmarks,
-                        #                                                  self.sample_grid)
-                        #
-                        # scipy.misc.imsave(train_sample_path, merge_images_train)
-                        # scipy.misc.imsave(valid_sample_path, merge_images_valid)
-
-                    elif (self.sample_every_epoch is False) and (step == 0 or (step + 1) % self.sample_every == 0):
-
-                            batch_maps_pred, batch_maps_small_pred = sess.run([self.pred_hm_f, self.pred_hm_p],
-                                                                              {self.train_images: batch_images})
-
-                            print 'map vals', batch_maps_pred.min(), batch_maps_pred.max()
-                            print 'small map vals', batch_maps_small_pred.min(), batch_maps_small_pred.max()
-
-                            sample_path_imgs = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-1.png' % (epoch, step + 1))
-                            sample_path_maps = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-2.png' % (epoch, step + 1))
-
-                            merged_img = merge_images_landmarks_maps(
-                                batch_images, batch_maps_pred, image_size=self.image_size,
-                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale)
-
-                            merged_map = merge_compare_maps(
-                                batch_maps_small_pred, batch_maps_pred, image_size=self.image_size/4,
-                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
-
-                            scipy.misc.imsave(sample_path_imgs, merged_img)
-                            scipy.misc.imsave(sample_path_maps, merged_map)
-
-                print('*** Finished Training ***')
-                # evaluate model on test set
-                # all_test_pred_landmarks = self.predict_landmarks_in_batches(test_data_paths,session=sess)
-                # _, all_test_real_landmarks = load_data(None, test_landmarks_paths, self.image_size,
-                #                                        self.num_landmarks, conv=True)
-                # all_test_loss = sess.run(self.l2_loss_test, {self.pred_landmarks_test: all_test_pred_landmarks,
-                #                                                self.test_landmarks: all_test_real_landmarks})
-                #
-                # print ('step: [%d/%d] test loss: [%.6f]' % (step, self.train_iter, all_test_loss))
+import scipy.io
+import scipy.misc
+from glob import glob
+import os
+import numpy as np
+from image_utils import *
+from ops import *
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+from tensorflow import contrib
+
+
+class DeepHeatmapsModel(object):
+
+    """facial landmark localization Network"""
+
+    def __init__(self, mode='TRAIN', train_iter=500000, learning_rate=0.000001, image_size=256, c_dim=3, batch_size=10,
+                 num_landmarks=68, img_path='data', save_log_path='logs', save_sample_path='sample',
+                 save_model_path='model',test_model_path='model/deep_heatmaps-1000'):
+
+        self.mode = mode
+        self.train_iter=train_iter
+        self.learning_rate=learning_rate
+
+        self.image_size = image_size
+        self.c_dim = c_dim
+        self.batch_size = batch_size
+
+        self.num_landmarks = num_landmarks
+
+        self.save_log_path=save_log_path
+        self.save_sample_path=save_sample_path
+        self.save_model_path=save_model_path
+        self.test_model_path=test_model_path
+        self.img_path=img_path
+
+        self.momentum = 0.95
+        self.step = 20000  # for lr decay
+        self.gamma = 0.05  # for lr decay
+
+        self.weight_initializer = 'random_normal'  # random_normal or xavier
+        self.weight_initializer_std = 0.01
+        self.bias_initializer = 0.0
+
+        self.l_weight_primary = 100.
+        self.l_weight_fusion = 3.*self.l_weight_primary
+
+        self.sigma = 6  # sigma for heatmap generation
+        self.scale = 'zero_center'  # scale for image normalization '255' / '1' / 'zero_center'
+
+        self.print_every=2
+        self.save_every=100
+        self.sample_every_epoch = False
+        self.sample_every=10
+        self.sample_grid=4
+        self.log_every_epoch=1
+        self.log_histograms = True
+
+        self.config = tf.ConfigProto()
+        self.config.gpu_options.allow_growth = True
+
+        bb_dir = '/Users/arik/Desktop/DATA/face_data/300W/Bounding_Boxes/'
+        test_data='full'  # if mode is TEST, this choose the set to use full/common/challenging/test
+        margin = 0.25  # for face crops
+        bb_type = 'gt'  # gt/init
+
+        self.bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=test_data)
+
+        self.img_menpo_list = load_menpo_image_list(img_path, mode, self.bb_dictionary, image_size,
+                                                    margin=margin, bb_type=bb_type, test_data=test_data)
+
+        if mode is 'TRAIN':
+            train_params = locals()
+            print_training_params_to_file(train_params)
+
+    def add_placeholders(self):
+
+        if self.mode == 'TEST':
+                self.test_images = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'images')
+                # self.test_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks * 2], 'landmarks')
+
+                self.test_heatmaps = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'heatmaps')
+
+                self.test_heatmaps_small = tf.placeholder(
+                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'heatmaps_small')
+
+        elif self.mode == 'TRAIN':
+                self.train_images = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'train_images')
+                # self.train_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks*2], 'train_landmarks')
+
+                self.train_heatmaps = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'train_heatmaps')
+
+                self.train_heatmaps_small = tf.placeholder(
+                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'train_heatmaps_small')
+
+                # self.valid_images = tf.placeholder(
+                #     tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'valid_images')
+                # # self.valid_landmarks = tf.placeholder(tf.float32, [None, self.num_landmarks * 2], 'valid_landmarks')
+                #
+                # self.valid_heatmaps = tf.placeholder(
+                #     tf.float32, [None, self.image_size, self.image_size, self.num_landmarks], 'valid_heatmaps')
+                #
+                # self.valid_heatmaps_small = tf.placeholder(
+                #     tf.float32,[None, self.image_size / 4, self.image_size / 4, self.num_landmarks], 'valid_heatmaps_small')
+
+    def heatmaps_network(self, input_images, reuse=None, name='pred_heatmaps'):
+
+        with tf.name_scope(name):
+
+            # if training is None:
+            #     if self.mode == 'train':
+            #         training = True
+            #     else:
+            #         training = False
+
+            if self.weight_initializer == 'xavier':
+                weight_initializer = contrib.layers.xavier_initializer()
+            else:
+                weight_initializer = tf.random_normal_initializer(stddev=self.weight_initializer_std)
+
+            bias_init = tf.constant_initializer(self.bias_initializer)
+
+            with tf.variable_scope('heatmaps_network'):
+                with tf.name_scope('primary_net'):
+
+                    l1 = conv_relu_pool(input_images, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                        reuse=reuse, var_scope='conv_1')
+                    l2 = conv_relu_pool(l1, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                        reuse=reuse, var_scope='conv_2')
+                    l3 = conv_relu(l2, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                   reuse=reuse, var_scope='conv_3')
+
+                    l4_1 = conv_relu(l3, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_1')
+                    l4_2 = conv_relu(l3, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_2')
+                    l4_3 = conv_relu(l3, 3, 128, conv_dilation=3, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_3')
+                    l4_4 = conv_relu(l3, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_4')
+
+                    l4 = tf.concat([l4_1, l4_2, l4_3, l4_4], 3, name='conv_4')
+
+                    l5_1 = conv_relu(l4, 3, 256, conv_dilation=1, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_1')
+                    l5_2 = conv_relu(l4, 3, 256, conv_dilation=2, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_2')
+                    l5_3 = conv_relu(l4, 3, 256, conv_dilation=3, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_3')
+                    l5_4 = conv_relu(l4, 3, 256, conv_dilation=4, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_4')
+
+                    l5 = tf.concat([l5_1, l5_2, l5_3, l5_4], 3, name='conv_5')
+
+                    l6 = conv_relu(l5, 1, 512, conv_ker_init=weight_initializer,
+                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_6')
+                    l7 = conv_relu(l6, 1, 256, conv_ker_init=weight_initializer,
+                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_7')
+                    primary_out = conv(l7, 1, self.num_landmarks, conv_ker_init=weight_initializer,
+                                            conv_bias_init=bias_init, reuse=reuse, var_scope='conv_8')
+
+                with tf.name_scope('fusion_net'):
+
+                    l_fsn_0 = tf.concat([l3, l7], 3, name='conv_3_7_fsn')
+
+                    l_fsn_1_1 = conv_relu(l_fsn_0, 3, 64, conv_dilation=1, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_1')
+                    l_fsn_1_2 = conv_relu(l_fsn_0, 3, 64, conv_dilation=2, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_2')
+                    l_fsn_1_3 = conv_relu(l_fsn_0, 3, 64, conv_dilation=3, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_1_3')
+
+                    l_fsn_1 = tf.concat([l_fsn_1_1, l_fsn_1_2, l_fsn_1_3], 3, name='conv_fsn_1')
+
+                    l_fsn_2_1 = conv_relu(l_fsn_1, 3, 64, conv_dilation=1, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_1')
+                    l_fsn_2_2 = conv_relu(l_fsn_1, 3, 64, conv_dilation=2, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_2')
+                    l_fsn_2_3 = conv_relu(l_fsn_1, 3, 64, conv_dilation=4, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_3')
+                    l_fsn_2_4 = conv_relu(l_fsn_1, 5, 64, conv_dilation=3, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_2_4')
+
+                    l_fsn_2 = tf.concat([l_fsn_2_1, l_fsn_2_2, l_fsn_2_3, l_fsn_2_4], 3, name='conv_fsn_2')
+
+                    l_fsn_3_1 = conv_relu(l_fsn_2, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_1')
+                    l_fsn_3_2 = conv_relu(l_fsn_2, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_2')
+                    l_fsn_3_3 = conv_relu(l_fsn_2, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_3')
+                    l_fsn_3_4 = conv_relu(l_fsn_2, 5, 128, conv_dilation=3, conv_ker_init=weight_initializer,
+                                          conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_3_4')
+
+                    l_fsn_3 = tf.concat([l_fsn_3_1, l_fsn_3_2, l_fsn_3_3, l_fsn_3_4], 3, name='conv_fsn_3')
+
+                    l_fsn_4 = conv_relu(l_fsn_3, 1, 256, conv_ker_init=weight_initializer,
+                                        conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_4')
+                    l_fsn_5 = conv(l_fsn_4, 1, self.num_landmarks, conv_ker_init=weight_initializer,
+                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_fsn_5')
+
+                with tf.name_scope('upsample_net'):
+
+                    out = deconv(l_fsn_5, 8, self.num_landmarks, conv_stride=4,
+                                 conv_ker_init=deconv2d_bilinear_upsampling_initializer(
+                                     [8, 8, self.num_landmarks, self.num_landmarks]), conv_bias_init=bias_init,
+                                 reuse=reuse, var_scope='deconv_1')
+
+                self.all_layers = [l1, l2, l3, l4, l5, l6, l7, primary_out, l_fsn_1, l_fsn_2, l_fsn_3, l_fsn_4,
+                                   l_fsn_5, out]
+
+                return primary_out, out
+
+    def build_model(self):
+        if self.mode == 'TEST':
+            self.pred_hm_p, self.pred_hm_f = self.heatmaps_network(self.test_images)
+        elif self.mode == 'TRAIN':
+            self.pred_hm_p,self.pred_hm_f = self.heatmaps_network(self.train_images,name='pred_heatmaps_train')
+            # self.pred_landmarks_valid = self.landmarks_network(self.valid_images,name='pred_landmarks_valid')
+            # self.pred_landmarks_eval = self.landmarks_network(self.test_images,training=False,reuse=True,name='pred_landmarks_eval')
+            # self.pred_landmarks_train = self.landmarks_network(self.train_images, reuse=True, name='pred_landmarks_train')
+
+    def create_loss_ops(self):
+
+        def l2_loss_norm_eyes(pred_landmarks, real_landmarks, normalize=True, name='l2_loss'):
+
+            with tf.name_scope(name):
+                with tf.name_scope('real_pred_landmarks_diff'):
+                    landmarks_diff = pred_landmarks - real_landmarks
+
+                if normalize:
+                    with tf.name_scope('real_landmarks_eye_dist'):
+                        with tf.name_scope('left_eye'):
+                            p1_out = tf.slice(real_landmarks, [0, 72], [-1, 2])
+                            p1_in = tf.slice(real_landmarks, [0, 78], [-1, 2])
+                            p1 = (p1_in + p1_out) / 2
+                        with tf.name_scope('right_eye'):
+                            p2_out = tf.slice(real_landmarks, [0, 90], [-1, 2])
+                            p2_in = tf.slice(real_landmarks, [0, 84], [-1, 2])
+                            p2 = (p2_in + p2_out) / 2
+                        eps = 1e-6
+                        eye_dist = tf.expand_dims(tf.sqrt(tf.reduce_sum(tf.square(p1 - p2), axis=1)) + eps, axis=1)
+                    norm_landmarks_diff = landmarks_diff / eye_dist
+                    l2_landmarks_norm = tf.reduce_mean(tf.square(norm_landmarks_diff))
+
+                    out = l2_landmarks_norm
+                else:
+                    l2_landmarks = tf.reduce_mean(tf.square(landmarks_diff))
+                    out = l2_landmarks
+
+                return out
+
+        if self.mode is 'TRAIN':
+            primary_maps_diff = self.pred_hm_p-self.train_heatmaps_small
+            fusion_maps_diff = self.pred_hm_f - self.train_heatmaps
+
+            self.l2_primary = tf.reduce_mean(tf.square(primary_maps_diff))
+            self.l2_fusion = tf.reduce_mean(tf.square(fusion_maps_diff))
+
+            self.total_loss = self.l_weight_primary * self.l2_primary + self.l_weight_fusion * self.l2_fusion
+
+            # self.l2_loss_batch_train = l2_loss_norm_eyes(self.pred_landmarks_train, self.train_landmarks,
+            #                                      self.normalize_loss_by_eyes, name='loss_train_batch')
+            # with tf.name_scope('losses_not_for_train_step'):
+            #     self.l2_loss_train = l2_loss_norm_eyes(self.pred_landmarks_train, self.train_landmarks,
+            #                                            self.normalize_loss_by_eyes, name='train')
+            #
+            #     self.l2_loss_valid = l2_loss_norm_eyes(self.pred_landmarks_valid, self.valid_landmarks,
+            #                                            self.normalize_loss_by_eyes, name='valid')
+        # else:
+            # self.l2_loss_test = l2_loss_norm_eyes(self.pred_landmarks_eval, self.test_landmarks,
+            #                                       self.normalize_loss_by_eyes)
+
+    # def predict_landmarks_in_batches(self,image_paths,session):
+    #
+    #     num_batches = int(1.*len(image_paths)/self.batch_size)
+    #     if num_batches == 0:
+    #         batch_size = len(image_paths)
+    #         num_batches = 1
+    #     else:
+    #         batch_size = self.batch_size
+    #
+    #     for i in range(num_batches):
+    #         batch_image_paths = image_paths[i * batch_size:(i + 1) * batch_size]
+    #         batch_images, _ = \
+    #             load_data(batch_image_paths, None, self.image_size, self.num_landmarks, conv=True)
+    #         if i == 0:
+    #             all_pred_landmarks = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
+    #         else:
+    #             batch_pred = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
+    #             all_pred_landmarks = np.concatenate((all_pred_landmarks,batch_pred),0)
+    #
+    #     reminder = len(image_paths)-num_batches*batch_size
+    #     if reminder >0:
+    #         reminder_paths = image_paths[-reminder:]
+    #         batch_images, _ = \
+    #             load_data(reminder_paths, None, self.image_size, self.num_landmarks, conv=True)
+    #         batch_pred = session.run(self.pred_landmarks_eval,{self.test_images:batch_images})
+    #         all_pred_landmarks = np.concatenate((all_pred_landmarks, batch_pred), 0)
+    #
+    #     return all_pred_landmarks
+
+    def create_summary_ops(self):
+
+            var_summary = [tf.summary.histogram(var.name,var) for var in tf.trainable_variables()]
+            grads = tf.gradients(self.total_loss, tf.trainable_variables())
+            grads = list(zip(grads, tf.trainable_variables()))
+            grad_summary = [tf.summary.histogram(var.name+'/grads',grad) for grad,var in grads]
+            activ_summary = [tf.summary.histogram(layer.name, layer) for layer in self.all_layers]
+            l2_primary = tf.summary.scalar('l2_primary', self.l2_primary)
+            l2_fusion = tf.summary.scalar('l2_fusion', self.l2_fusion)
+            l_total = tf.summary.scalar('l_total', self.total_loss)
+
+            if self.log_histograms:
+                self.batch_summary_op = tf.summary.merge([l2_primary, l2_fusion, l_total, var_summary, grad_summary,
+                                                          activ_summary])
+            else:
+                self.batch_summary_op = tf.summary.merge([l2_primary, l2_fusion, l_total])
+
+            # l2_train_loss_summary = tf.summary.scalar('l2_loss_train', self.l2_loss_train)
+            # l2_valid_loss_summary = tf.summary.scalar('l2_loss_valid', self.l2_loss_valid)
+            #
+            # self.epoch_summary_op = tf.summary.merge([l2_train_loss_summary, l2_valid_loss_summary])
+
+    def eval(self):
+
+        self.add_placeholders()
+        # build model
+        self.build_model()
+
+        num_images = len(self.img_menpo_list)
+        img_inds = np.arange(num_images)
+
+        sample_iter = int(1. * len(num_images) / self.sample_grid)
+
+        if self.max_test_sample is not None:
+            if self.max_test_sample < sample_iter:
+                sample_iter = self.max_test_sample
+
+        with tf.Session(config=self.config) as sess:
+
+            # load trained parameters
+            print ('loading test model...')
+            saver = tf.train.Saver()
+            saver.restore(sess, self.test_model_path)
+
+            _, model_name = os.path.split(self.test_model_path)
+
+            # if self.new_test_data is False:
+            #     # create loss ops
+            #     self.create_loss_ops()
+            #
+            #     all_test_pred_landmarks = self.predict_landmarks_in_batches(test_data_paths, session=sess)
+            #     _, all_test_real_landmarks = load_data(None, test_landmarks_paths, self.image_size,
+            #                                            self.num_landmarks, conv=True)
+            #     all_test_loss = sess.run(self.l2_loss_test, {self.pred_landmarks_eval: all_test_pred_landmarks,
+            #                                                  self.test_landmarks: all_test_real_landmarks})
+            #     with open(os.path.join(self.save_log_path, model_name+'-test_loss.txt'), 'w') as f:
+            #         f.write(str(all_test_loss))
+
+            for i in range(sample_iter):
+
+                batch_inds = img_inds[i * self.sample_grid:(i + 1) * self.sample_grid]
+
+                batch_images, _, _, _ = \
+                    load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
+                              num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
+                              save_landmarks=False)
+
+                batch_maps_pred, batch_maps_small_pred = sess.run([self.pred_hm_f, self.pred_hm_p],
+                                                                  {self.test_images: batch_images})
+
+                sample_path_imgs = os.path.join(self.save_sample_path, model_name + '-sample-%d-to-%d-1.png' % (
+                                        i * self.sample_grid, (i + 1) * self.sample_grid))
+
+                sample_path_maps = os.path.join(self.save_sample_path, model_name + '-sample-%d-to-%d-2.png' % (
+                                        i * self.sample_grid, (i + 1) * self.sample_grid))
+
+                merged_img = merge_images_landmarks_maps(
+                    batch_images, batch_maps_pred, image_size=self.image_size,
+                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale)
+
+                merged_map = merge_compare_maps(
+                    batch_maps_small_pred, batch_maps_pred, image_size=self.image_size/4,
+                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
+
+                scipy.misc.imsave(sample_path_imgs, merged_img)
+                scipy.misc.imsave(sample_path_maps, merged_map)
+
+                print ('saved %s' % sample_path_imgs)
+
+    def train(self):
+            tf.set_random_seed(1234)
+            # build a graph
+            # add placeholders
+            self.add_placeholders()
+            # build model
+            self.build_model()
+            # create loss ops
+            self.create_loss_ops()
+            # create summary ops
+            self.create_summary_ops()
+
+            # create optimizer and training op
+            global_step = tf.Variable(0, trainable=False)
+            lr = tf.train.exponential_decay(self.learning_rate,global_step, self.step, self.gamma, staircase=True)
+            optimizer = tf.train.MomentumOptimizer(lr,self.momentum)
+
+            train_op = optimizer.minimize(self.total_loss,global_step=global_step)
+
+            with tf.Session(config=self.config) as sess:
+
+                tf.global_variables_initializer().run()
+
+                # create model saver and file writer
+                summary_writer = tf.summary.FileWriter(logdir=self.save_log_path, graph=tf.get_default_graph())
+                saver = tf.train.Saver()
+
+                print
+                print('*** Start Training ***')
+
+                # set random seed
+                epoch = 0
+                print_epoch=True
+
+                num_train_images = len(self.img_menpo_list)
+                num_train_images=10
+                img_inds = np.arange(num_train_images)
+                np.random.shuffle(img_inds)
+
+                for step in range(self.train_iter + 1):
+
+                    # get batch images
+                    j = step % int(float(num_train_images) / float(self.batch_size))
+
+                    if step > 0 and j == 0:
+                        np.random.shuffle(img_inds)  # shuffle data if finished epoch
+                        epoch += 1
+                        print_epoch=True
+
+                    batch_inds = img_inds[j * self.batch_size:(j + 1) * self.batch_size]
+
+                    batch_images, batch_maps, batch_maps_small, _ =\
+                        load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
+                                  num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale, save_landmarks=False)
+
+                    feed_dict_train = {self.train_images: batch_images, self.train_heatmaps: batch_maps,
+                                       self.train_heatmaps_small: batch_maps_small}
+
+                    sess.run(train_op, feed_dict_train)
+
+                    # print loss every *log_every_epoch* epoch
+                    # if step == 0 or (step+1) == self.train_iter or (epoch % self.log_every_epoch ==0 and print_epoch):
+                    #     if self.sample_every_epoch is not True:
+                    #         print_epoch=False
+                    #     all_train_pred_landmarks=self.predict_landmarks_in_batches(train_data_paths,session=sess)
+                    #     _,all_train_real_landmarks = load_data(None,train_landmarks_paths,self.image_size,
+                    #                                          self.num_landmarks, conv=True)
+                    #     all_train_loss = sess.run(self.l2_loss_train,{self.pred_landmarks_train:all_train_pred_landmarks,
+                    #                               self.train_landmarks:all_train_real_landmarks})
+                    #
+                    #     all_valid_pred_landmarks = self.predict_landmarks_in_batches(valid_data_paths,session=sess)
+                    #     _, all_valid_real_landmarks = load_data(None, valid_landmarks_paths, self.image_size,
+                    #                                             self.num_landmarks, conv=True)
+                    #     all_valid_loss = sess.run(self.l2_loss_valid, {self.pred_landmarks_valid: all_valid_pred_landmarks,
+                    #                                                    self.valid_landmarks: all_valid_real_landmarks})
+                    #     print("--------- EPOCH %d ---------" % (epoch))
+                    #     print ('step: [%d/%d] train loss: [%.6f] valid loss: [%.6f]'
+                    #            % (step + 1, self.train_iter, all_train_loss, all_valid_loss))
+                    #     print("----------------------------")
+                    #     summary= sess.run(self.epoch_summary_op,{self.l2_loss_valid:all_valid_loss,self.l2_loss_train:all_train_loss})
+                    #     summary_writer.add_summary(summary, epoch)
+
+                    # save to log and print status
+                    if step == 0 or (step + 1) % self.print_every == 0:
+
+                        summary, l_p, l_f, l_t = sess.run(
+                            [self.batch_summary_op, self.l2_primary,self.l2_fusion,self.total_loss],
+                            feed_dict_train)
+
+                        summary_writer.add_summary(summary, step)
+
+                        print ('epoch: [%d] step: [%d/%d] primary loss: [%.6f] fusion loss: [%.6f] total loss: [%.6f]'
+                               % (epoch, step + 1, self.train_iter, l_p, l_f, l_t))
+
+                    # save model
+                    if (step + 1) % self.save_every == 0:
+                        saver.save(sess, os.path.join(self.save_model_path, 'deep_heatmaps'), global_step=step + 1)
+                        print ('model/deep-heatmaps-%d saved' % (step + 1))
+
+                    # save images with landmarks
+                    if self.sample_every_epoch and (epoch % self.log_every_epoch ==0 and print_epoch):
+                        print_epoch = False
+
+                        # train_pred = sess.run(self.pred_landmarks_eval, {self.test_images: batch_images})
+                        # valid_pred = sess.run(self.pred_landmarks_eval, {self.test_images: valid_images_sample})
+                        #
+                        # train_sample_path = os.path.join(self.save_sample_path, 'train-epoch-%d.png' % (epoch))
+                        # valid_sample_path = os.path.join(self.save_sample_path, 'valid-epoch-%d.png' % (epoch))
+                        #
+                        # merge_images_train = merge_images_with_landmarks(batch_images, train_pred, self.image_size,
+                        #                                                  self.num_landmarks, self.sample_grid)
+                        # merge_images_valid = merge_images_with_landmarks(valid_images_sample, valid_pred,
+                        #                                                  self.image_size, self.num_landmarks,
+                        #                                                  self.sample_grid)
+                        #
+                        # scipy.misc.imsave(train_sample_path, merge_images_train)
+                        # scipy.misc.imsave(valid_sample_path, merge_images_valid)
+
+                    elif (self.sample_every_epoch is False) and (step == 0 or (step + 1) % self.sample_every == 0):
+
+                            batch_maps_pred, batch_maps_small_pred = sess.run([self.pred_hm_f, self.pred_hm_p],
+                                                                              {self.train_images: batch_images})
+
+                            print 'map vals', batch_maps_pred.min(), batch_maps_pred.max()
+                            print 'small map vals', batch_maps_small_pred.min(), batch_maps_small_pred.max()
+
+                            sample_path_imgs = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-1.png' % (epoch, step + 1))
+                            sample_path_maps = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-2.png' % (epoch, step + 1))
+
+                            merged_img = merge_images_landmarks_maps(
+                                batch_images, batch_maps_pred, image_size=self.image_size,
+                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale)
+
+                            merged_map = merge_compare_maps(
+                                batch_maps_small_pred, batch_maps_pred, image_size=self.image_size/4,
+                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
+
+                            scipy.misc.imsave(sample_path_imgs, merged_img)
+                            scipy.misc.imsave(sample_path_maps, merged_map)
+
+                print('*** Finished Training ***')
+                # evaluate model on test set
+                # all_test_pred_landmarks = self.predict_landmarks_in_batches(test_data_paths,session=sess)
+                # _, all_test_real_landmarks = load_data(None, test_landmarks_paths, self.image_size,
+                #                                        self.num_landmarks, conv=True)
+                # all_test_loss = sess.run(self.l2_loss_test, {self.pred_landmarks_test: all_test_pred_landmarks,
+                #                                                self.test_landmarks: all_test_real_landmarks})
+                #
+                # print ('step: [%d/%d] test loss: [%.6f]' % (step, self.train_iter, all_test_loss))

MakeItTalk/thirdparty/face_of_art/old/deep_heatmaps_model_primary.py

@@ -1,392 +1,392 @@
-import scipy.io
-import scipy.misc
-from glob import glob
-import os
-import numpy as np
-from image_utils import *
-from ops import *
-from sklearn.model_selection import train_test_split
-import tensorflow as tf
-from tensorflow import contrib
-
-
-class DeepHeatmapsModel(object):
-
-    """facial landmark localization Network"""
-
-    def __init__(self, mode='TRAIN', train_iter=500000, learning_rate=1e-8, image_size=256, c_dim=3, batch_size=10,
-                 num_landmarks=68, augment=True, img_path='data', save_log_path='logs', save_sample_path='sample',
-                 save_model_path='model',test_model_path='model/deep_heatmaps_primary-1000'):
-
-        self.mode = mode
-        self.train_iter=train_iter
-        self.learning_rate=learning_rate
-
-        self.image_size = image_size
-        self.c_dim = c_dim
-        self.batch_size = batch_size
-
-        self.num_landmarks = num_landmarks
-
-        self.save_log_path=save_log_path
-        self.save_sample_path=save_sample_path
-        self.save_model_path=save_model_path
-        self.test_model_path=test_model_path
-        self.img_path=img_path
-
-        self.momentum = 0.95
-        self.step = 80000  # for lr decay
-        self.gamma = 0.1  # for lr decay
-
-        self.weight_initializer = 'xavier'  # random_normal or xavier
-        self.weight_initializer_std = 0.01
-        self.bias_initializer = 0.0
-
-        self.sigma = 1.5  # sigma for heatmap generation
-        self.scale = '1'  # scale for image normalization '255' / '1' / '0'
-
-        self.print_every=1
-        self.save_every=5000
-        self.sample_every_epoch = False
-        self.sample_every=5
-        self.sample_grid=9
-        self.log_every_epoch=1
-        self.log_histograms = True
-
-        self.config = tf.ConfigProto()
-        self.config.gpu_options.allow_growth = True
-
-        bb_dir = os.path.join(img_path,'Bounding_Boxes')
-        self.test_data ='test'  # if mode is TEST, this choose the set to use full/common/challenging/test
-        margin = 0.25  # for face crops
-        bb_type = 'gt'  # gt/init
-
-        self.debug = False
-        self.debug_data_size = 20
-        self.compute_nme = True
-
-        self.bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=self.test_data)
-
-        self.img_menpo_list = load_menpo_image_list(img_path, mode, self.bb_dictionary, image_size, augment=augment,
-                                                    margin=margin, bb_type=bb_type, test_data=self.test_data)
-
-        if mode is 'TRAIN':
-            train_params = locals()
-            print_training_params_to_file(train_params)
-
-    def add_placeholders(self):
-
-        if self.mode == 'TEST':
-                self.test_images = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'images')
-
-                self.test_heatmaps_small = tf.placeholder(
-                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'heatmaps_small')
-
-        elif self.mode == 'TRAIN':
-                self.train_images = tf.placeholder(
-                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'train_images')
-
-                self.train_heatmaps_small = tf.placeholder(
-                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'train_heatmaps_small')
-
-                if self.compute_nme:
-                    self.train_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'train_lms_small')
-                    self.pred_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'pred_lms_small')
-
-
-    def heatmaps_network(self, input_images, reuse=None, name='pred_heatmaps'):
-
-        with tf.name_scope(name):
-
-            if self.weight_initializer == 'xavier':
-                weight_initializer = contrib.layers.xavier_initializer()
-            else:
-                weight_initializer = tf.random_normal_initializer(stddev=self.weight_initializer_std)
-
-            bias_init = tf.constant_initializer(self.bias_initializer)
-
-            with tf.variable_scope('heatmaps_network'):
-                with tf.name_scope('primary_net'):
-
-                    l1 = conv_relu_pool(input_images, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                        reuse=reuse, var_scope='conv_1')
-                    l2 = conv_relu_pool(l1, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                        reuse=reuse, var_scope='conv_2')
-                    l3 = conv_relu(l2, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
-                                   reuse=reuse, var_scope='conv_3')
-
-                    l4_1 = conv_relu(l3, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_1')
-                    l4_2 = conv_relu(l3, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_2')
-                    l4_3 = conv_relu(l3, 3, 128, conv_dilation=3, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_3')
-                    l4_4 = conv_relu(l3, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_4')
-
-                    l4 = tf.concat([l4_1, l4_2, l4_3, l4_4], 3, name='conv_4')
-
-                    l5_1 = conv_relu(l4, 3, 256, conv_dilation=1, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_1')
-                    l5_2 = conv_relu(l4, 3, 256, conv_dilation=2, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_2')
-                    l5_3 = conv_relu(l4, 3, 256, conv_dilation=3, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_3')
-                    l5_4 = conv_relu(l4, 3, 256, conv_dilation=4, conv_ker_init=weight_initializer,
-                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_4')
-
-                    l5 = tf.concat([l5_1, l5_2, l5_3, l5_4], 3, name='conv_5')
-
-                    l6 = conv_relu(l5, 1, 512, conv_ker_init=weight_initializer,
-                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_6')
-                    l7 = conv_relu(l6, 1, 256, conv_ker_init=weight_initializer,
-                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_7')
-                    primary_out = conv(l7, 1, self.num_landmarks, conv_ker_init=weight_initializer,
-                                            conv_bias_init=bias_init, reuse=reuse, var_scope='conv_8')
-
-                self.all_layers = [l1, l2, l3, l4, l5, l6, l7, primary_out]
-
-                return primary_out
-
-    def build_model(self):
-        if self.mode == 'TEST':
-            self.pred_hm_p = self.heatmaps_network(self.test_images)
-        elif self.mode == 'TRAIN':
-            self.pred_hm_p = self.heatmaps_network(self.train_images,name='pred_heatmaps_train')
-
-    def create_loss_ops(self):
-
-        def l2_loss_norm_eyes(pred_landmarks, real_landmarks, normalize=True, name='NME_loss'):
-
-            with tf.name_scope(name):
-                with tf.name_scope('real_pred_landmarks_diff'):
-                    landmarks_diff = pred_landmarks - real_landmarks
-
-                if normalize:
-                    with tf.name_scope('inter_pupil_dist'):
-                        with tf.name_scope('left_eye'):
-                            p1 = tf.reduce_mean(tf.slice(real_landmarks, [0, 42, 0], [-1, 6, 2]), axis=1)
-                        with tf.name_scope('right_eye'):
-                            p2 = tf.reduce_mean(tf.slice(real_landmarks, [0, 36, 0], [-1, 6, 2]), axis=1)
-                        eps = 1e-6
-                        eye_dist = tf.expand_dims(tf.expand_dims(
-                            tf.sqrt(tf.reduce_sum(tf.square(p1 - p2), axis=1)) + eps, axis=1), axis=1)
-
-                    norm_landmarks_diff = landmarks_diff / eye_dist
-                    l2_landmarks_norm = tf.reduce_mean(tf.square(norm_landmarks_diff))
-
-                    out = l2_landmarks_norm
-                else:
-                    l2_landmarks = tf.reduce_mean(tf.square(landmarks_diff))
-                    out = l2_landmarks
-
-                return out
-
-        if self.mode is 'TRAIN':
-            primary_maps_diff = self.pred_hm_p-self.train_heatmaps_small
-            self.total_loss = 1000.*tf.reduce_mean(tf.square(primary_maps_diff))
-            # self.total_loss = self.l2_primary
-
-            if self.compute_nme:
-                self.nme_loss = l2_loss_norm_eyes(self.pred_lms_small,self.train_lms_small)
-            else:
-                self.nme_loss = tf.constant(0.)
-
-    def create_summary_ops(self):
-
-            var_summary = [tf.summary.histogram(var.name,var) for var in tf.trainable_variables()]
-            grads = tf.gradients(self.total_loss, tf.trainable_variables())
-            grads = list(zip(grads, tf.trainable_variables()))
-            grad_summary = [tf.summary.histogram(var.name+'/grads',grad) for grad,var in grads]
-            activ_summary = [tf.summary.histogram(layer.name, layer) for layer in self.all_layers]
-            l_total = tf.summary.scalar('l_total', self.total_loss)
-            l_nme = tf.summary.scalar('l_nme', self.nme_loss)
-
-            if self.log_histograms:
-                self.batch_summary_op = tf.summary.merge([l_total, l_nme, var_summary, grad_summary,
-                                                          activ_summary])
-            else:
-                self.batch_summary_op = tf.summary.merge([l_total, l_nme])
-
-    def eval(self):
-
-        self.add_placeholders()
-        # build model
-        self.build_model()
-
-        num_images = len(self.img_menpo_list)
-        img_inds = np.arange(num_images)
-
-        sample_iter = int(1. * num_images / self.sample_grid)
-
-        with tf.Session(config=self.config) as sess:
-
-            # load trained parameters
-            print ('loading test model...')
-            saver = tf.train.Saver()
-            saver.restore(sess, self.test_model_path)
-
-            _, model_name = os.path.split(self.test_model_path)
-
-            for i in range(sample_iter):
-
-                batch_inds = img_inds[i * self.sample_grid:(i + 1) * self.sample_grid]
-
-                batch_images, _, batch_maps_gt, _ = \
-                    load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
-                              num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
-                              save_landmarks=False, primary=True)
-
-                batch_maps_small_pred = sess.run(self.pred_hm_p, {self.test_images: batch_images})
-
-                sample_path_imgs = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+'-sample-%d-to-%d-1.png' % (
-                                        i * self.sample_grid, (i + 1) * self.sample_grid))
-
-                sample_path_maps = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+ '-sample-%d-to-%d-2.png' % (
-                                        i * self.sample_grid, (i + 1) * self.sample_grid))
-
-                sample_path_channels = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+ '-sample-%d-to-%d-3.png' % (
-                    i * self.sample_grid, (i + 1) * self.sample_grid))
-
-                merged_img = merge_images_landmarks_maps(
-                    batch_images, batch_maps_small_pred, image_size=self.image_size,
-                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid,
-                    scale=self.scale,circle_size=0)
-
-                merged_map = merge_compare_maps(
-                    batch_maps_gt, batch_maps_small_pred,image_size=self.image_size/4,
-                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
-
-                map_per_channel = map_comapre_channels(
-                    batch_images, batch_maps_small_pred,batch_maps_gt, image_size=self.image_size / 4,
-                    num_landmarks=self.num_landmarks, scale=self.scale)
-
-                scipy.misc.imsave(sample_path_imgs, merged_img)
-                scipy.misc.imsave(sample_path_maps, merged_map)
-                scipy.misc.imsave(sample_path_channels, map_per_channel)
-
-                print ('saved %s' % sample_path_imgs)
-
-    def train(self):
-            tf.set_random_seed(1234)
-            np.random.seed(1234)
-            # build a graph
-            # add placeholders
-            self.add_placeholders()
-            # build model
-            self.build_model()
-            # create loss ops
-            self.create_loss_ops()
-            # create summary ops
-            self.create_summary_ops()
-
-            # create optimizer and training op
-            global_step = tf.Variable(0, trainable=False)
-            lr = tf.train.exponential_decay(self.learning_rate,global_step, self.step, self.gamma, staircase=True)
-            optimizer = tf.train.MomentumOptimizer(lr,self.momentum)
-
-            train_op = optimizer.minimize(self.total_loss,global_step=global_step)
-
-            with tf.Session(config=self.config) as sess:
-
-                tf.global_variables_initializer().run()
-
-                # create model saver and file writer
-                summary_writer = tf.summary.FileWriter(logdir=self.save_log_path, graph=tf.get_default_graph())
-                saver = tf.train.Saver()
-
-                print
-                print('*** Start Training ***')
-
-                # set random seed
-                epoch = 0
-
-                num_train_images = len(self.img_menpo_list)
-                if self.debug:
-                    num_train_images=self.debug_data_size
-
-                img_inds = np.arange(num_train_images)
-                np.random.shuffle(img_inds)
-
-                for step in range(self.train_iter + 1):
-
-                    # get batch images
-                    j = step % int(float(num_train_images) / float(self.batch_size))
-
-                    if step > 0 and j == 0:
-                        np.random.shuffle(img_inds)  # shuffle data if finished epoch
-                        epoch += 1
-
-                    batch_inds = img_inds[j * self.batch_size:(j + 1) * self.batch_size]
-
-                    batch_images, _, batch_maps_small, batch_lms_small =\
-                        load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
-                                  num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
-                                  save_landmarks=self.compute_nme, primary=True)
-
-                    feed_dict_train = {self.train_images: batch_images, self.train_heatmaps_small: batch_maps_small}
-
-                    sess.run(train_op, feed_dict_train)
-
-                    # save to log and print status
-                    if step == 0 or (step + 1) % self.print_every == 0:
-
-                        if self.compute_nme:
-                            batch_maps_small_pred = sess.run(self.pred_hm_p, {self.train_images: batch_images})
-                            pred_lms_small = batch_heat_maps_to_image(
-                                batch_maps_small_pred, self.batch_size, image_size=self.image_size/4,
-                                num_landmarks=self.num_landmarks)
-
-                            feed_dict_log = {
-                                self.train_images: batch_images, self.train_heatmaps_small: batch_maps_small,
-                                self.train_lms_small: batch_lms_small, self.pred_lms_small: pred_lms_small}
-                        else:
-                            feed_dict_log = feed_dict_train
-
-                        summary, l_t,l_nme = sess.run([self.batch_summary_op, self.total_loss, self.nme_loss],
-                                                      feed_dict_log)
-
-                        summary_writer.add_summary(summary, step)
-
-                        print ('epoch: [%d] step: [%d/%d] primary loss: [%.6f] nme loss: [%.6f] ' % (
-                            epoch, step + 1, self.train_iter, l_t, l_nme))
-
-                    # save model
-                    if (step + 1) % self.save_every == 0:
-                        saver.save(sess, os.path.join(self.save_model_path, 'deep_heatmaps'), global_step=step + 1)
-                        print ('model/deep-heatmaps-%d saved' % (step + 1))
-
-                    # save images with landmarks
-                    if (self.sample_every_epoch is False) and (step == 0 or (step + 1) % self.sample_every == 0):
-
-                            if not self.compute_nme:
-                                batch_maps_small_pred = sess.run(self.pred_hm_p,  {self.train_images: batch_images})
-
-                            print 'small map vals', batch_maps_small_pred.min(), batch_maps_small_pred.max()
-
-                            sample_path_imgs = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-1.png'
-                                                            % (epoch, step + 1))
-                            sample_path_maps = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-2.png'
-                                                            % (epoch, step + 1))
-                            sample_path_ch_maps = os.path.join(self.save_sample_path, 'epoch-%d-train-iter-%d-3.png'
-                                                               % (epoch, step + 1))
-
-                            merged_img = merge_images_landmarks_maps(
-                                batch_images, batch_maps_small_pred, image_size=self.image_size,
-                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale,
-                                circle_size=0)
-
-                            merged_map = merge_compare_maps(
-                                batch_maps_small_pred, batch_maps_small, image_size=self.image_size/4,
-                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
-
-                            map_per_channel = map_comapre_channels(batch_images, batch_maps_small_pred, batch_maps_small,
-                                                                   image_size=self.image_size/4,
-                                                                   num_landmarks=self.num_landmarks,scale=self.scale)
-
-                            scipy.misc.imsave(sample_path_imgs, merged_img)
-                            scipy.misc.imsave(sample_path_maps, merged_map)
-                            scipy.misc.imsave(sample_path_ch_maps, map_per_channel)
-
+import scipy.io
+import scipy.misc
+from glob import glob
+import os
+import numpy as np
+from image_utils import *
+from ops import *
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+from tensorflow import contrib
+
+
+class DeepHeatmapsModel(object):
+
+    """facial landmark localization Network"""
+
+    def __init__(self, mode='TRAIN', train_iter=500000, learning_rate=1e-8, image_size=256, c_dim=3, batch_size=10,
+                 num_landmarks=68, augment=True, img_path='data', save_log_path='logs', save_sample_path='sample',
+                 save_model_path='model',test_model_path='model/deep_heatmaps_primary-1000'):
+
+        self.mode = mode
+        self.train_iter=train_iter
+        self.learning_rate=learning_rate
+
+        self.image_size = image_size
+        self.c_dim = c_dim
+        self.batch_size = batch_size
+
+        self.num_landmarks = num_landmarks
+
+        self.save_log_path=save_log_path
+        self.save_sample_path=save_sample_path
+        self.save_model_path=save_model_path
+        self.test_model_path=test_model_path
+        self.img_path=img_path
+
+        self.momentum = 0.95
+        self.step = 80000  # for lr decay
+        self.gamma = 0.1  # for lr decay
+
+        self.weight_initializer = 'xavier'  # random_normal or xavier
+        self.weight_initializer_std = 0.01
+        self.bias_initializer = 0.0
+
+        self.sigma = 1.5  # sigma for heatmap generation
+        self.scale = '1'  # scale for image normalization '255' / '1' / '0'
+
+        self.print_every=1
+        self.save_every=5000
+        self.sample_every_epoch = False
+        self.sample_every=5
+        self.sample_grid=9
+        self.log_every_epoch=1
+        self.log_histograms = True
+
+        self.config = tf.ConfigProto()
+        self.config.gpu_options.allow_growth = True
+
+        bb_dir = os.path.join(img_path,'Bounding_Boxes')
+        self.test_data ='test'  # if mode is TEST, this choose the set to use full/common/challenging/test
+        margin = 0.25  # for face crops
+        bb_type = 'gt'  # gt/init
+
+        self.debug = False
+        self.debug_data_size = 20
+        self.compute_nme = True
+
+        self.bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=self.test_data)
+
+        self.img_menpo_list = load_menpo_image_list(img_path, mode, self.bb_dictionary, image_size, augment=augment,
+                                                    margin=margin, bb_type=bb_type, test_data=self.test_data)
+
+        if mode is 'TRAIN':
+            train_params = locals()
+            print_training_params_to_file(train_params)
+
+    def add_placeholders(self):
+
+        if self.mode == 'TEST':
+                self.test_images = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'images')
+
+                self.test_heatmaps_small = tf.placeholder(
+                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'heatmaps_small')
+
+        elif self.mode == 'TRAIN':
+                self.train_images = tf.placeholder(
+                    tf.float32, [None, self.image_size, self.image_size, self.c_dim], 'train_images')
+
+                self.train_heatmaps_small = tf.placeholder(
+                    tf.float32, [None, self.image_size/4, self.image_size/4, self.num_landmarks], 'train_heatmaps_small')
+
+                if self.compute_nme:
+                    self.train_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'train_lms_small')
+                    self.pred_lms_small = tf.placeholder(tf.float32, [None, self.num_landmarks, 2], 'pred_lms_small')
+
+
+    def heatmaps_network(self, input_images, reuse=None, name='pred_heatmaps'):
+
+        with tf.name_scope(name):
+
+            if self.weight_initializer == 'xavier':
+                weight_initializer = contrib.layers.xavier_initializer()
+            else:
+                weight_initializer = tf.random_normal_initializer(stddev=self.weight_initializer_std)
+
+            bias_init = tf.constant_initializer(self.bias_initializer)
+
+            with tf.variable_scope('heatmaps_network'):
+                with tf.name_scope('primary_net'):
+
+                    l1 = conv_relu_pool(input_images, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                        reuse=reuse, var_scope='conv_1')
+                    l2 = conv_relu_pool(l1, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                        reuse=reuse, var_scope='conv_2')
+                    l3 = conv_relu(l2, 5, 128, conv_ker_init=weight_initializer, conv_bias_init=bias_init,
+                                   reuse=reuse, var_scope='conv_3')
+
+                    l4_1 = conv_relu(l3, 3, 128, conv_dilation=1, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_1')
+                    l4_2 = conv_relu(l3, 3, 128, conv_dilation=2, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_2')
+                    l4_3 = conv_relu(l3, 3, 128, conv_dilation=3, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_3')
+                    l4_4 = conv_relu(l3, 3, 128, conv_dilation=4, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_4_4')
+
+                    l4 = tf.concat([l4_1, l4_2, l4_3, l4_4], 3, name='conv_4')
+
+                    l5_1 = conv_relu(l4, 3, 256, conv_dilation=1, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_1')
+                    l5_2 = conv_relu(l4, 3, 256, conv_dilation=2, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_2')
+                    l5_3 = conv_relu(l4, 3, 256, conv_dilation=3, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_3')
+                    l5_4 = conv_relu(l4, 3, 256, conv_dilation=4, conv_ker_init=weight_initializer,
+                                     conv_bias_init=bias_init, reuse=reuse, var_scope='conv_5_4')
+
+                    l5 = tf.concat([l5_1, l5_2, l5_3, l5_4], 3, name='conv_5')
+
+                    l6 = conv_relu(l5, 1, 512, conv_ker_init=weight_initializer,
+                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_6')
+                    l7 = conv_relu(l6, 1, 256, conv_ker_init=weight_initializer,
+                                   conv_bias_init=bias_init, reuse=reuse, var_scope='conv_7')
+                    primary_out = conv(l7, 1, self.num_landmarks, conv_ker_init=weight_initializer,
+                                            conv_bias_init=bias_init, reuse=reuse, var_scope='conv_8')
+
+                self.all_layers = [l1, l2, l3, l4, l5, l6, l7, primary_out]
+
+                return primary_out
+
+    def build_model(self):
+        if self.mode == 'TEST':
+            self.pred_hm_p = self.heatmaps_network(self.test_images)
+        elif self.mode == 'TRAIN':
+            self.pred_hm_p = self.heatmaps_network(self.train_images,name='pred_heatmaps_train')
+
+    def create_loss_ops(self):
+
+        def l2_loss_norm_eyes(pred_landmarks, real_landmarks, normalize=True, name='NME_loss'):
+
+            with tf.name_scope(name):
+                with tf.name_scope('real_pred_landmarks_diff'):
+                    landmarks_diff = pred_landmarks - real_landmarks
+
+                if normalize:
+                    with tf.name_scope('inter_pupil_dist'):
+                        with tf.name_scope('left_eye'):
+                            p1 = tf.reduce_mean(tf.slice(real_landmarks, [0, 42, 0], [-1, 6, 2]), axis=1)
+                        with tf.name_scope('right_eye'):
+                            p2 = tf.reduce_mean(tf.slice(real_landmarks, [0, 36, 0], [-1, 6, 2]), axis=1)
+                        eps = 1e-6
+                        eye_dist = tf.expand_dims(tf.expand_dims(
+                            tf.sqrt(tf.reduce_sum(tf.square(p1 - p2), axis=1)) + eps, axis=1), axis=1)
+
+                    norm_landmarks_diff = landmarks_diff / eye_dist
+                    l2_landmarks_norm = tf.reduce_mean(tf.square(norm_landmarks_diff))
+
+                    out = l2_landmarks_norm
+                else:
+                    l2_landmarks = tf.reduce_mean(tf.square(landmarks_diff))
+                    out = l2_landmarks
+
+                return out
+
+        if self.mode is 'TRAIN':
+            primary_maps_diff = self.pred_hm_p-self.train_heatmaps_small
+            self.total_loss = 1000.*tf.reduce_mean(tf.square(primary_maps_diff))
+            # self.total_loss = self.l2_primary
+
+            if self.compute_nme:
+                self.nme_loss = l2_loss_norm_eyes(self.pred_lms_small,self.train_lms_small)
+            else:
+                self.nme_loss = tf.constant(0.)
+
+    def create_summary_ops(self):
+
+            var_summary = [tf.summary.histogram(var.name,var) for var in tf.trainable_variables()]
+            grads = tf.gradients(self.total_loss, tf.trainable_variables())
+            grads = list(zip(grads, tf.trainable_variables()))
+            grad_summary = [tf.summary.histogram(var.name+'/grads',grad) for grad,var in grads]
+            activ_summary = [tf.summary.histogram(layer.name, layer) for layer in self.all_layers]
+            l_total = tf.summary.scalar('l_total', self.total_loss)
+            l_nme = tf.summary.scalar('l_nme', self.nme_loss)
+
+            if self.log_histograms:
+                self.batch_summary_op = tf.summary.merge([l_total, l_nme, var_summary, grad_summary,
+                                                          activ_summary])
+            else:
+                self.batch_summary_op = tf.summary.merge([l_total, l_nme])
+
+    def eval(self):
+
+        self.add_placeholders()
+        # build model
+        self.build_model()
+
+        num_images = len(self.img_menpo_list)
+        img_inds = np.arange(num_images)
+
+        sample_iter = int(1. * num_images / self.sample_grid)
+
+        with tf.Session(config=self.config) as sess:
+
+            # load trained parameters
+            print ('loading test model...')
+            saver = tf.train.Saver()
+            saver.restore(sess, self.test_model_path)
+
+            _, model_name = os.path.split(self.test_model_path)
+
+            for i in range(sample_iter):
+
+                batch_inds = img_inds[i * self.sample_grid:(i + 1) * self.sample_grid]
+
+                batch_images, _, batch_maps_gt, _ = \
+                    load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
+                              num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
+                              save_landmarks=False, primary=True)
+
+                batch_maps_small_pred = sess.run(self.pred_hm_p, {self.test_images: batch_images})
+
+                sample_path_imgs = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+'-sample-%d-to-%d-1.png' % (
+                                        i * self.sample_grid, (i + 1) * self.sample_grid))
+
+                sample_path_maps = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+ '-sample-%d-to-%d-2.png' % (
+                                        i * self.sample_grid, (i + 1) * self.sample_grid))
+
+                sample_path_channels = os.path.join(self.save_sample_path, model_name +'-'+ self.test_data+ '-sample-%d-to-%d-3.png' % (
+                    i * self.sample_grid, (i + 1) * self.sample_grid))
+
+                merged_img = merge_images_landmarks_maps(
+                    batch_images, batch_maps_small_pred, image_size=self.image_size,
+                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid,
+                    scale=self.scale,circle_size=0)
+
+                merged_map = merge_compare_maps(
+                    batch_maps_gt, batch_maps_small_pred,image_size=self.image_size/4,
+                    num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
+
+                map_per_channel = map_comapre_channels(
+                    batch_images, batch_maps_small_pred,batch_maps_gt, image_size=self.image_size / 4,
+                    num_landmarks=self.num_landmarks, scale=self.scale)
+
+                scipy.misc.imsave(sample_path_imgs, merged_img)
+                scipy.misc.imsave(sample_path_maps, merged_map)
+                scipy.misc.imsave(sample_path_channels, map_per_channel)
+
+                print ('saved %s' % sample_path_imgs)
+
+    def train(self):
+            tf.set_random_seed(1234)
+            np.random.seed(1234)
+            # build a graph
+            # add placeholders
+            self.add_placeholders()
+            # build model
+            self.build_model()
+            # create loss ops
+            self.create_loss_ops()
+            # create summary ops
+            self.create_summary_ops()
+
+            # create optimizer and training op
+            global_step = tf.Variable(0, trainable=False)
+            lr = tf.train.exponential_decay(self.learning_rate,global_step, self.step, self.gamma, staircase=True)
+            optimizer = tf.train.MomentumOptimizer(lr,self.momentum)
+
+            train_op = optimizer.minimize(self.total_loss,global_step=global_step)
+
+            with tf.Session(config=self.config) as sess:
+
+                tf.global_variables_initializer().run()
+
+                # create model saver and file writer
+                summary_writer = tf.summary.FileWriter(logdir=self.save_log_path, graph=tf.get_default_graph())
+                saver = tf.train.Saver()
+
+                print
+                print('*** Start Training ***')
+
+                # set random seed
+                epoch = 0
+
+                num_train_images = len(self.img_menpo_list)
+                if self.debug:
+                    num_train_images=self.debug_data_size
+
+                img_inds = np.arange(num_train_images)
+                np.random.shuffle(img_inds)
+
+                for step in range(self.train_iter + 1):
+
+                    # get batch images
+                    j = step % int(float(num_train_images) / float(self.batch_size))
+
+                    if step > 0 and j == 0:
+                        np.random.shuffle(img_inds)  # shuffle data if finished epoch
+                        epoch += 1
+
+                    batch_inds = img_inds[j * self.batch_size:(j + 1) * self.batch_size]
+
+                    batch_images, _, batch_maps_small, batch_lms_small =\
+                        load_data(self.img_menpo_list, batch_inds, image_size=self.image_size, c_dim=self.c_dim,
+                                  num_landmarks=self.num_landmarks, sigma=self.sigma, scale=self.scale,
+                                  save_landmarks=self.compute_nme, primary=True)
+
+                    feed_dict_train = {self.train_images: batch_images, self.train_heatmaps_small: batch_maps_small}
+
+                    sess.run(train_op, feed_dict_train)
+
+                    # save to log and print status
+                    if step == 0 or (step + 1) % self.print_every == 0:
+
+                        if self.compute_nme:
+                            batch_maps_small_pred = sess.run(self.pred_hm_p, {self.train_images: batch_images})
+                            pred_lms_small = batch_heat_maps_to_image(
+                                batch_maps_small_pred, self.batch_size, image_size=self.image_size/4,
+                                num_landmarks=self.num_landmarks)
+
+                            feed_dict_log = {
+                                self.train_images: batch_images, self.train_heatmaps_small: batch_maps_small,
+                                self.train_lms_small: batch_lms_small, self.pred_lms_small: pred_lms_small}
+                        else:
+                            feed_dict_log = feed_dict_train
+
+                        summary, l_t,l_nme = sess.run([self.batch_summary_op, self.total_loss, self.nme_loss],
+                                                      feed_dict_log)
+
+                        summary_writer.add_summary(summary, step)
+
+                        print ('epoch: [%d] step: [%d/%d] primary loss: [%.6f] nme loss: [%.6f] ' % (
+                            epoch, step + 1, self.train_iter, l_t, l_nme))
+
+                    # save model
+                    if (step + 1) % self.save_every == 0:
+                        saver.save(sess, os.path.join(self.save_model_path, 'deep_heatmaps'), global_step=step + 1)
+                        print ('model/deep-heatmaps-%d saved' % (step + 1))
+
+                    # save images with landmarks
+                    if (self.sample_every_epoch is False) and (step == 0 or (step + 1) % self.sample_every == 0):
+
+                            if not self.compute_nme:
+                                batch_maps_small_pred = sess.run(self.pred_hm_p,  {self.train_images: batch_images})
+
+                            print 'small map vals', batch_maps_small_pred.min(), batch_maps_small_pred.max()
+
+                            sample_path_imgs = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-1.png'
+                                                            % (epoch, step + 1))
+                            sample_path_maps = os.path.join(self.save_sample_path,'epoch-%d-train-iter-%d-2.png'
+                                                            % (epoch, step + 1))
+                            sample_path_ch_maps = os.path.join(self.save_sample_path, 'epoch-%d-train-iter-%d-3.png'
+                                                               % (epoch, step + 1))
+
+                            merged_img = merge_images_landmarks_maps(
+                                batch_images, batch_maps_small_pred, image_size=self.image_size,
+                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid, scale=self.scale,
+                                circle_size=0)
+
+                            merged_map = merge_compare_maps(
+                                batch_maps_small_pred, batch_maps_small, image_size=self.image_size/4,
+                                num_landmarks=self.num_landmarks, num_samples=self.sample_grid)
+
+                            map_per_channel = map_comapre_channels(batch_images, batch_maps_small_pred, batch_maps_small,
+                                                                   image_size=self.image_size/4,
+                                                                   num_landmarks=self.num_landmarks,scale=self.scale)
+
+                            scipy.misc.imsave(sample_path_imgs, merged_img)
+                            scipy.misc.imsave(sample_path_maps, merged_map)
+                            scipy.misc.imsave(sample_path_ch_maps, map_per_channel)
+
                 print('*** Finished Training ***')

MakeItTalk/thirdparty/face_of_art/old/eval_scripts/evaluate_and_compare_multiple_models.py

@@ -1,82 +1,82 @@
-from evaluation_functions import *
-from glob import glob
-
-flags = tf.app.flags
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-models_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/ect_like/saved_models/test'
-
-# define paths
-flags.DEFINE_string('img_dir', data_dir, 'data directory')
-flags.DEFINE_string('test_data', 'test', 'test set to use full/common/challenging/test/art')
-flags.DEFINE_string('models_dir', models_dir, 'directory containing multiple models to evaluate and compare')
-
-# parameters used to train network
-flags.DEFINE_integer('image_size', 256, 'image size')
-flags.DEFINE_integer('c_dim', 3, 'color channels')
-flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-
-# choose batch size and debug data size
-flags.DEFINE_integer('batch_size', 10, 'batch size')
-flags.DEFINE_bool('debug', True, 'run in debug mode - use subset of the data')
-flags.DEFINE_integer('debug_data_size', 50, 'subset data size to test in debug mode')
-
-# statistics parameters
-flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
-flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
-flags.DEFINE_string('log_path', 'logs/nme_statistics', 'direcotory for saving NME statistics')
-
-FLAGS = flags.FLAGS
-
-
-def main(_):
-
-    # create directories if not exist
-    if not tf.gfile.Exists(FLAGS.log_path):
-        tf.gfile.MakeDirs(FLAGS.log_path)
-
-    test_model_dirs = glob(os.path.join(FLAGS.models_dir, '*/'))
-
-    model_names = []
-    model_errors = []
-
-    for i, model_dir in enumerate(test_model_dirs):
-
-        model_name = model_dir.split('/')[-2]
-
-        if 'primary' in model_name.lower():
-            net_type = 'Primary'
-        elif 'fusion' in model_name.lower():
-            net_type = 'Fusion'
-        else:
-            sys.exit('\n*** Error: please give informative names for model directories, including network type! ***')
-
-        model_path = glob(os.path.join(model_dir, '*meta'))[0].split('.meta')[0]
-
-        print ('\n##### EVALUATING MODELS (%d/%d) #####' % (i+1,len(test_model_dirs)))
-
-        tf.reset_default_graph()  # reset graph
-
-        err = evaluate_heatmap_network(
-            model_path=model_path, network_type=net_type, img_path=FLAGS.img_dir, test_data=FLAGS.test_data,
-            batch_size=FLAGS.batch_size, image_size=FLAGS.image_size, margin=FLAGS.margin,
-            bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale, num_landmarks=FLAGS.num_landmarks,
-            debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
-
-        print_nme_statistics(
-            errors=err, model_path=model_path, network_type=net_type, test_data=FLAGS.test_data,
-            max_error=FLAGS.max_error, save_log=False, log_path=FLAGS.log_path,plot_ced=False)
-
-        model_names.append(model_name)
-        model_errors.append(err)
-
-    print_ced_compare_methods(
-        method_errors=tuple(model_errors),method_names=tuple(model_names), test_data=FLAGS.test_data,
-        log_path=FLAGS.log_path, save_log=FLAGS.save_log)
-
-
-if __name__ == '__main__':
-    tf.app.run()
+from evaluation_functions import *
+from glob import glob
+
+flags = tf.app.flags
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+models_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/ect_like/saved_models/test'
+
+# define paths
+flags.DEFINE_string('img_dir', data_dir, 'data directory')
+flags.DEFINE_string('test_data', 'test', 'test set to use full/common/challenging/test/art')
+flags.DEFINE_string('models_dir', models_dir, 'directory containing multiple models to evaluate and compare')
+
+# parameters used to train network
+flags.DEFINE_integer('image_size', 256, 'image size')
+flags.DEFINE_integer('c_dim', 3, 'color channels')
+flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+
+# choose batch size and debug data size
+flags.DEFINE_integer('batch_size', 10, 'batch size')
+flags.DEFINE_bool('debug', True, 'run in debug mode - use subset of the data')
+flags.DEFINE_integer('debug_data_size', 50, 'subset data size to test in debug mode')
+
+# statistics parameters
+flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
+flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
+flags.DEFINE_string('log_path', 'logs/nme_statistics', 'direcotory for saving NME statistics')
+
+FLAGS = flags.FLAGS
+
+
+def main(_):
+
+    # create directories if not exist
+    if not tf.gfile.Exists(FLAGS.log_path):
+        tf.gfile.MakeDirs(FLAGS.log_path)
+
+    test_model_dirs = glob(os.path.join(FLAGS.models_dir, '*/'))
+
+    model_names = []
+    model_errors = []
+
+    for i, model_dir in enumerate(test_model_dirs):
+
+        model_name = model_dir.split('/')[-2]
+
+        if 'primary' in model_name.lower():
+            net_type = 'Primary'
+        elif 'fusion' in model_name.lower():
+            net_type = 'Fusion'
+        else:
+            sys.exit('\n*** Error: please give informative names for model directories, including network type! ***')
+
+        model_path = glob(os.path.join(model_dir, '*meta'))[0].split('.meta')[0]
+
+        print ('\n##### EVALUATING MODELS (%d/%d) #####' % (i+1,len(test_model_dirs)))
+
+        tf.reset_default_graph()  # reset graph
+
+        err = evaluate_heatmap_network(
+            model_path=model_path, network_type=net_type, img_path=FLAGS.img_dir, test_data=FLAGS.test_data,
+            batch_size=FLAGS.batch_size, image_size=FLAGS.image_size, margin=FLAGS.margin,
+            bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale, num_landmarks=FLAGS.num_landmarks,
+            debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
+
+        print_nme_statistics(
+            errors=err, model_path=model_path, network_type=net_type, test_data=FLAGS.test_data,
+            max_error=FLAGS.max_error, save_log=False, log_path=FLAGS.log_path,plot_ced=False)
+
+        model_names.append(model_name)
+        model_errors.append(err)
+
+    print_ced_compare_methods(
+        method_errors=tuple(model_errors),method_names=tuple(model_names), test_data=FLAGS.test_data,
+        log_path=FLAGS.log_path, save_log=FLAGS.save_log)
+
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/eval_scripts/evaluate_model.py

@@ -1,54 +1,54 @@
-from evaluation_functions import *
-
-flags = tf.app.flags
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-model_path = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/tests/primary/old/no_flip/basic/' \
-            'tests_lr_primary_basic_no_flip/0.01/model/deep_heatmaps-80000'
-
-# define paths
-flags.DEFINE_string('img_dir', data_dir, 'data directory')
-flags.DEFINE_string('test_data', 'test', 'test set to use full/common/challenging/test/art')
-flags.DEFINE_string('model_path', model_path, 'model path')
-
-# parameters used to train network
-flags.DEFINE_string('network_type', 'Primary', 'network architecture Fusion/Primary')
-flags.DEFINE_integer('image_size', 256, 'image size')
-flags.DEFINE_integer('c_dim', 3, 'color channels')
-flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-
-# choose batch size and debug data size
-flags.DEFINE_integer('batch_size', 2, 'batch size')
-flags.DEFINE_bool('debug', True, 'run in debug mode - use subset of the data')
-flags.DEFINE_integer('debug_data_size', 4, 'subset data size to test in debug mode')
-
-# statistics parameters
-flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
-flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
-flags.DEFINE_string('log_path', 'logs/nme_statistics', 'directory for saving NME statistics')
-
-FLAGS = flags.FLAGS
-
-
-def main(_):
-
-    # create directories if not exist
-    if not tf.gfile.Exists(FLAGS.log_path):
-        tf.gfile.MakeDirs(FLAGS.log_path)
-
-    err = evaluate_heatmap_network(
-        model_path=FLAGS.model_path, network_type=FLAGS.network_type, img_path=FLAGS.img_dir,
-        test_data=FLAGS.test_data, batch_size=FLAGS.batch_size, image_size=FLAGS.image_size, margin=FLAGS.margin,
-        bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale, num_landmarks=FLAGS.num_landmarks,
-        debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
-
-    print_nme_statistics(
-        errors=err, model_path=FLAGS.model_path, network_type=FLAGS.network_type, test_data=FLAGS.test_data,
-        max_error=FLAGS.max_error, save_log=FLAGS.save_log, log_path=FLAGS.log_path)
-
-
-if __name__ == '__main__':
-    tf.app.run()
+from evaluation_functions import *
+
+flags = tf.app.flags
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+model_path = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/tests/primary/old/no_flip/basic/' \
+            'tests_lr_primary_basic_no_flip/0.01/model/deep_heatmaps-80000'
+
+# define paths
+flags.DEFINE_string('img_dir', data_dir, 'data directory')
+flags.DEFINE_string('test_data', 'test', 'test set to use full/common/challenging/test/art')
+flags.DEFINE_string('model_path', model_path, 'model path')
+
+# parameters used to train network
+flags.DEFINE_string('network_type', 'Primary', 'network architecture Fusion/Primary')
+flags.DEFINE_integer('image_size', 256, 'image size')
+flags.DEFINE_integer('c_dim', 3, 'color channels')
+flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+
+# choose batch size and debug data size
+flags.DEFINE_integer('batch_size', 2, 'batch size')
+flags.DEFINE_bool('debug', True, 'run in debug mode - use subset of the data')
+flags.DEFINE_integer('debug_data_size', 4, 'subset data size to test in debug mode')
+
+# statistics parameters
+flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
+flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
+flags.DEFINE_string('log_path', 'logs/nme_statistics', 'directory for saving NME statistics')
+
+FLAGS = flags.FLAGS
+
+
+def main(_):
+
+    # create directories if not exist
+    if not tf.gfile.Exists(FLAGS.log_path):
+        tf.gfile.MakeDirs(FLAGS.log_path)
+
+    err = evaluate_heatmap_network(
+        model_path=FLAGS.model_path, network_type=FLAGS.network_type, img_path=FLAGS.img_dir,
+        test_data=FLAGS.test_data, batch_size=FLAGS.batch_size, image_size=FLAGS.image_size, margin=FLAGS.margin,
+        bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale, num_landmarks=FLAGS.num_landmarks,
+        debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
+
+    print_nme_statistics(
+        errors=err, model_path=FLAGS.model_path, network_type=FLAGS.network_type, test_data=FLAGS.test_data,
+        max_error=FLAGS.max_error, save_log=FLAGS.save_log, log_path=FLAGS.log_path)
+
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/eval_scripts/evaluate_models.py

@@ -1,79 +1,79 @@
-from evaluation_functions import *
-from glob import glob
-
-flags = tf.app.flags
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-models_dir = 'tests_fusion'
-pre_train_model_name = 'deep_heatmaps-50000'
-datasets=['full','common','challenging','test']
-
-# define paths
-flags.DEFINE_string('img_dir', data_dir, 'data directory')
-flags.DEFINE_string('models_dir', models_dir, 'directory containing multiple models to evaluate')
-flags.DEFINE_string('model_name', pre_train_model_name, "model name. e.g: 'deep_heatmaps-50000'")
-
-
-# parameters used to train network
-flags.DEFINE_string('network_type', 'Primary', 'network architecture Fusion/Primary')
-flags.DEFINE_integer('image_size', 256, 'image size')
-flags.DEFINE_integer('c_dim', 3, 'color channels')
-flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-
-# choose batch size and debug data size
-flags.DEFINE_integer('batch_size', 2, 'batch size')
-flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
-flags.DEFINE_integer('debug_data_size', 4, 'subset data size to test in debug mode')
-
-# statistics parameters
-flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
-flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
-flags.DEFINE_string('log_path', 'logs/nme_statistics', 'directory for saving NME statistics')
-
-FLAGS = flags.FLAGS
-
-
-def main(_):
-    model_dirs = glob(os.path.join(FLAGS.models_dir,'*/'))
-
-    for test_data in datasets:
-        model_errors=[]
-        model_names=[]
-
-        for i, model_dir in enumerate(model_dirs):
-            print ('\n##### EVALUATING MODELS ON '+test_data+' set (%d/%d) #####' % (i + 1, len(model_dirs)))
-            # create directories if not exist
-            log_path = os.path.join(model_dir,'logs/nme_statistics')
-            if not os.path.exists(os.path.join(model_dir,'logs')):
-                os.mkdir(os.path.join(model_dir,'logs'))
-            if not os.path.exists(log_path):
-                os.mkdir(log_path)
-
-            model_name = model_dir.split('/')[-2]
-
-            tf.reset_default_graph()  # reset graph
-
-            err = evaluate_heatmap_network(
-                model_path=os.path.join(model_dir,'model',FLAGS.model_name), network_type=FLAGS.network_type,
-                img_path=FLAGS.img_dir, test_data=test_data, batch_size=FLAGS.batch_size, image_size=FLAGS.image_size,
-                margin=FLAGS.margin, bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale,
-                num_landmarks=FLAGS.num_landmarks, debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
-
-            print_nme_statistics(
-                errors=err, model_path=os.path.join(model_dir,'model', FLAGS.model_name),
-                network_type=FLAGS.network_type, test_data=test_data, max_error=FLAGS.max_error,
-                save_log=FLAGS.save_log, log_path=log_path, plot_ced=False)
-
-            model_names.append(model_name)
-            model_errors.append(err)
-
-        print_ced_compare_methods(
-            method_errors=tuple(model_errors), method_names=tuple(model_names), test_data=test_data,
-            log_path=FLAGS.models_dir, save_log=FLAGS.save_log)
-
-
-if __name__ == '__main__':
-    tf.app.run()
+from evaluation_functions import *
+from glob import glob
+
+flags = tf.app.flags
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+models_dir = 'tests_fusion'
+pre_train_model_name = 'deep_heatmaps-50000'
+datasets=['full','common','challenging','test']
+
+# define paths
+flags.DEFINE_string('img_dir', data_dir, 'data directory')
+flags.DEFINE_string('models_dir', models_dir, 'directory containing multiple models to evaluate')
+flags.DEFINE_string('model_name', pre_train_model_name, "model name. e.g: 'deep_heatmaps-50000'")
+
+
+# parameters used to train network
+flags.DEFINE_string('network_type', 'Primary', 'network architecture Fusion/Primary')
+flags.DEFINE_integer('image_size', 256, 'image size')
+flags.DEFINE_integer('c_dim', 3, 'color channels')
+flags.DEFINE_integer('num_landmarks', 68, 'number of face landmarks')
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+
+# choose batch size and debug data size
+flags.DEFINE_integer('batch_size', 2, 'batch size')
+flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
+flags.DEFINE_integer('debug_data_size', 4, 'subset data size to test in debug mode')
+
+# statistics parameters
+flags.DEFINE_float('max_error', 0.08, 'error threshold to be considered as failure')
+flags.DEFINE_bool('save_log', True, 'save statistics to log_dir')
+flags.DEFINE_string('log_path', 'logs/nme_statistics', 'directory for saving NME statistics')
+
+FLAGS = flags.FLAGS
+
+
+def main(_):
+    model_dirs = glob(os.path.join(FLAGS.models_dir,'*/'))
+
+    for test_data in datasets:
+        model_errors=[]
+        model_names=[]
+
+        for i, model_dir in enumerate(model_dirs):
+            print ('\n##### EVALUATING MODELS ON '+test_data+' set (%d/%d) #####' % (i + 1, len(model_dirs)))
+            # create directories if not exist
+            log_path = os.path.join(model_dir,'logs/nme_statistics')
+            if not os.path.exists(os.path.join(model_dir,'logs')):
+                os.mkdir(os.path.join(model_dir,'logs'))
+            if not os.path.exists(log_path):
+                os.mkdir(log_path)
+
+            model_name = model_dir.split('/')[-2]
+
+            tf.reset_default_graph()  # reset graph
+
+            err = evaluate_heatmap_network(
+                model_path=os.path.join(model_dir,'model',FLAGS.model_name), network_type=FLAGS.network_type,
+                img_path=FLAGS.img_dir, test_data=test_data, batch_size=FLAGS.batch_size, image_size=FLAGS.image_size,
+                margin=FLAGS.margin, bb_type=FLAGS.bb_type, c_dim=FLAGS.c_dim, scale=FLAGS.scale,
+                num_landmarks=FLAGS.num_landmarks, debug=FLAGS.debug, debug_data_size=FLAGS.debug_data_size)
+
+            print_nme_statistics(
+                errors=err, model_path=os.path.join(model_dir,'model', FLAGS.model_name),
+                network_type=FLAGS.network_type, test_data=test_data, max_error=FLAGS.max_error,
+                save_log=FLAGS.save_log, log_path=log_path, plot_ced=False)
+
+            model_names.append(model_name)
+            model_errors.append(err)
+
+        print_ced_compare_methods(
+            method_errors=tuple(model_errors), method_names=tuple(model_names), test_data=test_data,
+            log_path=FLAGS.models_dir, save_log=FLAGS.save_log)
+
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/eval_scripts/evaluation_functions.py

@@ -1,300 +1,300 @@
-import tensorflow as tf
-from menpofit.visualize import plot_cumulative_error_distribution
-from menpofit.error import compute_cumulative_error
-from scipy.integrate import simps
-from menpo_functions import load_menpo_image_list, load_bb_dictionary
-from logging_functions import *
-from data_loading_functions import *
-from time import time
-import sys
-from PyQt5 import QtWidgets
-qapp=QtWidgets.QApplication([''])
-
-
-def load_menpo_test_list(img_dir, test_data='full', image_size=256, margin=0.25, bb_type='gt'):
-    mode = 'TEST'
-    bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
-    bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=test_data)
-    img_menpo_list = load_menpo_image_list(
-        img_dir=img_dir, train_crop_dir=None, img_dir_ns=None, mode=mode, bb_dictionary=bb_dictionary,
-        image_size=image_size, margin=margin,
-        bb_type=bb_type, test_data=test_data, augment_basic=False, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0)
-    return img_menpo_list
-
-
-def evaluate_heatmap_fusion_network(model_path, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
-                                    bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
-                                    debug_data_size=20):
-    t = time()
-    from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
-    import logging
-    logging.getLogger('tensorflow').disabled = True
-
-    # load test image menpo list
-
-    test_menpo_img_list = load_menpo_test_list(
-        img_path, test_data=test_data, image_size=image_size, margin=margin, bb_type=bb_type)
-
-    if debug:
-        test_menpo_img_list = test_menpo_img_list[:debug_data_size]
-        print ('\n*** FUSION NETWORK: calculating normalized mean error on: ' + test_data +
-               ' set (%d images - debug mode) ***' % debug_data_size)
-    else:
-        print ('\n*** FUSION NETWORK: calculating normalized mean error on: ' + test_data + ' set (%d images) ***' %
-               (len(test_menpo_img_list)))
-
-    # create heatmap model
-
-    tf.reset_default_graph()
-
-    model = DeepHeatmapsModel(mode='TEST', batch_size=batch_size, image_size=image_size, c_dim=c_dim,
-                              num_landmarks=num_landmarks, img_path=img_path, test_model_path=model_path,
-                              test_data=test_data, menpo_verbose=False)
-
-    # add placeholders
-    model.add_placeholders()
-    # build model
-    model.build_model()
-    # create loss ops
-    model.create_loss_ops()
-
-    num_batches = int(1. * len(test_menpo_img_list) / batch_size)
-    if num_batches == 0:
-        batch_size = len(test_menpo_img_list)
-        num_batches = 1
-
-    reminder = len(test_menpo_img_list) - num_batches * batch_size
-    num_batches_reminder = num_batches + 1 * (reminder > 0)
-    img_inds = np.arange(len(test_menpo_img_list))
-
-    with tf.Session() as session:
-
-        # load trained parameters
-        saver = tf.train.Saver()
-        saver.restore(session, model_path)
-
-        print ('\nnum batches: ' + str(num_batches_reminder))
-
-        err = []
-        for j in range(num_batches):
-            print ('batch %d / %d ...' % (j + 1, num_batches_reminder))
-            batch_inds = img_inds[j * batch_size:(j + 1) * batch_size]
-
-            batch_images, _, batch_landmarks_gt = load_images_landmarks(
-                test_menpo_img_list, batch_inds=batch_inds, image_size=image_size,
-                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
-
-            batch_maps_pred = session.run(model.pred_hm_f, {model.images: batch_images})
-
-            batch_pred_landmarks = batch_heat_maps_to_landmarks(
-                batch_maps_pred, batch_size=batch_size, image_size=image_size, num_landmarks=num_landmarks)
-
-            batch_err = session.run(
-                model.nme_per_image, {model.lms: batch_landmarks_gt, model.pred_lms: batch_pred_landmarks})
-            err = np.hstack((err, batch_err))
-
-        if reminder > 0:
-            print ('batch %d / %d ...' % (j + 2, num_batches_reminder))
-            reminder_inds = img_inds[-reminder:]
-
-            batch_images, _, batch_landmarks_gt = load_images_landmarks(
-                test_menpo_img_list, batch_inds=reminder_inds, image_size=image_size,
-                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
-
-            batch_maps_pred = session.run(model.pred_hm_f, {model.images: batch_images})
-
-            batch_pred_landmarks = batch_heat_maps_to_landmarks(
-                batch_maps_pred, batch_size=reminder, image_size=image_size, num_landmarks=num_landmarks)
-
-            batch_err = session.run(
-                model.nme_per_image, {model.lms: batch_landmarks_gt, model.pred_lms: batch_pred_landmarks})
-            err = np.hstack((err, batch_err))
-
-        print ('\ndone!')
-        print ('run time: ' + str(time() - t))
-
-    return err
-
-
-def evaluate_heatmap_primary_network(model_path, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
-                                     bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
-                                     debug_data_size=20):
-    t = time()
-    from deep_heatmaps_model_primary_net import DeepHeatmapsModel
-    import logging
-    logging.getLogger('tensorflow').disabled = True
-
-    # load test image menpo list
-
-    test_menpo_img_list = load_menpo_test_list(
-        img_path, test_data=test_data, image_size=image_size, margin=margin, bb_type=bb_type)
-
-    if debug:
-        test_menpo_img_list = test_menpo_img_list[:debug_data_size]
-        print ('\n*** PRIMARY NETWORK: calculating normalized mean error on: ' + test_data +
-               ' set (%d images - debug mode) ***' % debug_data_size)
-    else:
-        print ('\n*** PRIMARY NETWORK: calculating normalized mean error on: ' + test_data +
-               ' set (%d images) ***' % (len(test_menpo_img_list)))
-
-    # create heatmap model
-
-    tf.reset_default_graph()
-
-    model = DeepHeatmapsModel(mode='TEST', batch_size=batch_size, image_size=image_size, c_dim=c_dim,
-                              num_landmarks=num_landmarks, img_path=img_path, test_model_path=model_path,
-                              test_data=test_data, menpo_verbose=False)
-
-    # add placeholders
-    model.add_placeholders()
-    # build model
-    model.build_model()
-    # create loss ops
-    model.create_loss_ops()
-
-    num_batches = int(1. * len(test_menpo_img_list) / batch_size)
-    if num_batches == 0:
-        batch_size = len(test_menpo_img_list)
-        num_batches = 1
-
-    reminder = len(test_menpo_img_list) - num_batches * batch_size
-    num_batches_reminder = num_batches + 1 * (reminder > 0)
-    img_inds = np.arange(len(test_menpo_img_list))
-
-    with tf.Session() as session:
-
-        # load trained parameters
-        saver = tf.train.Saver()
-        saver.restore(session, model_path)
-
-        print ('\nnum batches: ' + str(num_batches_reminder))
-
-        err = []
-        for j in range(num_batches):
-            print ('batch %d / %d ...' % (j + 1, num_batches_reminder))
-            batch_inds = img_inds[j * batch_size:(j + 1) * batch_size]
-
-            batch_images, _, batch_landmarks_gt = load_images_landmarks(
-                test_menpo_img_list, batch_inds=batch_inds, image_size=image_size,
-                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
-
-            batch_maps_small_pred = session.run(model.pred_hm_p, {model.images: batch_images})
-
-            batch_maps_small_pred = zoom(batch_maps_small_pred, zoom=[1, 4, 4, 1], order=1)  # NN interpolation
-
-            batch_pred_landmarks = batch_heat_maps_to_landmarks(
-                batch_maps_small_pred, batch_size=batch_size, image_size=image_size,
-                num_landmarks=num_landmarks)
-
-            batch_err = session.run(
-                model.nme_per_image, {model.lms_small: batch_landmarks_gt, model.pred_lms_small: batch_pred_landmarks})
-            err = np.hstack((err, batch_err))
-
-        if reminder > 0:
-            print ('batch %d / %d ...' % (j + 2, num_batches_reminder))
-            reminder_inds = img_inds[-reminder:]
-
-            batch_images, _, batch_landmarks_gt = load_images_landmarks(
-                test_menpo_img_list, batch_inds=reminder_inds, image_size=image_size,
-                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
-
-            batch_maps_small_pred = session.run(model.pred_hm_p, {model.images: batch_images})
-
-            batch_maps_small_pred = zoom(batch_maps_small_pred, zoom=[1, 4, 4, 1], order=1)  # NN interpolation
-
-            batch_pred_landmarks = batch_heat_maps_to_landmarks(
-                batch_maps_small_pred, batch_size=reminder, image_size=image_size,
-                num_landmarks=num_landmarks)
-
-            batch_err = session.run(
-                model.nme_per_image, {model.lms_small: batch_landmarks_gt, model.pred_lms_small: batch_pred_landmarks})
-            err = np.hstack((err, batch_err))
-
-        print ('\ndone!')
-        print ('run time: ' + str(time() - t))
-
-    return err
-
-
-def evaluate_heatmap_network(model_path, network_type, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
-                                     bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
-                                     debug_data_size=20):
-
-    if network_type.lower() == 'fusion':
-        return evaluate_heatmap_fusion_network(
-            model_path=model_path, img_path=img_path, test_data=test_data, batch_size=batch_size, image_size=image_size,
-            margin=margin, bb_type=bb_type, c_dim=c_dim, scale=scale, num_landmarks=num_landmarks, debug=debug,
-            debug_data_size=debug_data_size)
-    elif network_type.lower() == 'primary':
-        return evaluate_heatmap_primary_network(
-            model_path=model_path, img_path=img_path, test_data=test_data, batch_size=batch_size, image_size=image_size,
-            margin=margin, bb_type=bb_type, c_dim=c_dim, scale=scale, num_landmarks=num_landmarks, debug=debug,
-            debug_data_size=debug_data_size)
-    else:
-        sys.exit('\n*** Error: please choose a valid network type: Fusion/Primary ***')
-
-
-def AUC(errors, max_error, step_error=0.0001):
-    x_axis = list(np.arange(0., max_error + step_error, step_error))
-    ced = np.array(compute_cumulative_error(errors, x_axis))
-    return simps(ced, x=x_axis) / max_error, 1. - ced[-1]
-
-
-def print_nme_statistics(
-        errors, model_path, network_type, test_data, max_error=0.08, log_path='', save_log=True, plot_ced=True,
-        norm='interocular distance'):
-    auc, failures = AUC(errors, max_error=max_error)
-
-    print ("\n****** NME statistics for " + network_type + " Network ******\n")
-    print ("* model path: " + model_path)
-    print ("* dataset: " + test_data + ' set')
-
-    print ("\n* Normalized mean error (percentage of "+norm+"): %.2f" % (100 * np.mean(errors)))
-    print ("\n* AUC @ %.2f: %.2f" % (max_error, 100 * auc))
-    print ("\n* failure rate @ %.2f: %.2f" % (max_error, 100 * failures) + '%')
-
-    if plot_ced:
-        plt.figure()
-        plt.yticks(np.linspace(0, 1, 11))
-        plot_cumulative_error_distribution(
-            list(errors),
-            legend_entries=[network_type],
-            marker_style=['s'],
-            marker_size=7,
-            x_label='Normalised Point-to-Point Error\n('+norm+')\n*' + test_data + ' set*',
-        )
-
-    if save_log:
-        with open(os.path.join(log_path, network_type.lower() + "_nme_statistics_on_" + test_data + "_set.txt"),
-                  "wb") as f:
-            f.write(b"************************************************")
-            f.write(("\n****** NME statistics for " + str(network_type) + " Network ******\n").encode())
-            f.write(b"************************************************")
-            f.write(("\n\n* model path: " + str(model_path)).encode())
-            f.write(("\n\n* dataset: " + str(test_data) + ' set').encode())
-            f.write(b"\n\n* Normalized mean error (percentage of "+norm+"): %.2f" % (100 * np.mean(errors)))
-            f.write(b"\n\n* AUC @ %.2f: %.2f" % (max_error, 100 * auc))
-            f.write(("\n\n* failure rate @ %.2f: %.2f" % (max_error, 100 * failures) + '%').encode())
-        if plot_ced:
-            plt.savefig(os.path.join(log_path, network_type.lower() + '_nme_ced_on_' + test_data + '_set.png'),
-                        bbox_inches='tight')
-            plt.close()
-
-        print ('\nlog path: ' + log_path)
-
-
-def print_ced_compare_methods(
-        method_errors,method_names,test_data,log_path='', save_log=True, norm='interocular distance'):
-    plt.yticks(np.linspace(0, 1, 11))
-    plot_cumulative_error_distribution(
-        [list(err) for err in list(method_errors)],
-        legend_entries=list(method_names),
-        marker_style=['s'],
-        marker_size=7,
-        x_label='Normalised Point-to-Point Error\n('+norm+')\n*'+test_data+' set*'
-    )
-    if save_log:
-        plt.savefig(os.path.join(log_path,'nme_ced_on_'+test_data+'_set.png'), bbox_inches='tight')
-        print ('ced plot path: ' + os.path.join(log_path,'nme_ced_on_'+test_data+'_set.png'))
+import tensorflow as tf
+from menpofit.visualize import plot_cumulative_error_distribution
+from menpofit.error import compute_cumulative_error
+from scipy.integrate import simps
+from menpo_functions import load_menpo_image_list, load_bb_dictionary
+from logging_functions import *
+from data_loading_functions import *
+from time import time
+import sys
+from PyQt5 import QtWidgets
+qapp=QtWidgets.QApplication([''])
+
+
+def load_menpo_test_list(img_dir, test_data='full', image_size=256, margin=0.25, bb_type='gt'):
+    mode = 'TEST'
+    bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
+    bb_dictionary = load_bb_dictionary(bb_dir, mode, test_data=test_data)
+    img_menpo_list = load_menpo_image_list(
+        img_dir=img_dir, train_crop_dir=None, img_dir_ns=None, mode=mode, bb_dictionary=bb_dictionary,
+        image_size=image_size, margin=margin,
+        bb_type=bb_type, test_data=test_data, augment_basic=False, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0)
+    return img_menpo_list
+
+
+def evaluate_heatmap_fusion_network(model_path, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
+                                    bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
+                                    debug_data_size=20):
+    t = time()
+    from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
+    import logging
+    logging.getLogger('tensorflow').disabled = True
+
+    # load test image menpo list
+
+    test_menpo_img_list = load_menpo_test_list(
+        img_path, test_data=test_data, image_size=image_size, margin=margin, bb_type=bb_type)
+
+    if debug:
+        test_menpo_img_list = test_menpo_img_list[:debug_data_size]
+        print ('\n*** FUSION NETWORK: calculating normalized mean error on: ' + test_data +
+               ' set (%d images - debug mode) ***' % debug_data_size)
+    else:
+        print ('\n*** FUSION NETWORK: calculating normalized mean error on: ' + test_data + ' set (%d images) ***' %
+               (len(test_menpo_img_list)))
+
+    # create heatmap model
+
+    tf.reset_default_graph()
+
+    model = DeepHeatmapsModel(mode='TEST', batch_size=batch_size, image_size=image_size, c_dim=c_dim,
+                              num_landmarks=num_landmarks, img_path=img_path, test_model_path=model_path,
+                              test_data=test_data, menpo_verbose=False)
+
+    # add placeholders
+    model.add_placeholders()
+    # build model
+    model.build_model()
+    # create loss ops
+    model.create_loss_ops()
+
+    num_batches = int(1. * len(test_menpo_img_list) / batch_size)
+    if num_batches == 0:
+        batch_size = len(test_menpo_img_list)
+        num_batches = 1
+
+    reminder = len(test_menpo_img_list) - num_batches * batch_size
+    num_batches_reminder = num_batches + 1 * (reminder > 0)
+    img_inds = np.arange(len(test_menpo_img_list))
+
+    with tf.Session() as session:
+
+        # load trained parameters
+        saver = tf.train.Saver()
+        saver.restore(session, model_path)
+
+        print ('\nnum batches: ' + str(num_batches_reminder))
+
+        err = []
+        for j in range(num_batches):
+            print ('batch %d / %d ...' % (j + 1, num_batches_reminder))
+            batch_inds = img_inds[j * batch_size:(j + 1) * batch_size]
+
+            batch_images, _, batch_landmarks_gt = load_images_landmarks(
+                test_menpo_img_list, batch_inds=batch_inds, image_size=image_size,
+                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
+
+            batch_maps_pred = session.run(model.pred_hm_f, {model.images: batch_images})
+
+            batch_pred_landmarks = batch_heat_maps_to_landmarks(
+                batch_maps_pred, batch_size=batch_size, image_size=image_size, num_landmarks=num_landmarks)
+
+            batch_err = session.run(
+                model.nme_per_image, {model.lms: batch_landmarks_gt, model.pred_lms: batch_pred_landmarks})
+            err = np.hstack((err, batch_err))
+
+        if reminder > 0:
+            print ('batch %d / %d ...' % (j + 2, num_batches_reminder))
+            reminder_inds = img_inds[-reminder:]
+
+            batch_images, _, batch_landmarks_gt = load_images_landmarks(
+                test_menpo_img_list, batch_inds=reminder_inds, image_size=image_size,
+                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
+
+            batch_maps_pred = session.run(model.pred_hm_f, {model.images: batch_images})
+
+            batch_pred_landmarks = batch_heat_maps_to_landmarks(
+                batch_maps_pred, batch_size=reminder, image_size=image_size, num_landmarks=num_landmarks)
+
+            batch_err = session.run(
+                model.nme_per_image, {model.lms: batch_landmarks_gt, model.pred_lms: batch_pred_landmarks})
+            err = np.hstack((err, batch_err))
+
+        print ('\ndone!')
+        print ('run time: ' + str(time() - t))
+
+    return err
+
+
+def evaluate_heatmap_primary_network(model_path, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
+                                     bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
+                                     debug_data_size=20):
+    t = time()
+    from deep_heatmaps_model_primary_net import DeepHeatmapsModel
+    import logging
+    logging.getLogger('tensorflow').disabled = True
+
+    # load test image menpo list
+
+    test_menpo_img_list = load_menpo_test_list(
+        img_path, test_data=test_data, image_size=image_size, margin=margin, bb_type=bb_type)
+
+    if debug:
+        test_menpo_img_list = test_menpo_img_list[:debug_data_size]
+        print ('\n*** PRIMARY NETWORK: calculating normalized mean error on: ' + test_data +
+               ' set (%d images - debug mode) ***' % debug_data_size)
+    else:
+        print ('\n*** PRIMARY NETWORK: calculating normalized mean error on: ' + test_data +
+               ' set (%d images) ***' % (len(test_menpo_img_list)))
+
+    # create heatmap model
+
+    tf.reset_default_graph()
+
+    model = DeepHeatmapsModel(mode='TEST', batch_size=batch_size, image_size=image_size, c_dim=c_dim,
+                              num_landmarks=num_landmarks, img_path=img_path, test_model_path=model_path,
+                              test_data=test_data, menpo_verbose=False)
+
+    # add placeholders
+    model.add_placeholders()
+    # build model
+    model.build_model()
+    # create loss ops
+    model.create_loss_ops()
+
+    num_batches = int(1. * len(test_menpo_img_list) / batch_size)
+    if num_batches == 0:
+        batch_size = len(test_menpo_img_list)
+        num_batches = 1
+
+    reminder = len(test_menpo_img_list) - num_batches * batch_size
+    num_batches_reminder = num_batches + 1 * (reminder > 0)
+    img_inds = np.arange(len(test_menpo_img_list))
+
+    with tf.Session() as session:
+
+        # load trained parameters
+        saver = tf.train.Saver()
+        saver.restore(session, model_path)
+
+        print ('\nnum batches: ' + str(num_batches_reminder))
+
+        err = []
+        for j in range(num_batches):
+            print ('batch %d / %d ...' % (j + 1, num_batches_reminder))
+            batch_inds = img_inds[j * batch_size:(j + 1) * batch_size]
+
+            batch_images, _, batch_landmarks_gt = load_images_landmarks(
+                test_menpo_img_list, batch_inds=batch_inds, image_size=image_size,
+                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
+
+            batch_maps_small_pred = session.run(model.pred_hm_p, {model.images: batch_images})
+
+            batch_maps_small_pred = zoom(batch_maps_small_pred, zoom=[1, 4, 4, 1], order=1)  # NN interpolation
+
+            batch_pred_landmarks = batch_heat_maps_to_landmarks(
+                batch_maps_small_pred, batch_size=batch_size, image_size=image_size,
+                num_landmarks=num_landmarks)
+
+            batch_err = session.run(
+                model.nme_per_image, {model.lms_small: batch_landmarks_gt, model.pred_lms_small: batch_pred_landmarks})
+            err = np.hstack((err, batch_err))
+
+        if reminder > 0:
+            print ('batch %d / %d ...' % (j + 2, num_batches_reminder))
+            reminder_inds = img_inds[-reminder:]
+
+            batch_images, _, batch_landmarks_gt = load_images_landmarks(
+                test_menpo_img_list, batch_inds=reminder_inds, image_size=image_size,
+                c_dim=c_dim, num_landmarks=num_landmarks, scale=scale)
+
+            batch_maps_small_pred = session.run(model.pred_hm_p, {model.images: batch_images})
+
+            batch_maps_small_pred = zoom(batch_maps_small_pred, zoom=[1, 4, 4, 1], order=1)  # NN interpolation
+
+            batch_pred_landmarks = batch_heat_maps_to_landmarks(
+                batch_maps_small_pred, batch_size=reminder, image_size=image_size,
+                num_landmarks=num_landmarks)
+
+            batch_err = session.run(
+                model.nme_per_image, {model.lms_small: batch_landmarks_gt, model.pred_lms_small: batch_pred_landmarks})
+            err = np.hstack((err, batch_err))
+
+        print ('\ndone!')
+        print ('run time: ' + str(time() - t))
+
+    return err
+
+
+def evaluate_heatmap_network(model_path, network_type, img_path, test_data, batch_size=10, image_size=256, margin=0.25,
+                                     bb_type='gt', c_dim=3, scale=1, num_landmarks=68, debug=False,
+                                     debug_data_size=20):
+
+    if network_type.lower() == 'fusion':
+        return evaluate_heatmap_fusion_network(
+            model_path=model_path, img_path=img_path, test_data=test_data, batch_size=batch_size, image_size=image_size,
+            margin=margin, bb_type=bb_type, c_dim=c_dim, scale=scale, num_landmarks=num_landmarks, debug=debug,
+            debug_data_size=debug_data_size)
+    elif network_type.lower() == 'primary':
+        return evaluate_heatmap_primary_network(
+            model_path=model_path, img_path=img_path, test_data=test_data, batch_size=batch_size, image_size=image_size,
+            margin=margin, bb_type=bb_type, c_dim=c_dim, scale=scale, num_landmarks=num_landmarks, debug=debug,
+            debug_data_size=debug_data_size)
+    else:
+        sys.exit('\n*** Error: please choose a valid network type: Fusion/Primary ***')
+
+
+def AUC(errors, max_error, step_error=0.0001):
+    x_axis = list(np.arange(0., max_error + step_error, step_error))
+    ced = np.array(compute_cumulative_error(errors, x_axis))
+    return simps(ced, x=x_axis) / max_error, 1. - ced[-1]
+
+
+def print_nme_statistics(
+        errors, model_path, network_type, test_data, max_error=0.08, log_path='', save_log=True, plot_ced=True,
+        norm='interocular distance'):
+    auc, failures = AUC(errors, max_error=max_error)
+
+    print ("\n****** NME statistics for " + network_type + " Network ******\n")
+    print ("* model path: " + model_path)
+    print ("* dataset: " + test_data + ' set')
+
+    print ("\n* Normalized mean error (percentage of "+norm+"): %.2f" % (100 * np.mean(errors)))
+    print ("\n* AUC @ %.2f: %.2f" % (max_error, 100 * auc))
+    print ("\n* failure rate @ %.2f: %.2f" % (max_error, 100 * failures) + '%')
+
+    if plot_ced:
+        plt.figure()
+        plt.yticks(np.linspace(0, 1, 11))
+        plot_cumulative_error_distribution(
+            list(errors),
+            legend_entries=[network_type],
+            marker_style=['s'],
+            marker_size=7,
+            x_label='Normalised Point-to-Point Error\n('+norm+')\n*' + test_data + ' set*',
+        )
+
+    if save_log:
+        with open(os.path.join(log_path, network_type.lower() + "_nme_statistics_on_" + test_data + "_set.txt"),
+                  "wb") as f:
+            f.write(b"************************************************")
+            f.write(("\n****** NME statistics for " + str(network_type) + " Network ******\n").encode())
+            f.write(b"************************************************")
+            f.write(("\n\n* model path: " + str(model_path)).encode())
+            f.write(("\n\n* dataset: " + str(test_data) + ' set').encode())
+            f.write(b"\n\n* Normalized mean error (percentage of "+norm+"): %.2f" % (100 * np.mean(errors)))
+            f.write(b"\n\n* AUC @ %.2f: %.2f" % (max_error, 100 * auc))
+            f.write(("\n\n* failure rate @ %.2f: %.2f" % (max_error, 100 * failures) + '%').encode())
+        if plot_ced:
+            plt.savefig(os.path.join(log_path, network_type.lower() + '_nme_ced_on_' + test_data + '_set.png'),
+                        bbox_inches='tight')
+            plt.close()
+
+        print ('\nlog path: ' + log_path)
+
+
+def print_ced_compare_methods(
+        method_errors,method_names,test_data,log_path='', save_log=True, norm='interocular distance'):
+    plt.yticks(np.linspace(0, 1, 11))
+    plot_cumulative_error_distribution(
+        [list(err) for err in list(method_errors)],
+        legend_entries=list(method_names),
+        marker_style=['s'],
+        marker_size=7,
+        x_label='Normalised Point-to-Point Error\n('+norm+')\n*'+test_data+' set*'
+    )
+    if save_log:
+        plt.savefig(os.path.join(log_path,'nme_ced_on_'+test_data+'_set.png'), bbox_inches='tight')
+        print ('ced plot path: ' + os.path.join(log_path,'nme_ced_on_'+test_data+'_set.png'))
         plt.close()

MakeItTalk/thirdparty/face_of_art/old/image_utils.py

@@ -1,590 +1,590 @@
-import numpy as np
-import os
-from scipy.io import loadmat
-import cv2
-from menpo.shape.pointcloud import PointCloud
-from menpo.transform import ThinPlateSplines
-import menpo.io as mio
-import matplotlib.pyplot as plt
-from scipy.ndimage import zoom
-from glob import glob
-from deformation_functions import *
-
-'''********* bounding box and image loading functions *********'''
-
-
-def center_margin_bb(bb, img_bounds, margin=0.25):
-    bb_size = ([bb[0, 2] - bb[0, 0], bb[0, 3] - bb[0, 1]])
-    margins = (np.max(bb_size) * (1 + margin) - bb_size) / 2
-
-    bb_new = np.zeros_like(bb)
-    bb_new[0, 0] = np.maximum(bb[0, 0] - margins[0], 0)
-    bb_new[0, 2] = np.minimum(bb[0, 2] + margins[0], img_bounds[1])
-    bb_new[0, 1] = np.maximum(bb[0, 1] - margins[1], 0)
-    bb_new[0, 3] = np.minimum(bb[0, 3] + margins[1], img_bounds[0])
-    return bb_new
-
-
-def load_bb_files(bb_file_dirs):
-    bb_files_dict = {}
-    for bb_file in bb_file_dirs:
-        bb_mat = loadmat(bb_file)['bounding_boxes']
-        num_imgs = np.max(bb_mat.shape)
-        for i in range(num_imgs):
-            name = bb_mat[0][i][0][0][0][0]
-            bb_init = bb_mat[0][i][0][0][1] - 1  # matlab indicies
-            bb_gt = bb_mat[0][i][0][0][2] - 1  # matlab indicies
-            if str(name) in bb_files_dict.keys():
-                print str(name), 'already loaded from: ', bb_file
-            bb_files_dict[str(name)] = (bb_init, bb_gt)
-    return bb_files_dict
-
-
-def load_bb_dictionary(bb_dir, mode, test_data='full'):
-    if mode == 'TRAIN':
-        bb_dirs = \
-            ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
-    else:
-        if test_data == 'common':
-            bb_dirs = \
-                ['bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
-        elif test_data == 'challenging':
-            bb_dirs = ['bounding_boxes_ibug.mat']
-        elif test_data == 'full':
-            bb_dirs = \
-                ['bounding_boxes_ibug.mat', 'bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
-        elif test_data == 'training':
-            bb_dirs = \
-                ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
-        else:
-            bb_dirs=None
-
-    if mode == 'TEST' and test_data not in ['full', 'challenging', 'common', 'training']:
-        bb_files_dict = None
-    else:
-        bb_dirs = [os.path.join(bb_dir, dataset) for dataset in bb_dirs]
-        bb_files_dict = load_bb_files(bb_dirs)
-
-    return bb_files_dict
-
-
-def crop_to_face_image(img, bb_dictionary=None, gt=True, margin=0.25, image_size=256):
-    name = img.path.name
-    img_bounds = img.bounds()[1]
-
-    if bb_dictionary is None:
-        bb_menpo = img.landmarks['PTS'].bounding_box().points
-        bb = np.array([[bb_menpo[0, 1], bb_menpo[0, 0], bb_menpo[2, 1], bb_menpo[2, 0]]])
-    else:
-        if gt:
-            bb = bb_dictionary[name][1]  # ground truth
-        else:
-            bb = bb_dictionary[name][0]  # init from face detector
-
-    bb = center_margin_bb(bb, img_bounds, margin=margin)
-
-    bb_pointcloud = PointCloud(np.array([[bb[0, 1], bb[0, 0]],
-                                         [bb[0, 3], bb[0, 0]],
-                                         [bb[0, 3], bb[0, 2]],
-                                         [bb[0, 1], bb[0, 2]]]))
-
-    face_crop = img.crop_to_pointcloud(bb_pointcloud).resize([image_size, image_size])
-
-    return face_crop
-
-
-def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True):
-
-    # taken from MDM
-    jaw_indices = np.arange(0, 17)
-    lbrow_indices = np.arange(17, 22)
-    rbrow_indices = np.arange(22, 27)
-    upper_nose_indices = np.arange(27, 31)
-    lower_nose_indices = np.arange(31, 36)
-    leye_indices = np.arange(36, 42)
-    reye_indices = np.arange(42, 48)
-    outer_mouth_indices = np.arange(48, 60)
-    inner_mouth_indices = np.arange(60, 68)
-
-    mirrored_parts_68 = np.hstack([
-        jaw_indices[::-1], rbrow_indices[::-1], lbrow_indices[::-1],
-        upper_nose_indices, lower_nose_indices[::-1],
-        np.roll(reye_indices[::-1], 4), np.roll(leye_indices[::-1], 4),
-        np.roll(outer_mouth_indices[::-1], 7),
-        np.roll(inner_mouth_indices[::-1], 5)
-    ])
-
-    def mirror_landmarks_68(lms, im_size):
-        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
-        ).reshape(-1, 2))[mirrored_parts_68])
-
-    def mirror_image(im):
-        im = im.copy()
-        im.pixels = im.pixels[..., ::-1].copy()
-
-        for group in im.landmarks:
-            lms = im.landmarks[group]
-            if lms.points.shape[0] == 68:
-                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
-
-        return im
-
-    lim = image_size - crop_size
-    min_crop_inds = np.random.randint(0, lim, 2)
-    max_crop_inds = min_crop_inds + crop_size
-    flip_rand = np.random.random() > 0.5
-    rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
-
-    if flip and flip_rand:
-        rand_crop = img.crop(min_crop_inds, max_crop_inds)
-        rand_crop = mirror_image(rand_crop)
-        rand_crop = rand_crop.rotate_ccw_about_centre(rot_angle).resize([image_size, image_size])
-
-    else:
-        rand_crop = img.crop(min_crop_inds, max_crop_inds). \
-            rotate_ccw_about_centre(rot_angle).resize([image_size, image_size])
-
-    return rand_crop
-
-
-def load_menpo_image_list(img_dir, mode, bb_dictionary=None, image_size=256, margin=0.25, bb_type='gt',
-                          test_data='full', augment=True):
-    def crop_to_face_image_gt(img, bb_dictionary=bb_dictionary, margin=margin, image_size=image_size):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img, bb_dictionary=bb_dictionary, margin=margin, image_size=image_size):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    if mode is 'TRAIN':
-        img_set_dir = os.path.join(img_dir, 'training_set')
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-
-    image_menpo_list = mio.import_images(img_set_dir, verbose=True)
-
-    if bb_type is 'gt':
-        face_crop_image_list = image_menpo_list.map(crop_to_face_image_gt)
-    else:
-        face_crop_image_list = image_menpo_list.map(crop_to_face_image_init)
-
-    if mode is 'TRAIN' and augment:
-        out_image_list = face_crop_image_list.map(augment_face_image)
-    else:
-        out_image_list = face_crop_image_list
-
-    return out_image_list
-
-
-def augment_menpo_img_ns(img, img_dir_ns, p_ns=0):
-    img = img.copy()
-    texture_aug = p_ns > 0.5
-    if texture_aug:
-        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '*'))
-        num_augs = len(ns_augs)
-        if num_augs > 1:
-            ns_ind = np.random.randint(1, num_augs)
-            ns_aug = mio.import_image(ns_augs[ns_ind])
-            ns_pixels = ns_aug.pixels
-            img.pixels = ns_pixels
-    return img
-
-
-def augment_menpo_img_geom(img, p_geom=0):
-    img = img.copy()
-    if p_geom > 0.5:
-        lms_geom_warp=deform_face_geometric_style(img.landmarks['PTS'].points.copy(),p_scale=p_geom,p_shift=p_geom)
-        img = warp_face_image_tps(img,PointCloud(lms_geom_warp))
-    return img
-
-
-def warp_face_image_tps(img,new_shape):
-    tps = ThinPlateSplines(new_shape, img.landmarks['PTS'])
-    img_warp=img.warp_to_shape(img.shape,tps)
-    img_warp.landmarks['PTS']=new_shape
-    return img_warp
-
-
-def load_menpo_image_list_artistic_aug(
-        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-        bb_type='gt', test_data='full',augment_basic=True, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0):
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() <= p_texture))
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() <= p_geom))
-
-    if mode is 'TRAIN':
-        img_set_dir = os.path.join(img_dir, train_crop_dir)
-        out_image_list = mio.import_images(img_set_dir, verbose=True)
-
-        if augment_texture:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-        out_image_list = mio.import_images(img_set_dir, verbose=True)
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-
-    return out_image_list
-
-
-def reload_img_menpo_list_artistic_aug_train(
-        img_dir, train_crop_dir, img_dir_ns, mode, train_inds, image_size=256,
-        augment_basic=True, augment_texture=False, p_texture=0, augment_geom=False, p_geom=0):
-
-    img_menpo_list = load_menpo_image_list_artistic_aug(
-        img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode=mode,image_size=image_size,
-        augment_basic=augment_basic, augment_texture=augment_texture, p_texture=p_texture, augment_geom=augment_geom,
-        p_geom=p_geom)
-
-    img_menpo_list_train = img_menpo_list[train_inds]
-
-    return img_menpo_list_train
-
-
-'''********* heat-maps and image loading functions *********'''
-
-
-# look for: ECT-FaceAlignment/caffe/src/caffe/layers/data_heatmap.cpp
-def gaussian(x, y, x0, y0, sigma=6):
-    return 1./(np.sqrt(2*np.pi)*sigma) * np.exp(-0.5 * ((x-x0)**2 + (y-y0)**2) / sigma**2)
-
-
-def create_heat_maps(landmarks, num_landmarks=68, image_size=256, sigma=6):
-
-    x, y = np.mgrid[0:image_size, 0:image_size]
-
-    maps = np.zeros((image_size, image_size, num_landmarks))
-
-    for i in range(num_landmarks):
-        out = gaussian(x, y, landmarks[i,0], landmarks[i,1], sigma=sigma)
-        maps[:, :, i] = (8./3)*sigma*out  # copied from ECT
-
-    return maps
-
-
-def load_data(img_list, batch_inds, image_size=256, c_dim=3, num_landmarks=68 , sigma=6, scale='255',
-              save_landmarks=False, primary=False):
-
-    num_inputs = len(batch_inds)
-    batch_menpo_images = img_list[batch_inds]
-
-    images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
-    maps_small = np.zeros([num_inputs, image_size/4, image_size/4, num_landmarks]).astype('float32')
-
-    if primary:
-        maps = None
-    else:
-        maps = np.zeros([num_inputs, image_size, image_size, num_landmarks]).astype('float32')
-
-    if save_landmarks:
-        landmarks = np.zeros([num_inputs, num_landmarks, 2]).astype('float32')
-    else:
-        landmarks = None
-
-    for ind, img in enumerate(batch_menpo_images):
-
-        images[ind, :, :, :] = np.rollaxis(img.pixels, 0, 3)
-
-        if primary:
-            lms = img.resize([image_size/4,image_size/4]).landmarks['PTS'].points
-            maps_small[ind, :, :, :] = create_heat_maps(lms, num_landmarks, image_size/4, sigma)
-        else:
-            lms = img.landmarks['PTS'].points
-            maps[ind, :, :, :] = create_heat_maps(lms, num_landmarks, image_size, sigma)
-            maps_small[ind, :, :, :]=zoom(maps[ind, :, :, :],(0.25,0.25,1))
-
-        if save_landmarks:
-            landmarks[ind, :, :] = lms
-
-    if scale is '255':
-        images *= 255  # SAME AS ECT?
-    elif scale is '0':
-        images = 2 * images - 1
-
-    return images, maps, maps_small, landmarks
-
-
-def heat_maps_to_image(maps, landmarks=None, image_size=256, num_landmarks=68):
-
-    if landmarks is None:
-        landmarks = heat_maps_to_landmarks(maps, image_size=image_size, num_landmarks=num_landmarks)
-
-    x, y = np.mgrid[0:image_size, 0:image_size]
-
-    pixel_dist = np.sqrt(
-        np.square(np.expand_dims(x, 2) - landmarks[:, 0]) + np.square(np.expand_dims(y, 2) - landmarks[:, 1]))
-
-    nn_landmark = np.argmin(pixel_dist, 2)
-
-    map_image = maps[x, y, nn_landmark]
-    map_image = (map_image-map_image.min())/(map_image.max()-map_image.min())  # normalize for visualization
-
-    return map_image
-
-
-def heat_maps_to_landmarks(maps, image_size=256, num_landmarks=68):
-
-    landmarks = np.zeros((num_landmarks,2)).astype('float32')
-
-    for m_ind in range(num_landmarks):
-        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
-
-    return landmarks
-
-
-def batch_heat_maps_to_landmarks(batch_maps, batch_size, image_size=256, num_landmarks=68):
-    batch_landmarks = np.zeros((batch_size,num_landmarks, 2)).astype('float32')
-    for i in range(batch_size):
-        batch_landmarks[i,:,:]=heat_maps_to_landmarks(
-            batch_maps[i,:,:,:], image_size=image_size, num_landmarks=num_landmarks)
-
-    return batch_landmarks
-
-
-def print_training_params_to_file(init_locals):
-    del init_locals['self']
-    with open(os.path.join(init_locals['save_log_path'], 'Training_Parameters.txt'), 'w') as f:
-        f.write('Training Parameters:\n\n')
-        for key, value in init_locals.items():
-            f.write('* %s: %s\n' % (key, value))
-
-
-def create_img_with_landmarks(image, landmarks, image_size=256, num_landmarks=68, scale='255', circle_size=2):
-    image = image.reshape(image_size, image_size, -1)
-
-    if scale is '0':
-        image = 127.5 * (image + 1)
-    elif scale is '1':
-        image *= 255
-
-    landmarks = landmarks.reshape(num_landmarks, 2)
-    landmarks = np.clip(landmarks, 0, image_size)
-
-    for (y, x) in landmarks.astype('int'):
-        cv2.circle(image, (x, y), circle_size, (255, 0, 0), -1)
-
-    return image
-
-
-def merge_images_landmarks_maps(images, maps, image_size=256, num_landmarks=68, num_samples=9, scale='255',
-                                circle_size=2):
-    images = images[:num_samples]
-    if maps.shape[1] is not image_size:
-        images = zoom(images, (1, 0.25, 0.25, 1))
-        image_size /= 4
-    cmap = plt.get_cmap('jet')
-
-    row = int(np.sqrt(num_samples))
-    merged = np.zeros([row * image_size, row * image_size * 2, 3])
-
-    for idx, img in enumerate(images):
-        i = idx // row
-        j = idx % row
-
-        img_lamdmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
-        map_image = heat_maps_to_image(maps[idx, :, :, :], img_lamdmarks, image_size=image_size,
-                                       num_landmarks=num_landmarks)
-
-        rgba_map_image = cmap(map_image)
-        map_image = np.delete(rgba_map_image, 3, 2) * 255
-
-        img = create_img_with_landmarks(img, img_lamdmarks, image_size, num_landmarks, scale=scale,
-                                        circle_size=circle_size)
-
-        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = img
-        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = map_image
-
-    return merged
-
-
-def merge_compare_maps(maps_small, maps, image_size=64, num_landmarks=68, num_samples=9):
-
-    maps_small = maps_small[:num_samples]
-    maps = maps[:num_samples]
-
-    if maps_small.shape[1] is not image_size:
-        image_size = maps_small.shape[1]
-
-    if maps.shape[1] is not maps_small.shape[1]:
-        maps_rescale = zoom(maps, (1, 0.25, 0.25, 1))
-    else:
-        maps_rescale = maps
-
-    cmap = plt.get_cmap('jet')
-
-    row = int(np.sqrt(num_samples))
-    merged = np.zeros([row * image_size, row * image_size * 2, 3])
-
-    for idx, map_small in enumerate(maps_small):
-        i = idx // row
-        j = idx % row
-
-        map_image_small = heat_maps_to_image(map_small, image_size=image_size, num_landmarks=num_landmarks)
-        map_image = heat_maps_to_image(maps_rescale[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
-
-        rgba_map_image = cmap(map_image)
-        map_image = np.delete(rgba_map_image, 3, 2) * 255
-
-        rgba_map_image_small = cmap(map_image_small)
-        map_image_small = np.delete(rgba_map_image_small, 3, 2) * 255
-
-        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = map_image_small
-        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = map_image
-
-    return merged
-
-
-def normalize_map(map_in):
-    return (map_in - map_in.min()) / (map_in.max() - map_in.min())
-
-
-def map_to_rgb(map_gray):
-    cmap = plt.get_cmap('jet')
-    rgba_map_image = cmap(map_gray)
-    map_rgb = np.delete(rgba_map_image, 3, 2) * 255
-    return map_rgb
-
-
-def load_art_data(img_list, batch_inds, image_size=256, c_dim=3, scale='255'):
-
-    num_inputs = len(batch_inds)
-    batch_menpo_images = img_list[batch_inds]
-
-    images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
-
-    for ind, img in enumerate(batch_menpo_images):
-        images[ind, :, :, :] = np.rollaxis(img.pixels, 0, 3)
-
-    if scale is '255':
-        images *= 255  # SAME AS ECT?
-    elif scale is '0':
-        images = 2 * images - 1
-
-    return images
-
-
-def merge_images_landmarks_maps_gt(images, maps, maps_gt, image_size=256, num_landmarks=68, num_samples=9, scale='255',
-                                   circle_size=2, test_data='full', fast=False):
-    images = images[:num_samples]
-    if maps.shape[1] is not image_size:
-        images = zoom(images, (1, 0.25, 0.25, 1))
-        image_size /= 4
-    if maps_gt.shape[1] is not image_size:
-        maps_gt = zoom(maps_gt, (1, 0.25, 0.25, 1))
-
-    cmap = plt.get_cmap('jet')
-
-    row = int(np.sqrt(num_samples))
-    merged = np.zeros([row * image_size, row * image_size * 3, 3])
-
-    if fast:
-        maps_gt_images = np.amax(maps_gt, 3)
-        maps_images = np.amax(maps, 3)
-
-    for idx, img in enumerate(images):
-        i = idx // row
-        j = idx % row
-
-        img_landmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
-
-        if fast:
-            map_image = maps_images[idx]
-        else:
-            map_image = heat_maps_to_image(maps[idx, :, :, :], img_landmarks, image_size=image_size,
-                                           num_landmarks=num_landmarks)
-        rgba_map_image = cmap(map_image)
-        map_image = np.delete(rgba_map_image, 3, 2) * 255
-
-        if test_data not in ['full', 'challenging', 'common', 'training']:
-            map_gt_image = map_image.copy()
-        else:
-            if fast:
-                map_gt_image = maps_gt_images[idx]
-            else:
-                map_gt_image = heat_maps_to_image(maps_gt[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
-            rgba_map_gt_image = cmap(map_gt_image)
-            map_gt_image = np.delete(rgba_map_gt_image, 3, 2) * 255
-
-        img = create_img_with_landmarks(img, img_landmarks, image_size, num_landmarks, scale=scale,
-                                        circle_size=circle_size)
-
-        merged[i * image_size:(i + 1) * image_size, (j * 3) * image_size:(j * 3 + 1) * image_size, :] = img
-        merged[i * image_size:(i + 1) * image_size, (j * 3 + 1) * image_size:(j * 3 + 2) * image_size, :] = map_image
-        merged[i * image_size:(i + 1) * image_size, (j * 3 + 2) * image_size:(j * 3 + 3) * image_size, :] = map_gt_image
-
-    return merged
-
-
-def map_comapre_channels(images,maps1, maps2, image_size=64, num_landmarks=68, scale='255',test_data='full'):
-    map1 = maps1[0]
-    map2 = maps2[0]
-    image = images[0]
-
-    if image.shape[0] is not image_size:
-        image = zoom(image, (0.25, 0.25, 1))
-    if scale is '1':
-        image *= 255
-    elif scale is '0':
-        image = 127.5 * (image + 1)
-
-    row = np.ceil(np.sqrt(num_landmarks)).astype(np.int64)
-    merged = np.zeros([row * image_size, row * image_size * 2, 3])
-
-    for idx in range(num_landmarks):
-        i = idx // row
-        j = idx % row
-        channel_map = map_to_rgb(normalize_map(map1[:, :, idx]))
-        if test_data not in ['full', 'challenging', 'common', 'training']:
-            channel_map2=channel_map.copy()
-        else:
-            channel_map2 = map_to_rgb(normalize_map(map2[:, :, idx]))
-
-        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = channel_map
-        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = channel_map2
-
-    i = (idx + 1) // row
-    j = (idx + 1) % row
-    merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = image
-
-    return merged
-
-
-def train_val_shuffle_inds_per_epoch(valid_inds, train_inds, train_iter, batch_size, log_path, save_log=True):
-    np.random.seed(0)
-    num_train_images = len(train_inds)
-    num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
-    epoch_inds_shuffle = np.zeros((num_epochs, num_train_images)).astype(int)
-    img_inds = np.arange(num_train_images)
-    for i in range(num_epochs):
-        np.random.shuffle(img_inds)
-        epoch_inds_shuffle[i, :] = img_inds
-
-    if save_log:
-        with open(os.path.join(log_path, "train_val_shuffle_inds.csv"), "wb") as f:
-            if valid_inds is not None:
-                f.write(b'valid inds\n')
-                np.savetxt(f, valid_inds.reshape(1, -1), fmt='%i', delimiter=",")
-            f.write(b'train inds\n')
-            np.savetxt(f, train_inds.reshape(1, -1), fmt='%i', delimiter=",")
-            f.write(b'shuffle inds\n')
-            np.savetxt(f, epoch_inds_shuffle, fmt='%i', delimiter=",")
-
-    return epoch_inds_shuffle
+import numpy as np
+import os
+from scipy.io import loadmat
+import cv2
+from menpo.shape.pointcloud import PointCloud
+from menpo.transform import ThinPlateSplines
+import menpo.io as mio
+import matplotlib.pyplot as plt
+from scipy.ndimage import zoom
+from glob import glob
+from deformation_functions import *
+
+'''********* bounding box and image loading functions *********'''
+
+
+def center_margin_bb(bb, img_bounds, margin=0.25):
+    bb_size = ([bb[0, 2] - bb[0, 0], bb[0, 3] - bb[0, 1]])
+    margins = (np.max(bb_size) * (1 + margin) - bb_size) / 2
+
+    bb_new = np.zeros_like(bb)
+    bb_new[0, 0] = np.maximum(bb[0, 0] - margins[0], 0)
+    bb_new[0, 2] = np.minimum(bb[0, 2] + margins[0], img_bounds[1])
+    bb_new[0, 1] = np.maximum(bb[0, 1] - margins[1], 0)
+    bb_new[0, 3] = np.minimum(bb[0, 3] + margins[1], img_bounds[0])
+    return bb_new
+
+
+def load_bb_files(bb_file_dirs):
+    bb_files_dict = {}
+    for bb_file in bb_file_dirs:
+        bb_mat = loadmat(bb_file)['bounding_boxes']
+        num_imgs = np.max(bb_mat.shape)
+        for i in range(num_imgs):
+            name = bb_mat[0][i][0][0][0][0]
+            bb_init = bb_mat[0][i][0][0][1] - 1  # matlab indicies
+            bb_gt = bb_mat[0][i][0][0][2] - 1  # matlab indicies
+            if str(name) in bb_files_dict.keys():
+                print str(name), 'already loaded from: ', bb_file
+            bb_files_dict[str(name)] = (bb_init, bb_gt)
+    return bb_files_dict
+
+
+def load_bb_dictionary(bb_dir, mode, test_data='full'):
+    if mode == 'TRAIN':
+        bb_dirs = \
+            ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
+    else:
+        if test_data == 'common':
+            bb_dirs = \
+                ['bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
+        elif test_data == 'challenging':
+            bb_dirs = ['bounding_boxes_ibug.mat']
+        elif test_data == 'full':
+            bb_dirs = \
+                ['bounding_boxes_ibug.mat', 'bounding_boxes_helen_testset.mat', 'bounding_boxes_lfpw_testset.mat']
+        elif test_data == 'training':
+            bb_dirs = \
+                ['bounding_boxes_afw.mat', 'bounding_boxes_helen_trainset.mat', 'bounding_boxes_lfpw_trainset.mat']
+        else:
+            bb_dirs=None
+
+    if mode == 'TEST' and test_data not in ['full', 'challenging', 'common', 'training']:
+        bb_files_dict = None
+    else:
+        bb_dirs = [os.path.join(bb_dir, dataset) for dataset in bb_dirs]
+        bb_files_dict = load_bb_files(bb_dirs)
+
+    return bb_files_dict
+
+
+def crop_to_face_image(img, bb_dictionary=None, gt=True, margin=0.25, image_size=256):
+    name = img.path.name
+    img_bounds = img.bounds()[1]
+
+    if bb_dictionary is None:
+        bb_menpo = img.landmarks['PTS'].bounding_box().points
+        bb = np.array([[bb_menpo[0, 1], bb_menpo[0, 0], bb_menpo[2, 1], bb_menpo[2, 0]]])
+    else:
+        if gt:
+            bb = bb_dictionary[name][1]  # ground truth
+        else:
+            bb = bb_dictionary[name][0]  # init from face detector
+
+    bb = center_margin_bb(bb, img_bounds, margin=margin)
+
+    bb_pointcloud = PointCloud(np.array([[bb[0, 1], bb[0, 0]],
+                                         [bb[0, 3], bb[0, 0]],
+                                         [bb[0, 3], bb[0, 2]],
+                                         [bb[0, 1], bb[0, 2]]]))
+
+    face_crop = img.crop_to_pointcloud(bb_pointcloud).resize([image_size, image_size])
+
+    return face_crop
+
+
+def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True):
+
+    # taken from MDM
+    jaw_indices = np.arange(0, 17)
+    lbrow_indices = np.arange(17, 22)
+    rbrow_indices = np.arange(22, 27)
+    upper_nose_indices = np.arange(27, 31)
+    lower_nose_indices = np.arange(31, 36)
+    leye_indices = np.arange(36, 42)
+    reye_indices = np.arange(42, 48)
+    outer_mouth_indices = np.arange(48, 60)
+    inner_mouth_indices = np.arange(60, 68)
+
+    mirrored_parts_68 = np.hstack([
+        jaw_indices[::-1], rbrow_indices[::-1], lbrow_indices[::-1],
+        upper_nose_indices, lower_nose_indices[::-1],
+        np.roll(reye_indices[::-1], 4), np.roll(leye_indices[::-1], 4),
+        np.roll(outer_mouth_indices[::-1], 7),
+        np.roll(inner_mouth_indices[::-1], 5)
+    ])
+
+    def mirror_landmarks_68(lms, im_size):
+        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
+        ).reshape(-1, 2))[mirrored_parts_68])
+
+    def mirror_image(im):
+        im = im.copy()
+        im.pixels = im.pixels[..., ::-1].copy()
+
+        for group in im.landmarks:
+            lms = im.landmarks[group]
+            if lms.points.shape[0] == 68:
+                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
+
+        return im
+
+    lim = image_size - crop_size
+    min_crop_inds = np.random.randint(0, lim, 2)
+    max_crop_inds = min_crop_inds + crop_size
+    flip_rand = np.random.random() > 0.5
+    rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
+
+    if flip and flip_rand:
+        rand_crop = img.crop(min_crop_inds, max_crop_inds)
+        rand_crop = mirror_image(rand_crop)
+        rand_crop = rand_crop.rotate_ccw_about_centre(rot_angle).resize([image_size, image_size])
+
+    else:
+        rand_crop = img.crop(min_crop_inds, max_crop_inds). \
+            rotate_ccw_about_centre(rot_angle).resize([image_size, image_size])
+
+    return rand_crop
+
+
+def load_menpo_image_list(img_dir, mode, bb_dictionary=None, image_size=256, margin=0.25, bb_type='gt',
+                          test_data='full', augment=True):
+    def crop_to_face_image_gt(img, bb_dictionary=bb_dictionary, margin=margin, image_size=image_size):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img, bb_dictionary=bb_dictionary, margin=margin, image_size=image_size):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    if mode is 'TRAIN':
+        img_set_dir = os.path.join(img_dir, 'training_set')
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+
+    image_menpo_list = mio.import_images(img_set_dir, verbose=True)
+
+    if bb_type is 'gt':
+        face_crop_image_list = image_menpo_list.map(crop_to_face_image_gt)
+    else:
+        face_crop_image_list = image_menpo_list.map(crop_to_face_image_init)
+
+    if mode is 'TRAIN' and augment:
+        out_image_list = face_crop_image_list.map(augment_face_image)
+    else:
+        out_image_list = face_crop_image_list
+
+    return out_image_list
+
+
+def augment_menpo_img_ns(img, img_dir_ns, p_ns=0):
+    img = img.copy()
+    texture_aug = p_ns > 0.5
+    if texture_aug:
+        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '*'))
+        num_augs = len(ns_augs)
+        if num_augs > 1:
+            ns_ind = np.random.randint(1, num_augs)
+            ns_aug = mio.import_image(ns_augs[ns_ind])
+            ns_pixels = ns_aug.pixels
+            img.pixels = ns_pixels
+    return img
+
+
+def augment_menpo_img_geom(img, p_geom=0):
+    img = img.copy()
+    if p_geom > 0.5:
+        lms_geom_warp=deform_face_geometric_style(img.landmarks['PTS'].points.copy(),p_scale=p_geom,p_shift=p_geom)
+        img = warp_face_image_tps(img,PointCloud(lms_geom_warp))
+    return img
+
+
+def warp_face_image_tps(img,new_shape):
+    tps = ThinPlateSplines(new_shape, img.landmarks['PTS'])
+    img_warp=img.warp_to_shape(img.shape,tps)
+    img_warp.landmarks['PTS']=new_shape
+    return img_warp
+
+
+def load_menpo_image_list_artistic_aug(
+        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+        bb_type='gt', test_data='full',augment_basic=True, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0):
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() <= p_texture))
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() <= p_geom))
+
+    if mode is 'TRAIN':
+        img_set_dir = os.path.join(img_dir, train_crop_dir)
+        out_image_list = mio.import_images(img_set_dir, verbose=True)
+
+        if augment_texture:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+        out_image_list = mio.import_images(img_set_dir, verbose=True)
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+
+    return out_image_list
+
+
+def reload_img_menpo_list_artistic_aug_train(
+        img_dir, train_crop_dir, img_dir_ns, mode, train_inds, image_size=256,
+        augment_basic=True, augment_texture=False, p_texture=0, augment_geom=False, p_geom=0):
+
+    img_menpo_list = load_menpo_image_list_artistic_aug(
+        img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode=mode,image_size=image_size,
+        augment_basic=augment_basic, augment_texture=augment_texture, p_texture=p_texture, augment_geom=augment_geom,
+        p_geom=p_geom)
+
+    img_menpo_list_train = img_menpo_list[train_inds]
+
+    return img_menpo_list_train
+
+
+'''********* heat-maps and image loading functions *********'''
+
+
+# look for: ECT-FaceAlignment/caffe/src/caffe/layers/data_heatmap.cpp
+def gaussian(x, y, x0, y0, sigma=6):
+    return 1./(np.sqrt(2*np.pi)*sigma) * np.exp(-0.5 * ((x-x0)**2 + (y-y0)**2) / sigma**2)
+
+
+def create_heat_maps(landmarks, num_landmarks=68, image_size=256, sigma=6):
+
+    x, y = np.mgrid[0:image_size, 0:image_size]
+
+    maps = np.zeros((image_size, image_size, num_landmarks))
+
+    for i in range(num_landmarks):
+        out = gaussian(x, y, landmarks[i,0], landmarks[i,1], sigma=sigma)
+        maps[:, :, i] = (8./3)*sigma*out  # copied from ECT
+
+    return maps
+
+
+def load_data(img_list, batch_inds, image_size=256, c_dim=3, num_landmarks=68 , sigma=6, scale='255',
+              save_landmarks=False, primary=False):
+
+    num_inputs = len(batch_inds)
+    batch_menpo_images = img_list[batch_inds]
+
+    images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
+    maps_small = np.zeros([num_inputs, image_size/4, image_size/4, num_landmarks]).astype('float32')
+
+    if primary:
+        maps = None
+    else:
+        maps = np.zeros([num_inputs, image_size, image_size, num_landmarks]).astype('float32')
+
+    if save_landmarks:
+        landmarks = np.zeros([num_inputs, num_landmarks, 2]).astype('float32')
+    else:
+        landmarks = None
+
+    for ind, img in enumerate(batch_menpo_images):
+
+        images[ind, :, :, :] = np.rollaxis(img.pixels, 0, 3)
+
+        if primary:
+            lms = img.resize([image_size/4,image_size/4]).landmarks['PTS'].points
+            maps_small[ind, :, :, :] = create_heat_maps(lms, num_landmarks, image_size/4, sigma)
+        else:
+            lms = img.landmarks['PTS'].points
+            maps[ind, :, :, :] = create_heat_maps(lms, num_landmarks, image_size, sigma)
+            maps_small[ind, :, :, :]=zoom(maps[ind, :, :, :],(0.25,0.25,1))
+
+        if save_landmarks:
+            landmarks[ind, :, :] = lms
+
+    if scale is '255':
+        images *= 255  # SAME AS ECT?
+    elif scale is '0':
+        images = 2 * images - 1
+
+    return images, maps, maps_small, landmarks
+
+
+def heat_maps_to_image(maps, landmarks=None, image_size=256, num_landmarks=68):
+
+    if landmarks is None:
+        landmarks = heat_maps_to_landmarks(maps, image_size=image_size, num_landmarks=num_landmarks)
+
+    x, y = np.mgrid[0:image_size, 0:image_size]
+
+    pixel_dist = np.sqrt(
+        np.square(np.expand_dims(x, 2) - landmarks[:, 0]) + np.square(np.expand_dims(y, 2) - landmarks[:, 1]))
+
+    nn_landmark = np.argmin(pixel_dist, 2)
+
+    map_image = maps[x, y, nn_landmark]
+    map_image = (map_image-map_image.min())/(map_image.max()-map_image.min())  # normalize for visualization
+
+    return map_image
+
+
+def heat_maps_to_landmarks(maps, image_size=256, num_landmarks=68):
+
+    landmarks = np.zeros((num_landmarks,2)).astype('float32')
+
+    for m_ind in range(num_landmarks):
+        landmarks[m_ind, :] = np.unravel_index(maps[:, :, m_ind].argmax(), (image_size, image_size))
+
+    return landmarks
+
+
+def batch_heat_maps_to_landmarks(batch_maps, batch_size, image_size=256, num_landmarks=68):
+    batch_landmarks = np.zeros((batch_size,num_landmarks, 2)).astype('float32')
+    for i in range(batch_size):
+        batch_landmarks[i,:,:]=heat_maps_to_landmarks(
+            batch_maps[i,:,:,:], image_size=image_size, num_landmarks=num_landmarks)
+
+    return batch_landmarks
+
+
+def print_training_params_to_file(init_locals):
+    del init_locals['self']
+    with open(os.path.join(init_locals['save_log_path'], 'Training_Parameters.txt'), 'w') as f:
+        f.write('Training Parameters:\n\n')
+        for key, value in init_locals.items():
+            f.write('* %s: %s\n' % (key, value))
+
+
+def create_img_with_landmarks(image, landmarks, image_size=256, num_landmarks=68, scale='255', circle_size=2):
+    image = image.reshape(image_size, image_size, -1)
+
+    if scale is '0':
+        image = 127.5 * (image + 1)
+    elif scale is '1':
+        image *= 255
+
+    landmarks = landmarks.reshape(num_landmarks, 2)
+    landmarks = np.clip(landmarks, 0, image_size)
+
+    for (y, x) in landmarks.astype('int'):
+        cv2.circle(image, (x, y), circle_size, (255, 0, 0), -1)
+
+    return image
+
+
+def merge_images_landmarks_maps(images, maps, image_size=256, num_landmarks=68, num_samples=9, scale='255',
+                                circle_size=2):
+    images = images[:num_samples]
+    if maps.shape[1] is not image_size:
+        images = zoom(images, (1, 0.25, 0.25, 1))
+        image_size /= 4
+    cmap = plt.get_cmap('jet')
+
+    row = int(np.sqrt(num_samples))
+    merged = np.zeros([row * image_size, row * image_size * 2, 3])
+
+    for idx, img in enumerate(images):
+        i = idx // row
+        j = idx % row
+
+        img_lamdmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
+        map_image = heat_maps_to_image(maps[idx, :, :, :], img_lamdmarks, image_size=image_size,
+                                       num_landmarks=num_landmarks)
+
+        rgba_map_image = cmap(map_image)
+        map_image = np.delete(rgba_map_image, 3, 2) * 255
+
+        img = create_img_with_landmarks(img, img_lamdmarks, image_size, num_landmarks, scale=scale,
+                                        circle_size=circle_size)
+
+        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = img
+        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = map_image
+
+    return merged
+
+
+def merge_compare_maps(maps_small, maps, image_size=64, num_landmarks=68, num_samples=9):
+
+    maps_small = maps_small[:num_samples]
+    maps = maps[:num_samples]
+
+    if maps_small.shape[1] is not image_size:
+        image_size = maps_small.shape[1]
+
+    if maps.shape[1] is not maps_small.shape[1]:
+        maps_rescale = zoom(maps, (1, 0.25, 0.25, 1))
+    else:
+        maps_rescale = maps
+
+    cmap = plt.get_cmap('jet')
+
+    row = int(np.sqrt(num_samples))
+    merged = np.zeros([row * image_size, row * image_size * 2, 3])
+
+    for idx, map_small in enumerate(maps_small):
+        i = idx // row
+        j = idx % row
+
+        map_image_small = heat_maps_to_image(map_small, image_size=image_size, num_landmarks=num_landmarks)
+        map_image = heat_maps_to_image(maps_rescale[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
+
+        rgba_map_image = cmap(map_image)
+        map_image = np.delete(rgba_map_image, 3, 2) * 255
+
+        rgba_map_image_small = cmap(map_image_small)
+        map_image_small = np.delete(rgba_map_image_small, 3, 2) * 255
+
+        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = map_image_small
+        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = map_image
+
+    return merged
+
+
+def normalize_map(map_in):
+    return (map_in - map_in.min()) / (map_in.max() - map_in.min())
+
+
+def map_to_rgb(map_gray):
+    cmap = plt.get_cmap('jet')
+    rgba_map_image = cmap(map_gray)
+    map_rgb = np.delete(rgba_map_image, 3, 2) * 255
+    return map_rgb
+
+
+def load_art_data(img_list, batch_inds, image_size=256, c_dim=3, scale='255'):
+
+    num_inputs = len(batch_inds)
+    batch_menpo_images = img_list[batch_inds]
+
+    images = np.zeros([num_inputs, image_size, image_size, c_dim]).astype('float32')
+
+    for ind, img in enumerate(batch_menpo_images):
+        images[ind, :, :, :] = np.rollaxis(img.pixels, 0, 3)
+
+    if scale is '255':
+        images *= 255  # SAME AS ECT?
+    elif scale is '0':
+        images = 2 * images - 1
+
+    return images
+
+
+def merge_images_landmarks_maps_gt(images, maps, maps_gt, image_size=256, num_landmarks=68, num_samples=9, scale='255',
+                                   circle_size=2, test_data='full', fast=False):
+    images = images[:num_samples]
+    if maps.shape[1] is not image_size:
+        images = zoom(images, (1, 0.25, 0.25, 1))
+        image_size /= 4
+    if maps_gt.shape[1] is not image_size:
+        maps_gt = zoom(maps_gt, (1, 0.25, 0.25, 1))
+
+    cmap = plt.get_cmap('jet')
+
+    row = int(np.sqrt(num_samples))
+    merged = np.zeros([row * image_size, row * image_size * 3, 3])
+
+    if fast:
+        maps_gt_images = np.amax(maps_gt, 3)
+        maps_images = np.amax(maps, 3)
+
+    for idx, img in enumerate(images):
+        i = idx // row
+        j = idx % row
+
+        img_landmarks = heat_maps_to_landmarks(maps[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
+
+        if fast:
+            map_image = maps_images[idx]
+        else:
+            map_image = heat_maps_to_image(maps[idx, :, :, :], img_landmarks, image_size=image_size,
+                                           num_landmarks=num_landmarks)
+        rgba_map_image = cmap(map_image)
+        map_image = np.delete(rgba_map_image, 3, 2) * 255
+
+        if test_data not in ['full', 'challenging', 'common', 'training']:
+            map_gt_image = map_image.copy()
+        else:
+            if fast:
+                map_gt_image = maps_gt_images[idx]
+            else:
+                map_gt_image = heat_maps_to_image(maps_gt[idx, :, :, :], image_size=image_size, num_landmarks=num_landmarks)
+            rgba_map_gt_image = cmap(map_gt_image)
+            map_gt_image = np.delete(rgba_map_gt_image, 3, 2) * 255
+
+        img = create_img_with_landmarks(img, img_landmarks, image_size, num_landmarks, scale=scale,
+                                        circle_size=circle_size)
+
+        merged[i * image_size:(i + 1) * image_size, (j * 3) * image_size:(j * 3 + 1) * image_size, :] = img
+        merged[i * image_size:(i + 1) * image_size, (j * 3 + 1) * image_size:(j * 3 + 2) * image_size, :] = map_image
+        merged[i * image_size:(i + 1) * image_size, (j * 3 + 2) * image_size:(j * 3 + 3) * image_size, :] = map_gt_image
+
+    return merged
+
+
+def map_comapre_channels(images,maps1, maps2, image_size=64, num_landmarks=68, scale='255',test_data='full'):
+    map1 = maps1[0]
+    map2 = maps2[0]
+    image = images[0]
+
+    if image.shape[0] is not image_size:
+        image = zoom(image, (0.25, 0.25, 1))
+    if scale is '1':
+        image *= 255
+    elif scale is '0':
+        image = 127.5 * (image + 1)
+
+    row = np.ceil(np.sqrt(num_landmarks)).astype(np.int64)
+    merged = np.zeros([row * image_size, row * image_size * 2, 3])
+
+    for idx in range(num_landmarks):
+        i = idx // row
+        j = idx % row
+        channel_map = map_to_rgb(normalize_map(map1[:, :, idx]))
+        if test_data not in ['full', 'challenging', 'common', 'training']:
+            channel_map2=channel_map.copy()
+        else:
+            channel_map2 = map_to_rgb(normalize_map(map2[:, :, idx]))
+
+        merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = channel_map
+        merged[i * image_size:(i + 1) * image_size, (j * 2 + 1) * image_size:(j * 2 + 2) * image_size, :] = channel_map2
+
+    i = (idx + 1) // row
+    j = (idx + 1) % row
+    merged[i * image_size:(i + 1) * image_size, (j * 2) * image_size:(j * 2 + 1) * image_size, :] = image
+
+    return merged
+
+
+def train_val_shuffle_inds_per_epoch(valid_inds, train_inds, train_iter, batch_size, log_path, save_log=True):
+    np.random.seed(0)
+    num_train_images = len(train_inds)
+    num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
+    epoch_inds_shuffle = np.zeros((num_epochs, num_train_images)).astype(int)
+    img_inds = np.arange(num_train_images)
+    for i in range(num_epochs):
+        np.random.shuffle(img_inds)
+        epoch_inds_shuffle[i, :] = img_inds
+
+    if save_log:
+        with open(os.path.join(log_path, "train_val_shuffle_inds.csv"), "wb") as f:
+            if valid_inds is not None:
+                f.write(b'valid inds\n')
+                np.savetxt(f, valid_inds.reshape(1, -1), fmt='%i', delimiter=",")
+            f.write(b'train inds\n')
+            np.savetxt(f, train_inds.reshape(1, -1), fmt='%i', delimiter=",")
+            f.write(b'shuffle inds\n')
+            np.savetxt(f, epoch_inds_shuffle, fmt='%i', delimiter=",")
+
+    return epoch_inds_shuffle

MakeItTalk/thirdparty/face_of_art/old/main.py

@@ -1,46 +1,46 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
-
-# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
-
-flags = tf.app.flags
-flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
-flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
-flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
-flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', 'saved model to test')
-flags.DEFINE_string('test_data', 'full', 'dataset to test: full/common/challenging/test/art')
-flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
-
-FLAGS = flags.FLAGS
-
-
-def main(_):
-
-    # create directories if not exist
-    if not tf.gfile.Exists(FLAGS.save_model_path):
-        tf.gfile.MakeDirs(FLAGS.save_model_path)
-    if not tf.gfile.Exists(FLAGS.save_sample_path):
-        tf.gfile.MakeDirs(FLAGS.save_sample_path)
-    if not tf.gfile.Exists(FLAGS.save_log_path):
-        tf.gfile.MakeDirs(FLAGS.save_log_path)
-
-    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=80000, learning_rate=1e-11, momentum=0.95, step=80000,
-                              gamma=0.1, batch_size=4, image_size=256, c_dim=3, num_landmarks=68,
-                              augment_basic=True, basic_start=1, augment_texture=True, p_texture=0.,
-                              augment_geom=True, p_geom=0., artistic_start=2, artistic_step=1,
-                              img_path=FLAGS.img_path, save_log_path=FLAGS.save_log_path,
-                              save_sample_path=FLAGS.save_sample_path, save_model_path=FLAGS.save_model_path,
-                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
-                              load_pretrain=False, pre_train_path=FLAGS.pre_train_path)
-
-    if FLAGS.mode == 'TRAIN':
-        model.train()
-    else:
-        model.eval()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
+
+# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
+
+flags = tf.app.flags
+flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
+flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
+flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
+flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', 'saved model to test')
+flags.DEFINE_string('test_data', 'full', 'dataset to test: full/common/challenging/test/art')
+flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
+
+FLAGS = flags.FLAGS
+
+
+def main(_):
+
+    # create directories if not exist
+    if not tf.gfile.Exists(FLAGS.save_model_path):
+        tf.gfile.MakeDirs(FLAGS.save_model_path)
+    if not tf.gfile.Exists(FLAGS.save_sample_path):
+        tf.gfile.MakeDirs(FLAGS.save_sample_path)
+    if not tf.gfile.Exists(FLAGS.save_log_path):
+        tf.gfile.MakeDirs(FLAGS.save_log_path)
+
+    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=80000, learning_rate=1e-11, momentum=0.95, step=80000,
+                              gamma=0.1, batch_size=4, image_size=256, c_dim=3, num_landmarks=68,
+                              augment_basic=True, basic_start=1, augment_texture=True, p_texture=0.,
+                              augment_geom=True, p_geom=0., artistic_start=2, artistic_step=1,
+                              img_path=FLAGS.img_path, save_log_path=FLAGS.save_log_path,
+                              save_sample_path=FLAGS.save_sample_path, save_model_path=FLAGS.save_model_path,
+                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
+                              load_pretrain=False, pre_train_path=FLAGS.pre_train_path)
+
+    if FLAGS.mode == 'TRAIN':
+        model.train()
+    else:
+        model.eval()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/main_fusion.py

@@ -1,122 +1,122 @@
-import tensorflow as tf
-from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
-import os
-
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
-output_dir = os.getcwd()
-
-flags = tf.app.flags
-
-# mode and logging parameters
-flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
-flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
-flags.DEFINE_integer('save_every', 20000, "save model every X steps")
-flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
-flags.DEFINE_integer('sample_grid', 4, 'number of training images in sample')
-flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
-flags.DEFINE_integer('valid_size', 4, 'number of validation images to run')
-flags.DEFINE_integer('log_valid_every', 10, 'evaluate on valid set every X epochs')
-flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
-flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
-
-# define paths
-flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
-flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
-flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
-flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
-flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
-flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
-flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25', "directory of train images cropped to bb (+margin)")
-flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns', "dir of train imgs cropped to bb + style transfer")
-flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
-flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
-
-# pretrain parameters (for fine-tuning / resume training)
-flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-flags.DEFINE_bool('load_primary_only', False, 'fine-tuning using only primary network weights')
-
-# input data parameters
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-flags.DEFINE_float('sigma', 6, "std for heatmap generation gaussian")
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
-
-# optimization parameters
-flags.DEFINE_float('l_weight_primary', 1., 'primary loss weight')
-flags.DEFINE_float('l_weight_fusion', 0., 'fusion loss weight')
-flags.DEFINE_float('l_weight_upsample', 3., 'upsample loss weight')
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 6, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
-flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
-flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-flags.DEFINE_float('reg', 1e-5, 'scalar multiplier for weight decay (0 to disable)')
-flags.DEFINE_string('weight_initializer', 'xavier', 'weight initializer: random_normal / xavier')
-flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
-flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
-flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
-flags.DEFINE_float('p_texture', 0., 'probability of artistic texture augmentation')
-flags.DEFINE_bool('augment_geom', False, "use artistic geometric augmentation?")
-flags.DEFINE_float('p_geom', 0., 'probability of artistic geometric augmentation')
-
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
-    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
-    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
-
-    # create directories if not exist
-    if not os.path.exists(save_model_path):
-        os.mkdir(save_model_path)
-    if not os.path.exists(save_log_path):
-        os.mkdir(save_log_path)
-    if not os.path.exists(save_sample_path) and (not FLAGS.sample_to_log or FLAGS.mode != 'TRAIN'):
-        os.mkdir(save_sample_path)
-
-    model = DeepHeatmapsModel(
-        mode=FLAGS.mode, train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate,
-        l_weight_primary=FLAGS.l_weight_primary, l_weight_fusion=FLAGS.l_weight_fusion,
-        l_weight_upsample=FLAGS.l_weight_upsample, reg=FLAGS.reg, adam_optimizer=FLAGS.adam_optimizer,
-        momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
-        weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
-        bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
-        num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
-        bb_type=FLAGS.bb_type, win_mult=FLAGS.win_mult, augment_basic=FLAGS.augment_basic,
-        augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom,
-        p_geom=FLAGS.p_geom, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
-        save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
-        pre_train_path=FLAGS.pre_train_path, load_pretrain=FLAGS.load_pretrain, load_primary_only=FLAGS.load_primary_only,
-        img_path=FLAGS.img_path, test_data=FLAGS.test_data, valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size,
-        log_valid_every=FLAGS.log_valid_every, train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns,
-        print_every=FLAGS.print_every, save_every=FLAGS.save_every, sample_every=FLAGS.sample_every,
-        sample_grid=FLAGS.sample_grid, sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size,
-        debug=FLAGS.debug, use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
-
-    if FLAGS.mode == 'TRAIN':
-        model.train()
-    else:
-        model.eval()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
+import os
+
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
+output_dir = os.getcwd()
+
+flags = tf.app.flags
+
+# mode and logging parameters
+flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
+flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
+flags.DEFINE_integer('save_every', 20000, "save model every X steps")
+flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
+flags.DEFINE_integer('sample_grid', 4, 'number of training images in sample')
+flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
+flags.DEFINE_integer('valid_size', 4, 'number of validation images to run')
+flags.DEFINE_integer('log_valid_every', 10, 'evaluate on valid set every X epochs')
+flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
+flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
+
+# define paths
+flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
+flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
+flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
+flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
+flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
+flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
+flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25', "directory of train images cropped to bb (+margin)")
+flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns', "dir of train imgs cropped to bb + style transfer")
+flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
+flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
+
+# pretrain parameters (for fine-tuning / resume training)
+flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+flags.DEFINE_bool('load_primary_only', False, 'fine-tuning using only primary network weights')
+
+# input data parameters
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+flags.DEFINE_float('sigma', 6, "std for heatmap generation gaussian")
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
+
+# optimization parameters
+flags.DEFINE_float('l_weight_primary', 1., 'primary loss weight')
+flags.DEFINE_float('l_weight_fusion', 0., 'fusion loss weight')
+flags.DEFINE_float('l_weight_upsample', 3., 'upsample loss weight')
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 6, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
+flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
+flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+flags.DEFINE_float('reg', 1e-5, 'scalar multiplier for weight decay (0 to disable)')
+flags.DEFINE_string('weight_initializer', 'xavier', 'weight initializer: random_normal / xavier')
+flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
+flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
+flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
+flags.DEFINE_float('p_texture', 0., 'probability of artistic texture augmentation')
+flags.DEFINE_bool('augment_geom', False, "use artistic geometric augmentation?")
+flags.DEFINE_float('p_geom', 0., 'probability of artistic geometric augmentation')
+
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
+    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
+    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
+
+    # create directories if not exist
+    if not os.path.exists(save_model_path):
+        os.mkdir(save_model_path)
+    if not os.path.exists(save_log_path):
+        os.mkdir(save_log_path)
+    if not os.path.exists(save_sample_path) and (not FLAGS.sample_to_log or FLAGS.mode != 'TRAIN'):
+        os.mkdir(save_sample_path)
+
+    model = DeepHeatmapsModel(
+        mode=FLAGS.mode, train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate,
+        l_weight_primary=FLAGS.l_weight_primary, l_weight_fusion=FLAGS.l_weight_fusion,
+        l_weight_upsample=FLAGS.l_weight_upsample, reg=FLAGS.reg, adam_optimizer=FLAGS.adam_optimizer,
+        momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
+        weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
+        bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
+        num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
+        bb_type=FLAGS.bb_type, win_mult=FLAGS.win_mult, augment_basic=FLAGS.augment_basic,
+        augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom,
+        p_geom=FLAGS.p_geom, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
+        save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
+        pre_train_path=FLAGS.pre_train_path, load_pretrain=FLAGS.load_pretrain, load_primary_only=FLAGS.load_primary_only,
+        img_path=FLAGS.img_path, test_data=FLAGS.test_data, valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size,
+        log_valid_every=FLAGS.log_valid_every, train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns,
+        print_every=FLAGS.print_every, save_every=FLAGS.save_every, sample_every=FLAGS.sample_every,
+        sample_grid=FLAGS.sample_grid, sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size,
+        debug=FLAGS.debug, use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
+
+    if FLAGS.mode == 'TRAIN':
+        model.train()
+    else:
+        model.eval()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/main_fusion_server.py

@@ -1,92 +1,92 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_fusion import DeepHeatmapsModel
-import os
-
-# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
-output_dir = os.getcwd()
-
-flags = tf.app.flags
-
-flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
-
-# define paths
-flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
-flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
-flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', "saved model to test")
-flags.DEFINE_string('test_data','full', 'test set to use full/common/challenging/test/art')
-
-# pretrain parameters
-flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-flags.DEFINE_bool('load_primary_only', True, "load primary weight only?")
-
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-
-# optimization parameters
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 10, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-6, "initial learning rate")
-flags.DEFINE_float('momentum', 0.95, 'optimizer momentum')
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
-flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
-flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
-flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
-flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
-flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
-flags.DEFINE_integer('artistic_step', 10, 'increase probability of artistic augmentation every X epochs')
-flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
-
-
-# directory of test
-flags.DEFINE_string('output_dir', output_dir, "directory for saving test")
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
-    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
-    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
-
-    # create directories if not exist
-    if not os.path.exists(save_model_path):
-        os.mkdir(save_model_path)
-    if not os.path.exists(save_sample_path):
-        os.mkdir(save_sample_path)
-    if not os.path.exists(save_log_path):
-        os.mkdir(save_log_path)
-
-    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=FLAGS.train_iter, learning_rate=FLAGS.learning_rate,
-                              momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, batch_size=FLAGS.batch_size,
-                              image_size=FLAGS.image_size, c_dim=FLAGS.c_dim, num_landmarks=FLAGS.num_landmarks,
-                              augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start,
-                              augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
-                              augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
-                              artistic_start=FLAGS.artistic_start, artistic_step=FLAGS.artistic_step,
-                              img_path=FLAGS.img_path, save_log_path=save_log_path,
-                              save_sample_path=save_sample_path, save_model_path=save_model_path,
-                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
-                              load_pretrain=FLAGS.load_pretrain, load_primary_only=FLAGS.load_primary_only,
-                              pre_train_path=FLAGS.pre_train_path)
-
-    if FLAGS.mode == 'TRAIN':
-        model.train()
-    else:
-        model.eval()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_primary_fusion import DeepHeatmapsModel
+import os
+
+# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
+output_dir = os.getcwd()
+
+flags = tf.app.flags
+
+flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
+
+# define paths
+flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
+flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
+flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', "saved model to test")
+flags.DEFINE_string('test_data','full', 'test set to use full/common/challenging/test/art')
+
+# pretrain parameters
+flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+flags.DEFINE_bool('load_primary_only', True, "load primary weight only?")
+
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+
+# optimization parameters
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 10, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-6, "initial learning rate")
+flags.DEFINE_float('momentum', 0.95, 'optimizer momentum')
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
+flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
+flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
+flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
+flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
+flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
+flags.DEFINE_integer('artistic_step', 10, 'increase probability of artistic augmentation every X epochs')
+flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
+
+
+# directory of test
+flags.DEFINE_string('output_dir', output_dir, "directory for saving test")
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
+    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
+    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
+
+    # create directories if not exist
+    if not os.path.exists(save_model_path):
+        os.mkdir(save_model_path)
+    if not os.path.exists(save_sample_path):
+        os.mkdir(save_sample_path)
+    if not os.path.exists(save_log_path):
+        os.mkdir(save_log_path)
+
+    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=FLAGS.train_iter, learning_rate=FLAGS.learning_rate,
+                              momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, batch_size=FLAGS.batch_size,
+                              image_size=FLAGS.image_size, c_dim=FLAGS.c_dim, num_landmarks=FLAGS.num_landmarks,
+                              augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start,
+                              augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
+                              augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
+                              artistic_start=FLAGS.artistic_start, artistic_step=FLAGS.artistic_step,
+                              img_path=FLAGS.img_path, save_log_path=save_log_path,
+                              save_sample_path=save_sample_path, save_model_path=save_model_path,
+                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
+                              load_pretrain=FLAGS.load_pretrain, load_primary_only=FLAGS.load_primary_only,
+                              pre_train_path=FLAGS.pre_train_path)
+
+    if FLAGS.mode == 'TRAIN':
+        model.train()
+    else:
+        model.eval()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/main_primary_server.py

@@ -1,89 +1,89 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
-import os
-
-# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
-output_dir = os.getcwd()
-
-flags = tf.app.flags
-
-flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
-
-# define paths
-flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
-flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
-flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', "saved model to test")
-flags.DEFINE_string('test_data','full', 'test set to use full/common/challenging/test/art')
-
-# pretrain parameters
-flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-
-# optimization parameters
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 10, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-6, "initial learning rate")
-flags.DEFINE_float('momentum', 0.95, 'optimizer momentum')
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
-flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
-flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
-flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
-flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
-flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
-flags.DEFINE_integer('artistic_step', 10, 'increase probability of artistic augmentation every X epochs')
-flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
-
-# directory of test
-flags.DEFINE_string('output_dir', output_dir, "directory for saving test")
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
-    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
-    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
-
-    # create directories if not exist
-    if not os.path.exists(save_model_path):
-        os.mkdir(save_model_path)
-    if not os.path.exists(save_sample_path):
-        os.mkdir(save_sample_path)
-    if not os.path.exists(save_log_path):
-        os.mkdir(save_log_path)
-
-    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=FLAGS.train_iter, learning_rate=FLAGS.learning_rate,
-                              momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, batch_size=FLAGS.batch_size,
-                              image_size=FLAGS.image_size, c_dim=FLAGS.c_dim, num_landmarks=FLAGS.num_landmarks,
-                              augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start,
-                              augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
-                              augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
-                              artistic_start=FLAGS.artistic_start, artistic_step=FLAGS.artistic_step,
-                              img_path=FLAGS.img_path, save_log_path=save_log_path,
-                              save_sample_path=save_sample_path, save_model_path=save_model_path,
-                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
-                              load_pretrain=FLAGS.load_pretrain, pre_train_path=FLAGS.pre_train_path)
-
-    if FLAGS.mode == 'TRAIN':
-        model.train()
-    else:
-        model.eval()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
+import os
+
+# data_dir ='/mnt/External1/Yarden/deep_face_heatmaps/data/conventional_landmark_detection_dataset/'
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
+output_dir = os.getcwd()
+
+flags = tf.app.flags
+
+flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
+
+# define paths
+flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
+flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
+flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-5', "saved model to test")
+flags.DEFINE_string('test_data','full', 'test set to use full/common/challenging/test/art')
+
+# pretrain parameters
+flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+
+# optimization parameters
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 10, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-6, "initial learning rate")
+flags.DEFINE_float('momentum', 0.95, 'optimizer momentum')
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
+flags.DEFINE_bool('augment_texture', False,"use artistic texture augmentation?")
+flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
+flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
+flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
+flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
+flags.DEFINE_integer('artistic_step', 10, 'increase probability of artistic augmentation every X epochs')
+flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
+
+# directory of test
+flags.DEFINE_string('output_dir', output_dir, "directory for saving test")
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
+    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
+    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
+
+    # create directories if not exist
+    if not os.path.exists(save_model_path):
+        os.mkdir(save_model_path)
+    if not os.path.exists(save_sample_path):
+        os.mkdir(save_sample_path)
+    if not os.path.exists(save_log_path):
+        os.mkdir(save_log_path)
+
+    model = DeepHeatmapsModel(mode=FLAGS.mode, train_iter=FLAGS.train_iter, learning_rate=FLAGS.learning_rate,
+                              momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, batch_size=FLAGS.batch_size,
+                              image_size=FLAGS.image_size, c_dim=FLAGS.c_dim, num_landmarks=FLAGS.num_landmarks,
+                              augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start,
+                              augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
+                              augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
+                              artistic_start=FLAGS.artistic_start, artistic_step=FLAGS.artistic_step,
+                              img_path=FLAGS.img_path, save_log_path=save_log_path,
+                              save_sample_path=save_sample_path, save_model_path=save_model_path,
+                              test_data=FLAGS.test_data, test_model_path=FLAGS.test_model_path,
+                              load_pretrain=FLAGS.load_pretrain, pre_train_path=FLAGS.pre_train_path)
+
+    if FLAGS.mode == 'TRAIN':
+        model.train()
+    else:
+        model.eval()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/run_tests_template.py

@@ -1,50 +1,50 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
-import os
-import numpy as np
-
-num_tests = 10
-params = np.logspace(-8, -2, num_tests)
-max_iter = 80000
-
-output_dir = 'tests_lr_fusion'
-data_dir = '../conventional_landmark_detection_dataset'
-
-flags = tf.app.flags
-flags.DEFINE_string('output_dir', output_dir, "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-for param in params:
-    test_name = str(param)
-    test_dir = os.path.join(FLAGS.output_dir,test_name)
-    if not os.path.exists(test_dir):
-        os.mkdir(test_dir)
-
-    print '##### RUNNING TESTS ##### current directory:', test_dir
-
-    save_model_path = os.path.join(test_dir, 'model')
-    save_sample_path = os.path.join(test_dir, 'sample')
-    save_log_path = os.path.join(test_dir, 'logs')
-
-    # create directories if not exist
-    if not os.path.exists(save_model_path):
-        os.mkdir(save_model_path)
-    if not os.path.exists(save_sample_path):
-        os.mkdir(save_sample_path)
-    if not os.path.exists(save_log_path):
-        os.mkdir(save_log_path)
-
-    tf.reset_default_graph()  # reset graph
-
-    model = DeepHeatmapsModel(mode='TRAIN', train_iter=max_iter, learning_rate=param, momentum=0.95, step=80000,
-                              gamma=0.1, batch_size=4, image_size=256, c_dim=3, num_landmarks=68,
-                              augment_basic=True, basic_start=0, augment_texture=True, p_texture=0.5,
-                              augment_geom=True, p_geom=0.5, artistic_start=0, artistic_step=10,
-                              img_path=FLAGS.img_path, save_log_path=save_log_path, save_sample_path=save_sample_path,
-                              save_model_path=save_model_path)
-
-    model.train()
+import tensorflow as tf
+from deep_heatmaps_model_primary_valid import DeepHeatmapsModel
+import os
+import numpy as np
+
+num_tests = 10
+params = np.logspace(-8, -2, num_tests)
+max_iter = 80000
+
+output_dir = 'tests_lr_fusion'
+data_dir = '../conventional_landmark_detection_dataset'
+
+flags = tf.app.flags
+flags.DEFINE_string('output_dir', output_dir, "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+for param in params:
+    test_name = str(param)
+    test_dir = os.path.join(FLAGS.output_dir,test_name)
+    if not os.path.exists(test_dir):
+        os.mkdir(test_dir)
+
+    print '##### RUNNING TESTS ##### current directory:', test_dir
+
+    save_model_path = os.path.join(test_dir, 'model')
+    save_sample_path = os.path.join(test_dir, 'sample')
+    save_log_path = os.path.join(test_dir, 'logs')
+
+    # create directories if not exist
+    if not os.path.exists(save_model_path):
+        os.mkdir(save_model_path)
+    if not os.path.exists(save_sample_path):
+        os.mkdir(save_sample_path)
+    if not os.path.exists(save_log_path):
+        os.mkdir(save_log_path)
+
+    tf.reset_default_graph()  # reset graph
+
+    model = DeepHeatmapsModel(mode='TRAIN', train_iter=max_iter, learning_rate=param, momentum=0.95, step=80000,
+                              gamma=0.1, batch_size=4, image_size=256, c_dim=3, num_landmarks=68,
+                              augment_basic=True, basic_start=0, augment_texture=True, p_texture=0.5,
+                              augment_geom=True, p_geom=0.5, artistic_start=0, artistic_step=10,
+                              img_path=FLAGS.img_path, save_log_path=save_log_path, save_sample_path=save_sample_path,
+                              save_model_path=save_model_path)
+
+    model.train()

MakeItTalk/thirdparty/face_of_art/old/temp/Untitled.rtf

@@ -1,7 +1,7 @@
-{\rtf1\ansi\ansicpg1252\cocoartf1404\cocoasubrtf470
-{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
-{\colortbl;\red255\green255\blue255;}
-\paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0
-\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
-
+{\rtf1\ansi\ansicpg1252\cocoartf1404\cocoasubrtf470
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+\paperw11900\paperh16840\margl1440\margr1440\vieww10800\viewh8400\viewkind0
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+
 \f0\fs24 \cf0 a}

MakeItTalk/thirdparty/face_of_art/old/temp/create_art_data.py

@@ -1,132 +1,132 @@
-from create_art_data_functions import *
-from scipy.misc import imsave
-import sys
-
-
-'''THIS SCRIPT CREATES PRE-AUGMENTED DATA TO SAVE TRAINING TIME (ARTISTIC OR BASIC AUGMENTATION):
-    under the folder *outdir*, it will create a separate folder for each epoch. the folder will
-    contain the augmented images and matching landmark (pts) files.'''
-
-# parameter for calculating number of epochs
-num_train_images = 3148  # number of training images
-train_iter = 100000  # number of training iterations
-batch_size = 6  # batch size in training
-num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
-
-# augmentation parameters
-num_augs = 9  # number of style transfer augmented images
-aug_geom = True  # use artistic geometric augmentation?
-aug_texture = True  # use artistic texture augmentation?
-
-# image parameters
-bb_type = 'gt'  # face bounding-box type (gt/init)
-margin = 0.25  # margin for face crops - % of bb size
-image_size = 256  # image size
-
-# data-sets image paths
-dataset = 'training'  # dataset to augment (training/full/common/challenging/test)
-img_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-train_crop_dir = 'crop_gt_margin_0.25'  # directory of train images cropped to bb (+margin)
-img_dir_ns = os.path.join(img_dir, train_crop_dir+'_ns')  # dir of train imgs cropped to bb + style transfer
-outdir = '/Users/arik/Desktop/epoch_data'  # directory for saving augmented data
-
-# other parameters
-min_epoch_to_save = 0  # start saving images from this epoch (first epoch is 0)
-debug_data_size = 15
-debug = False
-random_seed = 1234  # random seed for numpy
-
-########################################################################################
-if aug_texture and img_dir_ns is None:
-    print('\n *** ERROR: aug_texture is True, and img_dir_ns is None.\n'
-          'please specify path for img_dir_ns to augment image texture!')
-    sys.exit()
-
-if not os.path.exists(outdir):
-    os.mkdir(outdir)
-
-gt = (bb_type == 'gt')
-bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
-
-if dataset == 'training':
-    mode = 'TRAIN'
-else:
-    mode = 'TEST'
-bb_dictionary = load_bb_dictionary(bb_dir, mode=mode, test_data=dataset)
-
-aug_geom_dir = os.path.join(outdir, 'aug_geom')
-aug_texture_dir = os.path.join(outdir, 'aug_texture')
-aug_geom_texture_dir = os.path.join(outdir, 'aug_geom_texture')
-aug_basic_dir = os.path.join(outdir, 'aug_basic')
-
-if not aug_geom and aug_texture:
-    save_aug_path = aug_texture_dir
-elif aug_geom and not aug_texture:
-    save_aug_path = aug_geom_dir
-elif aug_geom and aug_texture:
-    save_aug_path = aug_geom_texture_dir
-else:
-    save_aug_path = aug_basic_dir
-
-print ('saving augmented images: aug_geom=' + str(aug_geom) + ' aug_texture=' + str(aug_texture) +
-       ' : ' + str(save_aug_path))
-
-if not os.path.exists(save_aug_path):
-    os.mkdir(save_aug_path)
-
-np.random.seed(random_seed)
-ns_inds = np.arange(num_augs)
-
-for i in range(num_epochs):
-    print ('saving augmented images of epoch %d/%d' % (i, num_epochs-1))
-    if not os.path.exists(os.path.join(save_aug_path, str(i))) and i > min_epoch_to_save - 1:
-        os.mkdir(os.path.join(save_aug_path, str(i)))
-
-    if i % num_augs == 0:
-        np.random.shuffle(ns_inds)
-
-    if not aug_geom and aug_texture:
-        img_list = load_menpo_image_list_no_geom(
-            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
-            bb_dictionary=bb_dictionary,
-            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
-            augment_texture=True, p_texture=1.,
-            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
-    elif aug_geom and not aug_texture:
-        img_list = load_menpo_image_list_no_texture(
-            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
-            bb_dictionary=bb_dictionary,
-            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
-            augment_texture=True, p_texture=1.,
-            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
-    elif aug_geom and aug_texture:
-        img_list = load_menpo_image_list(
-            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
-            bb_dictionary=bb_dictionary,
-            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
-            augment_texture=True, p_texture=1.,
-            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
-    else:
-        img_list = load_menpo_image_list_no_artistic(
-            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
-            bb_dictionary=bb_dictionary,
-            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
-            augment_texture=True, p_texture=1.,
-            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
-
-    if debug:
-        img_list = img_list[:debug_data_size]
-
-    for im in img_list:
-        im_path = os.path.join(save_aug_path, str(i), im.path.name.split('.')[0] + '.png')
-        pts_path = os.path.join(save_aug_path, str(i), im.path.name.split('.')[0] + '.pts')
-        if i > min_epoch_to_save - 1:
-            if not os.path.exists(im_path):
-                if im.pixels.shape[0] == 1:
-                    im_pixels = gray2rgb(np.squeeze(im.pixels))
-                else:
-                    im_pixels = np.rollaxis(im.pixels, 0, 3)
-                imsave(im_path, im_pixels)
-            if not os.path.exists(pts_path):
-                mio.export_landmark_file(im.landmarks['PTS'], pts_path, overwrite=True)
+from create_art_data_functions import *
+from scipy.misc import imsave
+import sys
+
+
+'''THIS SCRIPT CREATES PRE-AUGMENTED DATA TO SAVE TRAINING TIME (ARTISTIC OR BASIC AUGMENTATION):
+    under the folder *outdir*, it will create a separate folder for each epoch. the folder will
+    contain the augmented images and matching landmark (pts) files.'''
+
+# parameter for calculating number of epochs
+num_train_images = 3148  # number of training images
+train_iter = 100000  # number of training iterations
+batch_size = 6  # batch size in training
+num_epochs = int(np.ceil((1. * train_iter) / (1. * num_train_images / batch_size)))+1
+
+# augmentation parameters
+num_augs = 9  # number of style transfer augmented images
+aug_geom = True  # use artistic geometric augmentation?
+aug_texture = True  # use artistic texture augmentation?
+
+# image parameters
+bb_type = 'gt'  # face bounding-box type (gt/init)
+margin = 0.25  # margin for face crops - % of bb size
+image_size = 256  # image size
+
+# data-sets image paths
+dataset = 'training'  # dataset to augment (training/full/common/challenging/test)
+img_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+train_crop_dir = 'crop_gt_margin_0.25'  # directory of train images cropped to bb (+margin)
+img_dir_ns = os.path.join(img_dir, train_crop_dir+'_ns')  # dir of train imgs cropped to bb + style transfer
+outdir = '/Users/arik/Desktop/epoch_data'  # directory for saving augmented data
+
+# other parameters
+min_epoch_to_save = 0  # start saving images from this epoch (first epoch is 0)
+debug_data_size = 15
+debug = False
+random_seed = 1234  # random seed for numpy
+
+########################################################################################
+if aug_texture and img_dir_ns is None:
+    print('\n *** ERROR: aug_texture is True, and img_dir_ns is None.\n'
+          'please specify path for img_dir_ns to augment image texture!')
+    sys.exit()
+
+if not os.path.exists(outdir):
+    os.mkdir(outdir)
+
+gt = (bb_type == 'gt')
+bb_dir = os.path.join(img_dir, 'Bounding_Boxes')
+
+if dataset == 'training':
+    mode = 'TRAIN'
+else:
+    mode = 'TEST'
+bb_dictionary = load_bb_dictionary(bb_dir, mode=mode, test_data=dataset)
+
+aug_geom_dir = os.path.join(outdir, 'aug_geom')
+aug_texture_dir = os.path.join(outdir, 'aug_texture')
+aug_geom_texture_dir = os.path.join(outdir, 'aug_geom_texture')
+aug_basic_dir = os.path.join(outdir, 'aug_basic')
+
+if not aug_geom and aug_texture:
+    save_aug_path = aug_texture_dir
+elif aug_geom and not aug_texture:
+    save_aug_path = aug_geom_dir
+elif aug_geom and aug_texture:
+    save_aug_path = aug_geom_texture_dir
+else:
+    save_aug_path = aug_basic_dir
+
+print ('saving augmented images: aug_geom=' + str(aug_geom) + ' aug_texture=' + str(aug_texture) +
+       ' : ' + str(save_aug_path))
+
+if not os.path.exists(save_aug_path):
+    os.mkdir(save_aug_path)
+
+np.random.seed(random_seed)
+ns_inds = np.arange(num_augs)
+
+for i in range(num_epochs):
+    print ('saving augmented images of epoch %d/%d' % (i, num_epochs-1))
+    if not os.path.exists(os.path.join(save_aug_path, str(i))) and i > min_epoch_to_save - 1:
+        os.mkdir(os.path.join(save_aug_path, str(i)))
+
+    if i % num_augs == 0:
+        np.random.shuffle(ns_inds)
+
+    if not aug_geom and aug_texture:
+        img_list = load_menpo_image_list_no_geom(
+            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
+            bb_dictionary=bb_dictionary,
+            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
+            augment_texture=True, p_texture=1.,
+            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
+    elif aug_geom and not aug_texture:
+        img_list = load_menpo_image_list_no_texture(
+            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
+            bb_dictionary=bb_dictionary,
+            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
+            augment_texture=True, p_texture=1.,
+            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
+    elif aug_geom and aug_texture:
+        img_list = load_menpo_image_list(
+            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
+            bb_dictionary=bb_dictionary,
+            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
+            augment_texture=True, p_texture=1.,
+            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
+    else:
+        img_list = load_menpo_image_list_no_artistic(
+            img_dir=img_dir, train_crop_dir=train_crop_dir, img_dir_ns=img_dir_ns, mode='TRAIN',
+            bb_dictionary=bb_dictionary,
+            image_size=image_size, margin=margin, bb_type=bb_type, augment_basic=True,
+            augment_texture=True, p_texture=1.,
+            augment_geom=True, p_geom=1., ns_ind=ns_inds[i % num_augs], dataset=dataset)
+
+    if debug:
+        img_list = img_list[:debug_data_size]
+
+    for im in img_list:
+        im_path = os.path.join(save_aug_path, str(i), im.path.name.split('.')[0] + '.png')
+        pts_path = os.path.join(save_aug_path, str(i), im.path.name.split('.')[0] + '.pts')
+        if i > min_epoch_to_save - 1:
+            if not os.path.exists(im_path):
+                if im.pixels.shape[0] == 1:
+                    im_pixels = gray2rgb(np.squeeze(im.pixels))
+                else:
+                    im_pixels = np.rollaxis(im.pixels, 0, 3)
+                imsave(im_path, im_pixels)
+            if not os.path.exists(pts_path):
+                mio.export_landmark_file(im.landmarks['PTS'], pts_path, overwrite=True)
 print ('DONE!')

MakeItTalk/thirdparty/face_of_art/old/temp/create_art_data_functions.py

@@ -1,318 +1,318 @@
-from menpo_functions import *
-from data_loading_functions import *
-from menpo.shape import bounding_box
-from menpo.transform import Translation, Rotation
-
-
-def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True, warp_mode='constant'):
-    """basic image augmentation: random crop, rotation and horizontal flip"""
-
-    #from menpo
-    def round_image_shape(shape, round):
-        if round not in ['ceil', 'round', 'floor']:
-            raise ValueError('round must be either ceil, round or floor')
-        # Ensure that the '+' operator means concatenate tuples
-        return tuple(getattr(np, round)(shape).astype(np.int))
-
-    # taken from MDM
-    def mirror_landmarks_68(lms, im_size):
-        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
-        ).reshape(-1, 2))[mirrored_parts_68])
-
-    # taken from MDM
-    def mirror_image(im):
-        im = im.copy()
-        im.pixels = im.pixels[..., ::-1].copy()
-
-        for group in im.landmarks:
-            lms = im.landmarks[group]
-            if lms.points.shape[0] == 68:
-                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
-
-        return im
-
-    flip_rand = np.random.random() > 0.5
-    #     rot_rand = np.random.random() > 0.5
-    #     crop_rand = np.random.random() > 0.5
-    rot_rand = True  # like ECT
-    crop_rand = True  # like ECT
-
-    if crop_rand:
-        lim = image_size - crop_size
-        min_crop_inds = np.random.randint(0, lim, 2)
-        max_crop_inds = min_crop_inds + crop_size
-        img = img.crop(min_crop_inds, max_crop_inds)
-
-    if flip and flip_rand:
-        img = mirror_image(img)
-
-    if rot_rand:
-        rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
-        # img = img.rotate_ccw_about_centre(rot_angle)
-
-        # Get image's bounding box coordinates
-        bbox = bounding_box((0, 0), [img.shape[0] - 1, img.shape[1] - 1])
-        # Translate to origin and rotate counter-clockwise
-        trans = Translation(-img.centre(),
-                            skip_checks=True).compose_before(
-            Rotation.init_from_2d_ccw_angle(rot_angle, degrees=True))
-        rotated_bbox = trans.apply(bbox)
-        # Create new translation so that min bbox values go to 0
-        t = Translation(-rotated_bbox.bounds()[0])
-        trans.compose_before_inplace(t)
-        rotated_bbox = trans.apply(bbox)
-        # Output image's shape is the range of the rotated bounding box
-        # while respecting the users rounding preference.
-        shape = round_image_shape(rotated_bbox.range() + 1, 'round')
-
-        img = img.warp_to_shape(
-            shape, trans.pseudoinverse(), warp_landmarks=True, mode=warp_mode)
-
-    img = img.resize([image_size, image_size])
-
-    return img
-
-
-def augment_menpo_img_ns(img, img_dir_ns, p_ns=0, ns_ind=None):
-    """texture style image augmentation using stylized copies in *img_dir_ns*"""
-
-    if p_ns > 0.5:
-        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
-        num_augs = len(ns_augs)
-        if num_augs > 0:
-            if ns_ind is None or ns_ind >= num_augs:
-                ns_ind = np.random.randint(0, num_augs)
-            ns_aug = mio.import_image(ns_augs[ns_ind])
-            img.pixels = ns_aug.pixels
-    return img
-
-
-def augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=0, ns_ind=None):
-    """texture style image augmentation using stylized copies in *img_dir_ns*"""
-
-    if p_ns > 0.5:
-        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
-        num_augs = len(ns_augs)
-        if num_augs > 0:
-            if ns_ind is None or ns_ind >= num_augs:
-                ns_ind = np.random.randint(0, num_augs)
-            # ns_aug = mio.import_image(ns_augs[ns_ind])
-            # ns_pixels = ns_aug.pixels
-    return img
-
-
-def augment_menpo_img_geom_dont_apply(img, p_geom=0):
-    """geometric style image augmentation using random face deformations"""
-
-    if p_geom > 0.5:
-        lms_geom_warp = deform_face_geometric_style(img.landmarks['PTS'].points.copy(), p_scale=p_geom, p_shift=p_geom)
-    return img
-
-
-def augment_menpo_img_geom(img, p_geom=0):
-    """geometric style image augmentation using random face deformations"""
-
-    if p_geom > 0.5:
-        lms_geom_warp = deform_face_geometric_style(img.landmarks['PTS'].points.copy(), p_scale=p_geom, p_shift=p_geom)
-        img=warp_face_image_tps(img, PointCloud(lms_geom_warp))
-    return img
-
-
-def load_menpo_image_list(
-        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom))
-
-    if mode is 'TRAIN':
-        if train_crop_dir is None:
-            img_set_dir = os.path.join(img_dir, dataset+'_set')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, train_crop_dir)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-        if augment_texture and img_dir_ns is not None:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-    return out_image_list
-
-
-def load_menpo_image_list_no_geom(
-        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom_dont_apply(img, p_geom=1. * (np.random.rand() < p_geom))
-
-    if mode is 'TRAIN':
-        if train_crop_dir is None:
-            img_set_dir = os.path.join(img_dir, dataset+'_set')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, train_crop_dir)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-        if augment_texture and img_dir_ns is not None:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-    return out_image_list
-
-
-def load_menpo_image_list_no_texture(
-        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom))
-
-    if mode is 'TRAIN':
-        if train_crop_dir is None:
-            img_set_dir = os.path.join(img_dir, dataset+'_set')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, train_crop_dir)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-        if augment_texture and img_dir_ns is not None:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-    return out_image_list
-
-
-def load_menpo_image_list_no_artistic(
-        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
-        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
-        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
-
-    def crop_to_face_image_gt(img):
-        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
-
-    def crop_to_face_image_init(img):
-        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
-
-    def augment_menpo_img_ns_rand(img):
-        return augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
-
-    def augment_menpo_img_geom_rand(img):
-        return augment_menpo_img_geom_dont_apply(img, p_geom=1. * (np.random.rand() < p_geom))
-
-    if mode is 'TRAIN':
-        if train_crop_dir is None:
-            img_set_dir = os.path.join(img_dir, dataset+'_set')
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            img_set_dir = os.path.join(img_dir, train_crop_dir)
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
-        if augment_texture and img_dir_ns is not None:
-            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
-        if augment_geom:
-            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
-        if augment_basic:
-            out_image_list = out_image_list.map(augment_face_image)
-
-    else:
-        img_set_dir = os.path.join(img_dir, test_data + '_set')
-        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
-            if bb_type is 'gt':
-                out_image_list = out_image_list.map(crop_to_face_image_gt)
-            elif bb_type is 'init':
-                out_image_list = out_image_list.map(crop_to_face_image_init)
-        else:
-            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
-
+from menpo_functions import *
+from data_loading_functions import *
+from menpo.shape import bounding_box
+from menpo.transform import Translation, Rotation
+
+
+def augment_face_image(img, image_size=256, crop_size=248, angle_range=30, flip=True, warp_mode='constant'):
+    """basic image augmentation: random crop, rotation and horizontal flip"""
+
+    #from menpo
+    def round_image_shape(shape, round):
+        if round not in ['ceil', 'round', 'floor']:
+            raise ValueError('round must be either ceil, round or floor')
+        # Ensure that the '+' operator means concatenate tuples
+        return tuple(getattr(np, round)(shape).astype(np.int))
+
+    # taken from MDM
+    def mirror_landmarks_68(lms, im_size):
+        return PointCloud(abs(np.array([0, im_size[1]]) - lms.as_vector(
+        ).reshape(-1, 2))[mirrored_parts_68])
+
+    # taken from MDM
+    def mirror_image(im):
+        im = im.copy()
+        im.pixels = im.pixels[..., ::-1].copy()
+
+        for group in im.landmarks:
+            lms = im.landmarks[group]
+            if lms.points.shape[0] == 68:
+                im.landmarks[group] = mirror_landmarks_68(lms, im.shape)
+
+        return im
+
+    flip_rand = np.random.random() > 0.5
+    #     rot_rand = np.random.random() > 0.5
+    #     crop_rand = np.random.random() > 0.5
+    rot_rand = True  # like ECT
+    crop_rand = True  # like ECT
+
+    if crop_rand:
+        lim = image_size - crop_size
+        min_crop_inds = np.random.randint(0, lim, 2)
+        max_crop_inds = min_crop_inds + crop_size
+        img = img.crop(min_crop_inds, max_crop_inds)
+
+    if flip and flip_rand:
+        img = mirror_image(img)
+
+    if rot_rand:
+        rot_angle = 2 * angle_range * np.random.random_sample() - angle_range
+        # img = img.rotate_ccw_about_centre(rot_angle)
+
+        # Get image's bounding box coordinates
+        bbox = bounding_box((0, 0), [img.shape[0] - 1, img.shape[1] - 1])
+        # Translate to origin and rotate counter-clockwise
+        trans = Translation(-img.centre(),
+                            skip_checks=True).compose_before(
+            Rotation.init_from_2d_ccw_angle(rot_angle, degrees=True))
+        rotated_bbox = trans.apply(bbox)
+        # Create new translation so that min bbox values go to 0
+        t = Translation(-rotated_bbox.bounds()[0])
+        trans.compose_before_inplace(t)
+        rotated_bbox = trans.apply(bbox)
+        # Output image's shape is the range of the rotated bounding box
+        # while respecting the users rounding preference.
+        shape = round_image_shape(rotated_bbox.range() + 1, 'round')
+
+        img = img.warp_to_shape(
+            shape, trans.pseudoinverse(), warp_landmarks=True, mode=warp_mode)
+
+    img = img.resize([image_size, image_size])
+
+    return img
+
+
+def augment_menpo_img_ns(img, img_dir_ns, p_ns=0, ns_ind=None):
+    """texture style image augmentation using stylized copies in *img_dir_ns*"""
+
+    if p_ns > 0.5:
+        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
+        num_augs = len(ns_augs)
+        if num_augs > 0:
+            if ns_ind is None or ns_ind >= num_augs:
+                ns_ind = np.random.randint(0, num_augs)
+            ns_aug = mio.import_image(ns_augs[ns_ind])
+            img.pixels = ns_aug.pixels
+    return img
+
+
+def augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=0, ns_ind=None):
+    """texture style image augmentation using stylized copies in *img_dir_ns*"""
+
+    if p_ns > 0.5:
+        ns_augs = glob(os.path.join(img_dir_ns, img.path.name.split('.')[0] + '_ns*'))
+        num_augs = len(ns_augs)
+        if num_augs > 0:
+            if ns_ind is None or ns_ind >= num_augs:
+                ns_ind = np.random.randint(0, num_augs)
+            # ns_aug = mio.import_image(ns_augs[ns_ind])
+            # ns_pixels = ns_aug.pixels
+    return img
+
+
+def augment_menpo_img_geom_dont_apply(img, p_geom=0):
+    """geometric style image augmentation using random face deformations"""
+
+    if p_geom > 0.5:
+        lms_geom_warp = deform_face_geometric_style(img.landmarks['PTS'].points.copy(), p_scale=p_geom, p_shift=p_geom)
+    return img
+
+
+def augment_menpo_img_geom(img, p_geom=0):
+    """geometric style image augmentation using random face deformations"""
+
+    if p_geom > 0.5:
+        lms_geom_warp = deform_face_geometric_style(img.landmarks['PTS'].points.copy(), p_scale=p_geom, p_shift=p_geom)
+        img=warp_face_image_tps(img, PointCloud(lms_geom_warp))
+    return img
+
+
+def load_menpo_image_list(
+        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom))
+
+    if mode is 'TRAIN':
+        if train_crop_dir is None:
+            img_set_dir = os.path.join(img_dir, dataset+'_set')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, train_crop_dir)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+        if augment_texture and img_dir_ns is not None:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+    return out_image_list
+
+
+def load_menpo_image_list_no_geom(
+        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom_dont_apply(img, p_geom=1. * (np.random.rand() < p_geom))
+
+    if mode is 'TRAIN':
+        if train_crop_dir is None:
+            img_set_dir = os.path.join(img_dir, dataset+'_set')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, train_crop_dir)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+        if augment_texture and img_dir_ns is not None:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+    return out_image_list
+
+
+def load_menpo_image_list_no_texture(
+        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom(img, p_geom=1. * (np.random.rand() < p_geom))
+
+    if mode is 'TRAIN':
+        if train_crop_dir is None:
+            img_set_dir = os.path.join(img_dir, dataset+'_set')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, train_crop_dir)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+        if augment_texture and img_dir_ns is not None:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+    return out_image_list
+
+
+def load_menpo_image_list_no_artistic(
+        img_dir, train_crop_dir, img_dir_ns, mode, bb_dictionary=None, image_size=256, margin=0.25,
+        bb_type='gt', test_data='full', augment_basic=True, augment_texture=False, p_texture=0,
+        augment_geom=False, p_geom=0, verbose=False,ns_ind=None, dataset='training'):
+
+    def crop_to_face_image_gt(img):
+        return crop_to_face_image(img, bb_dictionary, gt=True, margin=margin, image_size=image_size)
+
+    def crop_to_face_image_init(img):
+        return crop_to_face_image(img, bb_dictionary, gt=False, margin=margin, image_size=image_size)
+
+    def augment_menpo_img_ns_rand(img):
+        return augment_menpo_img_ns_dont_apply(img, img_dir_ns, p_ns=1. * (np.random.rand() < p_texture),ns_ind=ns_ind)
+
+    def augment_menpo_img_geom_rand(img):
+        return augment_menpo_img_geom_dont_apply(img, p_geom=1. * (np.random.rand() < p_geom))
+
+    if mode is 'TRAIN':
+        if train_crop_dir is None:
+            img_set_dir = os.path.join(img_dir, dataset+'_set')
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            img_set_dir = os.path.join(img_dir, train_crop_dir)
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
+        if augment_texture and img_dir_ns is not None:
+            out_image_list = out_image_list.map(augment_menpo_img_ns_rand)
+        if augment_geom:
+            out_image_list = out_image_list.map(augment_menpo_img_geom_rand)
+        if augment_basic:
+            out_image_list = out_image_list.map(augment_face_image)
+
+    else:
+        img_set_dir = os.path.join(img_dir, test_data + '_set')
+        if test_data in ['full', 'challenging', 'common', 'training', 'test']:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose, normalize=False)
+            if bb_type is 'gt':
+                out_image_list = out_image_list.map(crop_to_face_image_gt)
+            elif bb_type is 'init':
+                out_image_list = out_image_list.map(crop_to_face_image_init)
+        else:
+            out_image_list = mio.import_images(img_set_dir, verbose=verbose)
+
     return out_image_list

MakeItTalk/thirdparty/face_of_art/old/temp/main_primary.py

@@ -1,121 +1,121 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_net import DeepHeatmapsModel
-import os
-
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
-output_dir = os.getcwd()
-
-flags = tf.app.flags
-
-# mode and logging parameters
-flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
-flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
-flags.DEFINE_integer('save_every', 20000, "save model every X steps")
-flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
-flags.DEFINE_integer('sample_grid', 9, 'number of training images in sample')
-flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
-flags.DEFINE_integer('valid_size', 9, 'number of validation images to run')
-flags.DEFINE_integer('log_valid_every', 10, 'evaluate on valid set every X epochs')
-flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
-flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
-
-# define paths
-flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
-flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
-flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
-flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
-flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
-flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
-flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25', "directory of train images cropped to bb (+margin)")
-flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns', "dir of train imgs cropped to bb + style transfer")
-flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
-flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
-
-# pretrain parameters (for fine-tuning / resume training)
-flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-
-# input data parameters
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-flags.DEFINE_float('sigma', 1.5, "std for heatmap generation gaussian")
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
-flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
-
-# optimization parameters
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 10, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
-flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
-flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-flags.DEFINE_float('reg', 1e-5, 'scalar multiplier for weight decay (0 to disable)')
-flags.DEFINE_string('weight_initializer', 'xavier', 'weight initializer: random_normal / xavier')
-flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
-flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True, "use basic augmentation?")
-flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
-flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
-flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
-flags.DEFINE_bool('augment_geom', False, "use artistic geometric augmentation?")
-flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
-flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
-flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
-
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
-    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
-    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
-
-    # create directories if not exist
-    if not os.path.exists(save_model_path):
-        os.mkdir(save_model_path)
-    if not os.path.exists(save_log_path):
-        os.mkdir(save_log_path)
-    if not os.path.exists(save_sample_path) and (not FLAGS.sample_to_log or FLAGS.mode != 'TRAIN'):
-        os.mkdir(save_sample_path)
-
-    model = DeepHeatmapsModel(
-        mode=FLAGS.mode, train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate,
-        adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, reg=FLAGS.reg,
-        weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
-        bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
-        num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
-        bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult, augment_basic=FLAGS.augment_basic,
-        basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
-        augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom, artistic_step=FLAGS.artistic_step,
-        artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
-        save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
-        pre_train_path=FLAGS.pre_train_path, load_pretrain=FLAGS.load_pretrain, img_path=FLAGS.img_path,
-        test_data=FLAGS.test_data, valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size,
-        log_valid_every=FLAGS.log_valid_every, train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns,
-        print_every=FLAGS.print_every, save_every=FLAGS.save_every, sample_every=FLAGS.sample_every,
-        sample_grid=FLAGS.sample_grid, sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size,
-        debug=FLAGS.debug, use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
-
-    if FLAGS.mode == 'TRAIN':
-        model.train()
-    else:
-        model.eval()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_primary_net import DeepHeatmapsModel
+import os
+
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+pre_train_path = 'saved_models/0.01/model/deep_heatmaps-50000'
+output_dir = os.getcwd()
+
+flags = tf.app.flags
+
+# mode and logging parameters
+flags.DEFINE_string('mode', 'TRAIN', "'TRAIN' or 'TEST'")
+flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
+flags.DEFINE_integer('save_every', 20000, "save model every X steps")
+flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
+flags.DEFINE_integer('sample_grid', 9, 'number of training images in sample')
+flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
+flags.DEFINE_integer('valid_size', 9, 'number of validation images to run')
+flags.DEFINE_integer('log_valid_every', 10, 'evaluate on valid set every X epochs')
+flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
+flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
+
+# define paths
+flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
+flags.DEFINE_string('save_model_path', 'model', "directory for saving the model")
+flags.DEFINE_string('save_sample_path', 'sample', "directory for saving the sampled images")
+flags.DEFINE_string('save_log_path', 'logs', "directory for saving the log file")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
+flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
+flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
+flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25', "directory of train images cropped to bb (+margin)")
+flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns', "dir of train imgs cropped to bb + style transfer")
+flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
+flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
+
+# pretrain parameters (for fine-tuning / resume training)
+flags.DEFINE_string('pre_train_path', pre_train_path, 'pretrained model path')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+
+# input data parameters
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+flags.DEFINE_float('sigma', 1.5, "std for heatmap generation gaussian")
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
+flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
+
+# optimization parameters
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 10, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
+flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
+flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+flags.DEFINE_float('reg', 1e-5, 'scalar multiplier for weight decay (0 to disable)')
+flags.DEFINE_string('weight_initializer', 'xavier', 'weight initializer: random_normal / xavier')
+flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
+flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True, "use basic augmentation?")
+flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
+flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
+flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
+flags.DEFINE_bool('augment_geom', False, "use artistic geometric augmentation?")
+flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
+flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
+flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
+
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    save_model_path = os.path.join(FLAGS.output_dir, FLAGS.save_model_path)
+    save_sample_path = os.path.join(FLAGS.output_dir, FLAGS.save_sample_path)
+    save_log_path = os.path.join(FLAGS.output_dir, FLAGS.save_log_path)
+
+    # create directories if not exist
+    if not os.path.exists(save_model_path):
+        os.mkdir(save_model_path)
+    if not os.path.exists(save_log_path):
+        os.mkdir(save_log_path)
+    if not os.path.exists(save_sample_path) and (not FLAGS.sample_to_log or FLAGS.mode != 'TRAIN'):
+        os.mkdir(save_sample_path)
+
+    model = DeepHeatmapsModel(
+        mode=FLAGS.mode, train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate,
+        adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma, reg=FLAGS.reg,
+        weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
+        bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
+        num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
+        bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult, augment_basic=FLAGS.augment_basic,
+        basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture, p_texture=FLAGS.p_texture,
+        augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom, artistic_step=FLAGS.artistic_step,
+        artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
+        save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
+        pre_train_path=FLAGS.pre_train_path, load_pretrain=FLAGS.load_pretrain, img_path=FLAGS.img_path,
+        test_data=FLAGS.test_data, valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size,
+        log_valid_every=FLAGS.log_valid_every, train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns,
+        print_every=FLAGS.print_every, save_every=FLAGS.save_every, sample_every=FLAGS.sample_every,
+        sample_grid=FLAGS.sample_grid, sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size,
+        debug=FLAGS.debug, use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
+
+    if FLAGS.mode == 'TRAIN':
+        model.train()
+    else:
+        model.eval()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/temp/predict_landmarks.py

@@ -1,100 +1,100 @@
-from menpo_functions import *
-from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
-import os
-import pickle
-
-# directory for saving predictions
-out_dir = '/Users/arik/Desktop/out/'
-if not os.path.exists(out_dir):
-    os.mkdir(out_dir)
-
-# directory with conventional landmark detection datasets (for bounding box files)
-conv_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-
-# bounding box type for conventional landmark detection datasets (gt / init)
-bb_type='init'
-
-# directory with clm models for tuning step
-clm_path='pdm_clm_models/clm_models/g_t_all'
-
-# directory with pdm models for correction step
-pdm_path='pdm_clm_models/pdm_models/'
-
-# model path
-model_path = '/Users/arik/Dropbox/Thesis_dropbox/models/model_train_wiki/model/deep_heatmaps-60000'
-
-# directory containing test sets
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/artistic_faces/artistic_face_dataset/'
-test_sets = ['all_AF']  # test sets to evaluate
-
-
-# data_dir = '/Users/arik/Desktop/Thesis_mac/semi_art_sets/semi_art_sets_wiki_train_2/'
-# test_sets = [
-#     'challenging_set_aug_geom_texture',
-#     'common_set_aug_geom_texture',
-#     'test_set_aug_geom_texture',
-#     'full_set_aug_geom_texture'
-# ]
-
-
-# load heatmap model
-heatmap_model = DeepHeatmapsModel(
-    mode='TEST', img_path=conv_dir, test_model_path=model_path, menpo_verbose=False, scale=1)
-
-bb_dir = os.path.join(conv_dir, 'Bounding_Boxes')
-
-# predict landmarks for input test sets
-for i,test_data in enumerate(test_sets):
-
-    if i == 0:
-        reuse=None
-    else:
-        reuse=True
-
-    out_temp = os.path.join(out_dir, test_data)
-    if not os.path.exists(out_temp):
-        os.mkdir(out_temp)
-
-    bb_dictionary = load_bb_dictionary(bb_dir, mode='TEST', test_data=test_data)
-
-    img_list = load_menpo_image_list(img_dir=data_dir, train_crop_dir=data_dir, img_dir_ns=data_dir, mode='TEST',
-                                     test_data=test_data, bb_type=bb_type, bb_dictionary=bb_dictionary)
-
-    img_list = img_list[:10]
-    print test_data + ':' + str(len(img_list)) + ' images'
-
-    preds = heatmap_model.get_landmark_predictions(img_list=img_list, pdm_models_dir=pdm_path, clm_model_path=clm_path,
-                                                   reuse=reuse)
-
-    init_lms = preds['E']
-    ppdm_lms = preds['ECp']
-    clm_lms = preds['ECpT']
-    ect_lms = preds['ECT']
-    ecptp_jaw_lms = preds['ECpTp_jaw']
-    ecptp_out_lms = preds['ECpTp_out']
-
-    filehandler = open(os.path.join(out_temp,'E_lms'),"wb")
-    pickle.dump(init_lms,filehandler)
-    filehandler.close()
-
-    filehandler = open(os.path.join(out_temp,'ECp_lms'),"wb")
-    pickle.dump(ppdm_lms,filehandler)
-    filehandler.close()
-
-    filehandler = open(os.path.join(out_temp,'ECpT_lms'),"wb")
-    pickle.dump(clm_lms,filehandler)
-    filehandler.close()
-
-    filehandler = open(os.path.join(out_temp,'ECT_lms'),"wb")
-    pickle.dump(ect_lms,filehandler)
-    filehandler.close()
-
-    filehandler = open(os.path.join(out_temp,'ECpTp_jaw_lms'),"wb")
-    pickle.dump(ecptp_jaw_lms,filehandler)
-    filehandler.close()
-
-    filehandler = open(os.path.join(out_temp,'ECpTp_out_lms'),"wb")
-    pickle.dump(ecptp_out_lms,filehandler)
-    filehandler.close()
-
+from menpo_functions import *
+from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
+import os
+import pickle
+
+# directory for saving predictions
+out_dir = '/Users/arik/Desktop/out/'
+if not os.path.exists(out_dir):
+    os.mkdir(out_dir)
+
+# directory with conventional landmark detection datasets (for bounding box files)
+conv_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+
+# bounding box type for conventional landmark detection datasets (gt / init)
+bb_type='init'
+
+# directory with clm models for tuning step
+clm_path='pdm_clm_models/clm_models/g_t_all'
+
+# directory with pdm models for correction step
+pdm_path='pdm_clm_models/pdm_models/'
+
+# model path
+model_path = '/Users/arik/Dropbox/Thesis_dropbox/models/model_train_wiki/model/deep_heatmaps-60000'
+
+# directory containing test sets
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/artistic_faces/artistic_face_dataset/'
+test_sets = ['all_AF']  # test sets to evaluate
+
+
+# data_dir = '/Users/arik/Desktop/Thesis_mac/semi_art_sets/semi_art_sets_wiki_train_2/'
+# test_sets = [
+#     'challenging_set_aug_geom_texture',
+#     'common_set_aug_geom_texture',
+#     'test_set_aug_geom_texture',
+#     'full_set_aug_geom_texture'
+# ]
+
+
+# load heatmap model
+heatmap_model = DeepHeatmapsModel(
+    mode='TEST', img_path=conv_dir, test_model_path=model_path, menpo_verbose=False, scale=1)
+
+bb_dir = os.path.join(conv_dir, 'Bounding_Boxes')
+
+# predict landmarks for input test sets
+for i,test_data in enumerate(test_sets):
+
+    if i == 0:
+        reuse=None
+    else:
+        reuse=True
+
+    out_temp = os.path.join(out_dir, test_data)
+    if not os.path.exists(out_temp):
+        os.mkdir(out_temp)
+
+    bb_dictionary = load_bb_dictionary(bb_dir, mode='TEST', test_data=test_data)
+
+    img_list = load_menpo_image_list(img_dir=data_dir, train_crop_dir=data_dir, img_dir_ns=data_dir, mode='TEST',
+                                     test_data=test_data, bb_type=bb_type, bb_dictionary=bb_dictionary)
+
+    img_list = img_list[:10]
+    print test_data + ':' + str(len(img_list)) + ' images'
+
+    preds = heatmap_model.get_landmark_predictions(img_list=img_list, pdm_models_dir=pdm_path, clm_model_path=clm_path,
+                                                   reuse=reuse)
+
+    init_lms = preds['E']
+    ppdm_lms = preds['ECp']
+    clm_lms = preds['ECpT']
+    ect_lms = preds['ECT']
+    ecptp_jaw_lms = preds['ECpTp_jaw']
+    ecptp_out_lms = preds['ECpTp_out']
+
+    filehandler = open(os.path.join(out_temp,'E_lms'),"wb")
+    pickle.dump(init_lms,filehandler)
+    filehandler.close()
+
+    filehandler = open(os.path.join(out_temp,'ECp_lms'),"wb")
+    pickle.dump(ppdm_lms,filehandler)
+    filehandler.close()
+
+    filehandler = open(os.path.join(out_temp,'ECpT_lms'),"wb")
+    pickle.dump(clm_lms,filehandler)
+    filehandler.close()
+
+    filehandler = open(os.path.join(out_temp,'ECT_lms'),"wb")
+    pickle.dump(ect_lms,filehandler)
+    filehandler.close()
+
+    filehandler = open(os.path.join(out_temp,'ECpTp_jaw_lms'),"wb")
+    pickle.dump(ecptp_jaw_lms,filehandler)
+    filehandler.close()
+
+    filehandler = open(os.path.join(out_temp,'ECpTp_out_lms'),"wb")
+    pickle.dump(ecptp_out_lms,filehandler)
+    filehandler.close()
+
 print("\nDone!\n")

MakeItTalk/thirdparty/face_of_art/old/temp/run_tests_fusion.py

@@ -1,136 +1,136 @@
-import tensorflow as tf
-from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
-import os
-import numpy as np
-
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-output_dir = 'tests_fusion'
-pre_train_model_name = 'deep_heatmaps-50000'
-num_tests = 5
-params = np.logspace(-4, -6, num_tests)
-
-flags = tf.app.flags
-
-# mode and logging parameters
-flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
-flags.DEFINE_integer('save_every', 5000, "save model every X steps")
-flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
-flags.DEFINE_integer('sample_grid', 4, 'number of training images in sample')
-flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
-flags.DEFINE_integer('valid_size', 0, 'number of validation images to run')
-flags.DEFINE_integer('log_valid_every', 5, 'evaluate on valid set every X epochs')
-flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
-flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
-
-# define paths
-flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
-flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
-flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
-flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25',"directory of train images cropped to bb (+margin)")
-flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns',"dir of train imgs cropped to bb + style transfer")
-flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
-flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
-
-
-# pretrain parameters (for fine-tuning / resume training)
-flags.DEFINE_string('pre_train_model_name', pre_train_model_name, 'pretrained model name (e.g. deep_heatmaps-50000')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-flags.DEFINE_bool('load_primary_only', False, 'fine-tuning using only primary network weights')
-
-# input data parameters
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-flags.DEFINE_float('sigma', 6, "std for heatmap generation gaussian")
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
-flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
-
-# optimization parameters
-flags.DEFINE_float('l_weight_primary', 1., 'primary loss weight')
-flags.DEFINE_float('l_weight_fusion', 0., 'fusion loss weight')
-flags.DEFINE_float('l_weight_upsample', 3., 'upsample loss weight')
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 6, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
-flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
-flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-flags.DEFINE_float('reg', 0, 'scalar multiplier for weight decay (0 to disable)')
-flags.DEFINE_string('weight_initializer','xavier', 'weight initializer: random_normal / xavier')
-flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
-flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
-flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
-flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
-flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
-flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
-flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
-flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
-flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
-
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    for i, param in enumerate(params):
-
-        test_dir = os.path.join(FLAGS.output_dir, str(param))
-        if not os.path.exists(test_dir):
-            os.mkdir(test_dir)
-
-        print ('\n##### RUNNING TESTS FUSION (%d/%d) #####' % (i + 1, len(params)))
-        print ('##### current directory: ' + test_dir)
-
-        save_model_path = os.path.join(test_dir,'model')
-        save_sample_path = os.path.join(test_dir, 'sample')
-        save_log_path = os.path.join(test_dir, 'logs')
-
-        # create directories if not exist
-        if not os.path.exists(save_model_path):
-            os.mkdir(save_model_path)
-        if not os.path.exists(save_log_path):
-            os.mkdir(save_log_path)
-        if not os.path.exists(save_sample_path) and not FLAGS.sample_to_log:
-            os.mkdir(save_sample_path)
-
-        tf.reset_default_graph()  # reset graph
-
-        model = DeepHeatmapsModel(
-            mode='TRAIN', train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=param,
-            l_weight_primary=FLAGS.l_weight_primary, l_weight_fusion=FLAGS.l_weight_fusion,
-            l_weight_upsample=FLAGS.l_weight_upsample, reg=FLAGS.reg,
-            adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
-            weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
-            bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
-            num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
-            bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult,
-            augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture,
-            p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom, artistic_step=FLAGS.artistic_step,
-            artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
-            save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
-            pre_train_path=os.path.join(save_model_path, FLAGS.pre_train_model_name), load_pretrain=FLAGS.load_pretrain,
-            load_primary_only=FLAGS.load_primary_only, img_path=FLAGS.img_path, test_data=FLAGS.test_data,
-            valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size, log_valid_every=FLAGS.log_valid_every,
-            train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns, print_every=FLAGS.print_every,
-            save_every=FLAGS.save_every, sample_every=FLAGS.sample_every, sample_grid=FLAGS.sample_grid,
-            sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size, debug=FLAGS.debug,
-            use_epoch_data = FLAGS.use_epoch_data, epoch_data_dir = FLAGS.epoch_data_dir)
-
-        model.train()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_fusion_net import DeepHeatmapsModel
+import os
+import numpy as np
+
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+output_dir = 'tests_fusion'
+pre_train_model_name = 'deep_heatmaps-50000'
+num_tests = 5
+params = np.logspace(-4, -6, num_tests)
+
+flags = tf.app.flags
+
+# mode and logging parameters
+flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
+flags.DEFINE_integer('save_every', 5000, "save model every X steps")
+flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
+flags.DEFINE_integer('sample_grid', 4, 'number of training images in sample')
+flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
+flags.DEFINE_integer('valid_size', 0, 'number of validation images to run')
+flags.DEFINE_integer('log_valid_every', 5, 'evaluate on valid set every X epochs')
+flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
+flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
+
+# define paths
+flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
+flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
+flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
+flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25',"directory of train images cropped to bb (+margin)")
+flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns',"dir of train imgs cropped to bb + style transfer")
+flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
+flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
+
+
+# pretrain parameters (for fine-tuning / resume training)
+flags.DEFINE_string('pre_train_model_name', pre_train_model_name, 'pretrained model name (e.g. deep_heatmaps-50000')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+flags.DEFINE_bool('load_primary_only', False, 'fine-tuning using only primary network weights')
+
+# input data parameters
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+flags.DEFINE_float('sigma', 6, "std for heatmap generation gaussian")
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
+flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
+
+# optimization parameters
+flags.DEFINE_float('l_weight_primary', 1., 'primary loss weight')
+flags.DEFINE_float('l_weight_fusion', 0., 'fusion loss weight')
+flags.DEFINE_float('l_weight_upsample', 3., 'upsample loss weight')
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 6, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
+flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
+flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+flags.DEFINE_float('reg', 0, 'scalar multiplier for weight decay (0 to disable)')
+flags.DEFINE_string('weight_initializer','xavier', 'weight initializer: random_normal / xavier')
+flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
+flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
+flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
+flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
+flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
+flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
+flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
+flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
+flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
+
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    for i, param in enumerate(params):
+
+        test_dir = os.path.join(FLAGS.output_dir, str(param))
+        if not os.path.exists(test_dir):
+            os.mkdir(test_dir)
+
+        print ('\n##### RUNNING TESTS FUSION (%d/%d) #####' % (i + 1, len(params)))
+        print ('##### current directory: ' + test_dir)
+
+        save_model_path = os.path.join(test_dir,'model')
+        save_sample_path = os.path.join(test_dir, 'sample')
+        save_log_path = os.path.join(test_dir, 'logs')
+
+        # create directories if not exist
+        if not os.path.exists(save_model_path):
+            os.mkdir(save_model_path)
+        if not os.path.exists(save_log_path):
+            os.mkdir(save_log_path)
+        if not os.path.exists(save_sample_path) and not FLAGS.sample_to_log:
+            os.mkdir(save_sample_path)
+
+        tf.reset_default_graph()  # reset graph
+
+        model = DeepHeatmapsModel(
+            mode='TRAIN', train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=param,
+            l_weight_primary=FLAGS.l_weight_primary, l_weight_fusion=FLAGS.l_weight_fusion,
+            l_weight_upsample=FLAGS.l_weight_upsample, reg=FLAGS.reg,
+            adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
+            weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
+            bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
+            num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
+            bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult,
+            augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture,
+            p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom, artistic_step=FLAGS.artistic_step,
+            artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir, save_model_path=save_model_path,
+            save_sample_path=save_sample_path, save_log_path=save_log_path, test_model_path=FLAGS.test_model_path,
+            pre_train_path=os.path.join(save_model_path, FLAGS.pre_train_model_name), load_pretrain=FLAGS.load_pretrain,
+            load_primary_only=FLAGS.load_primary_only, img_path=FLAGS.img_path, test_data=FLAGS.test_data,
+            valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size, log_valid_every=FLAGS.log_valid_every,
+            train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns, print_every=FLAGS.print_every,
+            save_every=FLAGS.save_every, sample_every=FLAGS.sample_every, sample_grid=FLAGS.sample_grid,
+            sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size, debug=FLAGS.debug,
+            use_epoch_data = FLAGS.use_epoch_data, epoch_data_dir = FLAGS.epoch_data_dir)
+
+        model.train()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/old/temp/run_tests_primary.py

@@ -1,130 +1,130 @@
-import tensorflow as tf
-from deep_heatmaps_model_primary_net import DeepHeatmapsModel
-import os
-import numpy as np
-
-
-data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
-output_dir = 'tests_primary'
-pre_train_model_name = 'deep_heatmaps-50000'
-num_tests = 5
-params = np.logspace(-4, -6, num_tests)
-
-flags = tf.app.flags
-
-# mode and logging parameters
-flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
-flags.DEFINE_integer('save_every', 5000, "save model every X steps")
-flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
-flags.DEFINE_integer('sample_grid', 9, 'number of training images in sample')
-flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
-flags.DEFINE_integer('valid_size', 0, 'number of validation images to run')
-flags.DEFINE_integer('log_valid_every', 5, 'evaluate on valid set every X epochs')
-flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
-flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
-
-# define paths
-flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
-flags.DEFINE_string('img_path', data_dir, "data directory")
-flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
-flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
-flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
-flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25',"directory of train images cropped to bb (+margin)")
-flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns',"dir of train imgs cropped to bb + style transfer")
-flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
-flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
-
-
-# pretrain parameters (for fine-tuning / resume training)
-flags.DEFINE_string('pre_train_model_name', pre_train_model_name, 'pretrained model name (e.g. deep_heatmaps-50000')
-flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
-
-# input data parameters
-flags.DEFINE_integer('image_size', 256, "image size")
-flags.DEFINE_integer('c_dim', 3, "color channels")
-flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
-flags.DEFINE_float('sigma', 1.5, "std for heatmap generation gaussian")
-flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
-flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
-flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
-flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
-flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
-
-# optimization parameters
-flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
-flags.DEFINE_integer('batch_size', 10, "batch_size")
-flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
-flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
-flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
-flags.DEFINE_integer('step', 100000, 'step for lr decay')
-flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
-flags.DEFINE_float('reg', 0, 'scalar multiplier for weight decay (0 to disable)')
-flags.DEFINE_string('weight_initializer','xavier', 'weight initializer: random_normal / xavier')
-flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
-flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
-
-# augmentation parameters
-flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
-flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
-flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
-flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
-flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
-flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
-flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
-flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
-
-
-FLAGS = flags.FLAGS
-
-if not os.path.exists(FLAGS.output_dir):
-    os.mkdir(FLAGS.output_dir)
-
-
-def main(_):
-
-    for i, param in enumerate(params):
-
-        test_dir = os.path.join(FLAGS.output_dir, str(param))
-        if not os.path.exists(test_dir):
-            os.mkdir(test_dir)
-
-        print ('\n##### RUNNING TESTS PRIMARY (%d/%d) #####' % (i + 1, len(params)))
-        print ('##### current directory: ' + test_dir)
-
-        save_model_path = os.path.join(test_dir,'model')
-        save_sample_path = os.path.join(test_dir, 'sample')
-        save_log_path = os.path.join(test_dir, 'logs')
-
-        # create directories if not exist
-        if not os.path.exists(save_model_path):
-            os.mkdir(save_model_path)
-        if not os.path.exists(save_log_path):
-            os.mkdir(save_log_path)
-        if not os.path.exists(save_sample_path) and not FLAGS.sample_to_log:
-            os.mkdir(save_sample_path)
-
-        tf.reset_default_graph()  # reset graph
-
-        model = DeepHeatmapsModel(
-            mode='TRAIN', train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=param,
-            adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
-            reg=FLAGS.reg, weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
-            bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
-            num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
-            bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult,
-            augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture,
-            p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
-            artistic_step=FLAGS.artistic_step, artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir,
-            save_model_path=save_model_path, save_sample_path=save_sample_path, save_log_path=save_log_path,
-            test_model_path=FLAGS.test_model_path, pre_train_path=os.path.join(save_model_path, FLAGS.pre_train_model_name),
-            load_pretrain=FLAGS.load_pretrain, img_path=FLAGS.img_path, test_data=FLAGS.test_data,
-            valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size, log_valid_every=FLAGS.log_valid_every,
-            train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns, print_every=FLAGS.print_every,
-            save_every=FLAGS.save_every, sample_every=FLAGS.sample_every, sample_grid=FLAGS.sample_grid,
-            sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size, debug=FLAGS.debug,
-            use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
-
-        model.train()
-
-if __name__ == '__main__':
-    tf.app.run()
+import tensorflow as tf
+from deep_heatmaps_model_primary_net import DeepHeatmapsModel
+import os
+import numpy as np
+
+
+data_dir = '/Users/arik/Dropbox/a_mac_thesis/face_heatmap_networks/conventional_landmark_detection_dataset/'
+output_dir = 'tests_primary'
+pre_train_model_name = 'deep_heatmaps-50000'
+num_tests = 5
+params = np.logspace(-4, -6, num_tests)
+
+flags = tf.app.flags
+
+# mode and logging parameters
+flags.DEFINE_integer('print_every', 100, "print losses to screen + log every X steps")
+flags.DEFINE_integer('save_every', 5000, "save model every X steps")
+flags.DEFINE_integer('sample_every', 5000, "sample heatmaps + landmark predictions every X steps")
+flags.DEFINE_integer('sample_grid', 9, 'number of training images in sample')
+flags.DEFINE_bool('sample_to_log', True, 'samples will be saved to tensorboard log')
+flags.DEFINE_integer('valid_size', 0, 'number of validation images to run')
+flags.DEFINE_integer('log_valid_every', 5, 'evaluate on valid set every X epochs')
+flags.DEFINE_integer('debug_data_size', 20, 'subset data size to test in debug mode')
+flags.DEFINE_bool('debug', False, 'run in debug mode - use subset of the data')
+
+# define paths
+flags.DEFINE_string('output_dir', output_dir, "directory for saving models, logs and samples")
+flags.DEFINE_string('img_path', data_dir, "data directory")
+flags.DEFINE_string('test_model_path', 'model/deep_heatmaps-50000', "saved model to test")
+flags.DEFINE_string('test_data', 'full', 'test set to use: full/common/challenging/test/art')
+flags.DEFINE_string('valid_data', 'full', 'validation set to use: full/common/challenging/test/art')
+flags.DEFINE_string('train_crop_dir', 'crop_gt_margin_0.25',"directory of train images cropped to bb (+margin)")
+flags.DEFINE_string('img_dir_ns', 'crop_gt_margin_0.25_ns',"dir of train imgs cropped to bb + style transfer")
+flags.DEFINE_string('epoch_data_dir', 'epoch_data', "directory containing pre-augmented data for each epoch")
+flags.DEFINE_bool('use_epoch_data', False, "use pre-augmented data")
+
+
+# pretrain parameters (for fine-tuning / resume training)
+flags.DEFINE_string('pre_train_model_name', pre_train_model_name, 'pretrained model name (e.g. deep_heatmaps-50000')
+flags.DEFINE_bool('load_pretrain', False, "load pretrained weight?")
+
+# input data parameters
+flags.DEFINE_integer('image_size', 256, "image size")
+flags.DEFINE_integer('c_dim', 3, "color channels")
+flags.DEFINE_integer('num_landmarks', 68, "number of face landmarks")
+flags.DEFINE_float('sigma', 1.5, "std for heatmap generation gaussian")
+flags.DEFINE_integer('scale', 1, 'scale for image normalization 255/1/0')
+flags.DEFINE_float('margin', 0.25, 'margin for face crops - % of bb size')
+flags.DEFINE_string('bb_type', 'gt', "bb to use -  'gt':for ground truth / 'init':for face detector output")
+flags.DEFINE_bool('approx_maps', True, 'use heatmap approximation - major speed up')
+flags.DEFINE_float('win_mult', 3.33335, 'gaussian filter size for approx maps: 2 * sigma * win_mult + 1')
+
+# optimization parameters
+flags.DEFINE_integer('train_iter', 100000, 'maximum training iterations')
+flags.DEFINE_integer('batch_size', 10, "batch_size")
+flags.DEFINE_float('learning_rate', 1e-4, "initial learning rate")
+flags.DEFINE_bool('adam_optimizer', True, "use adam optimizer (if False momentum optimizer is used)")
+flags.DEFINE_float('momentum', 0.95, "optimizer momentum (if adam_optimizer==False)")
+flags.DEFINE_integer('step', 100000, 'step for lr decay')
+flags.DEFINE_float('gamma', 0.1, 'exponential base for lr decay')
+flags.DEFINE_float('reg', 0, 'scalar multiplier for weight decay (0 to disable)')
+flags.DEFINE_string('weight_initializer','xavier', 'weight initializer: random_normal / xavier')
+flags.DEFINE_float('weight_initializer_std', 0.01, 'std for random_normal weight initializer')
+flags.DEFINE_float('bias_initializer', 0.0, 'constant value for bias initializer')
+
+# augmentation parameters
+flags.DEFINE_bool('augment_basic', True,"use basic augmentation?")
+flags.DEFINE_integer('basic_start', 0,  'min epoch to start basic augmentation')
+flags.DEFINE_bool('augment_texture', False, "use artistic texture augmentation?")
+flags.DEFINE_float('p_texture', 0., 'initial probability of artistic texture augmentation')
+flags.DEFINE_bool('augment_geom', False,"use artistic geometric augmentation?")
+flags.DEFINE_float('p_geom', 0., 'initial probability of artistic geometric augmentation')
+flags.DEFINE_integer('artistic_step', -1, 'step for increasing probability of artistic augmentation in epochs')
+flags.DEFINE_integer('artistic_start', 0, 'min epoch to start artistic augmentation')
+
+
+FLAGS = flags.FLAGS
+
+if not os.path.exists(FLAGS.output_dir):
+    os.mkdir(FLAGS.output_dir)
+
+
+def main(_):
+
+    for i, param in enumerate(params):
+
+        test_dir = os.path.join(FLAGS.output_dir, str(param))
+        if not os.path.exists(test_dir):
+            os.mkdir(test_dir)
+
+        print ('\n##### RUNNING TESTS PRIMARY (%d/%d) #####' % (i + 1, len(params)))
+        print ('##### current directory: ' + test_dir)
+
+        save_model_path = os.path.join(test_dir,'model')
+        save_sample_path = os.path.join(test_dir, 'sample')
+        save_log_path = os.path.join(test_dir, 'logs')
+
+        # create directories if not exist
+        if not os.path.exists(save_model_path):
+            os.mkdir(save_model_path)
+        if not os.path.exists(save_log_path):
+            os.mkdir(save_log_path)
+        if not os.path.exists(save_sample_path) and not FLAGS.sample_to_log:
+            os.mkdir(save_sample_path)
+
+        tf.reset_default_graph()  # reset graph
+
+        model = DeepHeatmapsModel(
+            mode='TRAIN', train_iter=FLAGS.train_iter, batch_size=FLAGS.batch_size, learning_rate=param,
+            adam_optimizer=FLAGS.adam_optimizer, momentum=FLAGS.momentum, step=FLAGS.step, gamma=FLAGS.gamma,
+            reg=FLAGS.reg, weight_initializer=FLAGS.weight_initializer, weight_initializer_std=FLAGS.weight_initializer_std,
+            bias_initializer=FLAGS.bias_initializer, image_size=FLAGS.image_size, c_dim=FLAGS.c_dim,
+            num_landmarks=FLAGS.num_landmarks, sigma=FLAGS.sigma, scale=FLAGS.scale, margin=FLAGS.margin,
+            bb_type=FLAGS.bb_type, approx_maps=FLAGS.approx_maps, win_mult=FLAGS.win_mult,
+            augment_basic=FLAGS.augment_basic, basic_start=FLAGS.basic_start, augment_texture=FLAGS.augment_texture,
+            p_texture=FLAGS.p_texture, augment_geom=FLAGS.augment_geom, p_geom=FLAGS.p_geom,
+            artistic_step=FLAGS.artistic_step, artistic_start=FLAGS.artistic_start, output_dir=FLAGS.output_dir,
+            save_model_path=save_model_path, save_sample_path=save_sample_path, save_log_path=save_log_path,
+            test_model_path=FLAGS.test_model_path, pre_train_path=os.path.join(save_model_path, FLAGS.pre_train_model_name),
+            load_pretrain=FLAGS.load_pretrain, img_path=FLAGS.img_path, test_data=FLAGS.test_data,
+            valid_data=FLAGS.valid_data, valid_size=FLAGS.valid_size, log_valid_every=FLAGS.log_valid_every,
+            train_crop_dir=FLAGS.train_crop_dir, img_dir_ns=FLAGS.img_dir_ns, print_every=FLAGS.print_every,
+            save_every=FLAGS.save_every, sample_every=FLAGS.sample_every, sample_grid=FLAGS.sample_grid,
+            sample_to_log=FLAGS.sample_to_log, debug_data_size=FLAGS.debug_data_size, debug=FLAGS.debug,
+            use_epoch_data=FLAGS.use_epoch_data, epoch_data_dir=FLAGS.epoch_data_dir)
+
+        model.train()
+
+if __name__ == '__main__':
+    tf.app.run()

MakeItTalk/thirdparty/face_of_art/ops.py

@@ -1,99 +1,99 @@
-import tensorflow as tf
-import numpy as np
-
-
-def conv_relu_pool(input, conv_ker, conv_filters, conv_stride=1, conv_padding='SAME',
-                   conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
-                   pool_size=2, pool_stride=2, pool_padding='same', var_scope='layer', reuse=None):
-
-    with tf.variable_scope(var_scope):
-        conv = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
-                                strides=conv_stride, padding=conv_padding, bias_initializer=conv_bias_init,
-                                kernel_initializer=conv_ker_init, name='conv', reuse=reuse)
-        relu = tf.nn.relu(conv, name='relu')
-        out = tf.layers.max_pooling2d(relu, pool_size=(pool_size, pool_size),
-                                      strides=(pool_stride, pool_stride), padding=pool_padding, name='pool')
-        return out
-
-
-def conv_relu(input, conv_ker, conv_filters, conv_stride=1, conv_dilation=1, conv_padding='SAME',
-              conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
-              var_scope='layer', reuse=None):
-
-    with tf.variable_scope(var_scope):
-        conv = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
-                                strides=conv_stride, dilation_rate=conv_dilation, padding=conv_padding,
-                                bias_initializer=conv_bias_init, kernel_initializer=conv_ker_init, name='conv',
-                                reuse=reuse)
-        out = tf.nn.relu(conv, name='relu')
-        return out
-
-
-def conv(input, conv_ker, conv_filters, conv_stride=1, conv_dilation=1, conv_padding='SAME',
-         conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
-         var_scope='layer', reuse=None):
-
-    with tf.variable_scope(var_scope):
-        out = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
-                               strides=conv_stride, dilation_rate=conv_dilation, padding=conv_padding,
-                               bias_initializer=conv_bias_init, kernel_initializer=conv_ker_init, name='conv',
-                               reuse=reuse)
-        return out
-
-
-def deconv(input, conv_ker, conv_filters, conv_stride=1, conv_padding='SAME',
-           conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
-           var_scope='layer', reuse=None):
-
-    with tf.variable_scope(var_scope):
-        out = tf.layers.conv2d_transpose(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
-                                         strides=conv_stride, padding=conv_padding, bias_initializer=conv_bias_init,
-                                         kernel_initializer=conv_ker_init, name='deconv', reuse=reuse)
-        return out
-
-
-def deconv2d_bilinear_upsampling_initializer(shape):
-    """Returns the initializer that can be passed to DeConv2dLayer for initializ ingthe
-    weights in correspondence to channel-wise bilinear up-sampling.
-    Used in segmentation approaches such as [FCN](https://arxiv.org/abs/1605.06211)
-    Parameters
-    ----------
-    shape : tuple of int
-        The shape of the filters, [height, width, output_channels, in_channels].
-        It must match the shape passed to DeConv2dLayer.
-    Returns
-    -------
-    ``tf.constant_initializer``
-        A constant initializer with weights set to correspond to per channel bilinear upsampling
-        when passed as W_int in DeConv2dLayer
-    --------
-    from: tensorlayer
-    https://github.com/tensorlayer/tensorlayer/blob/c7a1a4924219244c71048709ca729aca0c34c453/tensorlayer/layers/convolution.py
-    """
-    if shape[0] != shape[1]:
-        raise Exception('deconv2d_bilinear_upsampling_initializer only supports symmetrical filter sizes')
-    if shape[3] < shape[2]:
-        raise Exception('deconv2d_bilinear_upsampling_initializer behaviour is not defined for num_in_channels < num_out_channels ')
-
-    filter_size = shape[0]
-    num_out_channels = shape[2]
-    num_in_channels = shape[3]
-
-    # Create bilinear filter kernel as numpy array
-    bilinear_kernel = np.zeros([filter_size, filter_size], dtype=np.float32)
-    scale_factor = (filter_size + 1) // 2
-    if filter_size % 2 == 1:
-        center = scale_factor - 1
-    else:
-        center = scale_factor - 0.5
-    for x in range(filter_size):
-        for y in range(filter_size):
-            bilinear_kernel[x, y] = (1 - abs(x - center) / scale_factor) * \
-                                    (1 - abs(y - center) / scale_factor)
-    weights = np.zeros((filter_size, filter_size, num_out_channels, num_in_channels))
-    for i in range(num_out_channels):
-        weights[:, :, i, i] = bilinear_kernel
-
-    # assign numpy array to constant_initalizer and pass to get_variable
-    bilinear_weights_init = tf.constant_initializer(value=weights, dtype=tf.float32)
+import tensorflow as tf
+import numpy as np
+
+
+def conv_relu_pool(input, conv_ker, conv_filters, conv_stride=1, conv_padding='SAME',
+                   conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
+                   pool_size=2, pool_stride=2, pool_padding='same', var_scope='layer', reuse=None):
+
+    with tf.variable_scope(var_scope):
+        conv = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
+                                strides=conv_stride, padding=conv_padding, bias_initializer=conv_bias_init,
+                                kernel_initializer=conv_ker_init, name='conv', reuse=reuse)
+        relu = tf.nn.relu(conv, name='relu')
+        out = tf.layers.max_pooling2d(relu, pool_size=(pool_size, pool_size),
+                                      strides=(pool_stride, pool_stride), padding=pool_padding, name='pool')
+        return out
+
+
+def conv_relu(input, conv_ker, conv_filters, conv_stride=1, conv_dilation=1, conv_padding='SAME',
+              conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
+              var_scope='layer', reuse=None):
+
+    with tf.variable_scope(var_scope):
+        conv = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
+                                strides=conv_stride, dilation_rate=conv_dilation, padding=conv_padding,
+                                bias_initializer=conv_bias_init, kernel_initializer=conv_ker_init, name='conv',
+                                reuse=reuse)
+        out = tf.nn.relu(conv, name='relu')
+        return out
+
+
+def conv(input, conv_ker, conv_filters, conv_stride=1, conv_dilation=1, conv_padding='SAME',
+         conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
+         var_scope='layer', reuse=None):
+
+    with tf.variable_scope(var_scope):
+        out = tf.layers.conv2d(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
+                               strides=conv_stride, dilation_rate=conv_dilation, padding=conv_padding,
+                               bias_initializer=conv_bias_init, kernel_initializer=conv_ker_init, name='conv',
+                               reuse=reuse)
+        return out
+
+
+def deconv(input, conv_ker, conv_filters, conv_stride=1, conv_padding='SAME',
+           conv_ker_init=tf.random_normal_initializer(0.01), conv_bias_init=tf.zeros_initializer(),
+           var_scope='layer', reuse=None):
+
+    with tf.variable_scope(var_scope):
+        out = tf.layers.conv2d_transpose(input, filters=conv_filters, kernel_size=[conv_ker, conv_ker],
+                                         strides=conv_stride, padding=conv_padding, bias_initializer=conv_bias_init,
+                                         kernel_initializer=conv_ker_init, name='deconv', reuse=reuse)
+        return out
+
+
+def deconv2d_bilinear_upsampling_initializer(shape):
+    """Returns the initializer that can be passed to DeConv2dLayer for initializ ingthe
+    weights in correspondence to channel-wise bilinear up-sampling.
+    Used in segmentation approaches such as [FCN](https://arxiv.org/abs/1605.06211)
+    Parameters
+    ----------
+    shape : tuple of int
+        The shape of the filters, [height, width, output_channels, in_channels].
+        It must match the shape passed to DeConv2dLayer.
+    Returns
+    -------
+    ``tf.constant_initializer``
+        A constant initializer with weights set to correspond to per channel bilinear upsampling
+        when passed as W_int in DeConv2dLayer
+    --------
+    from: tensorlayer
+    https://github.com/tensorlayer/tensorlayer/blob/c7a1a4924219244c71048709ca729aca0c34c453/tensorlayer/layers/convolution.py
+    """
+    if shape[0] != shape[1]:
+        raise Exception('deconv2d_bilinear_upsampling_initializer only supports symmetrical filter sizes')
+    if shape[3] < shape[2]:
+        raise Exception('deconv2d_bilinear_upsampling_initializer behaviour is not defined for num_in_channels < num_out_channels ')
+
+    filter_size = shape[0]
+    num_out_channels = shape[2]
+    num_in_channels = shape[3]
+
+    # Create bilinear filter kernel as numpy array
+    bilinear_kernel = np.zeros([filter_size, filter_size], dtype=np.float32)
+    scale_factor = (filter_size + 1) // 2
+    if filter_size % 2 == 1:
+        center = scale_factor - 1
+    else:
+        center = scale_factor - 0.5
+    for x in range(filter_size):
+        for y in range(filter_size):
+            bilinear_kernel[x, y] = (1 - abs(x - center) / scale_factor) * \
+                                    (1 - abs(y - center) / scale_factor)
+    weights = np.zeros((filter_size, filter_size, num_out_channels, num_in_channels))
+    for i in range(num_out_channels):
+        weights[:, :, i, i] = bilinear_kernel
+
+    # assign numpy array to constant_initalizer and pass to get_variable
+    bilinear_weights_init = tf.constant_initializer(value=weights, dtype=tf.float32)
     return bilinear_weights_init

MakeItTalk/thirdparty/face_of_art/pdm_clm_functions.py

@@ -1,203 +1,203 @@
-from thirdparty.face_of_art.logging_functions import *
-import os
-import numpy as np
-from menpo.shape import PointCloud
-from menpofit.clm import GradientDescentCLMFitter
-import pickle
-import math
-
-jaw_line_inds = np.arange(0, 17)
-nose_inds = np.arange(27, 36)
-left_eye_inds = np.arange(36, 42)
-right_eye_inds = np.arange(42, 48)
-left_brow_inds = np.arange(17, 22)
-right_brow_inds = np.arange(22, 27)
-mouth_inds = np.arange(48, 68)
-
-
-def sigmoid(x, rate, offset):
-    return 1 / (1 + math.exp(-rate * (x - offset)))
-
-
-def calculate_evidence(patch_responses, rate=0.25, offset=20):
-    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-
-    rspmapShape = patch_responses[0, 0, ...].shape
-    n_points = patch_responses.shape[0]
-
-    y_weight = [np.sum(patch_responses[i, 0, ...], axis=1) for i in range(n_points)]
-    x_weight = [np.sum(patch_responses[i, 0, ...], axis=0) for i in range(n_points)]
-
-    # y_weight /= y_weight.sum()
-    # x_weight /= x_weight.sum()
-
-    y_coordinate = range(0, rspmapShape[0])
-    x_coordinate = range(0, rspmapShape[1])
-
-    varList = [(np.abs(
-        np.average((y_coordinate - np.average(y_coordinate, weights=y_weight[i])) ** 2, weights=y_weight[i])),
-                np.abs(np.average((x_coordinate - np.average(x_coordinate, weights=x_weight[i])) ** 2,
-                                  weights=x_weight[i])))
-               for i in range(n_points)]
-
-    # patch_responses[patch_responses<0.001] = 0
-    prpList = [
-        (np.sum(patch_responses[i, 0, ...], axis=(-1, -2)), np.sum(patch_responses[i, 0, ...], axis=(-1, -2)))
-        for i in range(n_points)]
-
-    var = np.array(varList).flatten()
-    var[var == 0] = np.finfo(float).eps
-    var = np.sqrt(var)
-    var = 1 / var
-
-    weight = np.array(prpList).flatten()
-    weight *= var
-
-    # offset = np.average(weight) - 20
-    weight = [sigmoid(i, rate, offset) for i in weight]
-
-    weight = np.array(weight)
-
-    return weight
-
-
-def get_patches_around_landmarks(heat_maps, menpo_shape, patch_size=(30,30), image_shape=256):
-    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-
-    padH = int(image_shape / 2)
-    padW = int(image_shape / 2)
-
-    rps_zeros = np.zeros((1, 2 * image_shape, 2 * image_shape, menpo_shape.n_points))
-    rps_zeros[0, padH:padH + image_shape, padW:padW + image_shape, :] = heat_maps
-
-    rOffset = np.floor(patch_size[0] / 2).astype(int)
-    lOffset = patch_size[0] - rOffset
-
-    rspList = [rps_zeros[0, y - rOffset:y + lOffset, x - rOffset:x + lOffset, i] for i in range(menpo_shape.n_points)
-               for y in [np.around(menpo_shape.points[i][0] + 1 + padH).astype(int)]
-               for x in [np.around(menpo_shape.points[i][1] + 1 + padW).astype(int)]]
-    patches = np.array(rspList)[:, None, :, :]
-    return patches
-
-
-def pdm_correct(init_shape, pdm_model, part_inds=None):
-    """ correct landmarks using pdm (point distribution model)"""
-    pdm_model.set_target(PointCloud(init_shape))
-    if part_inds is None:
-        return pdm_model.target.points
-    else:
-        return pdm_model.target.points[part_inds]
-
-
-def weighted_pdm_transform(input_pdm_model, patches, shape, inirho=20):
-    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-    weight = calculate_evidence(patches, rate=0.5, offset=10).reshape((1, -1))
-    pdm_model = input_pdm_model.copy()
-
-    # write project_weight
-    ini_rho2_inv_prior = np.hstack((np.zeros((4,)), inirho / pdm_model.model.eigenvalues))
-    J = np.rollaxis(pdm_model.d_dp(None), -1, 1)
-    J = J.reshape((-1, J.shape[-1]))
-
-    initial_shape_mean = shape.points.ravel() - pdm_model.model._mean
-    iniJe = - J.T.dot(initial_shape_mean * weight[0])
-    iniJWJ = J.T.dot(np.diag(weight[0]).dot(J))
-    inv_JJ = np.linalg.inv(iniJWJ + np.diag(ini_rho2_inv_prior))
-    initial_p = -inv_JJ.dot(iniJe)
-
-    # Update pdm
-    pdm_model._from_vector_inplace(initial_p)
-    return pdm_model.target.points
-
-
-def w_pdm_correct(init_shape, patches, pdm_model, part_inds=None):
-    """ correct landmarks using weighted pdm"""
-
-    points = weighted_pdm_transform(input_pdm_model=pdm_model, patches=patches, shape=PointCloud(init_shape))
-
-    if (part_inds is not None and pdm_model.n_points < 68) or part_inds is None:
-        return points
-    else:
-        return points[part_inds]
-
-
-def feature_based_pdm_corr(lms_init, models_dir, train_type='basic', patches=None):
-    """ correct landmarks using part-based pdm"""
-
-    jaw_line_inds = np.arange(0, 17)
-    nose_inds = np.arange(27, 36)
-    left_eye_inds = np.arange(36, 42)
-    right_eye_inds = np.arange(42, 48)
-    left_brow_inds = np.arange(17, 22)
-    right_brow_inds = np.arange(22, 27)
-    mouth_inds = np.arange(48, 68)
-
-    '''
-    selected number of PCs:
-    jaw:7
-    eye:3
-    brow:2
-    nose:5
-    mouth:7
-    '''
-
-    new_lms = np.zeros((68, 2))
-
-    parts = ['l_brow', 'r_brow', 'l_eye', 'r_eye', 'mouth', 'nose', 'jaw']
-    part_inds_opt = [left_brow_inds, right_brow_inds, left_eye_inds, right_eye_inds, mouth_inds, nose_inds,
-                     jaw_line_inds]
-    pc_opt = [2, 2, 3, 3, 7, 5, 7]
-
-    for i, part in enumerate(parts):
-        part_inds = part_inds_opt[i]
-        pc = pc_opt[i]
-        temp_model = os.path.join(models_dir, train_type + '_' + part + '_' + str(pc))
-        filehandler = open(temp_model, "rb")
-        try:
-            pdm_temp = pickle.load(filehandler)
-        except UnicodeDecodeError:
-            pdm_temp = pickle.load(filehandler, fix_imports=True, encoding="latin1")
-        filehandler.close()
-
-        if patches is None:
-            part_lms_pdm = pdm_correct(lms_init[part_inds], pdm_temp)
-        else:
-            part_lms_pdm = w_pdm_correct(
-                init_shape=lms_init[part_inds], patches=patches, pdm_model=pdm_temp, part_inds=part_inds)
-
-        new_lms[part_inds] = part_lms_pdm
-    return new_lms
-
-
-def clm_correct(clm_model_path, image, map, lms_init):
-    """ tune landmarks using clm (constrained local model)"""
-
-    filehandler = open(os.path.join(clm_model_path), "rb")
-    try:
-        part_model = pickle.load(filehandler)
-    except UnicodeDecodeError:
-        part_model = pickle.load(filehandler, fix_imports=True, encoding="latin1")
-    filehandler.close()
-
-    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
-    part_model.opt = dict()
-    part_model.opt['numIter'] = 5
-    part_model.opt['kernel_covariance'] = 10
-    part_model.opt['sigOffset'] = 25
-    part_model.opt['sigRate'] = 0.25
-    part_model.opt['pdm_rho'] = 20
-    part_model.opt['verbose'] = False
-    part_model.opt['rho2'] = 20
-    part_model.opt['ablation'] = (True, True)
-    part_model.opt['ratio1'] = 0.12
-    part_model.opt['ratio2'] = 0.08
-    part_model.opt['smooth'] = True
-
-    fitter = GradientDescentCLMFitter(part_model, n_shape=30)
-
-    image.rspmap_data = np.swapaxes(np.swapaxes(map, 1, 3), 2, 3)
-
-    fr = fitter.fit_from_shape(image=image, initial_shape=PointCloud(lms_init), gt_shape=PointCloud(lms_init))
-    w_pdm_clm = fr.final_shape.points
-
-    return w_pdm_clm
+from thirdparty.face_of_art.logging_functions import *
+import os
+import numpy as np
+from menpo.shape import PointCloud
+from menpofit.clm import GradientDescentCLMFitter
+import pickle
+import math
+
+jaw_line_inds = np.arange(0, 17)
+nose_inds = np.arange(27, 36)
+left_eye_inds = np.arange(36, 42)
+right_eye_inds = np.arange(42, 48)
+left_brow_inds = np.arange(17, 22)
+right_brow_inds = np.arange(22, 27)
+mouth_inds = np.arange(48, 68)
+
+
+def sigmoid(x, rate, offset):
+    return 1 / (1 + math.exp(-rate * (x - offset)))
+
+
+def calculate_evidence(patch_responses, rate=0.25, offset=20):
+    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+
+    rspmapShape = patch_responses[0, 0, ...].shape
+    n_points = patch_responses.shape[0]
+
+    y_weight = [np.sum(patch_responses[i, 0, ...], axis=1) for i in range(n_points)]
+    x_weight = [np.sum(patch_responses[i, 0, ...], axis=0) for i in range(n_points)]
+
+    # y_weight /= y_weight.sum()
+    # x_weight /= x_weight.sum()
+
+    y_coordinate = range(0, rspmapShape[0])
+    x_coordinate = range(0, rspmapShape[1])
+
+    varList = [(np.abs(
+        np.average((y_coordinate - np.average(y_coordinate, weights=y_weight[i])) ** 2, weights=y_weight[i])),
+                np.abs(np.average((x_coordinate - np.average(x_coordinate, weights=x_weight[i])) ** 2,
+                                  weights=x_weight[i])))
+               for i in range(n_points)]
+
+    # patch_responses[patch_responses<0.001] = 0
+    prpList = [
+        (np.sum(patch_responses[i, 0, ...], axis=(-1, -2)), np.sum(patch_responses[i, 0, ...], axis=(-1, -2)))
+        for i in range(n_points)]
+
+    var = np.array(varList).flatten()
+    var[var == 0] = np.finfo(float).eps
+    var = np.sqrt(var)
+    var = 1 / var
+
+    weight = np.array(prpList).flatten()
+    weight *= var
+
+    # offset = np.average(weight) - 20
+    weight = [sigmoid(i, rate, offset) for i in weight]
+
+    weight = np.array(weight)
+
+    return weight
+
+
+def get_patches_around_landmarks(heat_maps, menpo_shape, patch_size=(30,30), image_shape=256):
+    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+
+    padH = int(image_shape / 2)
+    padW = int(image_shape / 2)
+
+    rps_zeros = np.zeros((1, 2 * image_shape, 2 * image_shape, menpo_shape.n_points))
+    rps_zeros[0, padH:padH + image_shape, padW:padW + image_shape, :] = heat_maps
+
+    rOffset = np.floor(patch_size[0] / 2).astype(int)
+    lOffset = patch_size[0] - rOffset
+
+    rspList = [rps_zeros[0, y - rOffset:y + lOffset, x - rOffset:x + lOffset, i] for i in range(menpo_shape.n_points)
+               for y in [np.around(menpo_shape.points[i][0] + 1 + padH).astype(int)]
+               for x in [np.around(menpo_shape.points[i][1] + 1 + padW).astype(int)]]
+    patches = np.array(rspList)[:, None, :, :]
+    return patches
+
+
+def pdm_correct(init_shape, pdm_model, part_inds=None):
+    """ correct landmarks using pdm (point distribution model)"""
+    pdm_model.set_target(PointCloud(init_shape))
+    if part_inds is None:
+        return pdm_model.target.points
+    else:
+        return pdm_model.target.points[part_inds]
+
+
+def weighted_pdm_transform(input_pdm_model, patches, shape, inirho=20):
+    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+    weight = calculate_evidence(patches, rate=0.5, offset=10).reshape((1, -1))
+    pdm_model = input_pdm_model.copy()
+
+    # write project_weight
+    ini_rho2_inv_prior = np.hstack((np.zeros((4,)), inirho / pdm_model.model.eigenvalues))
+    J = np.rollaxis(pdm_model.d_dp(None), -1, 1)
+    J = J.reshape((-1, J.shape[-1]))
+
+    initial_shape_mean = shape.points.ravel() - pdm_model.model._mean
+    iniJe = - J.T.dot(initial_shape_mean * weight[0])
+    iniJWJ = J.T.dot(np.diag(weight[0]).dot(J))
+    inv_JJ = np.linalg.inv(iniJWJ + np.diag(ini_rho2_inv_prior))
+    initial_p = -inv_JJ.dot(iniJe)
+
+    # Update pdm
+    pdm_model._from_vector_inplace(initial_p)
+    return pdm_model.target.points
+
+
+def w_pdm_correct(init_shape, patches, pdm_model, part_inds=None):
+    """ correct landmarks using weighted pdm"""
+
+    points = weighted_pdm_transform(input_pdm_model=pdm_model, patches=patches, shape=PointCloud(init_shape))
+
+    if (part_inds is not None and pdm_model.n_points < 68) or part_inds is None:
+        return points
+    else:
+        return points[part_inds]
+
+
+def feature_based_pdm_corr(lms_init, models_dir, train_type='basic', patches=None):
+    """ correct landmarks using part-based pdm"""
+
+    jaw_line_inds = np.arange(0, 17)
+    nose_inds = np.arange(27, 36)
+    left_eye_inds = np.arange(36, 42)
+    right_eye_inds = np.arange(42, 48)
+    left_brow_inds = np.arange(17, 22)
+    right_brow_inds = np.arange(22, 27)
+    mouth_inds = np.arange(48, 68)
+
+    '''
+    selected number of PCs:
+    jaw:7
+    eye:3
+    brow:2
+    nose:5
+    mouth:7
+    '''
+
+    new_lms = np.zeros((68, 2))
+
+    parts = ['l_brow', 'r_brow', 'l_eye', 'r_eye', 'mouth', 'nose', 'jaw']
+    part_inds_opt = [left_brow_inds, right_brow_inds, left_eye_inds, right_eye_inds, mouth_inds, nose_inds,
+                     jaw_line_inds]
+    pc_opt = [2, 2, 3, 3, 7, 5, 7]
+
+    for i, part in enumerate(parts):
+        part_inds = part_inds_opt[i]
+        pc = pc_opt[i]
+        temp_model = os.path.join(models_dir, train_type + '_' + part + '_' + str(pc))
+        filehandler = open(temp_model, "rb")
+        try:
+            pdm_temp = pickle.load(filehandler)
+        except UnicodeDecodeError:
+            pdm_temp = pickle.load(filehandler, fix_imports=True, encoding="latin1")
+        filehandler.close()
+
+        if patches is None:
+            part_lms_pdm = pdm_correct(lms_init[part_inds], pdm_temp)
+        else:
+            part_lms_pdm = w_pdm_correct(
+                init_shape=lms_init[part_inds], patches=patches, pdm_model=pdm_temp, part_inds=part_inds)
+
+        new_lms[part_inds] = part_lms_pdm
+    return new_lms
+
+
+def clm_correct(clm_model_path, image, map, lms_init):
+    """ tune landmarks using clm (constrained local model)"""
+
+    filehandler = open(os.path.join(clm_model_path), "rb")
+    try:
+        part_model = pickle.load(filehandler)
+    except UnicodeDecodeError:
+        part_model = pickle.load(filehandler, fix_imports=True, encoding="latin1")
+    filehandler.close()
+
+    # from ECT: https://github.com/HongwenZhang/ECT-FaceAlignment
+    part_model.opt = dict()
+    part_model.opt['numIter'] = 5
+    part_model.opt['kernel_covariance'] = 10
+    part_model.opt['sigOffset'] = 25
+    part_model.opt['sigRate'] = 0.25
+    part_model.opt['pdm_rho'] = 20
+    part_model.opt['verbose'] = False
+    part_model.opt['rho2'] = 20
+    part_model.opt['ablation'] = (True, True)
+    part_model.opt['ratio1'] = 0.12
+    part_model.opt['ratio2'] = 0.08
+    part_model.opt['smooth'] = True
+
+    fitter = GradientDescentCLMFitter(part_model, n_shape=30)
+
+    image.rspmap_data = np.swapaxes(np.swapaxes(map, 1, 3), 2, 3)
+
+    fr = fitter.fit_from_shape(image=image, initial_shape=PointCloud(lms_init), gt_shape=PointCloud(lms_init))
+    w_pdm_clm = fr.final_shape.points
+
+    return w_pdm_clm

MakeItTalk/thirdparty/face_of_art/pdm_clm_models/clm_models/basic_jaw

@@ -1,490 +1,490 @@
-ccopy_reg
-_reconstructor
-p0
-(cmenpofit.clm.base
-CLM
-p1
-c__builtin__
-object
-p2
-Ntp3
-Rp4
-(dp5
-S'opt'
-p6
-(dp7
-S'ablation'
-p8
-(I01
-I01
-tp9
-sS'verbose'
-p10
-I00
-sS'rho2'
-p11
-I20
-sS'sigRate'
-p12
-F0.25
-sS'ratio2'
-p13
-F0.08
-sS'imgDir'
-p14
-S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
-p15
-sS'dataset'
-p16
-S'demo'
-p17
-sS'ratio1'
-p18
-F0.12
-sS'smooth'
-p19
-I01
-sS'pdm_rho'
-p20
-I20
-sS'sigOffset'
-p21
-I25
-sS'kernel_covariance'
-p22
-I10
-sS'numIter'
-p23
-I5
-ssS'_shape_model_cls'
-p24
-(lp25
-cmenpofit.modelinstance
-OrthoPDM
-p26
-asS'max_shape_components'
-p27
-(lp28
-NasS'scales'
-p29
-(lp30
-I1
-asS'diagonal'
-p31
-I200
-sS'holistic_features'
-p32
-(lp33
-cmenpo.feature.features
-no_op
-p34
-asS'patch_shape'
-p35
-(lp36
-(I8
-I8
-tp37
-asS'expert_ensemble_cls'
-p38
-(lp39
-cmenpofit.clm.expert.ensemble
-FcnFilterExpertEnsemble
-p40
-asS'expert_ensembles'
-p41
-(lp42
-g0
-(g40
-g2
-Ntp43
-Rp44
-(dp45
-S'sample_offsets'
-p46
-NsS'cosine_mask'
-p47
-I01
-sS'context_shape'
-p48
-(I8
-I8
-tp49
-sg35
-g37
-sS'response_covariance'
-p50
-I3
-sS'patch_normalisation'
-p51
-g34
-sS'_icf'
-p52
-Nsbasg47
-I01
-sS'shape_models'
-p53
-(lp54
-g0
-(g26
-g2
-Ntp55
-Rp56
-(dp57
-S'similarity_model'
-p58
-g0
-(cmenpofit.modelinstance
-_SimilarityModel
-p59
-g2
-Ntp60
-Rp61
-(dp62
-S'_components'
-p63
-cnumpy.core.multiarray
-_reconstruct
-p64
-(cnumpy
-ndarray
-p65
-(I0
-tp66
-S'b'
-p67
-tp68
-Rp69
-(I1
-(I4
-I34
-tp70
-cnumpy
-dtype
-p71
-(S'f8'
-p72
-I0
-I1
-tp73
-Rp74
-(I3
-S'<'
-p75
-NNNI-1
-I-1
-I0
-tp76
-bI00
-S'hJ#\xf4?\xff\xcc\xbfa4\x1c\x16\x1b\xb0\xd0\xbfu,\xd1B\xbfB\xc4\xbf\t\xfc5^\xd1\x94\xd0\xbf\xa1\xac\xdb\x94\xe8\x1a\xb7\xbfu@a\x98\\\x0c\xd0\xbf\xf3\x01\x17Q\x84\xc4\x98\xbf&\xfcP\xff}*\xce\xbf\x16\xf3\xa8j#\x01\xa3?\x92bT\xfaT\xab\xca\xbf\xf7"\x87hj:\xb7?\x0b\xcc\xf2\x90RS\xc5\xbf\xbc\xc9\x1a\x87p[\xc1?/\xc3]D\x85\xab\xbd\xbf\x12\x08\x86\xf1\x8b\xe6\xc5?\xdf\x0e\xc0v\xec\x9c\xae\xbfO\x9a$.6\x11\xc7?\x88\xcd3*=\xfei?sj\xdde\x99{\xc5?.\xd8\xe5\xe3\xc0\x9e\xb0?\x852\xe9\xf8\x91\xbd\xc0?\xd5O\xdb\xa7\xc2\x90\xbe?*\xf0\xb9`\xbe\xd2\xb5?\x9f\xb1\x17\xd8\xdd\x9e\xc5?\x8b\x8f\x14,\xd7\xcb\x9f?\xa7\xa8CH,\xc1\xca?N|\x8b\x8e2\x1f\xa0\xbfAqXQJ\x12\xce?\xe4\xb0\xe6\x1c\x9f/\xb9\xbfp\x0eSA\xa8\xbc\xcf?\x95\xf9z\x7f\xfeC\xc5\xbfGh3\xb3^?\xd0?\xa0\x02Cm\x17\x01\xce\xbf\xb4q\xf3G\xa0M\xd0?c4\x1c\x16\x1b\xb0\xd0?lJ#\xf4?\xff\xcc\xbf\n\xfc5^\xd1\x94\xd0?v,\xd1B\xbfB\xc4\xbfv@a\x98\\\x0c\xd0?\xa2\xac\xdb\x94\xe8\x1a\xb7\xbf(\xfcP\xff}*\xce?\xf4\x01\x17Q\x84\xc4\x98\xbf\x93bT\xfaT\xab\xca?\x18\xf3\xa8j#\x01\xa3?\r\xcc\xf2\x90RS\xc5?\xf8"\x87hj:\xb7?1\xc3]D\x85\xab\xbd?\xbd\xc9\x1a\x87p[\xc1?\xe1\x0e\xc0v\xec\x9c\xae?\x13\x08\x86\xf1\x8b\xe6\xc5?\x9b\xcd3*=\xfei\xbfP\x9a$.6\x11\xc7?/\xd8\xe5\xe3\xc0\x9e\xb0\xbfwj\xdde\x99{\xc5?\xd8O\xdb\xa7\xc2\x90\xbe\xbf\x862\xe9\xf8\x91\xbd\xc0?\xa2\xb1\x17\xd8\xdd\x9e\xc5\xbf*\xf0\xb9`\xbe\xd2\xb5?\xaa\xa8CH,\xc1\xca\xbf\x8b\x8f\x14,\xd7\xcb\x9f?BqXQJ\x12\xce\xbfO|\x8b\x8e2\x1f\xa0\xbfq\x0eSA\xa8\xbc\xcf\xbf\xe7\xb0\xe6\x1c\x9f/\xb9\xbfHh3\xb3^?\xd0\xbf\x97\xf9z\x7f\xfeC\xc5\xbf\xb5q\xf3G\xa0M\xd0\xbf\xa2\x02Cm\x17\x01\xce\xbf\x14\xaf\xd2Hh\x0b\xcf\xbf\xef&z\x0c\x7f<\xb5\xbc\x14\xaf\xd2Hh\x0b\xcf\xbf*>\xa3\xae\xdf\xf1\xb2\xbc\x13\xaf\xd2Hh\x0b\xcf\xbf\xa1\x8a\x90\xac\xbem\xab\xbc\x12\xaf\xd2Hh\x0b\xcf\xbfiMT\x91\x1c*\x9e\xbc\x12\xaf\xd2Hh\x0b\xcf\xbf^\x9e\xc6\xb2\xccw\x81\xbc\x15\xaf\xd2Hh\x0b\xcf\xbf \x16\xf3\x95\x10\xd8\x8c<\x14\xaf\xd2Hh\x0b\xcf\xbf\xda\xec\x02\xdfu\xa5\x9f<\x16\xaf\xd2Hh\x0b\xcf\xbf\xf3\x84\x07q\xee\x80\xa8<\x1b\xaf\xd2Hh\x0b\xcf\xbfE\x8c5\xbb\xaf*\xad<\x1c\xaf\xd2Hh\x0b\xcf\xbf\'\xa1P\\\x03\xef\xad<\x1f\xaf\xd2Hh\x0b\xcf\xbf\xf6\xbb\xb2\x0c\xb4\x86\xaa<"\xaf\xd2Hh\x0b\xcf\xbf\x7f\x0ec\xffh=\xa5<&\xaf\xd2Hh\x0b\xcf\xbf/\xf7"<\x1c(\x9f<%\xaf\xd2Hh\x0b\xcf\xbf(\x9ar\x93G\xc8\x8b<\'\xaf\xd2Hh\x0b\xcf\xbf\x16\x89\x08\xbe\x8d9|\xbc)\xaf\xd2Hh\x0b\xcf\xbf2\xfeZ%\x00\xf8\x9a\xbc)\xaf\xd2Hh\x0b\xcf\xbf.-T\x8d\xacG\xa7\xbc\xe2\xa5\xf3\xf4\xc6*\xbc<\x12\xaf\xd2Hh\x0b\xcf\xbf\xd5R\x1azA\xcd\xb4<\x12\xaf\xd2Hh\x0b\xcf\xbf\x9a\ti\x19cD\xad<\x10\xaf\xd2Hh\x0b\xcf\xbf\xb1\x9et\x82%\x97\xa0<\x0f\xaf\xd2Hh\x0b\xcf\xbf\xf9L([\xb9\x11\x82<\x11\xaf\xd2Hh\x0b\xcf\xbf\xba\xc4\x0cj\xc1\xf1\x8a\xbc\x11\xaf\xd2Hh\x0b\xcf\xbf\x8c_O\xeb\xe1\xd1\xa1\xbc\x13\xaf\xd2Hh\x0b\xcf\xbf\r@|\xc3\xde\x8e\xaa\xbc\x17\xaf\xd2Hh\x0b\xcf\xbfK\xab6\xfa\\\x95\xaf\xbc\x19\xaf\xd2Hh\x0b\xcf\xbf*\xaa\xa2\xa0\xedF\xb0\xbc\x1b\xaf\xd2Hh\x0b\xcf\xbf\x952\xff_\xbf\x9d\xad\xbc\x1e\xaf\xd2Hh\x0b\xcf\xbfp\\\n\x03yx\xa8\xbc\x1d\xaf\xd2Hh\x0b\xcf\xbf\xf2C\xd3\x0f,k\xa0\xbc \xaf\xd2Hh\x0b\xcf\xbf\xf4\xa6\xde\xf10\xaf\x8f\xbc$\xaf\xd2Hh\x0b\xcf\xbf\x08O\x93\xf5U\xa5\x86<%\xaf\xd2Hh\x0b\xcf\xbf\x0c#\xb3\xfaDo\x9d<(\xaf\xd2Hh\x0b\xcf\xbfR+\xbc\xa7\xcb@\xaa<)\xaf\xd2Hh\x0b\xcf\xbf'
-p77
-tp78
-bsS'_mean'
-p79
-g64
-(g65
-(I0
-tp80
-g67
-tp81
-Rp82
-(I1
-(I34
-tp83
-g74
-I00
-S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
-p84
-tp85
-bsS'template_instance'
-p86
-g0
-(cmenpo.shape.pointcloud
-PointCloud
-p87
-g2
-Ntp88
-Rp89
-(dp90
-S'points'
-p91
-g64
-(g65
-(I0
-tp92
-g67
-tp93
-Rp94
-(I1
-(I17
-I2
-tp95
-g74
-I00
-S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
-p96
-tp97
-bsS'_landmarks'
-p98
-NsbsbsS'similarity_weights'
-p99
-g64
-(g65
-(I0
-tp100
-g67
-tp101
-Rp102
-(I1
-(I4
-tp103
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p104
-tp105
-bsS'_weights'
-p106
-g64
-(g65
-(I0
-tp107
-g67
-tp108
-Rp109
-(I1
-(I30
-tp110
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p111
-tp112
-bsS'_target'
-p113
-g0
-(g87
-g2
-Ntp114
-Rp115
-(dp116
-g91
-g64
-(g65
-(I0
-tp117
-g67
-tp118
-Rp119
-(I1
-(I17
-I2
-tp120
-g74
-I00
-S'I\x94!\x9e\xa9\xc4P\xc0\xc77\xa4W\xe2LS\xc0\xa7\xbb\xd0S\xb5nG\xc0\xfc;\xcd\nS-S\xc0\x8c)\x83)\xdc\xb8:\xc0\xb0_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0w\xf2\xc5\xcc\xb4qQ\xc0\x88p\x95\xd0\xc0\xfa%@\xae\xa9c|\x1e\xd8N\xc0Q\x98!\xa8L\xdd:@\xcd\rTB\xf4\xa9H\xc0ou\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb1\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0&E\x0c\'\xa5\xadJ@\x84a9\xdd\xed\x0f\xee?d\x81#4\x89\xd8H@<\xe4\xb2\xbd\xd083@\x7f\xbe\x81\xd2t\\C@\xb3\x1f\x00\\\xd8\xacA@\xe2\xca\x07\x8dR=9@\xe6?\xe0\x02S\x01I@j\xe0\xe7!\x0cc"@\x9f\xcbE\x15a\xf1N@\xf7\xb3\xf0\x85J\xa5"\xc0R\'\xf6\x01\xb6cQ@i_g~\xf7 =\xc0I\xf8<oDZR@\x04Ol\xe59\x98H\xc0\x11\xd0\x13\xff\x7f\xcaR@\xf1\xef\xa4\xef\xc3YQ\xc0\x86\xe0\x05\xe7\xfc\xdaR@'
-p121
-tp122
-bsg98
-NsbsS'global_transform'
-p123
-g0
-(cmenpofit.transform.homogeneous
-DifferentiableAlignmentSimilarity
-p124
-g2
-Ntp125
-Rp126
-(dp127
-S'_h_matrix'
-p128
-g64
-(g65
-(I0
-tp129
-g67
-tp130
-Rp131
-(I1
-(I3
-I3
-tp132
-g74
-I00
-S'\xff\xff\xff\xff\xff\xff\xef?^\xf0\xcd\x1dB\x8fd<\x00\x00\x00\x00\x00\x00\xd09 \xb2\x1d\xb53\x9e_\xbc\xff\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\xf0\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
-p133
-tp134
-bsg113
-g0
-(g87
-g2
-Ntp135
-Rp136
-(dp137
-g91
-g64
-(g65
-(I0
-tp138
-g67
-tp139
-Rp140
-(I1
-(I17
-I2
-tp141
-g74
-I00
-S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
-p142
-tp143
-bsg98
-NsbsS'allow_mirror'
-p144
-I00
-sS'_source'
-p145
-g136
-sbsS'model'
-p146
-g0
-(cmenpo.model.pca
-PCAModel
-p147
-g2
-Ntp148
-Rp149
-(dp150
-S'centred'
-p151
-I01
-sg86
-g0
-(g87
-g2
-Ntp152
-Rp153
-(dp154
-g91
-g64
-(g65
-(I0
-tp155
-g67
-tp156
-Rp157
-(I1
-(I17
-I2
-tp158
-g74
-I00
-S'\xd1\xe5\xf7\xba\x17\xb4L\xc0\xb0$3\x9e\x1d\xaeS\xc0\xfb)8>|\xa4C\xc0\xadu^\x0e\xd3\x10S\xc0\x96xK\x8c\xa4\xaa5\xc0\xc3\x07.\xa0KBR\xc0\xf4U\xed\x86\xb17\x14\xc01\xc7+\r\xc6pQ\xc0\xd7\xf5\xbc\xd9\xd6\x0e(@\x87\xd6\xd6<N\xe0P\xc0@5fx\x8d\xa99@\xb1\x8d\xde\x81\x91@N\xc0{\x07\xa1\xbe\x9c\xd5B@CC\xae\x04\xbaGI\xc0OZ\xb8\xaa#\xfeD@\x97\xfa\xea(j\xb2=\xc0m?t\x14\xf0KC@\x84\x7f\x05\x12\xd9\xa8\x0b\xc0@\x9f@\xfd7\x83C@\x8e\xf7\x1a\x1a\xdc%;@\xd8\xc6q\xd6i!A@`\x0f\xed\x92P\x92G@\xaejU\xe8\x8f\x016@)\x07Y :~O@m\xeeb&\xfd\xe2 @\x8b_._\xb1\xcdQ@\xaaV\xb0\xec@\xff#\xc0\xdd\\W\xd6\xde\xbfR@\xd0\xfa\xa6\xfa\xe3k:\xc0\x80\xa1H\xd5\xf8\xefR@\xdbM\xb9U2\x1bE\xc0\xd5\xee\x1f\x05\xd3\xddR@=xy\x03\x85\xd0L\xc0\xf6|\xbb<?\xb3R@'
-p159
-tp160
-bsg98
-NsbsS'_eigenvalues'
-p161
-g64
-(g65
-(I0
-tp162
-g67
-tp163
-Rp164
-(I1
-(I30
-tp165
-g74
-I00
-S"6\xf1\xa2i\xa9gy@\x9e3\xdc\x84\xdb\xb5i@\x9bi\x02\xdd9\xabR@4~K\x88'AC@}\xce\xcfWb\xd9:@\xb4\xfcv\x12H\xfe0@\xd1\xab\xfd\xfa\xc5\xa4-@\x9f\x12\x85\xd1\x9b\x91&@\x9fa\xe4\x07\x8c\x8f\x1d@\xff\xa3\x99\xda\x9a)\x15@\x99\x80\x80}\x03\x94\x11@\xd9F\xde\xb1\x1f\xca\x08@^cZw)\xaa\x04@\xdd\xeb4+\xe26\xfe?n\xb0\xe2\xc7_=\xfc?\xec\xa6\xe9\nO\xef\xf5?0\xc8\xf3G<\xda\xf3?\r$\x9e\x01\xccJ\xf2?\x01\x94\xc26\xd4\x91\xf0?q/S\xab:s\xee?\x82\x95^\xed\x0c\x97\xeb?\xb0l\xa1DL@\xea?\x18\xdf!Cgc\xe8?\x9a\xaeT\xac\x8b\xd8\xe6?c\xbe\x97QS\xff\xe5?\xd9\xb7\x18\xba\xe7:\xe4?\xed\x7flo\t-\xe2?`\x18\xe4\xd1\x173\xe0?D\xdft\x02\xb1\xcd\xdd?\x13\xa1\xa7\xf09$\xd7?"
-p166
-tp167
-bsS'_trimmed_eigenvalues'
-p168
-g64
-(g65
-(I0
-tp169
-g67
-tp170
-Rp171
-(I1
-(I1
-tp172
-g74
-I00
-S'\x93Ex\xe8/e\xd3?'
-p173
-tp174
-bsg63
-g64
-(g65
-(I0
-tp175
-g67
-tp176
-Rp177
-(I1
-(I30
-I34
-tp178
-g74
-I00
-S'\xb8\x86\xd5\xb9\x9c$\xd6\xbfZw\x81\x02\xe6e\xb5\xbf\xda\x05\xcb\xf8\xe3\xe9\xce\xbfWT\x91\x1f@\xa4\xbb\xbf\x12\x14\x83t\xd6\n\xc1\xbf\xcb\x01\xbb\x95\xc8\xe6\xc2\xbf\x84\xa6\\\x9a\xe2\x12\xa1\xbfH\x18D\xfcdD\xc7\xbf\x16\xc7U\x1c\xa4B\xa1?\xf9\x18\xb9\x05\x18\xe4\xc0\xbf)d\xabv<?\xb0?\xe5^\xf2\xe9\x03\xb3\x80\xbf=<\xfa\xce5\xd8\xae?\xbf\xd5@\xdcI\xac\xc3?\x10\xdfK\xce\x08\xcd\x9a?\x17\xa7@\n\xa4\xe9\xd3?\xffm\x96\x19&-\x85?\xe7\x9f0\xe8\xaf\xc5\xd7?\x99e\xc5\xc0\xf5\xaf\x81\xbf\xd4\x81\x90:q/\xd4?\xd8\xf2\xad\xb6\x9d\x02\xac\xbf\x16Ct\t\x8e\xa5\xc5?%843V\xd2\xb2\xbfeWr\x9f\x99\xbb\x90?\xcd_g$\xd3\x8a\xab\xbfF\xd5\xf6\x88VB\xbd\xbf\x90\xd0e\xa4z\xd6\x90?\xe5\x96\x07\xf0\xe4\x16\xc7\xbfV2\'[\xa8\r\xc0?\xdfo{\x84\x7f\x86\xc4\xbfJ$\xb1n\x0fO\xcf?c+\xdc\xcd`\xff\xbe\xbf\xda8\x05\xf2\xf1O\xd7?\xf5^\xb3\xd8\x18\x92\xb9\xbfU\xbc\xc7\xf0`{\xd0?,\x948\xf0\x88`\xc5\xbf/\x01\xbc\xe0\x84\xfc\xca?\xa8\x07X_\x81\x9b\xc2\xbf\x8d\xd7(\xcf\xe6\r\xc3? \xa4\xa4\x17\x9a4\xc3\xbf\xfaB\xb2\xd5\r9\xb8?\xc72\xd1\x18]\xd2\xc4\xbf\x0b\x96^\xbd9u\x9f?|\xae\x12x\x91*\xc6\xbf\xabx\xdd\xc8\xc5#\xaf\xbfy\x17\x9e\xce}\xe3\xc2\xbf\xc4\x93[t\xf6t\xc8\xbf\xd3\x1b:I\xde\xe6\xb2\xbf\x17\xdc\xd2\xde\x9b\xcd\xd3\xbfPw~\x85x\xde\x90\xbf<e6Pd?\xd6\xbf\x0e\x1f\x95,C\x92z?=\xf0U\xc4\xf4\xde\xd4\xbf\xcd\xbe\x9b\x83*\xa7\x9d?\xfcI\rK\xa7\x94\xca\xbf%\x1d\xfe\r\xb5!\xb4?\x1d\x0bx\xd7_\x7f\xb0\xbf\xa1Gw\x01\xed\xc8\xc1?\xbfw\xde/\x8a\x92\xa6?\xd3\x1e\x01*\xbdq\xc4?VH\xb5\xc2d\xf1\xbb?\xba,\xba\x87\xc3\xa7\xc3?g7\x8b)\x88\x88\xc4?}678\x11\xe3\xc2?\x83\x81i\xe7\xean\xca?\xfa2\xa0=\x11\x98\xc3?\xf1c\xdaQ\x05I\xcf?~\xe9"\xe2l\xa8\xc5?>\x98C\xe3\xf7\xe7\xc8?\x81;8\x89\xe2C\xcd?\xe4Pm@\xac\x91\xad?\xe9J;\xa4\t\x9e\xc8?\x92\xc1\x1e\x8c\x08\xeb\xb1\xbf\x93\xfe^83[\xbe?^\xf5\x13\xc0\xf5\xa1\xc1\xbfK\xb7o(\xaf\xf3\x88\xbf\xfd{\xc4\xcf\x10c\xc0\xbfg\x07}t\xe3\xed\xc8\xbf\xd8;N\xe3\x18R\xb2\xbf\x87Q\xe6\xdc\xc37\xd5\xbf\x10C2#\x00\x16P\xbf\x9b\x03n\xfd#\xb0\xd5\xbf\xa9\xfaM\xc9\x84\xe3\xb2?\xfd\x0f\xa3\x8c>\x15\xcb\xbf>@]\n\x9b#\xbd?X\xe1\n\xc0U\xc4r\xbf\x17!\xb0\x9d\xc7Q\xbb?\xb7g\x18Jc\x87\xca?P\x05\xab\x94\xd3\xc4\xab?1rV\x81\x9e%\xd5?\r\x82\xb8\xb3\x14\xd0\x9f\xbfr\x8d,\xed\x1d\x95\xd4?R@4\xe0\xd7\xe5\xbc\xbfA\xbe\xb2,\xf0\xe6\xc9?9\xc8q\xb72\xd5\xc2\xbf\x89\xd4\xaf\x8e\x13T\x96?\xd2\xa2\xe9BoR\xb7\xbf\xd4\x1b\x19\x8e\xd1\x0c\xbc\xbf\x04\xf6Z\xa7\x03\xbd\x99?.bx\xd2\xf6\xa8\xc7\xbf\x16d*!p\r\xc5?N!u\x9f%\x16\xce\xbf\x0eq\x8a\xbd\x8aI\xc9\xbf\x80\xa9\x92Z\x91{\xd0?H\xb0\xd8\x7f\xe9D\xb9\xbfQ({\n)P\xc2?^\xde\xea\xba6\x14\xb1?!\xbf\xf4\x19\xa0?\xaa?\xc7\xc9\xc5F\xa5G\xca?u1\x91\xf7\xa6\xfd\x92\xbf\x88\xf2\x91*\xce\x17\xd2?)\\s8\x95g\xa4\xbf\xea\xd3\xa3 V\xe2\xd3?\xb3\x83\x94\xe6\xf2 \xb0\xbf\x15\xef\x95\x85\xa5\xe2\xd1?\xa6:+y\xc7\xa3\xbd\xbf\xa0\x94b\xda\xd8\x0b\xbf?\x91O\xc3T\xf3u\xc3\xbf\x94\x0ee0pGd\xbf:u\xce^:\xb5\xc4\xbf\x90\xa3\xf0\xc7Qh\xbf\xbfFEv\xad\xf1\x13\xc2\xbf\xb7q\x8en\xae\xde\xd0\xbfY\x05\xf3\x92%l\xbc\xbf\xc8\x80q\xf2\xee\n\xd4\xbf5\x9e`\xd2G\x82\xa7\xbf\xb8\xd3\x11R]\xc1\xd2\xbfJ\x82\x17\xc6\xc7\xf4\x88\xbf>\x99\x94z\xc0\x95\xcb\xbfr<\xa44\x89]\x8c?\x89\xb3.\x9e"\xbf\xb3\xbf\xe6\xae\xd3\x81f\xe0\xb1?3J\xffzr\x08\xb6?\xa9\x9f\x82\xbd^!\xc0?:\x9b|a\x13\xa7\xcd?\xcc\xa2\x95\xa0i\x92\xc9?\x05\xe4o\x8b\x0b\xf2\xd5?\x0f\xf5\xee0\x12\x7f\xa3\xbfO\x1f\x85Z`\xf3\xc3?\xef\xe95C\xaa\x90\xb5\xbf\xa5e\xabDd:\x9d\xbfLr1=\x9f\xc6\xc1\xbf\xbe\xe3]\xf0|\x8c\xc7\xbf\xb3\x15\xfe\x02\xdeP\xbb\xbfw\x8b\xc4\t\x97\xc8\xd1\xbf\xec5OmU\x8c\x88\xbf\xfe\xfd\xeb\x11D \xd0\xbf\xe3\x04\xceD\x1cq\xb6?"\x83\xb0E\xaf#\xb6\xbf2\xa9r\xc8\xec\x03\xc0?,#\x02\xe3\x93S\xcb?\x12\x16\x8a\x97\x9eD\xba?j\xfb\xcdd\xcf\xfb\xd4?\x05\xad<K\x93b\xa8?|3t\xf3\xc4\xbb\xcd?\xddp\xaf7\x88U\xa8\xbf3\xc1\xe3sLb\xb0\xbf:8\xbe\xa3\xab\xb1\xc3\xbf\x0c\x88\xce#\xfd\x95\xce\xbf!\xf5q\xce\x84\xa5\xc7\xbf\x9b\xa8\x94G\x12\xa6\xd1\xbfH\x9b\xc5\x0c\x85\x9c\xb8\xbf\xd7\x10:\xd2\'&\xc7\xbfd\x1e\xe6y\xff\xab\xa9?\x86\x17\xb0\xee\x8f\xb3\xab\xbf?\xac\x99\xabz\xa4\xc4?\xa4\xab\x99\x83\x13\xa2\xbb?\x02g\xc2X$\xf5\xc3?l5\\\x1d\x19\xc7\xd0?:}\x97]\xb4\xde\xc0?\xb3\x05\xb0k\xb6\xa8\xc1?\xb6e\x07\xcf1\xce\xe0?\xaf\xfe\x9e[\xd5\r\x9f?\x91\x96y\xa5\x10\x8e\xcd?x\xbbq\x87\x85\xc5\x8b?#\xca\xcd\x10\xccW\xbb\xbf\xd05*Z\x1e\x12\xac?V\xbd \x16\x1f\xe4\xd6\xbf\xb8\xf7c \x04\x81\xab?\xae\x10\x9e]\xfc?\xd7\xbf\x90q\xc4\x02\xddA\x9e?%\x0f\xc4v\x19V\xc9\xbf\xa1\xben\xb2\x81\xb3\x9e\xbf\xaed}J\x17\xec\xb3?\x91\xc7\x05O\xeep\xb0\xbf\x13\xc5\xbaY/\xa0\xd1?\xc7\x0c\xeey\x1d\xf4\xb0\xbf6\x05\x7f\xb2\x9d\xa9\xca?\xf8\x87\xb7\xeb\xa1\xcd\x90\xbf\x93\xacH\xf2/5\x93?\x07\\\xd4\xd9L!\xae?D"\x8fB\xe7\x8d\xc4\xbf\x91Q\x95\x01=\xa4\xb9?\x05&\x94,XH\xca\xbfL\xf0*>\xb4\xad\xb7?\xd5y\x9e\xb9\xb1\x03\xbe\xbf-4n\xf5\x00\x0f\xa5?[\x1a\xaa\x95\xed\xec\x9b?\xb2+X\xa8\xc5\x17\xb0\xbf\x92\rWI\x1f\xc1\xbc?r\xfc\x142\xec>\xc5\xbf\x11\x10\xa5\xa8\x8fc\xb0?\x83\x1a\xc8c`{\xca\xbf\x11\x0b^!c\xd9\x9f\xbf\xf2\xadv\xcbh\xd0\xa5?/\xdc\xc5\xb7r\xdb\xc4\xbfl{\x00\x1b1\xf8\xc0?\xbcv\\7v\xc0\xb0?\xa1(S1\xdf\xd3\xb6?\x05\xeb\x90e\x8fS\xcd?\xd2\xdc\x81\xeb\xf5D\x97?\x0c\xde\xc8\xee6\xc9\xc4?\xb3\xd8\xa1\xae\x86 \x93\xbf\xc5 \x18\x86\\<\xad\xbf\x1d\x9en\xc8D\xda\x9b\xbf\xef\xe5\tyq\xa5\xce\xbfNO\xd8\x0f\x99\x12\x96\xbf\xec\x18q\x1e\xf7w\xcc\xbf\x93\x8b@\x18W\xd2\x9b\xbf[\x12\x96\xb4\xf2q\x88\xbf\x81\xe8bHE\x1b\x98\xbfQ\xbbL\n\x00\xe8\xc8?3\x84\x18\'=F\x92?\xf7\xd9.S\xea\t\xcc?\xc2\x8a:#\x1f\x02\xb4?\xeb3\xd5\xc4\xb2\x0c\xb8?4}\x9c\xba\xf9\x83\xa6?\x8e\xe0N\xaf\xadw\xbd\xbf`%\x84\xaa\xfa\xb1\xa8\xbfi\x00\xe4\x06ff\xd4\xbfY\x98`\xef[\xb8\xb2\xbfk\xed\xc43T\xf7\xd8\xbfV\x1e=\xce\xfc\xcd\x9c\xbf]\xa9rq\xfc\xb0\xc6\xbf\xf6ZO\xaell\x9f\xbf\xf8\xc9v\xcf\x02\x82\xc9?\x15\x00KZUz\xc0\xbf\xff\xce\xc5V\x04\x00\xe1?c\xe3a\x8e@y\xcc?\x9d\x96`\x18\'J\xb2\xbf\t$U\xaag\xe6Y\xbf\x07\xd7\xab\xb7\x0fA\x8c\xbf\xce\xe3\xfe*\xbf\xd5\xcc\xbf\xea\x06[\xdcA\xe8\xb2?\xbaP\xee\xa7\xa0\xe3\xd3\xbf\xf9\xc4\xaal\x84\x94\xbf?\x18\xca\xc7\xe2\xa3\x96\xc3\xbf\xa0\xa3z9%\x9c\x91\xbfh\xd9\x8e\x02\xf4\xc6\xc1?W\xfd\xe2\x9d\x9e\xc5\xbd\xbf\x9a6\x1b)\xd0[\xd9?-\x93\xbe\xe4\x0c\x91\xb7\xbfU\rK\x9aKh\xd4?\xdd>\xa3\x89\xaf\x0b\xb6?\xc0jd\x14\x06\xabi?\xdf^\xd6Rc\x1b\xbb?4\x95\xcb\x0b{]\xd3\xbf\xef%\xc8\x1c&a\x9d?\xe1\xe1\x8a-\xb7\x18\xd6\xbf\xcf\xb4\xd1\x16\x95*\xac\xbfX\x02?B\xf3\xaf\xc3\xbf\tDat\x19\x8f\xaa\xbf\xd1\xab(l{.\xc2?\x83\xeaZ\xc35:z\xbfOp\xdf\x921 \xd2?\xc3\xe4\xeedm\xb7\xa4?\xc0.y\xe5\xa7E\xca?Bq\xba\xcb\x87\xbb\x96?>\xc0\x01N\x16\'9\xbf\x180q\x80\xd9^\x8c\xbf\x81\xa6d:B\xd3\xcb\xbf\x89\xcb\xc7?\xcf\xd4\xa5\xbf\xd4\xdfaI\xe0y\xce\xbf\xc5B\xb8\xfb\xea\xa4\xb8?\x8f\xdaq\x9f\x83^\xa0?C\xa0\xeaE]\x00\xa3?\xdf1\xbe\x94^\xd9\xcf?\x8co\x01-\xa1s\x9e\xbf]o\x159\xf9\x7f\xd0?\x1c9\xe6Cal\xa4\xbf&\xf9\x0b\x08z\x9e\x95?\xbf\xec\xf0 7\xf2\xa4? \x94\xba\x9b\x8b\x18\xce\xbfd8\xe8\x99\xa1)\x8f?\x92T\xe6\x00\x99\xfa\xd1\xbf\xe8\x8dQ#o\xfb\xc1\xbf\xc0<\xa3\x02q\xfe\xb3?\x98\xdd\xe9w\xf6\x80\xc9\xbf\x84\x1c\r4\x05\xa9\xd1?\x9eA\x04\x9b}J\xa4?/\xee\xb3+\x00\xb8\xb8?\xd6*\xf4\xe7\x05_\xce? \x83\x8d\x0f\x1f\xbe\xd1\xbfHm[\x17\xee\xbf\xb6?\xf5v\xfc~\x858\xd3\xbf\xc6\x86\x10\xfe8\xcb\xb7\xbf\xed\x9cK\x89S\xf6^\xbf\x98\xbe\x00\x94\\\x1a\xb6\xbf\xc1\xf8\x94\xa9C\x95\xd2?\xdf\x91\nS\xa8\x98\xac?Y\x82\xe4B-\x92\xd1?\xea\'#\x99\x96\xe6\xb9?\x90\x81\x9b\xf7\xb5\x97\xa0?spq\xa6\xf3\xa3E\xbf\x80\x81k\xed\xff\x89\xd1\xbfA\xed\xc8<\xcb|\xbf\xbfQ\x8f\xf3\x92K#\xce\xbf\x8f\x85\x8f\xc6V\xf7\xd3\xbfJ\x91]|i\xcf\xad?\xe1\xa9(\xd2\xaf\xe0\xb9?pa$\xf6\xc6G\xc4?\x02\x1a\xcbS\xbc\xb6\xd8?\xf7\x82\x91]\x0f\x02\xb0?\xb0\x9c\xefC\xad\xf0\xcc?\xe1\x91\x812\xad8\x89?F\xb9F\x02\xca[\xc8\xbf\x01\xf2F\x9f\xbc\'\xb0\xbff\xd9\xba\x00\x07\xd9\xd5\xbf\xae\xa1z\x12"3\xc0\xbf\xe6,gn\xbf|\xae\xbfz\x871\xcam\xeb\xa7?\xbc\xbc\xd9\xeehZ\xd2?}\xd5\x9eO\x17u\xb1?\xec\n\xa7\xa5\xe8\xc0\xc8?\xde\x86\xb1iu\x04\xac?\xc8\xb6\xed\x89\xad\x89\xc5\xbf\x9fl\xf0\xdcd\x06\xa6\xbf\xcb{P\'o\t\xd4\xbf\xb8&W\x15\x8e5\x88\xbfoL\x1c\x82C6\xb9\xbfoJ\x150\xd1#\xa8?\xa1\x8e\xbeX\x96\x90\xc7?\x90\x84~\rS2\xac\xbf5\xf0\xa2\n}y\xcf?>\x8b\x8c91~\xb7\xbf\xb7K\xb6\x1a\xe9+\xb7?\x1d\xc3\xa5\xf3\xc6\xd4Q\xbfla\x9f\x01\x87@\xb3\xbf \x91l\xc7\xd0\x9d\xbe?\x13\x87\xcf\xc1\x99\xf0\xc3\xbf\xb4Z\xfd\x94"\x0f\xa2?\xdaI9\xbd\x1b\x19]\xbfb)4\xc8\x9f)\xae\xbf=\xcd\\\x03\xdf\xc3\xc0\xbfv-V\x10\t\xb8\xa1\xbf\xa7\x84\x90=\xef\xa0\xaa\xbf\x9e\x9b$\xa5k\xc2\x81\xbf$\x8fG\x91\x90\xd2\xc6?C\x8b6\xad{i\x92?\x98"TIM\xa9\xca?\xd6-\xe2K\xdb\xbe\xb3?\x17\xc3\x8c&\x19\xe1\xa2\xbfM\xcb\x0e\xe0/x\xb9?\xe9";,\x9c\x8a\xd1\xbf\xbe\x9a\xeak8\xd9\xb9\xbf%Gl\x0e\x14\x7f\xc5\xbf\xd9\x93{N\x19i\xc2\xbf\x859\\\x8d,[\xc4?t\xb7\x10Y\xe6d\xaf\xbfY]\xbbB\xcb\x0e\xd3?X@a\x8fta\xc5?\xff\x80\xfc\xc6\x9a\xe6\x83?1\xc4GH+\x1f\xb8?\x8b\xee\xe1Q\xc5\xf7\xd4\xbfCUq\x8b*x\x9d\xbf\xfd\xa8\xc4\xce\xff\xb2\xd1\xbfQ\x1f\x0bL-\xcc\xaa\xbf\xab\xc69\x9fG`\xc4?\x1aT\xdb\x0f\xc8\xcb\xbb\xbf\x08\xa9Y\xca\xd4\xe9\xdb?\x03\x89\xb1\x86\x01\xd4\xb5\xbf\xb3\xf3\x98c\xbas\xc3?x\x88}\x96\xed\x97\xc8?I\x16\xab\x1a&I\xd5\xbf8\xf3\xf3s\x00?\xc6\xbfy\xe1+\xfc\x01D\xc4?\x97\x95N\xc8\xfe\x97\xba?\xad[\xd9\x04\x043\xac\xbf\x07"\x7fi;\xa3\xcf?\xbdl<\xe5\xdee\xc9\xbf\x1c`c\'\xb1w\xac?\x80`\xf5>\xbb\xfb\xa9\xbf\x11c\xc5G\xd6S\xc7\xbf>\x12\xfa\x83Fy\xc4?{g\x91\xa2\xb3F\xcf\xbf\xa4\xdc;\xa3zk\xb5?\xdb\x9eS\xa2\xb6F\xb3?\x8c&\x9f\xce\x12]\xc0\xbf_=\xf0\xcf)\xf5\xd1?+QH\xfdPp\xb6\xbf\xe6t\xdb*\xa8 \xa4?\xaf\x0b\x18b\x12\xf8\xc0?\x1f\xd1\xdbzr\xb2\xd1\xbf\xc9\xa6\xe5#m\xe2\xb6?\xe5/\x95\x10\xb0\xcf\xc7\xbfm\xc7\xdck\x949\xbc\xbf\x1b\x1a\xa6\xf9\xf5\x85\xce?\xc8\xb2\x10\x8a\xf5\x10\xa6\xbf\xb8\xcbv"+.\xd4?*w\xe7\x04*\xbe\xc0?\x80S\x89\x9e"\x7f\x9f\xbf\xe4\xc0Sl\xeb\x87\x93?g\xe6\x8bp\x0c\x0f\xd7\xbf\x0b\x07\x9a\xa1\xfep\xc7\xbf\xa9\xec\xea/N \xc1\xbf\xe1\xa6\x1a\x8b\xe0K\xb2\xbf\x08V\x97w\x1e\xb7\xcd?m\xa5\xccJJ\xb3\xc3?\x83\x05\xc6K0\xc1\xcc\xbfm/\x11\xa9\x01\x05\xc8?CKg\xc80\x1f\xc1?pk\x0f\x1b\xa8\xb0\xc1\xbf\x98A\x7f(\xf7\xa4\xd5?\xe1I2\x06#\xd2\xc7\xbfc\x99\xf4\xf5#\xfd{?\xc8m"\x7f\x0f\xf0\xbb?>\xae\xffYY1\xd4\xbf\x87\x94\x92\'\xb0F\xc2?aeg\x83\xa9K\xc4\xbf\x90\x9d\x15\r\xb9\x14\xc6\xbf\xe9\xd3#x\x96\xac\xd1?S\xb0\xab:\xa3\xea\xbb\xbf\x89\x94+\t\x1a\xb5\xac?|9V\xdd\x8c\xd7\xd1?\xbcK5\x0e5\x1f\xc9\xbf\xfe\x13I\x9c\xf9\xcb\x9b\xbfI\xa2\xd0\x1bcm\xa1\xbf\xcf\x1d\x98\xd4\xb6\x0c\xcf\xbf\x83zh\xd7\r\x0e\xcf?BS\x9e\xfckr\xb3?\x1ff\nq\xb5,\x9c\xbf\x98t\xc9\xe5\xd7\x17\xc5?\x8cSThu\xcf\xcd\xbfq\xae\xf8\xd3)\x9b\xa1\xbf\x12\r\xdc\x98M\x8f\xb1\xbf>\xbb\x9a\x1a_Y\xb7\xbf\xa9\xf0\xfd\xd8\x99`\xcc?l\xfd\x9d5L\x99\xb2?\xd7\xcdK\x12\xc7(\xc1?"\xd2\x91y\x03S\xb3?\xb0V 3\x1d`\xc3\xbfj\xfe\xef`\x06\'\xbb\xbf\xd81\\\xc5)\x9c\xcc\xbf\xd4\x15h\x88y\xde\xc0\xbf\x18%(X\x8e\x1c\xd0?]c\xd4\xcc\xcdN\xc3?\xfc!\x0e\xc1\x17\xf1\xca?\xeb\xc5|\x1a\x9c\x1d\xc8?\x98\x9e"\x19e\xd6\xc3\xbf\xeaGv\xbc7\x96\xba\xbf*\x17-1\x84v\xca\xbf@\x10\xc4Ur\x12\xd2\xbf5\x9a\xb1\xfa\x00\xe4\x93?\xed\xe6\xaa\xa4\xf9k\xa8?p\x1f\xcd\xcb\xf5\xa2\xc9?\x06\xe5w\xf7\'\x7f\xd6?\xa7\xd8V\xc3u\xec\x99\xbf\n\xc9\xc4?\xa3H\xb8\xbf\x97\x95\'\x080\xd2\xa7\xbfF\x1fL\xb45\xdb\xd3\xbf\x10*\xbb\x8c\n\x93\x80?5\xac6wP9\xac?\x13-\x85\xfc\x00p\xa5\xbf\x00\x1cV\xb7a\xc9\xd0?\x86\xca\xacl\xc2\xf4\xb6\xbf\xce\xd9oE\xa4\xa4\x96?\rx~\x11\xd7\x00\xc3?\xda\xce\xcfW\xbd\xb5\xd0\xbf\xdf\x1aK\xa2\xc5\x14\xc2?\xcb\xc9\'\x8a~\x93\xaf\xbf\xc20\x02\xe4\xa9H\xc6\xbf/\xb7\xe1\xf9\x8a\xfb\xc7?\x8d\x85\xd3\xc1\xf9a\xc6\xbf\xbf\x0f\x07\xc8\xc5\xae\xb5?v\nW,\xbb3\xc4?\xf0yR\x8b\x81\xa9\xba\xbf\xb9!3}\xd2\x00\xb9\xbf\xf24\xe2\x93\xbf\xdc\xbd\xbf\x899\x83\xf6J\x15\xbf?6\xd3&\xa6\x92\x9d\xc4?{,%\x9au\r\xb0?\xec=\x86\t\xdcv\xc2?\x14k\xae\x1b\xfe\xf4\xa8\xbf$*\xddBbz\xc8\xbfr\x0e\xa0\xae\xd3\xef\xbb\xbf\xfd-{C"\xa2\xc5\xbfPr\t\x90\xfde\xa3\xbf\xb8\xa9zQ\x1c\xfc\xca?\x99+\xaf\x91\x19v\xc0?\xac1\xd7\xfb\xa6\x9a\xba?+\xf0O\xf7}b\xb8?\xfa\x84C\xdb\x02\x99\xd0\xbf\xad\xb3i\x9d\x85\xae\xb8\xbf\xf8\xd1vZK\x97\x98?LTNh2M\xc5\xbf\xf3V\xfc\xaaG\x8b\xce?\x99q2`,}\xb6?KR\xb1\x0c\x82}\xb6\xbf\xfd\xde\x93E{\x88\xd1?8\xb4\xd4\xf2E+\xd0\xbf\x957w^\xf4\xba\xc9\xbf\x05\xb5;VH\x86\xc0?4\xad/\xff\xfe\'\xd6\xbfW\xd2N\xdfp\xdc\xca?v\xd6>\x01\xb9b\xd1?OX\xaf&U\xf6\xaa\xbf\xa3\x14!\xfc\xbb\xd7\xd1?\xa9X\tW>\x1c\xbb\xbf\x1f\xd4\xfa\xf6\xb5\xbe\xcb\xbf\x96D\xa0\xd1)\xf2\x8b?\x1c\xb7\x1f\xef\xdd0\xa1\xbf\x10F\xe8\x0e\xa6\x8b\xb6\xbfV\'\xc48\x9b\xe8\xb6?\xf0\x80\x94\xc6\xe1\x8e\xc5?V>,\xc0>_H\xbf\xf3\xe1j\xb2\x81\xc4\x94\xbf\xd1|\x05^<|\x93\xbf\xb4\xe2\xeba\xeb\x9e\xc6\xbf\xd2b6\xd0\x15P\xb4\xbf\xb5\xfaiba\xce\xb2?\x1b\xd9\xea\xaa\xe5\x05\xa1\xbfD9#\xf7#\x1b\xc5?\\}q\xd0}\x96\xcf?\x8e\x0b\xb8\xec~\xb7\xc7\xbf^\x82%\xb0\xaa\xc2\xc3\xbf\xe4\x0e\xa1\x05\'>\xb1\xbf\x83\x96\xfe\x0c{\xd7\xcf\xbf\xb3\xe4YW*\x9e\xc6?\x13\xff\xf0j\xcda\xcc?\x84\xdd~\x83EF\xab?T\x82f\xe0\x05\xcd\xd3?\xd9en\xe2\xe4*\xc4\xbfI\x9dBll\xfc\xda\xbf\x19\xf1B\xc8|\xc5\xae\xbf\x1d\xd1r\xb4\xc9\x04\xae\xbf\x1a\x9a\xdd\xc4\xad$\xba?\xf4w?\xea\x83\xf9\xd4?\xd7 \xb3]\x91\xfe\xc9?O\xda\xdf\xae\x1b\xa2\xb9\xbf\xa6H\xb1n+t\xc0\xbf\x8au\x1f\xd5\x15\xa2\xb9\xbf\xa5\xb8\xcb\xbc\xa8\xc0\xd0\xbf7qO\xc3\xff\xe8\xab?w\x8f\xb5\xa4\xc7\x13\xca?\xd4\x9e;B\x9d\x10\xc6\xbf\x93\x1d\xdc5\x0b\xb8\xc7?\r\xaf\xa4*%\xa5\xd2?m\x89Z\x97H\x1b\xc6\xbf\xf8\xb1Yu\xe5p\xc3?K\x1d\xd1\x94 \xa0\xc4\xbfW\x19\x08Q\rL\xdb\xbft\xf4w\'v`\xc5?\xc9!\xa6\n\xcbt\xa0\xbf\x85`\x9b>\xc6B\x9c?\xb5\xb68e\xf8\xaa\xd8?6\x05\x15\n\x9d\x92\xb4\xbf\xed\xf1i$\x8e\t\xaa\xbf=w\xc4\xd9\x8d\xef\xb7?\xda\x86\xd0\xd3\xcd\xbd\xd5\xbfQ8\xf0\x9d\xb8_\xc4\xbf\xb3\xcc\xe5\xde\xf3_\xc1?\x10\xd0\xba\x80\xf8\xfa\xbd?P\xf1\x0b\xbe\xf9I\xc8?\xc24\xe3\x16\x10\xb0\xc3?\r\xdc\x94\xcd\x0f\xa3\xbd\xbfa\xbaV\x1e\x876\xd1\xbfh)\x9b\xbf8E\xb2\xbf\x99\xc7\xc4\xa3\x9dt\xa7?#\xc1MM\x86\x8f\xc0?x\xef\x0b\xc2\x9c\xfc\xc0?\xb2\x1e\xf0y\x8d\x0e\xbb\xbf\xa2\x9a\xc36\x9a\x8b\xa5\xbfe[I\x9f%\xa7\x8a?\x06\xfa\xf9zY\xfc\xb2\xbfc\xb0OpN\x18\xb8?\xa3$_\xb7he\xa1?\xbb\xe8^l\xb2\x83\xb3\xbf;\x8b<q\n\xa3\\?&F\x1f\x1c\xfag\x9d?\x13ql\x81\xd1z\xb0\xbf\xfb^&L\xd6\xf0\xad\xbf\x9f\xd0\xa2A\'i\xc4?HD\xd4\xc4\x98\xb9p\xbf\xc8\xcb?<\xdc\xb6\xc5\xbfL*\r\xa7r\x92\xb8?\xe0\x15FoJ\xcd\x91?\x84#aI0:\xbd\xbfW\xa8 \x94XL\xcb?Z9\xc5\x86\x99\x8c\xab?\xb1\xe0\xe2\x08.\x98\xd1\xbf\xb1M \xef\xb8P\xad?_\x8f\x02\x9e\xea\xdf\xb5?J\xe6\xeb\xf2\xb9\'\xcb\xbfz\x0b\\-|\xc5\xc6?\xb0\x06\xfd\xd7c\xa0\xd2?\xe0\xd3\x13&\x16\xd7\xd1\xbfq\xf1\xe0\xb1!\x14\xc8\xbf\xffXRg\xc1\x9c\xc7?/\xd6U\x17~O\xb5?c\xe2\xae\x16\x9agN\xbf\x17[\xc7_!i\xb2\xbf\x828\xa6$a\xf6\x9e\xbf\x80\xd4\xff.d&\xc3?re\x97=\xba>\xc1\xbfO\xd0\x90\xb0\xee\xa3\xce\xbf\xc5\xab\xe6\x14\x81[\xca?\xa3\x881\xf0\x00\xc6\xd1?6\xfc\xd1\xede\x01\xa7?\xcb\r\x16^\x08Y\xce\xbf\xea\xf8\x99\xc8u\xc8\xd6\xbf/\xe2X\xc3\x07\x88\xb6?\xf0\'\xa3PpB\xcc?\xf8rSe*\xc8\xc2?\n\xca\xbbp\x07\x7f\xc3?N\xf2)\x84\xa7j\xd2\xbf,\x9c\xf0\xa1L\xeb\xd2\xbf\x15u\x88\xca\xf7H\xb7?{\xccU\x8a+|\x97?\xcc/uZ\x898\xc7?\xd9\xa8\xc9\xd4w{\xd1?\xc6\x86\xa8 y\xd7\xbd\xbf\xb6u\xd4\x0f+D\xc0\xbf\xc9M|=4v\xbc\xbf\xdc[f)\xe0\xf7\xcd\xbf\x9f\xb8\x7f\xbd\xbd\xce\xc6?\xc2\x99rl\xa3\xa2\xd2?\xc2\x08Zd7\xee\xb6\xbf\xf9\xec\x12\x08\xa6\xa1\x9e\xbf\xa9\xacJy\x1b\x9f\xb8\xbf\x1b0\x8d2n1\xc8\xbfa\xca\x97\xd2\xccR\xc5?ev\x03\xfciy\xc7?j\xa8\xac\xc5\xc7\x99\xad\xbf\xe0\xd5r5\x90\xcd\xb8?O\x91\x17\x18\xc6\xb4\x94\xbf|Z#\xe5dG\xd1\xbf\x1b\xacz\xc8\xa1\x97\x8f\xbf\xdcpl\xb8\xf7=\xb6?\x88\x03&\x1fZy\xc0?\xbc\x10\xfb\xe0\x9d\x19\xc8?,s\xf2]\x97\x98\xd0\xbf\x03\xd7VL\xaa$\xc5\xbf\xc7\x18\xbc\xecW&\xd1?Y\x00C\xb1\xc8$\xb5\xbf\xe1|^\xf5\x82D\xbb\xbf,\xe1\xfaN!5\xb9?&\x16]\x11a\xde\xbb\xbf\'\xe2ea5\'Q?\x92\x90\x06R\xd6\xe4\xcd?_(x_U\xd6\xa8?q\xf7\xdb\xbc\\\x1c\xb1\xbf%\x02\xa6\xf3\xc09\xa8\xbf\xd3\xda\x93>y\x00\xc7\xbf\x8b\x86kJS\x9e\xb9\xbf\x10R\xf3u\x02\t\xbe?Ek\xcf\x9a\x11f\xc4?L\n\x16)\xb8\xf3\xb4?r\x7f\x9c\x9c\xa2\x86\xa0?V\x01\xe9\xe9`e\xa6\xbf=\xf5\xca\xd2\x00\xbc\xd0\xbf\xb3@(\xa2\xd4L\xa0\xbft\x07v\x9d!!\xd2?\x8c\x96l%\x8cV\xbc\xbf\x98\x82G\xab\xd8\x07\xbf\xbf\xc3Z \xcd\xdc\x85\xd2?\x02>t\xbe\xa7\xf4\xc5\xbf\x84\xed\x84\x9b\x89\x95\xd4\xbf\x8dG\x1cDR\xf4\xdb?QK^\x18\xbe`\xc7?\rjz\x05\x88g\xd5\xbf\xeb\xe6\x1aJ\xcbZh?Z?\x03\xf43\xb3\xac\xbf\x12\xeb$a\xbd\x0c\xa7\xbf\xd2Wu)[\xe3\xcf?k\x1dm\xaa0\x0b\xa9\xbf\xbajY.\x07\xae\xb6\xbf>`M*\x9f\x9a\xb5?\xd5+`\x90\xb6\x0f\xbc\xbf4\x03\x80\x04\xaf\xde\xa1\xbf\xe5\x8b\xdc#\x15v\xb4?\x01\xae\xc1o\x07)\x94\xbf\x9e\xdd\xfa\x05v\x86\xb8?B\xb5\x14\xb4\x10\xd1\x9b?\xca\xb4\xc6\x9dw\xe1\xc4\xbf\x14Bn\xc6\xaeG\x95?Z\xca\xb2^\x0f7~?\xe1w\xcaB\xd3\xbd\xa0\xbfM\xda\x00v`m\xc1?\xa6\xab6\xf1st\xa2?>9\xe9\x1fe\xc0\xb7\xbf\xfc\x00\x0e-4\xa4\xa1\xbfA"\xef\xf5\xf4\xf1\xab\xbf\xf5\x07\x82C\x87\x14\x8a\xbf\x00\xc3\x0f\xdbKZ\xc0?\x18\xc5L\xf4\x1d\xc1\xb9?`\xde\x8c\xc0\xc7g\xb4\xbf\x94\x88S\xe8TS\xc7\xbfY\xc2\xf9\x93\x8dsh\xbf\x0b\xfe\xbbs\x7f\xf9\xc4?O\xdd\x89a!\xde\xac?#X\xa1\xfd} \xbc\xbf\x05\xb7\x10\xacID\x83\xbfA\xdd\x11[\x93\xfa\xc6?\x83l\x95V\xc7\xcb\xc1\xbf\x8b\x0b\xbe\xa6\x16\x86\xd3\xbf\xb1\'\x98f\xa2\xa0\xc8?w\xbfg\x182\xcd\xbe?\xb2V\xe3\xacp\x01l\xbfZ\x16\x93:\x01\xb9\xd9?\x93\xd2\xb9/r\x99\xc3\xbf\xbd\x84<\xd5G|\xe3\xbf&\xfa?C\xfd\xcd\xa6?\x85?\xe6\xc8,Y\xd0?\x89 \x0c\x1bNT\xa3?\xb1J-\xa9\xad\xac\xbe\xbfd5\x86\x10\x85\xc4\xa3?\xa4\xab\x0e\x8d\xb0\xb1\xcc?\xe9\xf1\xf7\xa3m\xeef\xbf\xf2P\x94=\xeb\xa8\xb1\xbf\xff\x8e{\xb90\x01\xb4\xbfY\x8c\xf3\xf4\xbc\xce\xc8\xbf\xdf\xbc{W]"\xa0?\xc2\xa4\x14dq\x1e\xc8?\x10x\xad\xe1\xe3\xd2\xb9?:\xc3\xf6}\x82{\xbc?\xe6\xe1\x97V\x81S\xc6\xbfd\x04\x13{\x05\xff\xd3\xbf\x02g\x80\x00\x94\x9f\xb9?,\xd9\xba\xa2\x9a\x97\xd1?\x05^\x0e\xa9\xfc|\xb7?{PTp\xf9\x1b\x93?\x85I\xb88f\x9d\xcd\xbf\xca\x14\xf2\x984\xd9\xd2\xbf1\xe5P\xf6\x06z\xc8?\xf6\xb8l4\xd7\xe7\xcf?>\xa6\xc5\xbaB\x92\xb2\xbf\xac\x8e\x08\xb9p\x93\xb1?m\xa7\xbf\xdb\x98LU?\xefS.p\x1b)\xd8\xbf\x12lZ-\xc7\xcb\x9e\xbf\xdd\xe0\xba\xe2\xf4"\xd7?\xf1r\xadw8x\xb2?\xebxD\xd2\xcc\x93\xcb\xbf/Uv\xbe\xcf4n?\xf9A\x15\x0f\xc8)\xbb?\xd6^\x89\x01\x10\xd0\xbc\xbf\xd5 \x85\xf4\x9d\xe7\x94\xbf\x9d \xf2\xc7\xb2\x19\xb2?;\xa0E`\x08p\x91?\xb7#QQ\xc5.\xb2?a\xd4\x07s4&\xa1\xbf\'o\xf9g6\x1a\xb9\xbf[\xa64\x08|\xfa\xaf?\xc3\xb5\x85\xa7\xc7F\x9c\xbf\xcb\xb2\xa1\xbe\xa1\xfb\xc3\xbf8#\xc6J\x15w\xba?\xd5xrq\x82\xce\xcb?\x92T\x16\x8cL(\xb5\xbfC\xbaj\xc0\xc3\x87\xaf\xbf\x078\x12L\xc1U\x98?\'\xc9\xea\xa0N\xa9\xcb\xbf\x82\x04\xf98B\xcc\x86?>\x05B\xe1!\xf9\xdb?\xa6\xf4\x06\rb\x96\xa5?\x80\xdd\xdcY\x18^\xdb\xbfx\xeb\xbd\x90\x85{\xc2\xbf\xc7\xb3/}\x18]\xc3?\xde\x85\xf1=(\xc8\xc2?\xbe\x9b\x96\x82P^\xc0?\xd6\x05\xe9\xdah{\xa9\xbf\xecj\xc4\xbf\x06\x94\xd3\xbf\x1b"$do\xed\xab?\x85\xff\xf1\xaf\x1ce\xd8?Iv]"\x8c$\xbc\xbf\x17-\x8a\xd5#\xee\xd3\xbf\x9b\x14\x0f\xeav\xa9\xad?\xee\xd6\x1aZ\xe9\xd9\xbf?\xf5^\xb8\x83=J\x9e?(\xe5\xdf\xfb\xa0\xe2y?\xdf\x9a\xad\xbc\xe3\xc6\xb3\xbf\xa5\xf70\xbe\xe0\xe1\x89\xbf7\xdb\x86\x16\x1aL\xa9?\xb2\xe5\x9f\xd2\xf7W\xbf?{\xabp`\x8d\xa4$?\xfb\xa9;\x04\xd3\xc4\xd6\xbf\xf5\x9fDn\xb0F\x9f\xbfZ\xf2\xaa.T\xe3\xd8?A\xd9\x7f\x9fF\xed\xa8?qZ\x1f\x8a-\xd3\xb1\xbfCQ.\xec//\x87?\x80\x1eu{\xca\x1d\xd5\xbf\x1e6\xbc\xf9\x80\x17\xc2\xbfe\xee\xc6\xd8\xb8l\xdb?\x0b\x02\x965\x1b\xc1\xcb?2\xadn\x16\x7fU\xd0\xbf\xa6W\xa6]\x10\x99\xc4\xbf\x19\xf8\xe8\xc3\t\xd0\xb8?\xc0\x01\xfb\x86\x81W\xa6?\xf9\x96\x88znM\xa3\xbf\r|.b \xbd\xa3?WP\x12\n\xb8\xe8\x8e?D\xf3\x14\xb7\xc4\xf4\xad\xbf&\x8a\xf0ZC^\xa9\xbf\xd4\xfa%x\xd3-\xa9?8\xcf(\x8d\xf42\xbb?-9Pg\xd2\xfa\x8a?\xfdr\xbe\x8e\xea\xd0\xbb\xbf\x80\x1f\xaa)2\xab\x96\xbf\xd0A\xb8\x1b\xe5d\xb5?\x9dC\x8c\x96\xde\x83\xb2\xbf\x11\x81\x1eLh\x94\x95\xbf\x92?\x03o\x00h\xce?\xe7:\n\xfc\xff\x03\x99\xbf\xb4\xf1\x98\xb6\xb7\x08\xd5\xbf\xf4>u}\xb8\x1a\x85?\xde\x8c@\xa3\x89\xe2\xc3?\xc3IK(\x0e\xb9\x88?\xcc\xbf\t\xe3\x19\xfe\xc2\xbf\xc8a\xdbT\xfb\xfc{?<\xc5\x08\xea\xec\x10\xd1?C\xacv7#\xc4\xb8\xbf\xbdF\x0en\x89I\xbc\xbf\xa7\xc5\xf1{/J\xc3?Y}\xc2\xacc\xe8\xbb\xbf\x82\xb3}g\xbf[\xbf\xbf*Zj\xfdt\x1f\xcb?\x1a7\xd5 \xe5l~?\x057\xdf#lK\xc0\xbf\xf1\xe1i\x08\xf2C\xae?F\xb5\xf3\x8b\xcfb\x82\xbfa\xc7M\xbc\x8bN\xab?\x07\xc2H\x1f\xcc"\xbf?!\xa0\xea\xd0:\xfb\xcf\xbf\xef\x88\x05\x91\xcco\xcf\xbf\xcc\xea\xeaX\xec/\xd4?\x0c.\x05X\x97j\xd4?i]`\xccD{\xd0\xbf\xc8\x17p@\xea\xc9\xd1\xbf\x06\x85\x7f\xe8\xe1O\xc3?\x83\xa9\n\xb3\xb9\xf3\xaf?\x16\x1f\xae\x15\x81\xba\xa0\xbf\x97B\xfd\xf3/\xf3\xcc?\xa9~\xf5\xf3\xcd\xf0\x9b?\x19"\xfc\x8e\xc8F\xd7\xbf\x9d\xca\xb5\x86<\xe4\xaf\xbf\xf4\x10\xceQFa\xcf?\xdb6\xa3\x9a\xcf\x01\xb3?\xce\x99\xf7S\xf8\x15\x81\xbf\x04(\xe4d\x17L\xa2\xbf\xfaT*\x0648\xab\xbf\x8f\xbc\xf31l\x04\xa9\xbf\x0clrY\x05\xf6\x90\xbf\x03=\x82\xa4\xe0\x8f\xc1?\xd6#\xbdV\xb7\xc4\xbb?\xca\x19\x1ca\x98\xf8\xc7\xbf\xd1\xcb+\'B\x9e\xc7\xbfz\xb4F\xbbx\x80\xc1?\x84\x10\x84*\xbfQ\xbd?\x9e\x16|\xeb\x0c\x11\xa6\xbf\x13\xcf\xc46\x7f7\xb4?\xa4\x0b)\x15$]\x83?b\xb68L%&\xd0\xbf\x03\xea\x0f\xce\x89d\xa5\xbf\xe8\xc8\x0b\r|\xc3\xd4?\xf9\xe8\xbd^\xae\xec\xc0?i\xc7\x1b\x8a\xf7\xaa\xd7\xbf\xe7\xdf\xcc}\xc0t\xc4\xbf\xb3T\xe2\xc8;{\xd8?\x80N\xa2h\x82\xb9\xbe?yeQ\xca\x81\xe5\xd1\xbf\x82YK\x1e$M\xbd\xbf\xab\xac\x05D-\x16\xb7?e\x0b\x81_\nB\xb9?\xe9\xb5\x9a\x93Pd\xc0?e/*%Q\x8c\xa1\xbf*\xc1\x0c\xd4-%\xcb\xbf\x9a<\xfb\xd4w_\x86\xbf\x9c\xb2\x8f\xa7k\xae\xac?\xe3Z%q\x1az\x91\xbf#\x10\xd0\xca\x1cK\xcc?z\xa8\xa39\xab\x8b\xac?t\xa8c\x0e\xeeb\xd4\xbf\xfd\x05\x9a\xd2A\xa3\xa0\xbf\xe9+I\x92\xc0\x8a\xc0?\x90\xf5\xe4(\x9e?\xc1\xbfY\x0e\xed\x12\xc4\xbc\xc1?\x92\'9\xbd\x04\xaa\xd6?\xc5*\xc3\xda1\x94\xcc\xbf\xce\xbe\xb1n\xf8\xd7\xd9\xbf\xdd\xe9\xa6\xde\x9bMx?Pcx\xd8\x85\xef\xd3?\x1dT\x13~\x82f\xcd?-]R\xee})\xc5\xbfu\xa4\xaa@\xb6\x9b\xd2\xbf\x05\x06\xbe\xcf\x07\xf9\xb0?\xfbO_\x9fS\xd0\xcb?3\xe6\x15~\x86*\xa2\xbfNC:"Z\x10\xc0\xbf\xb7\xbbyS\xf8\x0e\x8a\xbf\\\xe9\xb3\x1fs\xa6\xb8?\xfe\xd9c\xc5\xaa\xa5\xb0?6\xe9h\xc5\x0e\x87\xb1\xbfO&&\x8b\x07\t\xb7\xbf-\x97X\xe2\xf4\tv?\x9ay0\xcc\xaeu\xba?\x893\x18\xd6\xb3*\xb5?\n\xe6\x0b\x83s\x81\xbb\xbf"\xb4E\x14\xfb"\xc6\xbf2\x82\xa5\xacC\xf8\xb6?\xb6Cn\xcb?\xdd\xcc?\x92\xff\x17\xd5\xc0H\xa7\xbff7H\xb3\x05\xba\xcc\xbfl*\xd4l\x83\xf3f?\xaf\x1fh8\xf5\xba\xcc?\xff\xed\x84\xdb\xdb\x92q\xbfi\xab\xae=\x89\xb3\xc9\xbf1\xd9\x17\x90\x9emz?\xa2D?b\xd5\x91\xb4?\xde0\xbbqGf\xa1?\x82\xe3\x88D:\xe7w?~\x07\xbd^6\xdf\xba\xbf\x8e\xab\xcb\xf0\x9a\xa4\x93\xbft\xbc\xd5h\x1fc\xc9?\xe8o(\xcd\xf8\xd8\x9c?\xb7\xb3\x0b]\xd6-\xd5\xbfDOm&\x05$\xa1\xbf6;\x902\xeb6\xda?=+W\x9c\xbbu\xa4?\xba\x8d\xe6x\xceE\xd4\xbf\x8d#\\\xe1=\xa4\xad\xbf\xa6\x04\xe4\x16\xa2\x0b\xc4?7\x1f\x1a>c#\xb0?\xf6\xb8rx-\x04\xb9\xbf,\x04\xdd"&\x8a\xa9\xbf\xbb\xb4\xa7\x842.\xba?\xad+\xee\xa8\x8a\x03\xae?Sm\xb9y\x81\x18\xb5\xbf\xda\x81\x18hZ\x8b\xb6\xbf\x92F \x1f\xcd\xe0\xaa?\xfc\xd8\xa0/@6\xc2?\xf0\x8e\xb7=\xd0\xa3\xa0\xbf`\xec\xf2$\x98\xe2\xcb\xbf\xbb\xb5V\xd1\xb4\xa3\x87?\xbe\xd1h\xed\xa2\x0f\xd3?\xe9u=\xf8\x00q_?\xa4\x85\xa6p\xa0Z\xd6\xbf\xe0\x9f\xdf\xedq4_?"\x10\x84?\xeb\xd5\xd6?\xfaw\xcc\xef\x0b/\x83?\x91<Ek\xc3\x8d\xd1\xbf\xf9\xf3\xc5\x97\xcd\x1b\x8a\xbf\x84\xdb\xee\'\x04\xed\xb8?M>\xbd\x91\xbfI\x92\xbf\x17\x84\x95\x14\x84J\xbc?\xd7\xae\xd4\x95\xff"\xaf?\xe5\x01\xc1z\xb8V\xcf\xbfZ\xaa\x17L\x9c\xff\xa4\xbf\xfb-\\>n@\xc4?\xa6\xa3\xe6\x82\xd9\xcb\xab\xbfI\x16\xc1\xfd%r\xa5?\x7f\xf0\xab#\x99\x0f\xc9?p\x99y\x8e\xf3\x07\xc6\xbf5\x15w"\x0e\x17\xd1\xbfw6WuXC\xc8?\xd4\xc4\xff\xc6B\x0e\xc9?$\xbf\xe8)\x90q\xc3\xbf"\x1eE\xff7m\xc1\xbf\x97\xf5\x93\x9c["\xbb?x\xb3\xe4\x8c@\x9e\xa2?4\x9a\xc3\xc7\xce\xb7\xb3\xbf\xac\xf5\x90\xb2f\x8d\xba?9\x9bR\xbc\x87)\xc1?\x1e\x1a\xf5\xab\xe7\x8d\xc9\xbf~]\xf2\x07\x12"\xd1\xbf\x12\x05i\xcd?b\xcd?=]\x8clXf\xd9?\x99\xfe"*\xd5\xd4\xc0\xbf\xd5\xf9\xe6*\xf0\xdd\xd6\xbf\xb0\xb7\xbe\x93\xc0\x0c\xa2?A\xc84\x0f\xfd\xfc\xc1?%\xcb +/\xb9\x7f\xbf\xa0y\xcb\x02\xeb\xcd\xc1?\xbb\xb1(\x1cy\x06\x87?\xda\xb3Q*{\xd0\xd0\xbf*?"rm,\x8b\xbf\x18\x7fn<{\xea\xbd?\xd5\x9f\x16@\x93f\x90\xbf\xbb\xd6>\xf1|L\xc3?\xec\x1e\xd4F\x94\xdd\xb0?\xcc0\x8cQA\xf3\xdb\xbf\xfa\x96O\xb2Lu\xb1\xbfXB\xa2\x87)y\xe1?\xc02\xab/1%\xb1?\xa0\xfb\x12\x88\xb2\x88\xdf\xbf\x05L\xe1{\x84D\xbf\xbf\xcb\x8eS\xa1wM\xd7?\xff\xbd\xe1D\xf2\x8e\xba?\x9b\x8a\xe0\x80\xc4\xda\xc8\xbfZ\xd7M\xdb6x\xa9\xbf\x8bn ;\xe2\xf8\xb5?\xe5\'\x00\x84Iz\xa4?\xdc\xb8\x07\xed\xed\xc4\xa6\xbf$\x94x\x02\xad-\xa0\xbf\xc1C\x1f\rDb\x9b?\x1d2G\x89R\xa5}?\x0c\xca|\xa3c\xf4\x7f\xbf \x18\x1a\xb9\xa3\x90\x91?b\xaaWo<[~\xbf\xc3C\xda\xa3\x8a\x99\xaa\xbf\xcc\xcf5\xaed\xbfp?\x1c\xfc\xd2\x97\xea\xb4\xae?1bk0\x06\xd5\x97?\xb8\xf3\xc03\x08\x7f\xa3\xbf\xef\xae\x01\xe2\xe9W\xa3\xbfvaf\xf36\xab\x9c?\x8a-%\xe6\xb3\xa4\xaf?\xc0i!ho\xc6\x94\xbf\xd3)\x94\x8e\xa0\xa4\xb1\xbfC\x1d\x84\xaf|\x8d\x82?\xa5\x93\xb3\xc8\xd4\x00\x9c?'
-p179
-tp180
-bsg79
-g64
-(g65
-(I0
-tp181
-g67
-tp182
-Rp183
-(I1
-(I34
-tp184
-g74
-I00
-S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
-p185
-tp186
-bsS'n_samples'
-p187
-I3148
-sS'_n_active_components'
-p188
-I30
-sbsbasS'reference_shape'
-p189
-g0
-(g87
-g2
-Ntp190
-Rp191
-(dp192
-g91
-g64
-(g65
-(I0
-tp193
-g67
-tp194
-Rp195
-(I1
-(I17
-I2
-tp196
-g74
-I00
-S'\xcf\x1c\xa2\xfci\xe0L@\xf3\x80\x82\xa8h\x0e8@\xd9AM\x15\x0c\x9aS@\xe1\xd6\xf7\xf5\t\xa98@4\x06\xdeIZ\xc1X@\xdf\xf9\xf4\xbch@;@\xc4\x89X\xbe\x89\xc2]@\xe3y\xb3\x9dB\xdc?@G\x97\x12\xff\xda0a@\xd5\xa7H\xd0\x89\x11D@_\xaa\xe1r\x9c3c@$\x9a\xb4\xbd\x02bJ@b\xf0\x8f\x07\xa8\xe0d@\xe6\xc4Y\x0e\x02\x07Q@l|v\x0b\xd42f@\x88\xd5\x88\xc8\xabDU@\x8d\xec\x15\x92-\x89f@z\xd6\x12\x832\x07Z@\xf5\x0eQ\xb0O\x14f@\xf6D\xdfXL\xb2^@\x95\x8d\xc5"\x04\xb3d@\x1a\x91\x8eR\x87fa@\xe0hL\xf6O\xffb@\xff1E\xbb;Dc@*\xdbn\x9d\xcd\xf6`@:\x1a\xb6-=\xc7d@\x15<-Q\x8a7]@)\xd3b4|\xc2e@m\x0f`\xc2\xd8\'X@ud\x1e\x86oBf@\x98\x9a1\x15\xf0\x06S@\xb1\x97\xe5s\xc6~f@\x06;A\x05\x99\xbbK@\xaa\x13\xc2\xfb_\x8af@'
-p197
-tp198
-bsg98
-Nsbsg48
-(lp199
-g49
-asg51
-g34
-sg46
+ccopy_reg
+_reconstructor
+p0
+(cmenpofit.clm.base
+CLM
+p1
+c__builtin__
+object
+p2
+Ntp3
+Rp4
+(dp5
+S'opt'
+p6
+(dp7
+S'ablation'
+p8
+(I01
+I01
+tp9
+sS'verbose'
+p10
+I00
+sS'rho2'
+p11
+I20
+sS'sigRate'
+p12
+F0.25
+sS'ratio2'
+p13
+F0.08
+sS'imgDir'
+p14
+S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
+p15
+sS'dataset'
+p16
+S'demo'
+p17
+sS'ratio1'
+p18
+F0.12
+sS'smooth'
+p19
+I01
+sS'pdm_rho'
+p20
+I20
+sS'sigOffset'
+p21
+I25
+sS'kernel_covariance'
+p22
+I10
+sS'numIter'
+p23
+I5
+ssS'_shape_model_cls'
+p24
+(lp25
+cmenpofit.modelinstance
+OrthoPDM
+p26
+asS'max_shape_components'
+p27
+(lp28
+NasS'scales'
+p29
+(lp30
+I1
+asS'diagonal'
+p31
+I200
+sS'holistic_features'
+p32
+(lp33
+cmenpo.feature.features
+no_op
+p34
+asS'patch_shape'
+p35
+(lp36
+(I8
+I8
+tp37
+asS'expert_ensemble_cls'
+p38
+(lp39
+cmenpofit.clm.expert.ensemble
+FcnFilterExpertEnsemble
+p40
+asS'expert_ensembles'
+p41
+(lp42
+g0
+(g40
+g2
+Ntp43
+Rp44
+(dp45
+S'sample_offsets'
+p46
+NsS'cosine_mask'
+p47
+I01
+sS'context_shape'
+p48
+(I8
+I8
+tp49
+sg35
+g37
+sS'response_covariance'
+p50
+I3
+sS'patch_normalisation'
+p51
+g34
+sS'_icf'
+p52
+Nsbasg47
+I01
+sS'shape_models'
+p53
+(lp54
+g0
+(g26
+g2
+Ntp55
+Rp56
+(dp57
+S'similarity_model'
+p58
+g0
+(cmenpofit.modelinstance
+_SimilarityModel
+p59
+g2
+Ntp60
+Rp61
+(dp62
+S'_components'
+p63
+cnumpy.core.multiarray
+_reconstruct
+p64
+(cnumpy
+ndarray
+p65
+(I0
+tp66
+S'b'
+p67
+tp68
+Rp69
+(I1
+(I4
+I34
+tp70
+cnumpy
+dtype
+p71
+(S'f8'
+p72
+I0
+I1
+tp73
+Rp74
+(I3
+S'<'
+p75
+NNNI-1
+I-1
+I0
+tp76
+bI00
+S'hJ#\xf4?\xff\xcc\xbfa4\x1c\x16\x1b\xb0\xd0\xbfu,\xd1B\xbfB\xc4\xbf\t\xfc5^\xd1\x94\xd0\xbf\xa1\xac\xdb\x94\xe8\x1a\xb7\xbfu@a\x98\\\x0c\xd0\xbf\xf3\x01\x17Q\x84\xc4\x98\xbf&\xfcP\xff}*\xce\xbf\x16\xf3\xa8j#\x01\xa3?\x92bT\xfaT\xab\xca\xbf\xf7"\x87hj:\xb7?\x0b\xcc\xf2\x90RS\xc5\xbf\xbc\xc9\x1a\x87p[\xc1?/\xc3]D\x85\xab\xbd\xbf\x12\x08\x86\xf1\x8b\xe6\xc5?\xdf\x0e\xc0v\xec\x9c\xae\xbfO\x9a$.6\x11\xc7?\x88\xcd3*=\xfei?sj\xdde\x99{\xc5?.\xd8\xe5\xe3\xc0\x9e\xb0?\x852\xe9\xf8\x91\xbd\xc0?\xd5O\xdb\xa7\xc2\x90\xbe?*\xf0\xb9`\xbe\xd2\xb5?\x9f\xb1\x17\xd8\xdd\x9e\xc5?\x8b\x8f\x14,\xd7\xcb\x9f?\xa7\xa8CH,\xc1\xca?N|\x8b\x8e2\x1f\xa0\xbfAqXQJ\x12\xce?\xe4\xb0\xe6\x1c\x9f/\xb9\xbfp\x0eSA\xa8\xbc\xcf?\x95\xf9z\x7f\xfeC\xc5\xbfGh3\xb3^?\xd0?\xa0\x02Cm\x17\x01\xce\xbf\xb4q\xf3G\xa0M\xd0?c4\x1c\x16\x1b\xb0\xd0?lJ#\xf4?\xff\xcc\xbf\n\xfc5^\xd1\x94\xd0?v,\xd1B\xbfB\xc4\xbfv@a\x98\\\x0c\xd0?\xa2\xac\xdb\x94\xe8\x1a\xb7\xbf(\xfcP\xff}*\xce?\xf4\x01\x17Q\x84\xc4\x98\xbf\x93bT\xfaT\xab\xca?\x18\xf3\xa8j#\x01\xa3?\r\xcc\xf2\x90RS\xc5?\xf8"\x87hj:\xb7?1\xc3]D\x85\xab\xbd?\xbd\xc9\x1a\x87p[\xc1?\xe1\x0e\xc0v\xec\x9c\xae?\x13\x08\x86\xf1\x8b\xe6\xc5?\x9b\xcd3*=\xfei\xbfP\x9a$.6\x11\xc7?/\xd8\xe5\xe3\xc0\x9e\xb0\xbfwj\xdde\x99{\xc5?\xd8O\xdb\xa7\xc2\x90\xbe\xbf\x862\xe9\xf8\x91\xbd\xc0?\xa2\xb1\x17\xd8\xdd\x9e\xc5\xbf*\xf0\xb9`\xbe\xd2\xb5?\xaa\xa8CH,\xc1\xca\xbf\x8b\x8f\x14,\xd7\xcb\x9f?BqXQJ\x12\xce\xbfO|\x8b\x8e2\x1f\xa0\xbfq\x0eSA\xa8\xbc\xcf\xbf\xe7\xb0\xe6\x1c\x9f/\xb9\xbfHh3\xb3^?\xd0\xbf\x97\xf9z\x7f\xfeC\xc5\xbf\xb5q\xf3G\xa0M\xd0\xbf\xa2\x02Cm\x17\x01\xce\xbf\x14\xaf\xd2Hh\x0b\xcf\xbf\xef&z\x0c\x7f<\xb5\xbc\x14\xaf\xd2Hh\x0b\xcf\xbf*>\xa3\xae\xdf\xf1\xb2\xbc\x13\xaf\xd2Hh\x0b\xcf\xbf\xa1\x8a\x90\xac\xbem\xab\xbc\x12\xaf\xd2Hh\x0b\xcf\xbfiMT\x91\x1c*\x9e\xbc\x12\xaf\xd2Hh\x0b\xcf\xbf^\x9e\xc6\xb2\xccw\x81\xbc\x15\xaf\xd2Hh\x0b\xcf\xbf \x16\xf3\x95\x10\xd8\x8c<\x14\xaf\xd2Hh\x0b\xcf\xbf\xda\xec\x02\xdfu\xa5\x9f<\x16\xaf\xd2Hh\x0b\xcf\xbf\xf3\x84\x07q\xee\x80\xa8<\x1b\xaf\xd2Hh\x0b\xcf\xbfE\x8c5\xbb\xaf*\xad<\x1c\xaf\xd2Hh\x0b\xcf\xbf\'\xa1P\\\x03\xef\xad<\x1f\xaf\xd2Hh\x0b\xcf\xbf\xf6\xbb\xb2\x0c\xb4\x86\xaa<"\xaf\xd2Hh\x0b\xcf\xbf\x7f\x0ec\xffh=\xa5<&\xaf\xd2Hh\x0b\xcf\xbf/\xf7"<\x1c(\x9f<%\xaf\xd2Hh\x0b\xcf\xbf(\x9ar\x93G\xc8\x8b<\'\xaf\xd2Hh\x0b\xcf\xbf\x16\x89\x08\xbe\x8d9|\xbc)\xaf\xd2Hh\x0b\xcf\xbf2\xfeZ%\x00\xf8\x9a\xbc)\xaf\xd2Hh\x0b\xcf\xbf.-T\x8d\xacG\xa7\xbc\xe2\xa5\xf3\xf4\xc6*\xbc<\x12\xaf\xd2Hh\x0b\xcf\xbf\xd5R\x1azA\xcd\xb4<\x12\xaf\xd2Hh\x0b\xcf\xbf\x9a\ti\x19cD\xad<\x10\xaf\xd2Hh\x0b\xcf\xbf\xb1\x9et\x82%\x97\xa0<\x0f\xaf\xd2Hh\x0b\xcf\xbf\xf9L([\xb9\x11\x82<\x11\xaf\xd2Hh\x0b\xcf\xbf\xba\xc4\x0cj\xc1\xf1\x8a\xbc\x11\xaf\xd2Hh\x0b\xcf\xbf\x8c_O\xeb\xe1\xd1\xa1\xbc\x13\xaf\xd2Hh\x0b\xcf\xbf\r@|\xc3\xde\x8e\xaa\xbc\x17\xaf\xd2Hh\x0b\xcf\xbfK\xab6\xfa\\\x95\xaf\xbc\x19\xaf\xd2Hh\x0b\xcf\xbf*\xaa\xa2\xa0\xedF\xb0\xbc\x1b\xaf\xd2Hh\x0b\xcf\xbf\x952\xff_\xbf\x9d\xad\xbc\x1e\xaf\xd2Hh\x0b\xcf\xbfp\\\n\x03yx\xa8\xbc\x1d\xaf\xd2Hh\x0b\xcf\xbf\xf2C\xd3\x0f,k\xa0\xbc \xaf\xd2Hh\x0b\xcf\xbf\xf4\xa6\xde\xf10\xaf\x8f\xbc$\xaf\xd2Hh\x0b\xcf\xbf\x08O\x93\xf5U\xa5\x86<%\xaf\xd2Hh\x0b\xcf\xbf\x0c#\xb3\xfaDo\x9d<(\xaf\xd2Hh\x0b\xcf\xbfR+\xbc\xa7\xcb@\xaa<)\xaf\xd2Hh\x0b\xcf\xbf'
+p77
+tp78
+bsS'_mean'
+p79
+g64
+(g65
+(I0
+tp80
+g67
+tp81
+Rp82
+(I1
+(I34
+tp83
+g74
+I00
+S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
+p84
+tp85
+bsS'template_instance'
+p86
+g0
+(cmenpo.shape.pointcloud
+PointCloud
+p87
+g2
+Ntp88
+Rp89
+(dp90
+S'points'
+p91
+g64
+(g65
+(I0
+tp92
+g67
+tp93
+Rp94
+(I1
+(I17
+I2
+tp95
+g74
+I00
+S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
+p96
+tp97
+bsS'_landmarks'
+p98
+NsbsbsS'similarity_weights'
+p99
+g64
+(g65
+(I0
+tp100
+g67
+tp101
+Rp102
+(I1
+(I4
+tp103
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p104
+tp105
+bsS'_weights'
+p106
+g64
+(g65
+(I0
+tp107
+g67
+tp108
+Rp109
+(I1
+(I30
+tp110
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p111
+tp112
+bsS'_target'
+p113
+g0
+(g87
+g2
+Ntp114
+Rp115
+(dp116
+g91
+g64
+(g65
+(I0
+tp117
+g67
+tp118
+Rp119
+(I1
+(I17
+I2
+tp120
+g74
+I00
+S'I\x94!\x9e\xa9\xc4P\xc0\xc77\xa4W\xe2LS\xc0\xa7\xbb\xd0S\xb5nG\xc0\xfc;\xcd\nS-S\xc0\x8c)\x83)\xdc\xb8:\xc0\xb0_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0w\xf2\xc5\xcc\xb4qQ\xc0\x88p\x95\xd0\xc0\xfa%@\xae\xa9c|\x1e\xd8N\xc0Q\x98!\xa8L\xdd:@\xcd\rTB\xf4\xa9H\xc0ou\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb1\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0&E\x0c\'\xa5\xadJ@\x84a9\xdd\xed\x0f\xee?d\x81#4\x89\xd8H@<\xe4\xb2\xbd\xd083@\x7f\xbe\x81\xd2t\\C@\xb3\x1f\x00\\\xd8\xacA@\xe2\xca\x07\x8dR=9@\xe6?\xe0\x02S\x01I@j\xe0\xe7!\x0cc"@\x9f\xcbE\x15a\xf1N@\xf7\xb3\xf0\x85J\xa5"\xc0R\'\xf6\x01\xb6cQ@i_g~\xf7 =\xc0I\xf8<oDZR@\x04Ol\xe59\x98H\xc0\x11\xd0\x13\xff\x7f\xcaR@\xf1\xef\xa4\xef\xc3YQ\xc0\x86\xe0\x05\xe7\xfc\xdaR@'
+p121
+tp122
+bsg98
+NsbsS'global_transform'
+p123
+g0
+(cmenpofit.transform.homogeneous
+DifferentiableAlignmentSimilarity
+p124
+g2
+Ntp125
+Rp126
+(dp127
+S'_h_matrix'
+p128
+g64
+(g65
+(I0
+tp129
+g67
+tp130
+Rp131
+(I1
+(I3
+I3
+tp132
+g74
+I00
+S'\xff\xff\xff\xff\xff\xff\xef?^\xf0\xcd\x1dB\x8fd<\x00\x00\x00\x00\x00\x00\xd09 \xb2\x1d\xb53\x9e_\xbc\xff\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\xf0\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
+p133
+tp134
+bsg113
+g0
+(g87
+g2
+Ntp135
+Rp136
+(dp137
+g91
+g64
+(g65
+(I0
+tp138
+g67
+tp139
+Rp140
+(I1
+(I17
+I2
+tp141
+g74
+I00
+S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
+p142
+tp143
+bsg98
+NsbsS'allow_mirror'
+p144
+I00
+sS'_source'
+p145
+g136
+sbsS'model'
+p146
+g0
+(cmenpo.model.pca
+PCAModel
+p147
+g2
+Ntp148
+Rp149
+(dp150
+S'centred'
+p151
+I01
+sg86
+g0
+(g87
+g2
+Ntp152
+Rp153
+(dp154
+g91
+g64
+(g65
+(I0
+tp155
+g67
+tp156
+Rp157
+(I1
+(I17
+I2
+tp158
+g74
+I00
+S'\xd1\xe5\xf7\xba\x17\xb4L\xc0\xb0$3\x9e\x1d\xaeS\xc0\xfb)8>|\xa4C\xc0\xadu^\x0e\xd3\x10S\xc0\x96xK\x8c\xa4\xaa5\xc0\xc3\x07.\xa0KBR\xc0\xf4U\xed\x86\xb17\x14\xc01\xc7+\r\xc6pQ\xc0\xd7\xf5\xbc\xd9\xd6\x0e(@\x87\xd6\xd6<N\xe0P\xc0@5fx\x8d\xa99@\xb1\x8d\xde\x81\x91@N\xc0{\x07\xa1\xbe\x9c\xd5B@CC\xae\x04\xbaGI\xc0OZ\xb8\xaa#\xfeD@\x97\xfa\xea(j\xb2=\xc0m?t\x14\xf0KC@\x84\x7f\x05\x12\xd9\xa8\x0b\xc0@\x9f@\xfd7\x83C@\x8e\xf7\x1a\x1a\xdc%;@\xd8\xc6q\xd6i!A@`\x0f\xed\x92P\x92G@\xaejU\xe8\x8f\x016@)\x07Y :~O@m\xeeb&\xfd\xe2 @\x8b_._\xb1\xcdQ@\xaaV\xb0\xec@\xff#\xc0\xdd\\W\xd6\xde\xbfR@\xd0\xfa\xa6\xfa\xe3k:\xc0\x80\xa1H\xd5\xf8\xefR@\xdbM\xb9U2\x1bE\xc0\xd5\xee\x1f\x05\xd3\xddR@=xy\x03\x85\xd0L\xc0\xf6|\xbb<?\xb3R@'
+p159
+tp160
+bsg98
+NsbsS'_eigenvalues'
+p161
+g64
+(g65
+(I0
+tp162
+g67
+tp163
+Rp164
+(I1
+(I30
+tp165
+g74
+I00
+S"6\xf1\xa2i\xa9gy@\x9e3\xdc\x84\xdb\xb5i@\x9bi\x02\xdd9\xabR@4~K\x88'AC@}\xce\xcfWb\xd9:@\xb4\xfcv\x12H\xfe0@\xd1\xab\xfd\xfa\xc5\xa4-@\x9f\x12\x85\xd1\x9b\x91&@\x9fa\xe4\x07\x8c\x8f\x1d@\xff\xa3\x99\xda\x9a)\x15@\x99\x80\x80}\x03\x94\x11@\xd9F\xde\xb1\x1f\xca\x08@^cZw)\xaa\x04@\xdd\xeb4+\xe26\xfe?n\xb0\xe2\xc7_=\xfc?\xec\xa6\xe9\nO\xef\xf5?0\xc8\xf3G<\xda\xf3?\r$\x9e\x01\xccJ\xf2?\x01\x94\xc26\xd4\x91\xf0?q/S\xab:s\xee?\x82\x95^\xed\x0c\x97\xeb?\xb0l\xa1DL@\xea?\x18\xdf!Cgc\xe8?\x9a\xaeT\xac\x8b\xd8\xe6?c\xbe\x97QS\xff\xe5?\xd9\xb7\x18\xba\xe7:\xe4?\xed\x7flo\t-\xe2?`\x18\xe4\xd1\x173\xe0?D\xdft\x02\xb1\xcd\xdd?\x13\xa1\xa7\xf09$\xd7?"
+p166
+tp167
+bsS'_trimmed_eigenvalues'
+p168
+g64
+(g65
+(I0
+tp169
+g67
+tp170
+Rp171
+(I1
+(I1
+tp172
+g74
+I00
+S'\x93Ex\xe8/e\xd3?'
+p173
+tp174
+bsg63
+g64
+(g65
+(I0
+tp175
+g67
+tp176
+Rp177
+(I1
+(I30
+I34
+tp178
+g74
+I00
+S'\xb8\x86\xd5\xb9\x9c$\xd6\xbfZw\x81\x02\xe6e\xb5\xbf\xda\x05\xcb\xf8\xe3\xe9\xce\xbfWT\x91\x1f@\xa4\xbb\xbf\x12\x14\x83t\xd6\n\xc1\xbf\xcb\x01\xbb\x95\xc8\xe6\xc2\xbf\x84\xa6\\\x9a\xe2\x12\xa1\xbfH\x18D\xfcdD\xc7\xbf\x16\xc7U\x1c\xa4B\xa1?\xf9\x18\xb9\x05\x18\xe4\xc0\xbf)d\xabv<?\xb0?\xe5^\xf2\xe9\x03\xb3\x80\xbf=<\xfa\xce5\xd8\xae?\xbf\xd5@\xdcI\xac\xc3?\x10\xdfK\xce\x08\xcd\x9a?\x17\xa7@\n\xa4\xe9\xd3?\xffm\x96\x19&-\x85?\xe7\x9f0\xe8\xaf\xc5\xd7?\x99e\xc5\xc0\xf5\xaf\x81\xbf\xd4\x81\x90:q/\xd4?\xd8\xf2\xad\xb6\x9d\x02\xac\xbf\x16Ct\t\x8e\xa5\xc5?%843V\xd2\xb2\xbfeWr\x9f\x99\xbb\x90?\xcd_g$\xd3\x8a\xab\xbfF\xd5\xf6\x88VB\xbd\xbf\x90\xd0e\xa4z\xd6\x90?\xe5\x96\x07\xf0\xe4\x16\xc7\xbfV2\'[\xa8\r\xc0?\xdfo{\x84\x7f\x86\xc4\xbfJ$\xb1n\x0fO\xcf?c+\xdc\xcd`\xff\xbe\xbf\xda8\x05\xf2\xf1O\xd7?\xf5^\xb3\xd8\x18\x92\xb9\xbfU\xbc\xc7\xf0`{\xd0?,\x948\xf0\x88`\xc5\xbf/\x01\xbc\xe0\x84\xfc\xca?\xa8\x07X_\x81\x9b\xc2\xbf\x8d\xd7(\xcf\xe6\r\xc3? \xa4\xa4\x17\x9a4\xc3\xbf\xfaB\xb2\xd5\r9\xb8?\xc72\xd1\x18]\xd2\xc4\xbf\x0b\x96^\xbd9u\x9f?|\xae\x12x\x91*\xc6\xbf\xabx\xdd\xc8\xc5#\xaf\xbfy\x17\x9e\xce}\xe3\xc2\xbf\xc4\x93[t\xf6t\xc8\xbf\xd3\x1b:I\xde\xe6\xb2\xbf\x17\xdc\xd2\xde\x9b\xcd\xd3\xbfPw~\x85x\xde\x90\xbf<e6Pd?\xd6\xbf\x0e\x1f\x95,C\x92z?=\xf0U\xc4\xf4\xde\xd4\xbf\xcd\xbe\x9b\x83*\xa7\x9d?\xfcI\rK\xa7\x94\xca\xbf%\x1d\xfe\r\xb5!\xb4?\x1d\x0bx\xd7_\x7f\xb0\xbf\xa1Gw\x01\xed\xc8\xc1?\xbfw\xde/\x8a\x92\xa6?\xd3\x1e\x01*\xbdq\xc4?VH\xb5\xc2d\xf1\xbb?\xba,\xba\x87\xc3\xa7\xc3?g7\x8b)\x88\x88\xc4?}678\x11\xe3\xc2?\x83\x81i\xe7\xean\xca?\xfa2\xa0=\x11\x98\xc3?\xf1c\xdaQ\x05I\xcf?~\xe9"\xe2l\xa8\xc5?>\x98C\xe3\xf7\xe7\xc8?\x81;8\x89\xe2C\xcd?\xe4Pm@\xac\x91\xad?\xe9J;\xa4\t\x9e\xc8?\x92\xc1\x1e\x8c\x08\xeb\xb1\xbf\x93\xfe^83[\xbe?^\xf5\x13\xc0\xf5\xa1\xc1\xbfK\xb7o(\xaf\xf3\x88\xbf\xfd{\xc4\xcf\x10c\xc0\xbfg\x07}t\xe3\xed\xc8\xbf\xd8;N\xe3\x18R\xb2\xbf\x87Q\xe6\xdc\xc37\xd5\xbf\x10C2#\x00\x16P\xbf\x9b\x03n\xfd#\xb0\xd5\xbf\xa9\xfaM\xc9\x84\xe3\xb2?\xfd\x0f\xa3\x8c>\x15\xcb\xbf>@]\n\x9b#\xbd?X\xe1\n\xc0U\xc4r\xbf\x17!\xb0\x9d\xc7Q\xbb?\xb7g\x18Jc\x87\xca?P\x05\xab\x94\xd3\xc4\xab?1rV\x81\x9e%\xd5?\r\x82\xb8\xb3\x14\xd0\x9f\xbfr\x8d,\xed\x1d\x95\xd4?R@4\xe0\xd7\xe5\xbc\xbfA\xbe\xb2,\xf0\xe6\xc9?9\xc8q\xb72\xd5\xc2\xbf\x89\xd4\xaf\x8e\x13T\x96?\xd2\xa2\xe9BoR\xb7\xbf\xd4\x1b\x19\x8e\xd1\x0c\xbc\xbf\x04\xf6Z\xa7\x03\xbd\x99?.bx\xd2\xf6\xa8\xc7\xbf\x16d*!p\r\xc5?N!u\x9f%\x16\xce\xbf\x0eq\x8a\xbd\x8aI\xc9\xbf\x80\xa9\x92Z\x91{\xd0?H\xb0\xd8\x7f\xe9D\xb9\xbfQ({\n)P\xc2?^\xde\xea\xba6\x14\xb1?!\xbf\xf4\x19\xa0?\xaa?\xc7\xc9\xc5F\xa5G\xca?u1\x91\xf7\xa6\xfd\x92\xbf\x88\xf2\x91*\xce\x17\xd2?)\\s8\x95g\xa4\xbf\xea\xd3\xa3 V\xe2\xd3?\xb3\x83\x94\xe6\xf2 \xb0\xbf\x15\xef\x95\x85\xa5\xe2\xd1?\xa6:+y\xc7\xa3\xbd\xbf\xa0\x94b\xda\xd8\x0b\xbf?\x91O\xc3T\xf3u\xc3\xbf\x94\x0ee0pGd\xbf:u\xce^:\xb5\xc4\xbf\x90\xa3\xf0\xc7Qh\xbf\xbfFEv\xad\xf1\x13\xc2\xbf\xb7q\x8en\xae\xde\xd0\xbfY\x05\xf3\x92%l\xbc\xbf\xc8\x80q\xf2\xee\n\xd4\xbf5\x9e`\xd2G\x82\xa7\xbf\xb8\xd3\x11R]\xc1\xd2\xbfJ\x82\x17\xc6\xc7\xf4\x88\xbf>\x99\x94z\xc0\x95\xcb\xbfr<\xa44\x89]\x8c?\x89\xb3.\x9e"\xbf\xb3\xbf\xe6\xae\xd3\x81f\xe0\xb1?3J\xffzr\x08\xb6?\xa9\x9f\x82\xbd^!\xc0?:\x9b|a\x13\xa7\xcd?\xcc\xa2\x95\xa0i\x92\xc9?\x05\xe4o\x8b\x0b\xf2\xd5?\x0f\xf5\xee0\x12\x7f\xa3\xbfO\x1f\x85Z`\xf3\xc3?\xef\xe95C\xaa\x90\xb5\xbf\xa5e\xabDd:\x9d\xbfLr1=\x9f\xc6\xc1\xbf\xbe\xe3]\xf0|\x8c\xc7\xbf\xb3\x15\xfe\x02\xdeP\xbb\xbfw\x8b\xc4\t\x97\xc8\xd1\xbf\xec5OmU\x8c\x88\xbf\xfe\xfd\xeb\x11D \xd0\xbf\xe3\x04\xceD\x1cq\xb6?"\x83\xb0E\xaf#\xb6\xbf2\xa9r\xc8\xec\x03\xc0?,#\x02\xe3\x93S\xcb?\x12\x16\x8a\x97\x9eD\xba?j\xfb\xcdd\xcf\xfb\xd4?\x05\xad<K\x93b\xa8?|3t\xf3\xc4\xbb\xcd?\xddp\xaf7\x88U\xa8\xbf3\xc1\xe3sLb\xb0\xbf:8\xbe\xa3\xab\xb1\xc3\xbf\x0c\x88\xce#\xfd\x95\xce\xbf!\xf5q\xce\x84\xa5\xc7\xbf\x9b\xa8\x94G\x12\xa6\xd1\xbfH\x9b\xc5\x0c\x85\x9c\xb8\xbf\xd7\x10:\xd2\'&\xc7\xbfd\x1e\xe6y\xff\xab\xa9?\x86\x17\xb0\xee\x8f\xb3\xab\xbf?\xac\x99\xabz\xa4\xc4?\xa4\xab\x99\x83\x13\xa2\xbb?\x02g\xc2X$\xf5\xc3?l5\\\x1d\x19\xc7\xd0?:}\x97]\xb4\xde\xc0?\xb3\x05\xb0k\xb6\xa8\xc1?\xb6e\x07\xcf1\xce\xe0?\xaf\xfe\x9e[\xd5\r\x9f?\x91\x96y\xa5\x10\x8e\xcd?x\xbbq\x87\x85\xc5\x8b?#\xca\xcd\x10\xccW\xbb\xbf\xd05*Z\x1e\x12\xac?V\xbd \x16\x1f\xe4\xd6\xbf\xb8\xf7c \x04\x81\xab?\xae\x10\x9e]\xfc?\xd7\xbf\x90q\xc4\x02\xddA\x9e?%\x0f\xc4v\x19V\xc9\xbf\xa1\xben\xb2\x81\xb3\x9e\xbf\xaed}J\x17\xec\xb3?\x91\xc7\x05O\xeep\xb0\xbf\x13\xc5\xbaY/\xa0\xd1?\xc7\x0c\xeey\x1d\xf4\xb0\xbf6\x05\x7f\xb2\x9d\xa9\xca?\xf8\x87\xb7\xeb\xa1\xcd\x90\xbf\x93\xacH\xf2/5\x93?\x07\\\xd4\xd9L!\xae?D"\x8fB\xe7\x8d\xc4\xbf\x91Q\x95\x01=\xa4\xb9?\x05&\x94,XH\xca\xbfL\xf0*>\xb4\xad\xb7?\xd5y\x9e\xb9\xb1\x03\xbe\xbf-4n\xf5\x00\x0f\xa5?[\x1a\xaa\x95\xed\xec\x9b?\xb2+X\xa8\xc5\x17\xb0\xbf\x92\rWI\x1f\xc1\xbc?r\xfc\x142\xec>\xc5\xbf\x11\x10\xa5\xa8\x8fc\xb0?\x83\x1a\xc8c`{\xca\xbf\x11\x0b^!c\xd9\x9f\xbf\xf2\xadv\xcbh\xd0\xa5?/\xdc\xc5\xb7r\xdb\xc4\xbfl{\x00\x1b1\xf8\xc0?\xbcv\\7v\xc0\xb0?\xa1(S1\xdf\xd3\xb6?\x05\xeb\x90e\x8fS\xcd?\xd2\xdc\x81\xeb\xf5D\x97?\x0c\xde\xc8\xee6\xc9\xc4?\xb3\xd8\xa1\xae\x86 \x93\xbf\xc5 \x18\x86\\<\xad\xbf\x1d\x9en\xc8D\xda\x9b\xbf\xef\xe5\tyq\xa5\xce\xbfNO\xd8\x0f\x99\x12\x96\xbf\xec\x18q\x1e\xf7w\xcc\xbf\x93\x8b@\x18W\xd2\x9b\xbf[\x12\x96\xb4\xf2q\x88\xbf\x81\xe8bHE\x1b\x98\xbfQ\xbbL\n\x00\xe8\xc8?3\x84\x18\'=F\x92?\xf7\xd9.S\xea\t\xcc?\xc2\x8a:#\x1f\x02\xb4?\xeb3\xd5\xc4\xb2\x0c\xb8?4}\x9c\xba\xf9\x83\xa6?\x8e\xe0N\xaf\xadw\xbd\xbf`%\x84\xaa\xfa\xb1\xa8\xbfi\x00\xe4\x06ff\xd4\xbfY\x98`\xef[\xb8\xb2\xbfk\xed\xc43T\xf7\xd8\xbfV\x1e=\xce\xfc\xcd\x9c\xbf]\xa9rq\xfc\xb0\xc6\xbf\xf6ZO\xaell\x9f\xbf\xf8\xc9v\xcf\x02\x82\xc9?\x15\x00KZUz\xc0\xbf\xff\xce\xc5V\x04\x00\xe1?c\xe3a\x8e@y\xcc?\x9d\x96`\x18\'J\xb2\xbf\t$U\xaag\xe6Y\xbf\x07\xd7\xab\xb7\x0fA\x8c\xbf\xce\xe3\xfe*\xbf\xd5\xcc\xbf\xea\x06[\xdcA\xe8\xb2?\xbaP\xee\xa7\xa0\xe3\xd3\xbf\xf9\xc4\xaal\x84\x94\xbf?\x18\xca\xc7\xe2\xa3\x96\xc3\xbf\xa0\xa3z9%\x9c\x91\xbfh\xd9\x8e\x02\xf4\xc6\xc1?W\xfd\xe2\x9d\x9e\xc5\xbd\xbf\x9a6\x1b)\xd0[\xd9?-\x93\xbe\xe4\x0c\x91\xb7\xbfU\rK\x9aKh\xd4?\xdd>\xa3\x89\xaf\x0b\xb6?\xc0jd\x14\x06\xabi?\xdf^\xd6Rc\x1b\xbb?4\x95\xcb\x0b{]\xd3\xbf\xef%\xc8\x1c&a\x9d?\xe1\xe1\x8a-\xb7\x18\xd6\xbf\xcf\xb4\xd1\x16\x95*\xac\xbfX\x02?B\xf3\xaf\xc3\xbf\tDat\x19\x8f\xaa\xbf\xd1\xab(l{.\xc2?\x83\xeaZ\xc35:z\xbfOp\xdf\x921 \xd2?\xc3\xe4\xeedm\xb7\xa4?\xc0.y\xe5\xa7E\xca?Bq\xba\xcb\x87\xbb\x96?>\xc0\x01N\x16\'9\xbf\x180q\x80\xd9^\x8c\xbf\x81\xa6d:B\xd3\xcb\xbf\x89\xcb\xc7?\xcf\xd4\xa5\xbf\xd4\xdfaI\xe0y\xce\xbf\xc5B\xb8\xfb\xea\xa4\xb8?\x8f\xdaq\x9f\x83^\xa0?C\xa0\xeaE]\x00\xa3?\xdf1\xbe\x94^\xd9\xcf?\x8co\x01-\xa1s\x9e\xbf]o\x159\xf9\x7f\xd0?\x1c9\xe6Cal\xa4\xbf&\xf9\x0b\x08z\x9e\x95?\xbf\xec\xf0 7\xf2\xa4? \x94\xba\x9b\x8b\x18\xce\xbfd8\xe8\x99\xa1)\x8f?\x92T\xe6\x00\x99\xfa\xd1\xbf\xe8\x8dQ#o\xfb\xc1\xbf\xc0<\xa3\x02q\xfe\xb3?\x98\xdd\xe9w\xf6\x80\xc9\xbf\x84\x1c\r4\x05\xa9\xd1?\x9eA\x04\x9b}J\xa4?/\xee\xb3+\x00\xb8\xb8?\xd6*\xf4\xe7\x05_\xce? \x83\x8d\x0f\x1f\xbe\xd1\xbfHm[\x17\xee\xbf\xb6?\xf5v\xfc~\x858\xd3\xbf\xc6\x86\x10\xfe8\xcb\xb7\xbf\xed\x9cK\x89S\xf6^\xbf\x98\xbe\x00\x94\\\x1a\xb6\xbf\xc1\xf8\x94\xa9C\x95\xd2?\xdf\x91\nS\xa8\x98\xac?Y\x82\xe4B-\x92\xd1?\xea\'#\x99\x96\xe6\xb9?\x90\x81\x9b\xf7\xb5\x97\xa0?spq\xa6\xf3\xa3E\xbf\x80\x81k\xed\xff\x89\xd1\xbfA\xed\xc8<\xcb|\xbf\xbfQ\x8f\xf3\x92K#\xce\xbf\x8f\x85\x8f\xc6V\xf7\xd3\xbfJ\x91]|i\xcf\xad?\xe1\xa9(\xd2\xaf\xe0\xb9?pa$\xf6\xc6G\xc4?\x02\x1a\xcbS\xbc\xb6\xd8?\xf7\x82\x91]\x0f\x02\xb0?\xb0\x9c\xefC\xad\xf0\xcc?\xe1\x91\x812\xad8\x89?F\xb9F\x02\xca[\xc8\xbf\x01\xf2F\x9f\xbc\'\xb0\xbff\xd9\xba\x00\x07\xd9\xd5\xbf\xae\xa1z\x12"3\xc0\xbf\xe6,gn\xbf|\xae\xbfz\x871\xcam\xeb\xa7?\xbc\xbc\xd9\xeehZ\xd2?}\xd5\x9eO\x17u\xb1?\xec\n\xa7\xa5\xe8\xc0\xc8?\xde\x86\xb1iu\x04\xac?\xc8\xb6\xed\x89\xad\x89\xc5\xbf\x9fl\xf0\xdcd\x06\xa6\xbf\xcb{P\'o\t\xd4\xbf\xb8&W\x15\x8e5\x88\xbfoL\x1c\x82C6\xb9\xbfoJ\x150\xd1#\xa8?\xa1\x8e\xbeX\x96\x90\xc7?\x90\x84~\rS2\xac\xbf5\xf0\xa2\n}y\xcf?>\x8b\x8c91~\xb7\xbf\xb7K\xb6\x1a\xe9+\xb7?\x1d\xc3\xa5\xf3\xc6\xd4Q\xbfla\x9f\x01\x87@\xb3\xbf \x91l\xc7\xd0\x9d\xbe?\x13\x87\xcf\xc1\x99\xf0\xc3\xbf\xb4Z\xfd\x94"\x0f\xa2?\xdaI9\xbd\x1b\x19]\xbfb)4\xc8\x9f)\xae\xbf=\xcd\\\x03\xdf\xc3\xc0\xbfv-V\x10\t\xb8\xa1\xbf\xa7\x84\x90=\xef\xa0\xaa\xbf\x9e\x9b$\xa5k\xc2\x81\xbf$\x8fG\x91\x90\xd2\xc6?C\x8b6\xad{i\x92?\x98"TIM\xa9\xca?\xd6-\xe2K\xdb\xbe\xb3?\x17\xc3\x8c&\x19\xe1\xa2\xbfM\xcb\x0e\xe0/x\xb9?\xe9";,\x9c\x8a\xd1\xbf\xbe\x9a\xeak8\xd9\xb9\xbf%Gl\x0e\x14\x7f\xc5\xbf\xd9\x93{N\x19i\xc2\xbf\x859\\\x8d,[\xc4?t\xb7\x10Y\xe6d\xaf\xbfY]\xbbB\xcb\x0e\xd3?X@a\x8fta\xc5?\xff\x80\xfc\xc6\x9a\xe6\x83?1\xc4GH+\x1f\xb8?\x8b\xee\xe1Q\xc5\xf7\xd4\xbfCUq\x8b*x\x9d\xbf\xfd\xa8\xc4\xce\xff\xb2\xd1\xbfQ\x1f\x0bL-\xcc\xaa\xbf\xab\xc69\x9fG`\xc4?\x1aT\xdb\x0f\xc8\xcb\xbb\xbf\x08\xa9Y\xca\xd4\xe9\xdb?\x03\x89\xb1\x86\x01\xd4\xb5\xbf\xb3\xf3\x98c\xbas\xc3?x\x88}\x96\xed\x97\xc8?I\x16\xab\x1a&I\xd5\xbf8\xf3\xf3s\x00?\xc6\xbfy\xe1+\xfc\x01D\xc4?\x97\x95N\xc8\xfe\x97\xba?\xad[\xd9\x04\x043\xac\xbf\x07"\x7fi;\xa3\xcf?\xbdl<\xe5\xdee\xc9\xbf\x1c`c\'\xb1w\xac?\x80`\xf5>\xbb\xfb\xa9\xbf\x11c\xc5G\xd6S\xc7\xbf>\x12\xfa\x83Fy\xc4?{g\x91\xa2\xb3F\xcf\xbf\xa4\xdc;\xa3zk\xb5?\xdb\x9eS\xa2\xb6F\xb3?\x8c&\x9f\xce\x12]\xc0\xbf_=\xf0\xcf)\xf5\xd1?+QH\xfdPp\xb6\xbf\xe6t\xdb*\xa8 \xa4?\xaf\x0b\x18b\x12\xf8\xc0?\x1f\xd1\xdbzr\xb2\xd1\xbf\xc9\xa6\xe5#m\xe2\xb6?\xe5/\x95\x10\xb0\xcf\xc7\xbfm\xc7\xdck\x949\xbc\xbf\x1b\x1a\xa6\xf9\xf5\x85\xce?\xc8\xb2\x10\x8a\xf5\x10\xa6\xbf\xb8\xcbv"+.\xd4?*w\xe7\x04*\xbe\xc0?\x80S\x89\x9e"\x7f\x9f\xbf\xe4\xc0Sl\xeb\x87\x93?g\xe6\x8bp\x0c\x0f\xd7\xbf\x0b\x07\x9a\xa1\xfep\xc7\xbf\xa9\xec\xea/N \xc1\xbf\xe1\xa6\x1a\x8b\xe0K\xb2\xbf\x08V\x97w\x1e\xb7\xcd?m\xa5\xccJJ\xb3\xc3?\x83\x05\xc6K0\xc1\xcc\xbfm/\x11\xa9\x01\x05\xc8?CKg\xc80\x1f\xc1?pk\x0f\x1b\xa8\xb0\xc1\xbf\x98A\x7f(\xf7\xa4\xd5?\xe1I2\x06#\xd2\xc7\xbfc\x99\xf4\xf5#\xfd{?\xc8m"\x7f\x0f\xf0\xbb?>\xae\xffYY1\xd4\xbf\x87\x94\x92\'\xb0F\xc2?aeg\x83\xa9K\xc4\xbf\x90\x9d\x15\r\xb9\x14\xc6\xbf\xe9\xd3#x\x96\xac\xd1?S\xb0\xab:\xa3\xea\xbb\xbf\x89\x94+\t\x1a\xb5\xac?|9V\xdd\x8c\xd7\xd1?\xbcK5\x0e5\x1f\xc9\xbf\xfe\x13I\x9c\xf9\xcb\x9b\xbfI\xa2\xd0\x1bcm\xa1\xbf\xcf\x1d\x98\xd4\xb6\x0c\xcf\xbf\x83zh\xd7\r\x0e\xcf?BS\x9e\xfckr\xb3?\x1ff\nq\xb5,\x9c\xbf\x98t\xc9\xe5\xd7\x17\xc5?\x8cSThu\xcf\xcd\xbfq\xae\xf8\xd3)\x9b\xa1\xbf\x12\r\xdc\x98M\x8f\xb1\xbf>\xbb\x9a\x1a_Y\xb7\xbf\xa9\xf0\xfd\xd8\x99`\xcc?l\xfd\x9d5L\x99\xb2?\xd7\xcdK\x12\xc7(\xc1?"\xd2\x91y\x03S\xb3?\xb0V 3\x1d`\xc3\xbfj\xfe\xef`\x06\'\xbb\xbf\xd81\\\xc5)\x9c\xcc\xbf\xd4\x15h\x88y\xde\xc0\xbf\x18%(X\x8e\x1c\xd0?]c\xd4\xcc\xcdN\xc3?\xfc!\x0e\xc1\x17\xf1\xca?\xeb\xc5|\x1a\x9c\x1d\xc8?\x98\x9e"\x19e\xd6\xc3\xbf\xeaGv\xbc7\x96\xba\xbf*\x17-1\x84v\xca\xbf@\x10\xc4Ur\x12\xd2\xbf5\x9a\xb1\xfa\x00\xe4\x93?\xed\xe6\xaa\xa4\xf9k\xa8?p\x1f\xcd\xcb\xf5\xa2\xc9?\x06\xe5w\xf7\'\x7f\xd6?\xa7\xd8V\xc3u\xec\x99\xbf\n\xc9\xc4?\xa3H\xb8\xbf\x97\x95\'\x080\xd2\xa7\xbfF\x1fL\xb45\xdb\xd3\xbf\x10*\xbb\x8c\n\x93\x80?5\xac6wP9\xac?\x13-\x85\xfc\x00p\xa5\xbf\x00\x1cV\xb7a\xc9\xd0?\x86\xca\xacl\xc2\xf4\xb6\xbf\xce\xd9oE\xa4\xa4\x96?\rx~\x11\xd7\x00\xc3?\xda\xce\xcfW\xbd\xb5\xd0\xbf\xdf\x1aK\xa2\xc5\x14\xc2?\xcb\xc9\'\x8a~\x93\xaf\xbf\xc20\x02\xe4\xa9H\xc6\xbf/\xb7\xe1\xf9\x8a\xfb\xc7?\x8d\x85\xd3\xc1\xf9a\xc6\xbf\xbf\x0f\x07\xc8\xc5\xae\xb5?v\nW,\xbb3\xc4?\xf0yR\x8b\x81\xa9\xba\xbf\xb9!3}\xd2\x00\xb9\xbf\xf24\xe2\x93\xbf\xdc\xbd\xbf\x899\x83\xf6J\x15\xbf?6\xd3&\xa6\x92\x9d\xc4?{,%\x9au\r\xb0?\xec=\x86\t\xdcv\xc2?\x14k\xae\x1b\xfe\xf4\xa8\xbf$*\xddBbz\xc8\xbfr\x0e\xa0\xae\xd3\xef\xbb\xbf\xfd-{C"\xa2\xc5\xbfPr\t\x90\xfde\xa3\xbf\xb8\xa9zQ\x1c\xfc\xca?\x99+\xaf\x91\x19v\xc0?\xac1\xd7\xfb\xa6\x9a\xba?+\xf0O\xf7}b\xb8?\xfa\x84C\xdb\x02\x99\xd0\xbf\xad\xb3i\x9d\x85\xae\xb8\xbf\xf8\xd1vZK\x97\x98?LTNh2M\xc5\xbf\xf3V\xfc\xaaG\x8b\xce?\x99q2`,}\xb6?KR\xb1\x0c\x82}\xb6\xbf\xfd\xde\x93E{\x88\xd1?8\xb4\xd4\xf2E+\xd0\xbf\x957w^\xf4\xba\xc9\xbf\x05\xb5;VH\x86\xc0?4\xad/\xff\xfe\'\xd6\xbfW\xd2N\xdfp\xdc\xca?v\xd6>\x01\xb9b\xd1?OX\xaf&U\xf6\xaa\xbf\xa3\x14!\xfc\xbb\xd7\xd1?\xa9X\tW>\x1c\xbb\xbf\x1f\xd4\xfa\xf6\xb5\xbe\xcb\xbf\x96D\xa0\xd1)\xf2\x8b?\x1c\xb7\x1f\xef\xdd0\xa1\xbf\x10F\xe8\x0e\xa6\x8b\xb6\xbfV\'\xc48\x9b\xe8\xb6?\xf0\x80\x94\xc6\xe1\x8e\xc5?V>,\xc0>_H\xbf\xf3\xe1j\xb2\x81\xc4\x94\xbf\xd1|\x05^<|\x93\xbf\xb4\xe2\xeba\xeb\x9e\xc6\xbf\xd2b6\xd0\x15P\xb4\xbf\xb5\xfaiba\xce\xb2?\x1b\xd9\xea\xaa\xe5\x05\xa1\xbfD9#\xf7#\x1b\xc5?\\}q\xd0}\x96\xcf?\x8e\x0b\xb8\xec~\xb7\xc7\xbf^\x82%\xb0\xaa\xc2\xc3\xbf\xe4\x0e\xa1\x05\'>\xb1\xbf\x83\x96\xfe\x0c{\xd7\xcf\xbf\xb3\xe4YW*\x9e\xc6?\x13\xff\xf0j\xcda\xcc?\x84\xdd~\x83EF\xab?T\x82f\xe0\x05\xcd\xd3?\xd9en\xe2\xe4*\xc4\xbfI\x9dBll\xfc\xda\xbf\x19\xf1B\xc8|\xc5\xae\xbf\x1d\xd1r\xb4\xc9\x04\xae\xbf\x1a\x9a\xdd\xc4\xad$\xba?\xf4w?\xea\x83\xf9\xd4?\xd7 \xb3]\x91\xfe\xc9?O\xda\xdf\xae\x1b\xa2\xb9\xbf\xa6H\xb1n+t\xc0\xbf\x8au\x1f\xd5\x15\xa2\xb9\xbf\xa5\xb8\xcb\xbc\xa8\xc0\xd0\xbf7qO\xc3\xff\xe8\xab?w\x8f\xb5\xa4\xc7\x13\xca?\xd4\x9e;B\x9d\x10\xc6\xbf\x93\x1d\xdc5\x0b\xb8\xc7?\r\xaf\xa4*%\xa5\xd2?m\x89Z\x97H\x1b\xc6\xbf\xf8\xb1Yu\xe5p\xc3?K\x1d\xd1\x94 \xa0\xc4\xbfW\x19\x08Q\rL\xdb\xbft\xf4w\'v`\xc5?\xc9!\xa6\n\xcbt\xa0\xbf\x85`\x9b>\xc6B\x9c?\xb5\xb68e\xf8\xaa\xd8?6\x05\x15\n\x9d\x92\xb4\xbf\xed\xf1i$\x8e\t\xaa\xbf=w\xc4\xd9\x8d\xef\xb7?\xda\x86\xd0\xd3\xcd\xbd\xd5\xbfQ8\xf0\x9d\xb8_\xc4\xbf\xb3\xcc\xe5\xde\xf3_\xc1?\x10\xd0\xba\x80\xf8\xfa\xbd?P\xf1\x0b\xbe\xf9I\xc8?\xc24\xe3\x16\x10\xb0\xc3?\r\xdc\x94\xcd\x0f\xa3\xbd\xbfa\xbaV\x1e\x876\xd1\xbfh)\x9b\xbf8E\xb2\xbf\x99\xc7\xc4\xa3\x9dt\xa7?#\xc1MM\x86\x8f\xc0?x\xef\x0b\xc2\x9c\xfc\xc0?\xb2\x1e\xf0y\x8d\x0e\xbb\xbf\xa2\x9a\xc36\x9a\x8b\xa5\xbfe[I\x9f%\xa7\x8a?\x06\xfa\xf9zY\xfc\xb2\xbfc\xb0OpN\x18\xb8?\xa3$_\xb7he\xa1?\xbb\xe8^l\xb2\x83\xb3\xbf;\x8b<q\n\xa3\\?&F\x1f\x1c\xfag\x9d?\x13ql\x81\xd1z\xb0\xbf\xfb^&L\xd6\xf0\xad\xbf\x9f\xd0\xa2A\'i\xc4?HD\xd4\xc4\x98\xb9p\xbf\xc8\xcb?<\xdc\xb6\xc5\xbfL*\r\xa7r\x92\xb8?\xe0\x15FoJ\xcd\x91?\x84#aI0:\xbd\xbfW\xa8 \x94XL\xcb?Z9\xc5\x86\x99\x8c\xab?\xb1\xe0\xe2\x08.\x98\xd1\xbf\xb1M \xef\xb8P\xad?_\x8f\x02\x9e\xea\xdf\xb5?J\xe6\xeb\xf2\xb9\'\xcb\xbfz\x0b\\-|\xc5\xc6?\xb0\x06\xfd\xd7c\xa0\xd2?\xe0\xd3\x13&\x16\xd7\xd1\xbfq\xf1\xe0\xb1!\x14\xc8\xbf\xffXRg\xc1\x9c\xc7?/\xd6U\x17~O\xb5?c\xe2\xae\x16\x9agN\xbf\x17[\xc7_!i\xb2\xbf\x828\xa6$a\xf6\x9e\xbf\x80\xd4\xff.d&\xc3?re\x97=\xba>\xc1\xbfO\xd0\x90\xb0\xee\xa3\xce\xbf\xc5\xab\xe6\x14\x81[\xca?\xa3\x881\xf0\x00\xc6\xd1?6\xfc\xd1\xede\x01\xa7?\xcb\r\x16^\x08Y\xce\xbf\xea\xf8\x99\xc8u\xc8\xd6\xbf/\xe2X\xc3\x07\x88\xb6?\xf0\'\xa3PpB\xcc?\xf8rSe*\xc8\xc2?\n\xca\xbbp\x07\x7f\xc3?N\xf2)\x84\xa7j\xd2\xbf,\x9c\xf0\xa1L\xeb\xd2\xbf\x15u\x88\xca\xf7H\xb7?{\xccU\x8a+|\x97?\xcc/uZ\x898\xc7?\xd9\xa8\xc9\xd4w{\xd1?\xc6\x86\xa8 y\xd7\xbd\xbf\xb6u\xd4\x0f+D\xc0\xbf\xc9M|=4v\xbc\xbf\xdc[f)\xe0\xf7\xcd\xbf\x9f\xb8\x7f\xbd\xbd\xce\xc6?\xc2\x99rl\xa3\xa2\xd2?\xc2\x08Zd7\xee\xb6\xbf\xf9\xec\x12\x08\xa6\xa1\x9e\xbf\xa9\xacJy\x1b\x9f\xb8\xbf\x1b0\x8d2n1\xc8\xbfa\xca\x97\xd2\xccR\xc5?ev\x03\xfciy\xc7?j\xa8\xac\xc5\xc7\x99\xad\xbf\xe0\xd5r5\x90\xcd\xb8?O\x91\x17\x18\xc6\xb4\x94\xbf|Z#\xe5dG\xd1\xbf\x1b\xacz\xc8\xa1\x97\x8f\xbf\xdcpl\xb8\xf7=\xb6?\x88\x03&\x1fZy\xc0?\xbc\x10\xfb\xe0\x9d\x19\xc8?,s\xf2]\x97\x98\xd0\xbf\x03\xd7VL\xaa$\xc5\xbf\xc7\x18\xbc\xecW&\xd1?Y\x00C\xb1\xc8$\xb5\xbf\xe1|^\xf5\x82D\xbb\xbf,\xe1\xfaN!5\xb9?&\x16]\x11a\xde\xbb\xbf\'\xe2ea5\'Q?\x92\x90\x06R\xd6\xe4\xcd?_(x_U\xd6\xa8?q\xf7\xdb\xbc\\\x1c\xb1\xbf%\x02\xa6\xf3\xc09\xa8\xbf\xd3\xda\x93>y\x00\xc7\xbf\x8b\x86kJS\x9e\xb9\xbf\x10R\xf3u\x02\t\xbe?Ek\xcf\x9a\x11f\xc4?L\n\x16)\xb8\xf3\xb4?r\x7f\x9c\x9c\xa2\x86\xa0?V\x01\xe9\xe9`e\xa6\xbf=\xf5\xca\xd2\x00\xbc\xd0\xbf\xb3@(\xa2\xd4L\xa0\xbft\x07v\x9d!!\xd2?\x8c\x96l%\x8cV\xbc\xbf\x98\x82G\xab\xd8\x07\xbf\xbf\xc3Z \xcd\xdc\x85\xd2?\x02>t\xbe\xa7\xf4\xc5\xbf\x84\xed\x84\x9b\x89\x95\xd4\xbf\x8dG\x1cDR\xf4\xdb?QK^\x18\xbe`\xc7?\rjz\x05\x88g\xd5\xbf\xeb\xe6\x1aJ\xcbZh?Z?\x03\xf43\xb3\xac\xbf\x12\xeb$a\xbd\x0c\xa7\xbf\xd2Wu)[\xe3\xcf?k\x1dm\xaa0\x0b\xa9\xbf\xbajY.\x07\xae\xb6\xbf>`M*\x9f\x9a\xb5?\xd5+`\x90\xb6\x0f\xbc\xbf4\x03\x80\x04\xaf\xde\xa1\xbf\xe5\x8b\xdc#\x15v\xb4?\x01\xae\xc1o\x07)\x94\xbf\x9e\xdd\xfa\x05v\x86\xb8?B\xb5\x14\xb4\x10\xd1\x9b?\xca\xb4\xc6\x9dw\xe1\xc4\xbf\x14Bn\xc6\xaeG\x95?Z\xca\xb2^\x0f7~?\xe1w\xcaB\xd3\xbd\xa0\xbfM\xda\x00v`m\xc1?\xa6\xab6\xf1st\xa2?>9\xe9\x1fe\xc0\xb7\xbf\xfc\x00\x0e-4\xa4\xa1\xbfA"\xef\xf5\xf4\xf1\xab\xbf\xf5\x07\x82C\x87\x14\x8a\xbf\x00\xc3\x0f\xdbKZ\xc0?\x18\xc5L\xf4\x1d\xc1\xb9?`\xde\x8c\xc0\xc7g\xb4\xbf\x94\x88S\xe8TS\xc7\xbfY\xc2\xf9\x93\x8dsh\xbf\x0b\xfe\xbbs\x7f\xf9\xc4?O\xdd\x89a!\xde\xac?#X\xa1\xfd} \xbc\xbf\x05\xb7\x10\xacID\x83\xbfA\xdd\x11[\x93\xfa\xc6?\x83l\x95V\xc7\xcb\xc1\xbf\x8b\x0b\xbe\xa6\x16\x86\xd3\xbf\xb1\'\x98f\xa2\xa0\xc8?w\xbfg\x182\xcd\xbe?\xb2V\xe3\xacp\x01l\xbfZ\x16\x93:\x01\xb9\xd9?\x93\xd2\xb9/r\x99\xc3\xbf\xbd\x84<\xd5G|\xe3\xbf&\xfa?C\xfd\xcd\xa6?\x85?\xe6\xc8,Y\xd0?\x89 \x0c\x1bNT\xa3?\xb1J-\xa9\xad\xac\xbe\xbfd5\x86\x10\x85\xc4\xa3?\xa4\xab\x0e\x8d\xb0\xb1\xcc?\xe9\xf1\xf7\xa3m\xeef\xbf\xf2P\x94=\xeb\xa8\xb1\xbf\xff\x8e{\xb90\x01\xb4\xbfY\x8c\xf3\xf4\xbc\xce\xc8\xbf\xdf\xbc{W]"\xa0?\xc2\xa4\x14dq\x1e\xc8?\x10x\xad\xe1\xe3\xd2\xb9?:\xc3\xf6}\x82{\xbc?\xe6\xe1\x97V\x81S\xc6\xbfd\x04\x13{\x05\xff\xd3\xbf\x02g\x80\x00\x94\x9f\xb9?,\xd9\xba\xa2\x9a\x97\xd1?\x05^\x0e\xa9\xfc|\xb7?{PTp\xf9\x1b\x93?\x85I\xb88f\x9d\xcd\xbf\xca\x14\xf2\x984\xd9\xd2\xbf1\xe5P\xf6\x06z\xc8?\xf6\xb8l4\xd7\xe7\xcf?>\xa6\xc5\xbaB\x92\xb2\xbf\xac\x8e\x08\xb9p\x93\xb1?m\xa7\xbf\xdb\x98LU?\xefS.p\x1b)\xd8\xbf\x12lZ-\xc7\xcb\x9e\xbf\xdd\xe0\xba\xe2\xf4"\xd7?\xf1r\xadw8x\xb2?\xebxD\xd2\xcc\x93\xcb\xbf/Uv\xbe\xcf4n?\xf9A\x15\x0f\xc8)\xbb?\xd6^\x89\x01\x10\xd0\xbc\xbf\xd5 \x85\xf4\x9d\xe7\x94\xbf\x9d \xf2\xc7\xb2\x19\xb2?;\xa0E`\x08p\x91?\xb7#QQ\xc5.\xb2?a\xd4\x07s4&\xa1\xbf\'o\xf9g6\x1a\xb9\xbf[\xa64\x08|\xfa\xaf?\xc3\xb5\x85\xa7\xc7F\x9c\xbf\xcb\xb2\xa1\xbe\xa1\xfb\xc3\xbf8#\xc6J\x15w\xba?\xd5xrq\x82\xce\xcb?\x92T\x16\x8cL(\xb5\xbfC\xbaj\xc0\xc3\x87\xaf\xbf\x078\x12L\xc1U\x98?\'\xc9\xea\xa0N\xa9\xcb\xbf\x82\x04\xf98B\xcc\x86?>\x05B\xe1!\xf9\xdb?\xa6\xf4\x06\rb\x96\xa5?\x80\xdd\xdcY\x18^\xdb\xbfx\xeb\xbd\x90\x85{\xc2\xbf\xc7\xb3/}\x18]\xc3?\xde\x85\xf1=(\xc8\xc2?\xbe\x9b\x96\x82P^\xc0?\xd6\x05\xe9\xdah{\xa9\xbf\xecj\xc4\xbf\x06\x94\xd3\xbf\x1b"$do\xed\xab?\x85\xff\xf1\xaf\x1ce\xd8?Iv]"\x8c$\xbc\xbf\x17-\x8a\xd5#\xee\xd3\xbf\x9b\x14\x0f\xeav\xa9\xad?\xee\xd6\x1aZ\xe9\xd9\xbf?\xf5^\xb8\x83=J\x9e?(\xe5\xdf\xfb\xa0\xe2y?\xdf\x9a\xad\xbc\xe3\xc6\xb3\xbf\xa5\xf70\xbe\xe0\xe1\x89\xbf7\xdb\x86\x16\x1aL\xa9?\xb2\xe5\x9f\xd2\xf7W\xbf?{\xabp`\x8d\xa4$?\xfb\xa9;\x04\xd3\xc4\xd6\xbf\xf5\x9fDn\xb0F\x9f\xbfZ\xf2\xaa.T\xe3\xd8?A\xd9\x7f\x9fF\xed\xa8?qZ\x1f\x8a-\xd3\xb1\xbfCQ.\xec//\x87?\x80\x1eu{\xca\x1d\xd5\xbf\x1e6\xbc\xf9\x80\x17\xc2\xbfe\xee\xc6\xd8\xb8l\xdb?\x0b\x02\x965\x1b\xc1\xcb?2\xadn\x16\x7fU\xd0\xbf\xa6W\xa6]\x10\x99\xc4\xbf\x19\xf8\xe8\xc3\t\xd0\xb8?\xc0\x01\xfb\x86\x81W\xa6?\xf9\x96\x88znM\xa3\xbf\r|.b \xbd\xa3?WP\x12\n\xb8\xe8\x8e?D\xf3\x14\xb7\xc4\xf4\xad\xbf&\x8a\xf0ZC^\xa9\xbf\xd4\xfa%x\xd3-\xa9?8\xcf(\x8d\xf42\xbb?-9Pg\xd2\xfa\x8a?\xfdr\xbe\x8e\xea\xd0\xbb\xbf\x80\x1f\xaa)2\xab\x96\xbf\xd0A\xb8\x1b\xe5d\xb5?\x9dC\x8c\x96\xde\x83\xb2\xbf\x11\x81\x1eLh\x94\x95\xbf\x92?\x03o\x00h\xce?\xe7:\n\xfc\xff\x03\x99\xbf\xb4\xf1\x98\xb6\xb7\x08\xd5\xbf\xf4>u}\xb8\x1a\x85?\xde\x8c@\xa3\x89\xe2\xc3?\xc3IK(\x0e\xb9\x88?\xcc\xbf\t\xe3\x19\xfe\xc2\xbf\xc8a\xdbT\xfb\xfc{?<\xc5\x08\xea\xec\x10\xd1?C\xacv7#\xc4\xb8\xbf\xbdF\x0en\x89I\xbc\xbf\xa7\xc5\xf1{/J\xc3?Y}\xc2\xacc\xe8\xbb\xbf\x82\xb3}g\xbf[\xbf\xbf*Zj\xfdt\x1f\xcb?\x1a7\xd5 \xe5l~?\x057\xdf#lK\xc0\xbf\xf1\xe1i\x08\xf2C\xae?F\xb5\xf3\x8b\xcfb\x82\xbfa\xc7M\xbc\x8bN\xab?\x07\xc2H\x1f\xcc"\xbf?!\xa0\xea\xd0:\xfb\xcf\xbf\xef\x88\x05\x91\xcco\xcf\xbf\xcc\xea\xeaX\xec/\xd4?\x0c.\x05X\x97j\xd4?i]`\xccD{\xd0\xbf\xc8\x17p@\xea\xc9\xd1\xbf\x06\x85\x7f\xe8\xe1O\xc3?\x83\xa9\n\xb3\xb9\xf3\xaf?\x16\x1f\xae\x15\x81\xba\xa0\xbf\x97B\xfd\xf3/\xf3\xcc?\xa9~\xf5\xf3\xcd\xf0\x9b?\x19"\xfc\x8e\xc8F\xd7\xbf\x9d\xca\xb5\x86<\xe4\xaf\xbf\xf4\x10\xceQFa\xcf?\xdb6\xa3\x9a\xcf\x01\xb3?\xce\x99\xf7S\xf8\x15\x81\xbf\x04(\xe4d\x17L\xa2\xbf\xfaT*\x0648\xab\xbf\x8f\xbc\xf31l\x04\xa9\xbf\x0clrY\x05\xf6\x90\xbf\x03=\x82\xa4\xe0\x8f\xc1?\xd6#\xbdV\xb7\xc4\xbb?\xca\x19\x1ca\x98\xf8\xc7\xbf\xd1\xcb+\'B\x9e\xc7\xbfz\xb4F\xbbx\x80\xc1?\x84\x10\x84*\xbfQ\xbd?\x9e\x16|\xeb\x0c\x11\xa6\xbf\x13\xcf\xc46\x7f7\xb4?\xa4\x0b)\x15$]\x83?b\xb68L%&\xd0\xbf\x03\xea\x0f\xce\x89d\xa5\xbf\xe8\xc8\x0b\r|\xc3\xd4?\xf9\xe8\xbd^\xae\xec\xc0?i\xc7\x1b\x8a\xf7\xaa\xd7\xbf\xe7\xdf\xcc}\xc0t\xc4\xbf\xb3T\xe2\xc8;{\xd8?\x80N\xa2h\x82\xb9\xbe?yeQ\xca\x81\xe5\xd1\xbf\x82YK\x1e$M\xbd\xbf\xab\xac\x05D-\x16\xb7?e\x0b\x81_\nB\xb9?\xe9\xb5\x9a\x93Pd\xc0?e/*%Q\x8c\xa1\xbf*\xc1\x0c\xd4-%\xcb\xbf\x9a<\xfb\xd4w_\x86\xbf\x9c\xb2\x8f\xa7k\xae\xac?\xe3Z%q\x1az\x91\xbf#\x10\xd0\xca\x1cK\xcc?z\xa8\xa39\xab\x8b\xac?t\xa8c\x0e\xeeb\xd4\xbf\xfd\x05\x9a\xd2A\xa3\xa0\xbf\xe9+I\x92\xc0\x8a\xc0?\x90\xf5\xe4(\x9e?\xc1\xbfY\x0e\xed\x12\xc4\xbc\xc1?\x92\'9\xbd\x04\xaa\xd6?\xc5*\xc3\xda1\x94\xcc\xbf\xce\xbe\xb1n\xf8\xd7\xd9\xbf\xdd\xe9\xa6\xde\x9bMx?Pcx\xd8\x85\xef\xd3?\x1dT\x13~\x82f\xcd?-]R\xee})\xc5\xbfu\xa4\xaa@\xb6\x9b\xd2\xbf\x05\x06\xbe\xcf\x07\xf9\xb0?\xfbO_\x9fS\xd0\xcb?3\xe6\x15~\x86*\xa2\xbfNC:"Z\x10\xc0\xbf\xb7\xbbyS\xf8\x0e\x8a\xbf\\\xe9\xb3\x1fs\xa6\xb8?\xfe\xd9c\xc5\xaa\xa5\xb0?6\xe9h\xc5\x0e\x87\xb1\xbfO&&\x8b\x07\t\xb7\xbf-\x97X\xe2\xf4\tv?\x9ay0\xcc\xaeu\xba?\x893\x18\xd6\xb3*\xb5?\n\xe6\x0b\x83s\x81\xbb\xbf"\xb4E\x14\xfb"\xc6\xbf2\x82\xa5\xacC\xf8\xb6?\xb6Cn\xcb?\xdd\xcc?\x92\xff\x17\xd5\xc0H\xa7\xbff7H\xb3\x05\xba\xcc\xbfl*\xd4l\x83\xf3f?\xaf\x1fh8\xf5\xba\xcc?\xff\xed\x84\xdb\xdb\x92q\xbfi\xab\xae=\x89\xb3\xc9\xbf1\xd9\x17\x90\x9emz?\xa2D?b\xd5\x91\xb4?\xde0\xbbqGf\xa1?\x82\xe3\x88D:\xe7w?~\x07\xbd^6\xdf\xba\xbf\x8e\xab\xcb\xf0\x9a\xa4\x93\xbft\xbc\xd5h\x1fc\xc9?\xe8o(\xcd\xf8\xd8\x9c?\xb7\xb3\x0b]\xd6-\xd5\xbfDOm&\x05$\xa1\xbf6;\x902\xeb6\xda?=+W\x9c\xbbu\xa4?\xba\x8d\xe6x\xceE\xd4\xbf\x8d#\\\xe1=\xa4\xad\xbf\xa6\x04\xe4\x16\xa2\x0b\xc4?7\x1f\x1a>c#\xb0?\xf6\xb8rx-\x04\xb9\xbf,\x04\xdd"&\x8a\xa9\xbf\xbb\xb4\xa7\x842.\xba?\xad+\xee\xa8\x8a\x03\xae?Sm\xb9y\x81\x18\xb5\xbf\xda\x81\x18hZ\x8b\xb6\xbf\x92F \x1f\xcd\xe0\xaa?\xfc\xd8\xa0/@6\xc2?\xf0\x8e\xb7=\xd0\xa3\xa0\xbf`\xec\xf2$\x98\xe2\xcb\xbf\xbb\xb5V\xd1\xb4\xa3\x87?\xbe\xd1h\xed\xa2\x0f\xd3?\xe9u=\xf8\x00q_?\xa4\x85\xa6p\xa0Z\xd6\xbf\xe0\x9f\xdf\xedq4_?"\x10\x84?\xeb\xd5\xd6?\xfaw\xcc\xef\x0b/\x83?\x91<Ek\xc3\x8d\xd1\xbf\xf9\xf3\xc5\x97\xcd\x1b\x8a\xbf\x84\xdb\xee\'\x04\xed\xb8?M>\xbd\x91\xbfI\x92\xbf\x17\x84\x95\x14\x84J\xbc?\xd7\xae\xd4\x95\xff"\xaf?\xe5\x01\xc1z\xb8V\xcf\xbfZ\xaa\x17L\x9c\xff\xa4\xbf\xfb-\\>n@\xc4?\xa6\xa3\xe6\x82\xd9\xcb\xab\xbfI\x16\xc1\xfd%r\xa5?\x7f\xf0\xab#\x99\x0f\xc9?p\x99y\x8e\xf3\x07\xc6\xbf5\x15w"\x0e\x17\xd1\xbfw6WuXC\xc8?\xd4\xc4\xff\xc6B\x0e\xc9?$\xbf\xe8)\x90q\xc3\xbf"\x1eE\xff7m\xc1\xbf\x97\xf5\x93\x9c["\xbb?x\xb3\xe4\x8c@\x9e\xa2?4\x9a\xc3\xc7\xce\xb7\xb3\xbf\xac\xf5\x90\xb2f\x8d\xba?9\x9bR\xbc\x87)\xc1?\x1e\x1a\xf5\xab\xe7\x8d\xc9\xbf~]\xf2\x07\x12"\xd1\xbf\x12\x05i\xcd?b\xcd?=]\x8clXf\xd9?\x99\xfe"*\xd5\xd4\xc0\xbf\xd5\xf9\xe6*\xf0\xdd\xd6\xbf\xb0\xb7\xbe\x93\xc0\x0c\xa2?A\xc84\x0f\xfd\xfc\xc1?%\xcb +/\xb9\x7f\xbf\xa0y\xcb\x02\xeb\xcd\xc1?\xbb\xb1(\x1cy\x06\x87?\xda\xb3Q*{\xd0\xd0\xbf*?"rm,\x8b\xbf\x18\x7fn<{\xea\xbd?\xd5\x9f\x16@\x93f\x90\xbf\xbb\xd6>\xf1|L\xc3?\xec\x1e\xd4F\x94\xdd\xb0?\xcc0\x8cQA\xf3\xdb\xbf\xfa\x96O\xb2Lu\xb1\xbfXB\xa2\x87)y\xe1?\xc02\xab/1%\xb1?\xa0\xfb\x12\x88\xb2\x88\xdf\xbf\x05L\xe1{\x84D\xbf\xbf\xcb\x8eS\xa1wM\xd7?\xff\xbd\xe1D\xf2\x8e\xba?\x9b\x8a\xe0\x80\xc4\xda\xc8\xbfZ\xd7M\xdb6x\xa9\xbf\x8bn ;\xe2\xf8\xb5?\xe5\'\x00\x84Iz\xa4?\xdc\xb8\x07\xed\xed\xc4\xa6\xbf$\x94x\x02\xad-\xa0\xbf\xc1C\x1f\rDb\x9b?\x1d2G\x89R\xa5}?\x0c\xca|\xa3c\xf4\x7f\xbf \x18\x1a\xb9\xa3\x90\x91?b\xaaWo<[~\xbf\xc3C\xda\xa3\x8a\x99\xaa\xbf\xcc\xcf5\xaed\xbfp?\x1c\xfc\xd2\x97\xea\xb4\xae?1bk0\x06\xd5\x97?\xb8\xf3\xc03\x08\x7f\xa3\xbf\xef\xae\x01\xe2\xe9W\xa3\xbfvaf\xf36\xab\x9c?\x8a-%\xe6\xb3\xa4\xaf?\xc0i!ho\xc6\x94\xbf\xd3)\x94\x8e\xa0\xa4\xb1\xbfC\x1d\x84\xaf|\x8d\x82?\xa5\x93\xb3\xc8\xd4\x00\x9c?'
+p179
+tp180
+bsg79
+g64
+(g65
+(I0
+tp181
+g67
+tp182
+Rp183
+(I1
+(I34
+tp184
+g74
+I00
+S'J\x94!\x9e\xa9\xc4P\xc0\xc87\xa4W\xe2LS\xc0\xa8\xbb\xd0S\xb5nG\xc0\xfd;\xcd\nS-S\xc0\x8d)\x83)\xdc\xb8:\xc0\xb1_\xb6\xb4\x81\x8fR\xc00\x81\x8ci\x18\xa5\x1c\xc0x\xf2\xc5\xcc\xb4qQ\xc0\x89p\x95\xd0\xc0\xfa%@\xaf\xa9c|\x1e\xd8N\xc0R\x98!\xa8L\xdd:@\xce\rTB\xf4\xa9H\xc0pu\xc1\x16\n\x13D@\xcad\xd03H(A\xc0\xb2\x14\xc6\xbb9TI@\xe0\xf7T\xfd\xe0\xb31\xc0\'E\x0c\'\xa5\xadJ@\x88a9\xdd\xed\x0f\xee?e\x81#4\x89\xd8H@=\xe4\xb2\xbd\xd083@\x80\xbe\x81\xd2t\\C@\xb4\x1f\x00\\\xd8\xacA@\xe3\xca\x07\x8dR=9@\xe7?\xe0\x02S\x01I@k\xe0\xe7!\x0cc"@\xa0\xcbE\x15a\xf1N@\xf8\xb3\xf0\x85J\xa5"\xc0S\'\xf6\x01\xb6cQ@j_g~\xf7 =\xc0J\xf8<oDZR@\x05Ol\xe59\x98H\xc0\x12\xd0\x13\xff\x7f\xcaR@\xf2\xef\xa4\xef\xc3YQ\xc0\x87\xe0\x05\xe7\xfc\xdaR@'
+p185
+tp186
+bsS'n_samples'
+p187
+I3148
+sS'_n_active_components'
+p188
+I30
+sbsbasS'reference_shape'
+p189
+g0
+(g87
+g2
+Ntp190
+Rp191
+(dp192
+g91
+g64
+(g65
+(I0
+tp193
+g67
+tp194
+Rp195
+(I1
+(I17
+I2
+tp196
+g74
+I00
+S'\xcf\x1c\xa2\xfci\xe0L@\xf3\x80\x82\xa8h\x0e8@\xd9AM\x15\x0c\x9aS@\xe1\xd6\xf7\xf5\t\xa98@4\x06\xdeIZ\xc1X@\xdf\xf9\xf4\xbch@;@\xc4\x89X\xbe\x89\xc2]@\xe3y\xb3\x9dB\xdc?@G\x97\x12\xff\xda0a@\xd5\xa7H\xd0\x89\x11D@_\xaa\xe1r\x9c3c@$\x9a\xb4\xbd\x02bJ@b\xf0\x8f\x07\xa8\xe0d@\xe6\xc4Y\x0e\x02\x07Q@l|v\x0b\xd42f@\x88\xd5\x88\xc8\xabDU@\x8d\xec\x15\x92-\x89f@z\xd6\x12\x832\x07Z@\xf5\x0eQ\xb0O\x14f@\xf6D\xdfXL\xb2^@\x95\x8d\xc5"\x04\xb3d@\x1a\x91\x8eR\x87fa@\xe0hL\xf6O\xffb@\xff1E\xbb;Dc@*\xdbn\x9d\xcd\xf6`@:\x1a\xb6-=\xc7d@\x15<-Q\x8a7]@)\xd3b4|\xc2e@m\x0f`\xc2\xd8\'X@ud\x1e\x86oBf@\x98\x9a1\x15\xf0\x06S@\xb1\x97\xe5s\xc6~f@\x06;A\x05\x99\xbbK@\xaa\x13\xc2\xfb_\x8af@'
+p197
+tp198
+bsg98
+Nsbsg48
+(lp199
+g49
+asg51
+g34
+sg46
 Nsb.

MakeItTalk/thirdparty/face_of_art/pdm_clm_models/clm_models/basic_l_brow

@@ -1,490 +1,490 @@
-ccopy_reg
-_reconstructor
-p0
-(cmenpofit.clm.base
-CLM
-p1
-c__builtin__
-object
-p2
-Ntp3
-Rp4
-(dp5
-S'opt'
-p6
-(dp7
-S'ablation'
-p8
-(I01
-I01
-tp9
-sS'verbose'
-p10
-I00
-sS'rho2'
-p11
-I20
-sS'sigRate'
-p12
-F0.25
-sS'ratio2'
-p13
-F0.08
-sS'imgDir'
-p14
-S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
-p15
-sS'dataset'
-p16
-S'demo'
-p17
-sS'ratio1'
-p18
-F0.12
-sS'smooth'
-p19
-I01
-sS'pdm_rho'
-p20
-I20
-sS'sigOffset'
-p21
-I25
-sS'kernel_covariance'
-p22
-I10
-sS'numIter'
-p23
-I5
-ssS'_shape_model_cls'
-p24
-(lp25
-cmenpofit.modelinstance
-OrthoPDM
-p26
-asS'max_shape_components'
-p27
-(lp28
-NasS'scales'
-p29
-(lp30
-I1
-asS'diagonal'
-p31
-I200
-sS'holistic_features'
-p32
-(lp33
-cmenpo.feature.features
-no_op
-p34
-asS'patch_shape'
-p35
-(lp36
-(I8
-I8
-tp37
-asS'expert_ensemble_cls'
-p38
-(lp39
-cmenpofit.clm.expert.ensemble
-FcnFilterExpertEnsemble
-p40
-asS'expert_ensembles'
-p41
-(lp42
-g0
-(g40
-g2
-Ntp43
-Rp44
-(dp45
-S'sample_offsets'
-p46
-NsS'cosine_mask'
-p47
-I01
-sS'context_shape'
-p48
-(I8
-I8
-tp49
-sg35
-g37
-sS'response_covariance'
-p50
-I3
-sS'patch_normalisation'
-p51
-g34
-sS'_icf'
-p52
-Nsbasg47
-I01
-sS'shape_models'
-p53
-(lp54
-g0
-(g26
-g2
-Ntp55
-Rp56
-(dp57
-S'similarity_model'
-p58
-g0
-(cmenpofit.modelinstance
-_SimilarityModel
-p59
-g2
-Ntp60
-Rp61
-(dp62
-S'_components'
-p63
-cnumpy.core.multiarray
-_reconstruct
-p64
-(cnumpy
-ndarray
-p65
-(I0
-tp66
-S'b'
-p67
-tp68
-Rp69
-(I1
-(I4
-I10
-tp70
-cnumpy
-dtype
-p71
-(S'f8'
-p72
-I0
-I1
-tp73
-Rp74
-(I3
-S'<'
-p75
-NNNI-1
-I-1
-I0
-tp76
-bI00
-S"x-G|\xee\x1b\xc5\xbf\xab;\xdb\xeb\x84\x92\xe2?\xb5v\n8\xd5\xe1\xab?N\xa52\xe4%*\xd6?\xb4\x0b\x91\xb9T%\xbd?\xd2j\xc9\x94\x15[\x91?\xb7\xfd9FxM\xb0?YB\x01\xf3\x9d}\xd4\xbf\x1b\xeaA\xa3\xda+\xb1\xbf\xa48\x1a\x91\xa1\xf3\xe3\xbf\xaa;\xdb\xeb\x84\x92\xe2\xbf|-G|\xee\x1b\xc5\xbfO\xa52\xe4%*\xd6\xbf\xb0v\n8\xd5\xe1\xab?\xd7j\xc9\x94\x15[\x91\xbf\xb4\x0b\x91\xb9T%\xbd?ZB\x01\xf3\x9d}\xd4?\xbc\xfd9FxM\xb0?\xa58\x1a\x91\xa1\xf3\xe3?\x15\xeaA\xa3\xda+\xb1\xbf\xec\xed\xbf\xc5%\x9f\xdc\xbf\xfb0\x86\x9a1r\xc6\xbc\xe8\xed\xbf\xc5%\x9f\xdc\xbf\xf8B\xbc\xc2\x90\x85\x84\xbc\xdb\xed\xbf\xc5%\x9f\xdc\xbfc7\x92\xc7_\xe6\xb0<\xce\xed\xbf\xc5%\x9f\xdc\xbf\xf2\xc2\x19\x03g\xd9\xb5<\xc1\xed\xbf\xc5%\x9f\xdc\xbf;\xfb\x91\xb5.l\xa8<Z\x12T\x06\xf4\xcc\xc4<\xed\xed\xbf\xc5%\x9f\xdc\xbf<\xb7<\xc0\x98\xc4\x8d<\xe7\xed\xbf\xc5%\x9f\xdc\xbf\xfez\x81\x10y`\xb0\xbc\xd9\xed\xbf\xc5%\x9f\xdc\xbf\xc2\xda\xedh'\x07\xb4\xbc\xce\xed\xbf\xc5%\x9f\xdc\xbfQ\xec\xc2\x13\xb2\xb8\xa5\xbc\xc3\xed\xbf\xc5%\x9f\xdc\xbf"
-p77
-tp78
-bsS'_mean'
-p79
-g64
-(g65
-(I0
-tp80
-g67
-tp81
-Rp82
-(I1
-(I10
-tp83
-g74
-I00
-S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
-p84
-tp85
-bsS'template_instance'
-p86
-g0
-(cmenpo.shape.pointcloud
-PointCloud
-p87
-g2
-Ntp88
-Rp89
-(dp90
-S'points'
-p91
-g64
-(g65
-(I0
-tp92
-g67
-tp93
-Rp94
-(I1
-(I5
-I2
-tp95
-g74
-I00
-S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
-p96
-tp97
-bsS'_landmarks'
-p98
-NsbsbsS'similarity_weights'
-p99
-g64
-(g65
-(I0
-tp100
-g67
-tp101
-Rp102
-(I1
-(I4
-tp103
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p104
-tp105
-bsS'_weights'
-p106
-g64
-(g65
-(I0
-tp107
-g67
-tp108
-Rp109
-(I1
-(I6
-tp110
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p111
-tp112
-bsS'_target'
-p113
-g0
-(g87
-g2
-Ntp114
-Rp115
-(dp116
-g91
-g64
-(g65
-(I0
-tp117
-g67
-tp118
-Rp119
-(I1
-(I5
-I2
-tp120
-g74
-I00
-S'Q`\xad\xf8b\xe29@X\xa8\x8d\x1e\x11\xc6V\xc0\xf0G\x8c\x0eC\x18!\xc0H\xa7\x80\xf3\xba-K\xc0\xb5\xa2s\xe6\x99\xde1\xc0\xa6\xcb\xc60.H\x05\xc0m\xaba+\x93\xfd#\xc0\xa33\xd0<B I@\x7fxz\x15D\x0e%@\xb9\x18l\xeb\x0ewX@'
-p121
-tp122
-bsg98
-NsbsS'global_transform'
-p123
-g0
-(cmenpofit.transform.homogeneous
-DifferentiableAlignmentSimilarity
-p124
-g2
-Ntp125
-Rp126
-(dp127
-S'_h_matrix'
-p128
-g64
-(g65
-(I0
-tp129
-g67
-tp130
-Rp131
-(I1
-(I3
-I3
-tp132
-g74
-I00
-S'\x01\x00\x00\x00\x00\x00\xf0?\x14?\xffim\xc5\xb0\xbc\x00\x00\x00\x00\x00\x00\x00:\x9e\x15A\xa5\x81\xc6\x98<\x01\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
-p133
-tp134
-bsg113
-g0
-(g87
-g2
-Ntp135
-Rp136
-(dp137
-g91
-g64
-(g65
-(I0
-tp138
-g67
-tp139
-Rp140
-(I1
-(I5
-I2
-tp141
-g74
-I00
-S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
-p142
-tp143
-bsg98
-NsbsS'allow_mirror'
-p144
-I00
-sS'_source'
-p145
-g136
-sbsS'model'
-p146
-g0
-(cmenpo.model.pca
-PCAModel
-p147
-g2
-Ntp148
-Rp149
-(dp150
-S'centred'
-p151
-I01
-sg86
-g0
-(g87
-g2
-Ntp152
-Rp153
-(dp154
-g91
-g64
-(g65
-(I0
-tp155
-g67
-tp156
-Rp157
-(I1
-(I5
-I2
-tp158
-g74
-I00
-S"\xd4\xe1\rs\n\x8b2@\xa7\xff\xf6\x06\x07\xc1X\xc0+\x97u\x96\xcb\xd4\x01\xc0\xf1\r'/U\xf0H\xc0\x06\xbcznz\xf6$\xc0\x12\x14\xe1]\xc6\x16\x00@\xee\xca_\xdePN$\xc0\x12\x9aDLYeH@\x86R\xb8\x98\xd2G\x11@\t1y\xc5\xce\x85X@"
-p159
-tp160
-bsg98
-NsbsS'_eigenvalues'
-p161
-g64
-(g65
-(I0
-tp162
-g67
-tp163
-Rp164
-(I1
-(I6
-tp165
-g74
-I00
-S'\x04\x9b\x8d\xa8\x00\x94d@\xeex\x9f\x01\xe1\xd6D@\xd2\x00?\xe1\xdd\xcd/@\xaaoX\xe3ss"@Y8\xa1\xec\x80O\x1c@o\xb6\xf3\xc4\xd7\xf4\x10@'
-p166
-tp167
-bsS'_trimmed_eigenvalues'
-p168
-g64
-(g65
-(I0
-tp169
-g67
-tp170
-Rp171
-(I1
-(I1
-tp172
-g74
-I00
-S'\xc0Q\x01\xab\xf7\xcc\xf1?'
-p173
-tp174
-bsg63
-g64
-(g65
-(I0
-tp175
-g67
-tp176
-Rp177
-(I1
-(I6
-I10
-tp178
-g74
-I00
-S'\xbcL\xa6T\x9c\xa8\xde?\xe39\x13l\x125\xd8?CS\xb6\xae\xab\xd2\xd3\xbf\xc5\xf1arQ\xcc\xc9\xbf:\xec\x14\xa9\x13\x81\xdf\xbfGQI{\xf6\x94\xbd\xbf\x97p\xf2\t\xda[\xc1\xbf\xd0[2\xd9\x0fN\x92?\x11+\x1e\x08\x10Y\xdd?\xafI\x8cF4:\xb4\xbf5\xfbM\xaf9-\xbf\xbfG\xe2\x05\x16P\xaa\xdb?\xf48\xed\x82&\xda\xd3\xbf\xa8t\xe8\x98\x8f\xf5\xd3\xbf\x8c+\xfd\x00\x81\xb6\xd0?}\xcd\xca\x9c\xb9B\xd5\xbf\xd6\x0ee,\xcd\xd8\xd6?\xfdU\xc6\x1f\x00\xf3\xce\xbfC\x05C}\xb2\xd3\xc7\xbf\xda\x8a\x90/y\x07\xdd?\xa2\x84\x04)a\x86\xd6\xbfY\x96\xa9\xbdV\xa3\xc5?0\xdc\x0f\x06\x9fQ\xe1?\xc3(\x12\xd5\xc4\xb4\xb5?\xfc\xf7s\xe8\xbd\xac\xc1\xbf\x03T\xb9\x0b\xe6\xa1\xdb\xbf\xc5\xf2\x82P\xa3\xc0\xd7\xbf\x04v\xac\x89LR\xbe\xbf\x01\xbb\xa1a%z\xd4?&\x1c\x0b\x9a\x9c\xf7\xd2?\x06;n\xd6\xa0s\xc3?\xf3\xd4\x15\xde\x92_\xcc\xbf\x9f\xa6\xc8\xa6\xa0*\x86?\xc8?tF\x88\x17\xe0?\xa0\x140\xd0G\xde\xdd\xbf\xe0*Ld\xd4:\xa4\xbf\x97@~\xe2\xc2\xbd\xd8?\xe7\xa7M0\xef>\xdf\xbf\xbb:\xee\n\x82*\xb5\xbfI0\xf3=\x05\x8e\xcf?\xc42\x1a\x8d\x83\n\xcb\xbfA\x89\x8f%\xbcS\xc5?,J\xf9O\xff\xff\xdb?\xd0\x16\xdb|\xf1\xfc\xdd\xbfP\x0bU\x98\x03:\xde\xbf\xea\xe1T\x0c\xd8{\xd1?\xe7\xf10\xa8\x81G\xda?`\xf0\xd2\x01v\r\xbf?\xc2.\x902w\x10\xc5\xbf9/\xd9\x8a\x88\xb0\xb7\xbf\xf5\xb0\x85\xf6\xb5\xed|\xbf\x9e_V\x9b\xe03\x98?\xc6z\x14Ns\x10\x97?x\xa0M\x01>?\xcf\xbf\x849y\xd7\xa8Y\xc0?\x92\x95\x06"\xea?\xe4?\x01\xf5\x81S\xa7d\xd3\xbf\xee\xa1\xb7\x14\x87f\xe3\xbf\xafN|\x15\x05u\xc4?\x02\x06\xa7\xb85\xd3\xc8?'
-p179
-tp180
-bsg79
-g64
-(g65
-(I0
-tp181
-g67
-tp182
-Rp183
-(I1
-(I10
-tp184
-g74
-I00
-S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
-p185
-tp186
-bsS'n_samples'
-p187
-I3148
-sS'_n_active_components'
-p188
-I6
-sbsbasS'reference_shape'
-p189
-g0
-(g87
-g2
-Ntp190
-Rp191
-(dp192
-g91
-g64
-(g65
-(I0
-tp193
-g67
-tp194
-Rp195
-(I1
-(I5
-I2
-tp196
-g74
-I00
-S"\xe8\r\xf7\xfcN$d@v4$\x98T\x08b@(sf\x9ec\x9f_@\x8aan\x9e\x0b\xbaf@\xbc\xbfJ\xf7\xc4\x1c]@\xd2\xdd\xa9\x93DVm@\x8bu\xea)\x97\x05_@_\xcf\xfc\x1a'\x18r@\x03)\xd1\\\xd8$b@`\xe2\x9b\xbaE3u@"
-p197
-tp198
-bsg98
-Nsbsg48
-(lp199
-g49
-asg51
-g34
-sg46
+ccopy_reg
+_reconstructor
+p0
+(cmenpofit.clm.base
+CLM
+p1
+c__builtin__
+object
+p2
+Ntp3
+Rp4
+(dp5
+S'opt'
+p6
+(dp7
+S'ablation'
+p8
+(I01
+I01
+tp9
+sS'verbose'
+p10
+I00
+sS'rho2'
+p11
+I20
+sS'sigRate'
+p12
+F0.25
+sS'ratio2'
+p13
+F0.08
+sS'imgDir'
+p14
+S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
+p15
+sS'dataset'
+p16
+S'demo'
+p17
+sS'ratio1'
+p18
+F0.12
+sS'smooth'
+p19
+I01
+sS'pdm_rho'
+p20
+I20
+sS'sigOffset'
+p21
+I25
+sS'kernel_covariance'
+p22
+I10
+sS'numIter'
+p23
+I5
+ssS'_shape_model_cls'
+p24
+(lp25
+cmenpofit.modelinstance
+OrthoPDM
+p26
+asS'max_shape_components'
+p27
+(lp28
+NasS'scales'
+p29
+(lp30
+I1
+asS'diagonal'
+p31
+I200
+sS'holistic_features'
+p32
+(lp33
+cmenpo.feature.features
+no_op
+p34
+asS'patch_shape'
+p35
+(lp36
+(I8
+I8
+tp37
+asS'expert_ensemble_cls'
+p38
+(lp39
+cmenpofit.clm.expert.ensemble
+FcnFilterExpertEnsemble
+p40
+asS'expert_ensembles'
+p41
+(lp42
+g0
+(g40
+g2
+Ntp43
+Rp44
+(dp45
+S'sample_offsets'
+p46
+NsS'cosine_mask'
+p47
+I01
+sS'context_shape'
+p48
+(I8
+I8
+tp49
+sg35
+g37
+sS'response_covariance'
+p50
+I3
+sS'patch_normalisation'
+p51
+g34
+sS'_icf'
+p52
+Nsbasg47
+I01
+sS'shape_models'
+p53
+(lp54
+g0
+(g26
+g2
+Ntp55
+Rp56
+(dp57
+S'similarity_model'
+p58
+g0
+(cmenpofit.modelinstance
+_SimilarityModel
+p59
+g2
+Ntp60
+Rp61
+(dp62
+S'_components'
+p63
+cnumpy.core.multiarray
+_reconstruct
+p64
+(cnumpy
+ndarray
+p65
+(I0
+tp66
+S'b'
+p67
+tp68
+Rp69
+(I1
+(I4
+I10
+tp70
+cnumpy
+dtype
+p71
+(S'f8'
+p72
+I0
+I1
+tp73
+Rp74
+(I3
+S'<'
+p75
+NNNI-1
+I-1
+I0
+tp76
+bI00
+S"x-G|\xee\x1b\xc5\xbf\xab;\xdb\xeb\x84\x92\xe2?\xb5v\n8\xd5\xe1\xab?N\xa52\xe4%*\xd6?\xb4\x0b\x91\xb9T%\xbd?\xd2j\xc9\x94\x15[\x91?\xb7\xfd9FxM\xb0?YB\x01\xf3\x9d}\xd4\xbf\x1b\xeaA\xa3\xda+\xb1\xbf\xa48\x1a\x91\xa1\xf3\xe3\xbf\xaa;\xdb\xeb\x84\x92\xe2\xbf|-G|\xee\x1b\xc5\xbfO\xa52\xe4%*\xd6\xbf\xb0v\n8\xd5\xe1\xab?\xd7j\xc9\x94\x15[\x91\xbf\xb4\x0b\x91\xb9T%\xbd?ZB\x01\xf3\x9d}\xd4?\xbc\xfd9FxM\xb0?\xa58\x1a\x91\xa1\xf3\xe3?\x15\xeaA\xa3\xda+\xb1\xbf\xec\xed\xbf\xc5%\x9f\xdc\xbf\xfb0\x86\x9a1r\xc6\xbc\xe8\xed\xbf\xc5%\x9f\xdc\xbf\xf8B\xbc\xc2\x90\x85\x84\xbc\xdb\xed\xbf\xc5%\x9f\xdc\xbfc7\x92\xc7_\xe6\xb0<\xce\xed\xbf\xc5%\x9f\xdc\xbf\xf2\xc2\x19\x03g\xd9\xb5<\xc1\xed\xbf\xc5%\x9f\xdc\xbf;\xfb\x91\xb5.l\xa8<Z\x12T\x06\xf4\xcc\xc4<\xed\xed\xbf\xc5%\x9f\xdc\xbf<\xb7<\xc0\x98\xc4\x8d<\xe7\xed\xbf\xc5%\x9f\xdc\xbf\xfez\x81\x10y`\xb0\xbc\xd9\xed\xbf\xc5%\x9f\xdc\xbf\xc2\xda\xedh'\x07\xb4\xbc\xce\xed\xbf\xc5%\x9f\xdc\xbfQ\xec\xc2\x13\xb2\xb8\xa5\xbc\xc3\xed\xbf\xc5%\x9f\xdc\xbf"
+p77
+tp78
+bsS'_mean'
+p79
+g64
+(g65
+(I0
+tp80
+g67
+tp81
+Rp82
+(I1
+(I10
+tp83
+g74
+I00
+S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
+p84
+tp85
+bsS'template_instance'
+p86
+g0
+(cmenpo.shape.pointcloud
+PointCloud
+p87
+g2
+Ntp88
+Rp89
+(dp90
+S'points'
+p91
+g64
+(g65
+(I0
+tp92
+g67
+tp93
+Rp94
+(I1
+(I5
+I2
+tp95
+g74
+I00
+S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
+p96
+tp97
+bsS'_landmarks'
+p98
+NsbsbsS'similarity_weights'
+p99
+g64
+(g65
+(I0
+tp100
+g67
+tp101
+Rp102
+(I1
+(I4
+tp103
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p104
+tp105
+bsS'_weights'
+p106
+g64
+(g65
+(I0
+tp107
+g67
+tp108
+Rp109
+(I1
+(I6
+tp110
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p111
+tp112
+bsS'_target'
+p113
+g0
+(g87
+g2
+Ntp114
+Rp115
+(dp116
+g91
+g64
+(g65
+(I0
+tp117
+g67
+tp118
+Rp119
+(I1
+(I5
+I2
+tp120
+g74
+I00
+S'Q`\xad\xf8b\xe29@X\xa8\x8d\x1e\x11\xc6V\xc0\xf0G\x8c\x0eC\x18!\xc0H\xa7\x80\xf3\xba-K\xc0\xb5\xa2s\xe6\x99\xde1\xc0\xa6\xcb\xc60.H\x05\xc0m\xaba+\x93\xfd#\xc0\xa33\xd0<B I@\x7fxz\x15D\x0e%@\xb9\x18l\xeb\x0ewX@'
+p121
+tp122
+bsg98
+NsbsS'global_transform'
+p123
+g0
+(cmenpofit.transform.homogeneous
+DifferentiableAlignmentSimilarity
+p124
+g2
+Ntp125
+Rp126
+(dp127
+S'_h_matrix'
+p128
+g64
+(g65
+(I0
+tp129
+g67
+tp130
+Rp131
+(I1
+(I3
+I3
+tp132
+g74
+I00
+S'\x01\x00\x00\x00\x00\x00\xf0?\x14?\xffim\xc5\xb0\xbc\x00\x00\x00\x00\x00\x00\x00:\x9e\x15A\xa5\x81\xc6\x98<\x01\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
+p133
+tp134
+bsg113
+g0
+(g87
+g2
+Ntp135
+Rp136
+(dp137
+g91
+g64
+(g65
+(I0
+tp138
+g67
+tp139
+Rp140
+(I1
+(I5
+I2
+tp141
+g74
+I00
+S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
+p142
+tp143
+bsg98
+NsbsS'allow_mirror'
+p144
+I00
+sS'_source'
+p145
+g136
+sbsS'model'
+p146
+g0
+(cmenpo.model.pca
+PCAModel
+p147
+g2
+Ntp148
+Rp149
+(dp150
+S'centred'
+p151
+I01
+sg86
+g0
+(g87
+g2
+Ntp152
+Rp153
+(dp154
+g91
+g64
+(g65
+(I0
+tp155
+g67
+tp156
+Rp157
+(I1
+(I5
+I2
+tp158
+g74
+I00
+S"\xd4\xe1\rs\n\x8b2@\xa7\xff\xf6\x06\x07\xc1X\xc0+\x97u\x96\xcb\xd4\x01\xc0\xf1\r'/U\xf0H\xc0\x06\xbcznz\xf6$\xc0\x12\x14\xe1]\xc6\x16\x00@\xee\xca_\xdePN$\xc0\x12\x9aDLYeH@\x86R\xb8\x98\xd2G\x11@\t1y\xc5\xce\x85X@"
+p159
+tp160
+bsg98
+NsbsS'_eigenvalues'
+p161
+g64
+(g65
+(I0
+tp162
+g67
+tp163
+Rp164
+(I1
+(I6
+tp165
+g74
+I00
+S'\x04\x9b\x8d\xa8\x00\x94d@\xeex\x9f\x01\xe1\xd6D@\xd2\x00?\xe1\xdd\xcd/@\xaaoX\xe3ss"@Y8\xa1\xec\x80O\x1c@o\xb6\xf3\xc4\xd7\xf4\x10@'
+p166
+tp167
+bsS'_trimmed_eigenvalues'
+p168
+g64
+(g65
+(I0
+tp169
+g67
+tp170
+Rp171
+(I1
+(I1
+tp172
+g74
+I00
+S'\xc0Q\x01\xab\xf7\xcc\xf1?'
+p173
+tp174
+bsg63
+g64
+(g65
+(I0
+tp175
+g67
+tp176
+Rp177
+(I1
+(I6
+I10
+tp178
+g74
+I00
+S'\xbcL\xa6T\x9c\xa8\xde?\xe39\x13l\x125\xd8?CS\xb6\xae\xab\xd2\xd3\xbf\xc5\xf1arQ\xcc\xc9\xbf:\xec\x14\xa9\x13\x81\xdf\xbfGQI{\xf6\x94\xbd\xbf\x97p\xf2\t\xda[\xc1\xbf\xd0[2\xd9\x0fN\x92?\x11+\x1e\x08\x10Y\xdd?\xafI\x8cF4:\xb4\xbf5\xfbM\xaf9-\xbf\xbfG\xe2\x05\x16P\xaa\xdb?\xf48\xed\x82&\xda\xd3\xbf\xa8t\xe8\x98\x8f\xf5\xd3\xbf\x8c+\xfd\x00\x81\xb6\xd0?}\xcd\xca\x9c\xb9B\xd5\xbf\xd6\x0ee,\xcd\xd8\xd6?\xfdU\xc6\x1f\x00\xf3\xce\xbfC\x05C}\xb2\xd3\xc7\xbf\xda\x8a\x90/y\x07\xdd?\xa2\x84\x04)a\x86\xd6\xbfY\x96\xa9\xbdV\xa3\xc5?0\xdc\x0f\x06\x9fQ\xe1?\xc3(\x12\xd5\xc4\xb4\xb5?\xfc\xf7s\xe8\xbd\xac\xc1\xbf\x03T\xb9\x0b\xe6\xa1\xdb\xbf\xc5\xf2\x82P\xa3\xc0\xd7\xbf\x04v\xac\x89LR\xbe\xbf\x01\xbb\xa1a%z\xd4?&\x1c\x0b\x9a\x9c\xf7\xd2?\x06;n\xd6\xa0s\xc3?\xf3\xd4\x15\xde\x92_\xcc\xbf\x9f\xa6\xc8\xa6\xa0*\x86?\xc8?tF\x88\x17\xe0?\xa0\x140\xd0G\xde\xdd\xbf\xe0*Ld\xd4:\xa4\xbf\x97@~\xe2\xc2\xbd\xd8?\xe7\xa7M0\xef>\xdf\xbf\xbb:\xee\n\x82*\xb5\xbfI0\xf3=\x05\x8e\xcf?\xc42\x1a\x8d\x83\n\xcb\xbfA\x89\x8f%\xbcS\xc5?,J\xf9O\xff\xff\xdb?\xd0\x16\xdb|\xf1\xfc\xdd\xbfP\x0bU\x98\x03:\xde\xbf\xea\xe1T\x0c\xd8{\xd1?\xe7\xf10\xa8\x81G\xda?`\xf0\xd2\x01v\r\xbf?\xc2.\x902w\x10\xc5\xbf9/\xd9\x8a\x88\xb0\xb7\xbf\xf5\xb0\x85\xf6\xb5\xed|\xbf\x9e_V\x9b\xe03\x98?\xc6z\x14Ns\x10\x97?x\xa0M\x01>?\xcf\xbf\x849y\xd7\xa8Y\xc0?\x92\x95\x06"\xea?\xe4?\x01\xf5\x81S\xa7d\xd3\xbf\xee\xa1\xb7\x14\x87f\xe3\xbf\xafN|\x15\x05u\xc4?\x02\x06\xa7\xb85\xd3\xc8?'
+p179
+tp180
+bsg79
+g64
+(g65
+(I0
+tp181
+g67
+tp182
+Rp183
+(I1
+(I10
+tp184
+g74
+I00
+S'I`\xad\xf8b\xe29@W\xa8\x8d\x1e\x11\xc6V\xc0\xf6G\x8c\x0eC\x18!\xc0F\xa7\x80\xf3\xba-K\xc0\xb4\xa2s\xe6\x99\xde1\xc0\xa1\xcb\xc60.H\x05\xc0e\xaba+\x93\xfd#\xc0\xa23\xd0<B I@\x8bxz\x15D\x0e%@\xb7\x18l\xeb\x0ewX@'
+p185
+tp186
+bsS'n_samples'
+p187
+I3148
+sS'_n_active_components'
+p188
+I6
+sbsbasS'reference_shape'
+p189
+g0
+(g87
+g2
+Ntp190
+Rp191
+(dp192
+g91
+g64
+(g65
+(I0
+tp193
+g67
+tp194
+Rp195
+(I1
+(I5
+I2
+tp196
+g74
+I00
+S"\xe8\r\xf7\xfcN$d@v4$\x98T\x08b@(sf\x9ec\x9f_@\x8aan\x9e\x0b\xbaf@\xbc\xbfJ\xf7\xc4\x1c]@\xd2\xdd\xa9\x93DVm@\x8bu\xea)\x97\x05_@_\xcf\xfc\x1a'\x18r@\x03)\xd1\\\xd8$b@`\xe2\x9b\xbaE3u@"
+p197
+tp198
+bsg98
+Nsbsg48
+(lp199
+g49
+asg51
+g34
+sg46
 Nsb.

MakeItTalk/thirdparty/face_of_art/pdm_clm_models/clm_models/basic_l_eye

@@ -1,486 +1,486 @@
-ccopy_reg
-_reconstructor
-p0
-(cmenpofit.clm.base
-CLM
-p1
-c__builtin__
-object
-p2
-Ntp3
-Rp4
-(dp5
-S'opt'
-p6
-(dp7
-S'ablation'
-p8
-(I01
-I01
-tp9
-sS'verbose'
-p10
-I00
-sS'rho2'
-p11
-I20
-sS'sigRate'
-p12
-F0.25
-sS'ratio2'
-p13
-F0.08
-sS'smooth'
-p14
-I01
-sS'dataset'
-p15
-S'demo'
-p16
-sS'ratio1'
-p17
-F0.12
-sS'pdm_rho'
-p18
-I20
-sS'sigOffset'
-p19
-I25
-sS'kernel_covariance'
-p20
-I10
-sS'numIter'
-p21
-I5
-ssS'_shape_model_cls'
-p22
-(lp23
-cmenpofit.modelinstance
-OrthoPDM
-p24
-asS'max_shape_components'
-p25
-(lp26
-NasS'scales'
-p27
-(lp28
-I1
-asS'diagonal'
-p29
-I200
-sS'holistic_features'
-p30
-(lp31
-cmenpo.feature.features
-no_op
-p32
-asS'patch_shape'
-p33
-(lp34
-(I8
-I8
-tp35
-asS'expert_ensemble_cls'
-p36
-(lp37
-cmenpofit.clm.expert.ensemble
-FcnFilterExpertEnsemble
-p38
-asS'expert_ensembles'
-p39
-(lp40
-g0
-(g38
-g2
-Ntp41
-Rp42
-(dp43
-S'sample_offsets'
-p44
-NsS'cosine_mask'
-p45
-I01
-sS'context_shape'
-p46
-(I8
-I8
-tp47
-sg33
-g35
-sS'response_covariance'
-p48
-I3
-sS'patch_normalisation'
-p49
-g32
-sS'_icf'
-p50
-Nsbasg45
-I01
-sS'shape_models'
-p51
-(lp52
-g0
-(g24
-g2
-Ntp53
-Rp54
-(dp55
-S'similarity_model'
-p56
-g0
-(cmenpofit.modelinstance
-_SimilarityModel
-p57
-g2
-Ntp58
-Rp59
-(dp60
-S'_components'
-p61
-cnumpy.core.multiarray
-_reconstruct
-p62
-(cnumpy
-ndarray
-p63
-(I0
-tp64
-S'b'
-p65
-tp66
-Rp67
-(I1
-(I4
-I12
-tp68
-cnumpy
-dtype
-p69
-(S'f8'
-p70
-I0
-I1
-tp71
-Rp72
-(I3
-S'<'
-p73
-NNNI-1
-I-1
-I0
-tp74
-bI00
-S'\x80Y7\x85z\xd5\x85\xbf\xfd\xa4E\x80\xdda\xe2?<~[\x891\x08\xca?\xfa\x8c\xe9Q\xa3t\xcb?$JN\x81\xe09\xc9?W\x9d\xc7u\xea\xd3\xcb\xbf\xf1HK\x07\xcb\x95\xb3\xbf\xca6\xe9\xff\x8f\xe4\xe2\xbf\x8e.\xf6\xb9Q\xb0\xc3\xbf\xc3/\xa8\x9e\xaaZ\xca\xbf\xae\x7f\xba$\x83i\xc4\xbfS\x86\x14\xc1\xbb\xc4\xcc?\xfd\xa4E\x80\xdda\xe2\xbf\x9bY7\x85z\xd5\x85\xbf\xfa\x8c\xe9Q\xa3t\xcb\xbf<~[\x891\x08\xca?X\x9d\xc7u\xea\xd3\xcb?%JN\x81\xe09\xc9?\xca6\xe9\xff\x8f\xe4\xe2?\xedHK\x07\xcb\x95\xb3\xbf\xc6/\xa8\x9e\xaaZ\xca?\x8e.\xf6\xb9Q\xb0\xc3\xbfQ\x86\x14\xc1\xbb\xc4\xcc\xbf\xaf\x7f\xba$\x83i\xc4\xbf\\,\x0cp\xbd \xda\xbf<\xcd\x19(\xdb\xa7\xa0<N,\x0cp\xbd \xda\xbfT %\x14yg\xc5<5,\x0cp\xbd \xda\xbfB\x17\x82D\xc0\xdd\xc2<!,\x0cp\xbd \xda\xbf\x12\x9c\x8b)\x8c\xed\xb5\xbc6,\x0cp\xbd \xda\xbfz\xd9\xc4?\xe1\xde\xc0\xbcL,\x0cp\xbd \xda\xbf\xde\xa6\xa6E\xf1\x96\xbc\xbc|\xa0\xb9\xa94^\xa7\xbc[,\x0cp\xbd \xda\xbf\x19\x95\x81\xd7\x82E\xc5\xbcH,\x0cp\xbd \xda\xbf\xdb\x98x\x19\x9d\xcb\xc1\xbc0,\x0cp\xbd \xda\xbf\xf7\x87\x821\xa1\x93\xba<\x1e,\x0cp\xbd \xda\xbf\x9aD\xdbW\x02\xb5\xc1<3,\x0cp\xbd \xda\xbf(\xc9\xba\x1a\xb8+\xbd<H,\x0cp\xbd \xda\xbf'
-p75
-tp76
-bsS'_mean'
-p77
-g62
-(g63
-(I0
-tp78
-g65
-tp79
-Rp80
-(I1
-(I12
-tp81
-g72
-I00
-S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
-p82
-tp83
-bsS'template_instance'
-p84
-g0
-(cmenpo.shape.pointcloud
-PointCloud
-p85
-g2
-Ntp86
-Rp87
-(dp88
-S'points'
-p89
-g62
-(g63
-(I0
-tp90
-g65
-tp91
-Rp92
-(I1
-(I6
-I2
-tp93
-g72
-I00
-S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
-p94
-tp95
-bsS'_landmarks'
-p96
-NsbsbsS'similarity_weights'
-p97
-g62
-(g63
-(I0
-tp98
-g65
-tp99
-Rp100
-(I1
-(I4
-tp101
-g72
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p102
-tp103
-bsS'_weights'
-p104
-g62
-(g63
-(I0
-tp105
-g65
-tp106
-Rp107
-(I1
-(I8
-tp108
-g72
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p109
-tp110
-bsS'_target'
-p111
-g0
-(g85
-g2
-Ntp112
-Rp113
-(dp114
-g89
-g62
-(g63
-(I0
-tp115
-g65
-tp116
-Rp117
-(I1
-(I6
-I2
-tp118
-g72
-I00
-S'\xfe\xbdE\xceL=\xfb?\xa3gE\xd3\xec\xeeV\xc0\x12\xd2\xc3Y\x0b=@\xc0\xab\xf4\xdcda A\xc0\x8f$ o\xb1x?\xc0Z\xeb\xc4K\xd0[A@C8K\xa9\x16o(@\xb8\x08b\xd9\xfa\x91W@\xa0F\xe9\x92.\x908@m\xd1\x9ap}p@@\xfd\x894n9w9@\xa5\t\xbcc\x08\xf2A\xc0'
-p119
-tp120
-bsg96
-NsbsS'global_transform'
-p121
-g0
-(cmenpofit.transform.homogeneous
-DifferentiableAlignmentSimilarity
-p122
-g2
-Ntp123
-Rp124
-(dp125
-S'_h_matrix'
-p126
-g62
-(g63
-(I0
-tp127
-g65
-tp128
-Rp129
-(I1
-(I3
-I3
-tp130
-g72
-I00
-S'\xfc\xff\xff\xff\xff\xff\xef?s)\xcc\xc7\xdfN\x8e\xbc\x00\x00\x00\x00\x00\x00\xd09\x8fu\xdde\xf1l\x8b<\xfe\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\x10:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
-p131
-tp132
-bsg111
-g0
-(g85
-g2
-Ntp133
-Rp134
-(dp135
-g89
-g62
-(g63
-(I0
-tp136
-g65
-tp137
-Rp138
-(I1
-(I6
-I2
-tp139
-g72
-I00
-S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
-p140
-tp141
-bsg96
-NsbsS'allow_mirror'
-p142
-I00
-sS'_source'
-p143
-g134
-sbsS'model'
-p144
-g0
-(cmenpo.model.pca
-PCAModel
-p145
-g2
-Ntp146
-Rp147
-(dp148
-S'centred'
-p149
-I01
-sg84
-g0
-(g85
-g2
-Ntp150
-Rp151
-(dp152
-g89
-g62
-(g63
-(I0
-tp153
-g65
-tp154
-Rp155
-(I1
-(I6
-I2
-tp156
-g72
-I00
-S'\xbe[\x86X\xbbp+@\xe5[2\t\x00cV\xc0o{D\x81\xa7+E\xc0\x97r&~f\xf6A\xc0\x04\xcbP\xb8)\x17A\xc0\xcc\xbaUg\xe2\xb5C@$\\\xcas\xc4\x8b2@:\xd9\xb7\xef\x8dPV@\x18t\xb6\xca\x19\x0f7@\xbc\xfd\x81\xbd\xc5pA@\xca\x8ef\x88f25@\x13@\xbcs]\x0bC\xc0'
-p157
-tp158
-bsg96
-NsbsS'_eigenvalues'
-p159
-g62
-(g63
-(I0
-tp160
-g65
-tp161
-Rp162
-(I1
-(I8
-tp163
-g72
-I00
-S'd\x8c-9=\xf2p@#\xa0\x90\xeaD\xbfQ@\xc5@K\x9a\xd93O@\xe50\x84-\xda\x166@\xb9\x03U\x8fb\xd80@\xebg\xa6\xc21\x92#@z8\\\x1e\xd5[ @\xf8\xde\xc6(\xcf\xfb\x19@'
-p164
-tp165
-bsS'_trimmed_eigenvalues'
-p166
-g62
-(g63
-(I0
-tp167
-g65
-tp168
-Rp169
-(I1
-(I1
-tp170
-g72
-I00
-S'L\xa2\xee\xf8\xc3X\x0c@'
-p171
-tp172
-bsg61
-g62
-(g63
-(I0
-tp173
-g65
-tp174
-Rp175
-(I1
-(I8
-I12
-tp176
-g72
-I00
-S'\xce\x7f&\xb9\xf8H\xb8?\xd0U\x01\xa7\x1f\x90\xda?T\xfazS\x89\xdc\xdf\xbf_y\x1c\xfah$\xb7\xbfj\xadM\xaa\xbb\x1d\xde\xbf\xffK\x98\xe4\xcb^\xa3\xbf\xbe\x1a\x06\xe4\x8c\xee\xbb?`\x14n\x19*S\xc5\xbf\x01 \x92J\xeb1\xd7?\x01F\x0c\xe2]?\xad\xbf\x14a\xebKx\xba\xd9?%l\xba\x8b\xac&\xb0\xbf\xed>HAs\xd2\xc7?\xa1\xa7\xe3\x89\xdfW\xda?\x1e\xdf\xb0\x8e\x8d\x0e\xb6\xbfm\xff\x10UP\xa7\xd2\xbf\xdf9\x1f\xa8\xa3\xdc\xb5?\x1b\xbc|\xe7\x8e\xee\xd6\xbfdg\xcf\xcb\xa0\xbc\xd4?){\x18\xa7\xa9!\xe1?:\xc6\xf7\xec\xb3\xd0\xcf\xbf\xa2\x1a1\x88*c\xc7\xbfn:S\xfc\x05\xb1\xd0\xbf_T\xb9]\xf9N\xbd\xbf\x11~\x90#\x9b4\xe2\xbf1\xa49\x06d\x8e\xd1?(\xc2\r\xed\x86J\xcc?\xa80\xd3\x16\x9b\x86\xc9\xbfE)z$=&\xcd?\xf1"\x13\x97\x17\xc8\xbe\xbfbr\xca=\x05\xbf\xdb\xbf\xffZ\x1f\x0e\xad-\xd1?v]\x9a8\xca\xe6\xce?\xd0\x8d\xdc@\xb7Z\xae\xbf\x13J\xda_t\xfc\xd3?\xbe\x18\x1ev\xcd\xf6\xc4\xbf_u\xd2-@\xa9\xd2\xbfy\xc8\xc4\xf9Z\xea\xcb\xbf\xa6\x84\xe2\x13\x04*b?\x01\x07\r</\xe8\xaa\xbf\x82\xfdP&\x8e\xbd\xbd\xbf\xdd\x8f\x1f\xe0\xe6"\xe3\xbf\x027\xf5\xd5\x81h\xce?1\xbc\x10\x1c\x9a|\x8a?\xc4\xc5\xf7qkH\xa5?\x9e\xben\xb7h\xf4\xd0?\xfa\xb6\n\xac\x02.\xc0?,\xf0)\xce\xd9\xe7\xe2?\xa1da\xba\xfc\xad\xb9?\x97\xc2 \x838\x81\xc6\xbf-\xc7\xb6\xc9\x9c\xfc\xb6\xbf\x8aQH\xa6\x96#\xe4?EjP\x04\xfd\x8f\xab\xbf\x10\xc5\xe3\xe4\xbc\xb3\xcf\xbf\xf4\x81\xf5G/2\xc6\xbfl\x14\x9c\xb8\xf6\xfc\xd2?\xda\xbf\xd8-\xd0\x99\xc3?\xe7k\x9f\xaf\xe4\x9f\xe2\xbf\xda\x1b\xb7\xc5\\G\xb0?`\x90Q8\x80X\xb4?\x1b\xce`\x10\xe5\x08\xbe?8BA\xc2O\x02\xb1\xbf\xe2\xbcMh<\xbe\xe4\xbf\x034\xb5\x88_\xf6\x96?.a@\x1f\x9b%\xe5?\xda9~\x97\xa8\x1d\xb9\xbfaG\x9b\x98\x03\xb7\xc6\xbf\xa7\xa5\xb1\xd4n\xec\xac\xbf\x84\x82a\xe2Y\xa3\xc1\xbf\x0b/\x85\xf4\xf5O\xc4?\x9f\xd1\x01\x17p\xb8\xc7?\x81G\xc1\xf1Wq\xa4?\x86\x96B\x935\xc2\xba?\x1cN\x81\xdb\xe1\xc9\xa2\xbf^E\xe2\x10$\xcb\xbd\xbfZw\xdc\xa8h\xa6\xd9\xbfO\xa5\xb3i\xdf\xc5\xbd?]\x89*\xb7\xe9\xe9\xc9?0v\x14P|\x9f\xc7\xbf\x16\x0c\xa5\xaa)E\x97?#\xf1\xd6\x1f\xb3\xf6\xdf?[GZa\x8e\x02\xd1\xbf\xab\xb3\xd121\xd6\xda\xbf\x0eSg\xcf\xeb\x98\xde?\x1f\xb3\xd3\xd1lD\xc0\xbfPBQ\xab\x9c7\xa7\xbf\xbb\xa9Li\x97\x05{?!5\xf9\xadf\x7f\xcd\xbf\xf2$\x1e\xea\x8b\x04n\xbf\xab\x0c<\x84\xb4_\xd7?kx\x9a\x8d\x1b\xfd\xc2?\xc2\x03\xc9\x83^\x05\x99?\xf9\x03B%W,\xde\xbf\xd9\xf2$\xc7\x12.\xde\xbf\xf8\xaa\x8d\x81\xf2\x9f\xdc?\xd2\x18\x13G\xaf\xe4\xd6?'
-p177
-tp178
-bsg77
-g62
-(g63
-(I0
-tp179
-g65
-tp180
-Rp181
-(I1
-(I12
-tp182
-g72
-I00
-S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
-p183
-tp184
-bsS'n_samples'
-p185
-I3148
-sS'_n_active_components'
-p186
-I8
-sbsbasS'reference_shape'
-p187
-g0
-(g85
-g2
-Ntp188
-Rp189
-(dp190
-g89
-g62
-(g63
-(I0
-tp191
-g65
-tp192
-Rp193
-(I1
-(I6
-I2
-tp194
-g72
-I00
-S"\xe1P\xbe\x86\x923x@ft\xc0\x89\xe9Mw@\xe5\x85\x92\xd3\xeb\x05v@\xa1\xacg\xaf?\x02{@\xa9\x1b\xaa\x8fV\x19v@jk\x0bsSo\x7f@\x00x\x84s\x84\xedx@\xa0\x88\xaf\xe9\xe6\x9d\x81@!\xe0[\x12\x17\xb8y@6q\x1b'kL\x7f@\x1eE\xfaF\xd2\xc1y@\xe6\xa8?\xcd\x08\xdez@"
-p195
-tp196
-bsg96
-Nsbsg46
-(lp197
-g47
-asg49
-g32
-sg44
+ccopy_reg
+_reconstructor
+p0
+(cmenpofit.clm.base
+CLM
+p1
+c__builtin__
+object
+p2
+Ntp3
+Rp4
+(dp5
+S'opt'
+p6
+(dp7
+S'ablation'
+p8
+(I01
+I01
+tp9
+sS'verbose'
+p10
+I00
+sS'rho2'
+p11
+I20
+sS'sigRate'
+p12
+F0.25
+sS'ratio2'
+p13
+F0.08
+sS'smooth'
+p14
+I01
+sS'dataset'
+p15
+S'demo'
+p16
+sS'ratio1'
+p17
+F0.12
+sS'pdm_rho'
+p18
+I20
+sS'sigOffset'
+p19
+I25
+sS'kernel_covariance'
+p20
+I10
+sS'numIter'
+p21
+I5
+ssS'_shape_model_cls'
+p22
+(lp23
+cmenpofit.modelinstance
+OrthoPDM
+p24
+asS'max_shape_components'
+p25
+(lp26
+NasS'scales'
+p27
+(lp28
+I1
+asS'diagonal'
+p29
+I200
+sS'holistic_features'
+p30
+(lp31
+cmenpo.feature.features
+no_op
+p32
+asS'patch_shape'
+p33
+(lp34
+(I8
+I8
+tp35
+asS'expert_ensemble_cls'
+p36
+(lp37
+cmenpofit.clm.expert.ensemble
+FcnFilterExpertEnsemble
+p38
+asS'expert_ensembles'
+p39
+(lp40
+g0
+(g38
+g2
+Ntp41
+Rp42
+(dp43
+S'sample_offsets'
+p44
+NsS'cosine_mask'
+p45
+I01
+sS'context_shape'
+p46
+(I8
+I8
+tp47
+sg33
+g35
+sS'response_covariance'
+p48
+I3
+sS'patch_normalisation'
+p49
+g32
+sS'_icf'
+p50
+Nsbasg45
+I01
+sS'shape_models'
+p51
+(lp52
+g0
+(g24
+g2
+Ntp53
+Rp54
+(dp55
+S'similarity_model'
+p56
+g0
+(cmenpofit.modelinstance
+_SimilarityModel
+p57
+g2
+Ntp58
+Rp59
+(dp60
+S'_components'
+p61
+cnumpy.core.multiarray
+_reconstruct
+p62
+(cnumpy
+ndarray
+p63
+(I0
+tp64
+S'b'
+p65
+tp66
+Rp67
+(I1
+(I4
+I12
+tp68
+cnumpy
+dtype
+p69
+(S'f8'
+p70
+I0
+I1
+tp71
+Rp72
+(I3
+S'<'
+p73
+NNNI-1
+I-1
+I0
+tp74
+bI00
+S'\x80Y7\x85z\xd5\x85\xbf\xfd\xa4E\x80\xdda\xe2?<~[\x891\x08\xca?\xfa\x8c\xe9Q\xa3t\xcb?$JN\x81\xe09\xc9?W\x9d\xc7u\xea\xd3\xcb\xbf\xf1HK\x07\xcb\x95\xb3\xbf\xca6\xe9\xff\x8f\xe4\xe2\xbf\x8e.\xf6\xb9Q\xb0\xc3\xbf\xc3/\xa8\x9e\xaaZ\xca\xbf\xae\x7f\xba$\x83i\xc4\xbfS\x86\x14\xc1\xbb\xc4\xcc?\xfd\xa4E\x80\xdda\xe2\xbf\x9bY7\x85z\xd5\x85\xbf\xfa\x8c\xe9Q\xa3t\xcb\xbf<~[\x891\x08\xca?X\x9d\xc7u\xea\xd3\xcb?%JN\x81\xe09\xc9?\xca6\xe9\xff\x8f\xe4\xe2?\xedHK\x07\xcb\x95\xb3\xbf\xc6/\xa8\x9e\xaaZ\xca?\x8e.\xf6\xb9Q\xb0\xc3\xbfQ\x86\x14\xc1\xbb\xc4\xcc\xbf\xaf\x7f\xba$\x83i\xc4\xbf\\,\x0cp\xbd \xda\xbf<\xcd\x19(\xdb\xa7\xa0<N,\x0cp\xbd \xda\xbfT %\x14yg\xc5<5,\x0cp\xbd \xda\xbfB\x17\x82D\xc0\xdd\xc2<!,\x0cp\xbd \xda\xbf\x12\x9c\x8b)\x8c\xed\xb5\xbc6,\x0cp\xbd \xda\xbfz\xd9\xc4?\xe1\xde\xc0\xbcL,\x0cp\xbd \xda\xbf\xde\xa6\xa6E\xf1\x96\xbc\xbc|\xa0\xb9\xa94^\xa7\xbc[,\x0cp\xbd \xda\xbf\x19\x95\x81\xd7\x82E\xc5\xbcH,\x0cp\xbd \xda\xbf\xdb\x98x\x19\x9d\xcb\xc1\xbc0,\x0cp\xbd \xda\xbf\xf7\x87\x821\xa1\x93\xba<\x1e,\x0cp\xbd \xda\xbf\x9aD\xdbW\x02\xb5\xc1<3,\x0cp\xbd \xda\xbf(\xc9\xba\x1a\xb8+\xbd<H,\x0cp\xbd \xda\xbf'
+p75
+tp76
+bsS'_mean'
+p77
+g62
+(g63
+(I0
+tp78
+g65
+tp79
+Rp80
+(I1
+(I12
+tp81
+g72
+I00
+S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
+p82
+tp83
+bsS'template_instance'
+p84
+g0
+(cmenpo.shape.pointcloud
+PointCloud
+p85
+g2
+Ntp86
+Rp87
+(dp88
+S'points'
+p89
+g62
+(g63
+(I0
+tp90
+g65
+tp91
+Rp92
+(I1
+(I6
+I2
+tp93
+g72
+I00
+S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
+p94
+tp95
+bsS'_landmarks'
+p96
+NsbsbsS'similarity_weights'
+p97
+g62
+(g63
+(I0
+tp98
+g65
+tp99
+Rp100
+(I1
+(I4
+tp101
+g72
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p102
+tp103
+bsS'_weights'
+p104
+g62
+(g63
+(I0
+tp105
+g65
+tp106
+Rp107
+(I1
+(I8
+tp108
+g72
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p109
+tp110
+bsS'_target'
+p111
+g0
+(g85
+g2
+Ntp112
+Rp113
+(dp114
+g89
+g62
+(g63
+(I0
+tp115
+g65
+tp116
+Rp117
+(I1
+(I6
+I2
+tp118
+g72
+I00
+S'\xfe\xbdE\xceL=\xfb?\xa3gE\xd3\xec\xeeV\xc0\x12\xd2\xc3Y\x0b=@\xc0\xab\xf4\xdcda A\xc0\x8f$ o\xb1x?\xc0Z\xeb\xc4K\xd0[A@C8K\xa9\x16o(@\xb8\x08b\xd9\xfa\x91W@\xa0F\xe9\x92.\x908@m\xd1\x9ap}p@@\xfd\x894n9w9@\xa5\t\xbcc\x08\xf2A\xc0'
+p119
+tp120
+bsg96
+NsbsS'global_transform'
+p121
+g0
+(cmenpofit.transform.homogeneous
+DifferentiableAlignmentSimilarity
+p122
+g2
+Ntp123
+Rp124
+(dp125
+S'_h_matrix'
+p126
+g62
+(g63
+(I0
+tp127
+g65
+tp128
+Rp129
+(I1
+(I3
+I3
+tp130
+g72
+I00
+S'\xfc\xff\xff\xff\xff\xff\xef?s)\xcc\xc7\xdfN\x8e\xbc\x00\x00\x00\x00\x00\x00\xd09\x8fu\xdde\xf1l\x8b<\xfe\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\x10:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
+p131
+tp132
+bsg111
+g0
+(g85
+g2
+Ntp133
+Rp134
+(dp135
+g89
+g62
+(g63
+(I0
+tp136
+g65
+tp137
+Rp138
+(I1
+(I6
+I2
+tp139
+g72
+I00
+S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
+p140
+tp141
+bsg96
+NsbsS'allow_mirror'
+p142
+I00
+sS'_source'
+p143
+g134
+sbsS'model'
+p144
+g0
+(cmenpo.model.pca
+PCAModel
+p145
+g2
+Ntp146
+Rp147
+(dp148
+S'centred'
+p149
+I01
+sg84
+g0
+(g85
+g2
+Ntp150
+Rp151
+(dp152
+g89
+g62
+(g63
+(I0
+tp153
+g65
+tp154
+Rp155
+(I1
+(I6
+I2
+tp156
+g72
+I00
+S'\xbe[\x86X\xbbp+@\xe5[2\t\x00cV\xc0o{D\x81\xa7+E\xc0\x97r&~f\xf6A\xc0\x04\xcbP\xb8)\x17A\xc0\xcc\xbaUg\xe2\xb5C@$\\\xcas\xc4\x8b2@:\xd9\xb7\xef\x8dPV@\x18t\xb6\xca\x19\x0f7@\xbc\xfd\x81\xbd\xc5pA@\xca\x8ef\x88f25@\x13@\xbcs]\x0bC\xc0'
+p157
+tp158
+bsg96
+NsbsS'_eigenvalues'
+p159
+g62
+(g63
+(I0
+tp160
+g65
+tp161
+Rp162
+(I1
+(I8
+tp163
+g72
+I00
+S'd\x8c-9=\xf2p@#\xa0\x90\xeaD\xbfQ@\xc5@K\x9a\xd93O@\xe50\x84-\xda\x166@\xb9\x03U\x8fb\xd80@\xebg\xa6\xc21\x92#@z8\\\x1e\xd5[ @\xf8\xde\xc6(\xcf\xfb\x19@'
+p164
+tp165
+bsS'_trimmed_eigenvalues'
+p166
+g62
+(g63
+(I0
+tp167
+g65
+tp168
+Rp169
+(I1
+(I1
+tp170
+g72
+I00
+S'L\xa2\xee\xf8\xc3X\x0c@'
+p171
+tp172
+bsg61
+g62
+(g63
+(I0
+tp173
+g65
+tp174
+Rp175
+(I1
+(I8
+I12
+tp176
+g72
+I00
+S'\xce\x7f&\xb9\xf8H\xb8?\xd0U\x01\xa7\x1f\x90\xda?T\xfazS\x89\xdc\xdf\xbf_y\x1c\xfah$\xb7\xbfj\xadM\xaa\xbb\x1d\xde\xbf\xffK\x98\xe4\xcb^\xa3\xbf\xbe\x1a\x06\xe4\x8c\xee\xbb?`\x14n\x19*S\xc5\xbf\x01 \x92J\xeb1\xd7?\x01F\x0c\xe2]?\xad\xbf\x14a\xebKx\xba\xd9?%l\xba\x8b\xac&\xb0\xbf\xed>HAs\xd2\xc7?\xa1\xa7\xe3\x89\xdfW\xda?\x1e\xdf\xb0\x8e\x8d\x0e\xb6\xbfm\xff\x10UP\xa7\xd2\xbf\xdf9\x1f\xa8\xa3\xdc\xb5?\x1b\xbc|\xe7\x8e\xee\xd6\xbfdg\xcf\xcb\xa0\xbc\xd4?){\x18\xa7\xa9!\xe1?:\xc6\xf7\xec\xb3\xd0\xcf\xbf\xa2\x1a1\x88*c\xc7\xbfn:S\xfc\x05\xb1\xd0\xbf_T\xb9]\xf9N\xbd\xbf\x11~\x90#\x9b4\xe2\xbf1\xa49\x06d\x8e\xd1?(\xc2\r\xed\x86J\xcc?\xa80\xd3\x16\x9b\x86\xc9\xbfE)z$=&\xcd?\xf1"\x13\x97\x17\xc8\xbe\xbfbr\xca=\x05\xbf\xdb\xbf\xffZ\x1f\x0e\xad-\xd1?v]\x9a8\xca\xe6\xce?\xd0\x8d\xdc@\xb7Z\xae\xbf\x13J\xda_t\xfc\xd3?\xbe\x18\x1ev\xcd\xf6\xc4\xbf_u\xd2-@\xa9\xd2\xbfy\xc8\xc4\xf9Z\xea\xcb\xbf\xa6\x84\xe2\x13\x04*b?\x01\x07\r</\xe8\xaa\xbf\x82\xfdP&\x8e\xbd\xbd\xbf\xdd\x8f\x1f\xe0\xe6"\xe3\xbf\x027\xf5\xd5\x81h\xce?1\xbc\x10\x1c\x9a|\x8a?\xc4\xc5\xf7qkH\xa5?\x9e\xben\xb7h\xf4\xd0?\xfa\xb6\n\xac\x02.\xc0?,\xf0)\xce\xd9\xe7\xe2?\xa1da\xba\xfc\xad\xb9?\x97\xc2 \x838\x81\xc6\xbf-\xc7\xb6\xc9\x9c\xfc\xb6\xbf\x8aQH\xa6\x96#\xe4?EjP\x04\xfd\x8f\xab\xbf\x10\xc5\xe3\xe4\xbc\xb3\xcf\xbf\xf4\x81\xf5G/2\xc6\xbfl\x14\x9c\xb8\xf6\xfc\xd2?\xda\xbf\xd8-\xd0\x99\xc3?\xe7k\x9f\xaf\xe4\x9f\xe2\xbf\xda\x1b\xb7\xc5\\G\xb0?`\x90Q8\x80X\xb4?\x1b\xce`\x10\xe5\x08\xbe?8BA\xc2O\x02\xb1\xbf\xe2\xbcMh<\xbe\xe4\xbf\x034\xb5\x88_\xf6\x96?.a@\x1f\x9b%\xe5?\xda9~\x97\xa8\x1d\xb9\xbfaG\x9b\x98\x03\xb7\xc6\xbf\xa7\xa5\xb1\xd4n\xec\xac\xbf\x84\x82a\xe2Y\xa3\xc1\xbf\x0b/\x85\xf4\xf5O\xc4?\x9f\xd1\x01\x17p\xb8\xc7?\x81G\xc1\xf1Wq\xa4?\x86\x96B\x935\xc2\xba?\x1cN\x81\xdb\xe1\xc9\xa2\xbf^E\xe2\x10$\xcb\xbd\xbfZw\xdc\xa8h\xa6\xd9\xbfO\xa5\xb3i\xdf\xc5\xbd?]\x89*\xb7\xe9\xe9\xc9?0v\x14P|\x9f\xc7\xbf\x16\x0c\xa5\xaa)E\x97?#\xf1\xd6\x1f\xb3\xf6\xdf?[GZa\x8e\x02\xd1\xbf\xab\xb3\xd121\xd6\xda\xbf\x0eSg\xcf\xeb\x98\xde?\x1f\xb3\xd3\xd1lD\xc0\xbfPBQ\xab\x9c7\xa7\xbf\xbb\xa9Li\x97\x05{?!5\xf9\xadf\x7f\xcd\xbf\xf2$\x1e\xea\x8b\x04n\xbf\xab\x0c<\x84\xb4_\xd7?kx\x9a\x8d\x1b\xfd\xc2?\xc2\x03\xc9\x83^\x05\x99?\xf9\x03B%W,\xde\xbf\xd9\xf2$\xc7\x12.\xde\xbf\xf8\xaa\x8d\x81\xf2\x9f\xdc?\xd2\x18\x13G\xaf\xe4\xd6?'
+p177
+tp178
+bsg77
+g62
+(g63
+(I0
+tp179
+g65
+tp180
+Rp181
+(I1
+(I12
+tp182
+g72
+I00
+S'\xeb\xbdE\xceL=\xfb?\xa4gE\xd3\xec\xeeV\xc0\x14\xd2\xc3Y\x0b=@\xc0\xac\xf4\xdcda A\xc0\x92$ o\xb1x?\xc0[\xeb\xc4K\xd0[A@I8K\xa9\x16o(@\xb9\x08b\xd9\xfa\x91W@\xa3F\xe9\x92.\x908@n\xd1\x9ap}p@@\xff\x894n9w9@\xa6\t\xbcc\x08\xf2A\xc0'
+p183
+tp184
+bsS'n_samples'
+p185
+I3148
+sS'_n_active_components'
+p186
+I8
+sbsbasS'reference_shape'
+p187
+g0
+(g85
+g2
+Ntp188
+Rp189
+(dp190
+g89
+g62
+(g63
+(I0
+tp191
+g65
+tp192
+Rp193
+(I1
+(I6
+I2
+tp194
+g72
+I00
+S"\xe1P\xbe\x86\x923x@ft\xc0\x89\xe9Mw@\xe5\x85\x92\xd3\xeb\x05v@\xa1\xacg\xaf?\x02{@\xa9\x1b\xaa\x8fV\x19v@jk\x0bsSo\x7f@\x00x\x84s\x84\xedx@\xa0\x88\xaf\xe9\xe6\x9d\x81@!\xe0[\x12\x17\xb8y@6q\x1b'kL\x7f@\x1eE\xfaF\xd2\xc1y@\xe6\xa8?\xcd\x08\xdez@"
+p195
+tp196
+bsg96
+Nsbsg46
+(lp197
+g47
+asg49
+g32
+sg44
 Nsb.

MakeItTalk/thirdparty/face_of_art/pdm_clm_models/clm_models/basic_mouth

@@ -1,490 +1,490 @@
-ccopy_reg
-_reconstructor
-p0
-(cmenpofit.clm.base
-CLM
-p1
-c__builtin__
-object
-p2
-Ntp3
-Rp4
-(dp5
-S'opt'
-p6
-(dp7
-S'ablation'
-p8
-(I01
-I01
-tp9
-sS'verbose'
-p10
-I00
-sS'rho2'
-p11
-I20
-sS'sigRate'
-p12
-F0.25
-sS'ratio2'
-p13
-F0.08
-sS'imgDir'
-p14
-S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
-p15
-sS'dataset'
-p16
-S'demo'
-p17
-sS'ratio1'
-p18
-F0.12
-sS'smooth'
-p19
-I01
-sS'pdm_rho'
-p20
-I20
-sS'sigOffset'
-p21
-I25
-sS'kernel_covariance'
-p22
-I10
-sS'numIter'
-p23
-I5
-ssS'_shape_model_cls'
-p24
-(lp25
-cmenpofit.modelinstance
-OrthoPDM
-p26
-asS'max_shape_components'
-p27
-(lp28
-NasS'scales'
-p29
-(lp30
-I1
-asS'diagonal'
-p31
-I200
-sS'holistic_features'
-p32
-(lp33
-cmenpo.feature.features
-no_op
-p34
-asS'patch_shape'
-p35
-(lp36
-(I8
-I8
-tp37
-asS'expert_ensemble_cls'
-p38
-(lp39
-cmenpofit.clm.expert.ensemble
-FcnFilterExpertEnsemble
-p40
-asS'expert_ensembles'
-p41
-(lp42
-g0
-(g40
-g2
-Ntp43
-Rp44
-(dp45
-S'sample_offsets'
-p46
-NsS'cosine_mask'
-p47
-I01
-sS'context_shape'
-p48
-(I8
-I8
-tp49
-sg35
-g37
-sS'response_covariance'
-p50
-I3
-sS'patch_normalisation'
-p51
-g34
-sS'_icf'
-p52
-Nsbasg47
-I01
-sS'shape_models'
-p53
-(lp54
-g0
-(g26
-g2
-Ntp55
-Rp56
-(dp57
-S'similarity_model'
-p58
-g0
-(cmenpofit.modelinstance
-_SimilarityModel
-p59
-g2
-Ntp60
-Rp61
-(dp62
-S'_components'
-p63
-cnumpy.core.multiarray
-_reconstruct
-p64
-(cnumpy
-ndarray
-p65
-(I0
-tp66
-S'b'
-p67
-tp68
-Rp69
-(I1
-(I4
-I40
-tp70
-cnumpy
-dtype
-p71
-(S'f8'
-p72
-I0
-I1
-tp73
-Rp74
-(I3
-S'<'
-p75
-NNNI-1
-I-1
-I0
-tp76
-bI00
-S'\xc0I\xb4\xb5\xa8\xc6\x9c\xbf\xd5J\xf4m\x93\xc6\xd8\xbf\xfe\xda\xff\x17\x85\x85\xb7\xbfQ\x02\x84\xbb0\xee\xce\xbf\xd0\xa6w]-\xbe\xbf\xbf\x9c\xd6FO\xbb\x8c\xb9\xbf\xdf\xd9\xdd^\x0c\\\xb9\xbf+M\x9f\x10\xfe\x0f|\xbf\x04pM0\xd2\x14\xc0\xbf\x925\x9b\xd1\x0b3\xb9?\xb8\xf6Y,\xaa-\xb8\xbf\x9a\xb4{\xfb\x137\xcf?\xb9\xc7\x9c\tdL\xa5\xbf\xe5\xc2\x8a\x17\x84\xaa\xd8?\xd7\xb4\xba\xc4\x80\xf1\xb7?\xc2\xd1\xcf$\x80\t\xd0?\x12\xd2\x9a\xfbD\xb2\xc3?;\x8e\x95;\x1d\xc3\xbc?V\xad\xb2\xf0\x97e\xc5?\xc9\xaa\x0f\xd4\x91!7\xbf\x9d\xb1\xbc+\xba?\xc4?\xefy\x89\xb1k\x82\xba\xbf\xc6\x8c\xdaE0U\xba?\x81\xea\xe5\x9a\xaa4\xcf\xbf\xbc\x87\xc0\xb6\xf1\x90\x97\xbf(\xe8\xdf\xb2b\xe7\xd4\xbf\xd0\x1a\x17\xbd*\xb8\xa2\xbf\xb4\x88\x0c\xf88\x98\xb9\xbf\xadCH\xd1\xb7+\x9c\xbf\x0c%]\xdf+\x1du\xbf\xffF\xa31\xcbq\xa4\xbf\xd3\xa1y\xe7\x99\xe9\xb9?\x85\x94=\xdb\xf9\x1c\xa1\xbf\x8e\xc1\x11n\xe3\xcb\xd4?C\xb5l0+(\x98?\xc6IN\xd9c\x83\xba?\xf9\x1a[\xb4\x17o\xa3?\xd6\x92CNp\xb8q\xbf\x91\xdfE\xe6W\xa8\x9c?\'\xe3\xe7\x0f\x83\xe6\xb9\xbf\xd7J\xf4m\x93\xc6\xd8?\x9eI\xb4\xb5\xa8\xc6\x9c\xbfQ\x02\x84\xbb0\xee\xce?\x00\xdb\xff\x17\x85\x85\xb7\xbf\x9c\xd6FO\xbb\x8c\xb9?\xd1\xa6w]-\xbe\xbf\xbf(M\x9f\x10\xfe\x0f|?\xdf\xd9\xdd^\x0c\\\xb9\xbf\x925\x9b\xd1\x0b3\xb9\xbf\x03pM0\xd2\x14\xc0\xbf\x99\xb4{\xfb\x137\xcf\xbf\xb8\xf6Y,\xaa-\xb8\xbf\xe5\xc2\x8a\x17\x84\xaa\xd8\xbf\xb8\xc7\x9c\tdL\xa5\xbf\xc2\xd1\xcf$\x80\t\xd0\xbf\xd7\xb4\xba\xc4\x80\xf1\xb7?;\x8e\x95;\x1d\xc3\xbc\xbf\x11\xd2\x9a\xfbD\xb2\xc3?P\xaa\x0f\xd4\x91!7?U\xad\xb2\xf0\x97e\xc5?\xefy\x89\xb1k\x82\xba?\x9e\xb1\xbc+\xba?\xc4?\x81\xea\xe5\x9a\xaa4\xcf?\xc6\x8c\xdaE0U\xba?(\xe8\xdf\xb2b\xe7\xd4?\xbd\x87\xc0\xb6\xf1\x90\x97\xbf\xb4\x88\x0c\xf88\x98\xb9?\xd1\x1a\x17\xbd*\xb8\xa2\xbf\x0b%]\xdf+\x1du?\xadCH\xd1\xb7+\x9c\xbf\xd3\xa1y\xe7\x99\xe9\xb9\xbf\xffF\xa31\xcbq\xa4\xbf\x8f\xc1\x11n\xe3\xcb\xd4\xbf\x85\x94=\xdb\xf9\x1c\xa1\xbf\xc6IN\xd9c\x83\xba\xbfD\xb5l0+(\x98?\xd6\x92CNp\xb8q?\xf9\x1a[\xb4\x17o\xa3?&\xe3\xe7\x0f\x83\xe6\xb9?\x91\xdfE\xe6W\xa8\x9c?\xd0\xed\xbf\xc5%\x9f\xcc\xbf\x08r\x97l\x01,\xa0<\xd9\xed\xbf\xc5%\x9f\xcc\xbf\xd6]\x7f+[Z\x88<\xd7\xed\xbf\xc5%\x9f\xcc\xbf$\xc2\xce\xb8\x10\x1dz\xbc\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x8bv\xc0\xdb^\xdf\x89\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf\xa6\xa4\x1a\xea\xd8\x83\x9b\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbfXk\x00C\xe3\x10\xa3\xbc\xdf\xed\xbf\xc5%\x9f\xcc\xbfM\x05_\\\xf6\x0f\xa6\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbf\n\x0cSg9a\x8d\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbf\x9b\xfb\xee\xcf\xbb\xd7\x85<\xdb\xed\xbf\xc5%\x9f\xcc\xbfg6\t\x98\x9eM\x97<\xda\xed\xbf\xc5%\x9f\xcc\xbf\'R\x8b\xa6\x07\x12\xa0<\xd8\xed\xbf\xc5%\x9f\xcc\xbf\xa7L\xb9\xeda^\xa2<\xd4\xed\xbf\xc5%\x9f\xcc\xbf\x08\xfaJ\xff\xa0v\x9d<\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x84>E\xae+\xe5t<\xd9\xed\xbf\xc5%\x9f\xcc\xbf\x1d\xb3\x9fq\x04\tj\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf7\xcc\x1bE3\xdb\x8d\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbfx\\\x95\x05\xac\xb5\xa2\xbc\xdd\xed\xbf\xc5%\x9f\xcc\xbfL\x00F\x0e\x8c`~\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf+HV}\xa2\tw<\xd6\xed\xbf\xc5%\x9f\xcc\xbfs\x16[\xd0\x04\xa2\x8b<\xb9n&\xb8\xfc\xb1\x9c\xbc\xd6\xed\xbf\xc5%\x9f\xcc\xbf\x1fv|\xc5\t=y\xbc\xd3\xed\xbf\xc5%\x9f\xcc\xbf\t\x8f\xf37"#{<\xd7\xed\xbf\xc5%\x9f\xcc\xbf\xb3\x86o?\xc2\xee\x86<\xd9\xed\xbf\xc5%\x9f\xcc\xbfY\xa3j[\x19\xd3\x97<\xdc\xed\xbf\xc5%\x9f\xcc\xbf\xeb\xe3\xdb0\xd3\x99\x9e<\xdc\xed\xbf\xc5%\x9f\xcc\xbf\xf2\xa8\xd8P\xc6V\xa3<\xe0\xed\xbf\xc5%\x9f\xcc\xbfo\x83\xf4\xdf`\xf6\x80<\xe1\xed\xbf\xc5%\x9f\xcc\xbfE$\xd3%\xe6\xfc\x84\xbc\xe0\xed\xbf\xc5%\x9f\xcc\xbfjw\xa8\xf2\nx\x95\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbf\xfd\x17U\xee\xe3\xf1\x9b\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf\x7fm\xbeQt\x07\xa1\xbc\xd8\xed\xbf\xc5%\x9f\xcc\xbf\xb3\xa8\xd9N\r\xd7\x99\xbc\xd3\xed\xbf\xc5%\x9f\xcc\xbfqd\x01\xfb\xd9\xcar\xbc\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x98?\xbeC\'5g<\xda\xed\xbf\xc5%\x9f\xcc\xbf!d\xa0\t\x05\xc2\x8e<\xdd\xed\xbf\xc5%\x9f\xcc\xbf\xa5\xe5\x8f1\xdbJ\x9f<\xde\xed\xbf\xc5%\x9f\xcc\xbf\x1a\x0b*\xce\xca\x0ft<\xdd\xed\xbf\xc5%\x9f\xcc\xbf\x7fc\xff\xed\xc5\x9bv\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbf\xc0 \xeaA(p\x88\xbc\xd8\xed\xbf\xc5%\x9f\xcc\xbf'
-p77
-tp78
-bsS'_mean'
-p79
-g64
-(g65
-(I0
-tp80
-g67
-tp81
-Rp82
-(I1
-(I40
-tp83
-g74
-I00
-S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
-p84
-tp85
-bsS'template_instance'
-p86
-g0
-(cmenpo.shape.pointcloud
-PointCloud
-p87
-g2
-Ntp88
-Rp89
-(dp90
-S'points'
-p91
-g64
-(g65
-(I0
-tp92
-g67
-tp93
-Rp94
-(I1
-(I20
-I2
-tp95
-g74
-I00
-S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
-p96
-tp97
-bsS'_landmarks'
-p98
-NsbsbsS'similarity_weights'
-p99
-g64
-(g65
-(I0
-tp100
-g67
-tp101
-Rp102
-(I1
-(I4
-tp103
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p104
-tp105
-bsS'_weights'
-p106
-g64
-(g65
-(I0
-tp107
-g67
-tp108
-Rp109
-(I1
-(I36
-tp110
-g74
-I00
-S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-p111
-tp112
-bsS'_target'
-p113
-g0
-(g87
-g2
-Ntp114
-Rp115
-(dp116
-g91
-g64
-(g65
-(I0
-tp117
-g67
-tp118
-Rp119
-(I1
-(I20
-I2
-tp120
-g74
-I00
-S'(\xc4\xbcx\x90\x9b\x19\xc0\xf6\xc2:\x7f<\x0cV\xc09%\x19\x9a\x87\xee4\xc0\x0b\xc6r\xc3^\x86K\xc0N`B\xfat?<\xc0mI\xd2\x0f\x93\xbc6\xc0\xdf\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x04!\x9c\xee\x16\x9f<\xc0@u\x8a}\xc3l6@tN\xe1D)\x845\xc0D\xa7\xb6\x90;\xc7K@N!\xe1K\x10\xf4"\xc0\xc4\xfa\xdd\x11D\xf3U@~\x8c\xc0\x9c\x9fN5@\x8fw\t\x03\xf1\x8aL@m\x9f\xdc\x1e\x19\x87A@f\xf04\xe9h\x989@\x18\x9a~\xd2}\nC@/\xebG\x95\x95\x95\xb4\xbfm\xa4q\x1c\xfb\x04B@`]\xfbU6\x977\xc0\xb1\xa4|\xd9\xf5n7@\x85=\xd3)\x16\xc5K\xc0\xb6z\x156\xb2\xf8\x14\xc0m\x16\xaf\xf0-\x9aR\xc0\x8b\xda=c\x88\xa8 \xc0\x06\xa2\x8d\xd5\xcc\xc66\xc0\x13PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf=\xfd}\xef\x881"\xc0g\xeb\xb8\xfd7\x0f7@\xc9\x1f<\x11;u\x1e\xc0\x04\xc1"\xb8\xb5\x81R@\x0cV\xe42E\x7f\x15@|\x8d\x1f+\x13\x987@\xd3 yRQK!@&\x17W\x12\xec\x89\xef\xbf\xfe\x8eH\'\x96\x80\x19@$n69x\x0c7\xc0'
-p121
-tp122
-bsg98
-NsbsS'global_transform'
-p123
-g0
-(cmenpofit.transform.homogeneous
-DifferentiableAlignmentSimilarity
-p124
-g2
-Ntp125
-Rp126
-(dp127
-S'_h_matrix'
-p128
-g64
-(g65
-(I0
-tp129
-g67
-tp130
-Rp131
-(I1
-(I3
-I3
-tp132
-g74
-I00
-S'\xfb\xff\xff\xff\xff\xff\xef?D\xbc\xd8\x8bG\xe0k<\x00\x00\x00\x00\x00\x00\xe8\xb9F\x87\xeb\x1b:`_<\xff\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\xd0\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
-p133
-tp134
-bsg113
-g0
-(g87
-g2
-Ntp135
-Rp136
-(dp137
-g91
-g64
-(g65
-(I0
-tp138
-g67
-tp139
-Rp140
-(I1
-(I20
-I2
-tp141
-g74
-I00
-S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
-p142
-tp143
-bsg98
-NsbsS'allow_mirror'
-p144
-I00
-sS'_source'
-p145
-g136
-sbsS'model'
-p146
-g0
-(cmenpo.model.pca
-PCAModel
-p147
-g2
-Ntp148
-Rp149
-(dp150
-S'centred'
-p151
-I01
-sg86
-g0
-(g87
-g2
-Ntp152
-Rp153
-(dp154
-g91
-g64
-(g65
-(I0
-tp155
-g67
-tp156
-Rp157
-(I1
-(I20
-I2
-tp158
-g74
-I00
-S'\n\x10\xa7&WA$@X\xde\x0f\xf5\xdesU\xc0j*\xf7\x87\x1a\xbf6\xc0\xec\xd1\xdaw\xe1\xa9K\xc0\xf9\xaa\x1aC\xb2pB\xc0k2\xe7r\xc8\'8\xc0\xf6\x90\x08\x1b\xd6\xc8@\xc0\x91\x88g@\xdfK\t\xc0\xf6\xcd\x8d\xf1\xe9\x87B\xc0\x0c\xe9h\xae\xb8\xfb3@\xf1\x0f_\xb4\x7fI6\xc0\xa7\x9dC\xb1\xe7KL@(\xf2(V\xe1}\x14@\x0e\x05n]\x7f\xc8W@b\x15%\xa4b15@A\xbc&\x9a\x04dL@O5\xf38N=?@\xc8\\\xd4\x14\xa6\xe35@\xdb\xa8-\xe7\xa6\xc1@@\x15\xddg\xb6jX\xd0\xbf\x1e\xb3o\x10\xe4\xf2@@S\xfd\xfd\xea,{8\xc0~\xb7\xd8\x9a?\x878@g\x97`\xadH\xc2K\xc0r\xd4i0Y\n @F\x04{\xa6v\xb3R\xc0\xc3x\xac\x11\xcf\xa9\x1b\xc0\xb5\xa4f\x06n\x8a7\xc00\x04\xcf\xbfH\x89"\xc0\xb2&"\xb8\x9b\xe4\xe4\xbf~+V*\x13\xd0"\xc0\xc5j\xf9\xfeu%4@\xe4\xb9\x0e\xf6D\xc6\x19@uk\xa1\xe0p\x85T@S\xec\x0b\x93@R\xd8\xbf\xd9JD\r\xdd=4@wG\xe3\x88\x0c\x00\x10@\xc6\x18\xd9\xf3Vr\xf2\xbfb\x92\xd2\xe1\x93\x7f\xdb?\xac\x0c\xbaa\x15\xfe7\xc0'
-p159
-tp160
-bsg98
-NsbsS'_eigenvalues'
-p161
-g64
-(g65
-(I0
-tp162
-g67
-tp163
-Rp164
-(I1
-(I36
-tp165
-g74
-I00
-S's\xebe\x0f^\x07\x90@q\xb5\xf4|\x96\xc6\x8f@\xb4\xac!`@D\x80@Ud X\xc2\x9fb@\xedv\x8f\xee\xc0R[@v\xe8O\x95\xe6\x9eD@\x9a\xc0\xbc\xcb\xf0\x04A@\xcb\xfb\xfch)\xa5<@~A\xc5\x0bs\x837@\xb7\xf8a\x97\x8aL4@\xe1g\x89\xf7\xf8\xeb/@1{&\xdfD\x94,@MB\xeb\x82?u*@nr\x81\x8d\xd6\xb9!@\xb8\xf6`\xaa\x9f[ @]\xbe\r\xbe\x15?\x1a@\xd7\xcc\xa8\xe7\x87\x8b\x18@:\x98\xc5\x83\xdf\x02\x15@\xfd\xb5(CNV\x12@.\xa4\x8a\xf7\'\x1c\x11@\xb2\xc2\xe8L"\xab\x0e@Aw\xd6\x11\xb9\xb7\n@\xbe\xf1\xae\xb2\xa5\x8c\x04@e\xf0\x99\xffU\x7f\x02@\xf2\xd5X\x92\xb4\xcb\x01@p@\x1f\xf0F\x9e\x00@MR\x15\xd8\x9a(\x00@]\xf5\xbd\xdfy\x04\xff?\x9c3 \xa9\xf3\x9f\xf6?\x81\xab\xf2\\\xef\x8f\xf5?\x86\xd9\xe6\x17\x7f4\xf3?\xfey[b\xe4\xfc\xf0?\nx\xc8\x91F3\xee?\x1etI^0\xba\xea?\x8eh("\x98\xcf\xe0?\xef\xf5\xcdhz\x95\xd8?'
-p166
-tp167
-bsS'_trimmed_eigenvalues'
-p168
-g64
-(g65
-(I0
-tp169
-g67
-tp170
-Rp171
-(I1
-(I1
-tp172
-g74
-I00
-S'j\xd0r@\xe9=\xca?'
-p173
-tp174
-bsg63
-g64
-(g65
-(I0
-tp175
-g67
-tp176
-Rp177
-(I1
-(I36
-I40
-tp178
-g74
-I00
-S'\x98\x8a\xbb\xd6\x0c!p\xbfCJ_41\x93\xd7?\x7f\xd9J\xdesU\xc4\xbf\xb1\x85/\xd3~\x11\xab?@m\xcdETS\xcb\xbf\xc6ey8\x05O\xb3\xbf\xd0\n\xa2\x9ffA\xcd\xbf\xa1e\xb3-\xdd\xaf\xbd\xbf\x90\x04(\x88\xfc-\xcb\xbf\xdad\x9c_07\xc2\xbf\xf6\xa7\xacU\x07\x89\xc3\xbf"\x91\xa5k\xf9.\xa7\xbf"F\xd1!\x06\x8c\x88\xbf\x0b\xe6\x05:\x86\x8e\xa8?\xbc\x1c\xac\xde\xaeZ\xc6?\xa6\xc4\x06\xb69\x19\x90?\xd3\xac*Y_\xdf\xce?9\xdd\x16\xcd\x89\xb8\xae\xbf\xf0U\x8e{Y1\xce?\xb4\xec\x0cjIb\xa6\xbf0\xbd\xbe\xe6\xfc\x00\xcd?\x12p\xd6@\x0cB\x84\xbf\xaa\xf6\xb69\xa3\x1f\xc3?\x12^Nid\x85\xba?k\xca\xfd\x8a\xef#\x95\xbfw^\xbfOZE\xd5?u\xba\x1f5\xf7O\xc9\xbf\x0f?SD\x880\xa8\xbf\x0f\xba\x89WU\xcc\xca\xbfO\xc1\xc8\xecWD\xb8\xbfE\xf8\xf9\x9c\x04\x13\xc8\xbf\xd9}Y`\xce\x1d\xbf\xbfI/\xfa\x07\xc7\xbc\x99\xbf\x9c\x9d\x96\x93\x8d\x96\xa4?-0(\x88\xc5h\xcb?\xee\x02\x81\xack3\xb8\xbf\x18\xbfS\xcbW\x1a\xc9?\x12\xec\xf6B\x16\xe1\xb2\xbf2\x98\r?>\xa7\xc7?\x01\xb1\x0f\xb4\xa5\xbf\xa2\xbfCjX+\xd2\xf1\xad?mZ8\xdbX\x18\xd2?eCt<\x146\xb6?\x81\xb0\xd1\xd5\x04B\x8b\xbfA\xb6-\x1e\xf5(\xb8?\x13\xc8\xe9Q\xae\xa7\xca\xbf\xd3M\x95\x1cld\xba?H\x16\xab`\xa3\xa0\xca\xbfJ\xe0\x89\tCD\xb7?X\xa2\x12\xc4\xd8\xe9\xc3\xbf\xc1\xc8k\x0e$\x05\xb8?*\x15aA\xbc\x8d\xb0?D\xaauS\xba{\xa2?\xb0{\xdd\x0cI\xcc\xdb?\xb4\xd6\xf5\xc5\x15=\xad\xbf\xa9[\xcd\xf2\xc8Q\xc3?e$\x1f\x0et\x19\xbe\xbf\xadp\xf5\x05\xbf\xb9\xa6\xbf\x00\x12\xe9\xed"y\xc1\xbf\xc6\xb9\x07\xab\xb9\x03\xb9\xbf\xbf^i\x8ez9\xc3\xbfD\xeb\xf7\x85\x95m\xb7\xbf\xd7\xbaHm\x99S\xbc\xbf\xf3\xb3U\xff\xcc\xe6\xb3?\xd2\xb6T8\x94\xf0\xac?G\xd9\xd8\xda\x1e\x8f\xd0?W\xac\x07\x1f\x99\xce\xbb?\x16\x8aU\xf4~\xec\xc5\xbf[U\xf7;\xd3x\xbe?ybA\t\xaa\xf7\xc5\xbf\xda\xf3\x83\xe7\xe4\xde\xbd?\xb9\x00\n\xc0\xf1\xab\xbc\xbf\xecA\xb7\x94\x96*\xa0?F\xb9\xbe\'\x04\x14\xd9?\xac\xec\xf2\x10\xecN\xbe\xbf0n6\x93i\xbb\xb8\xbfg(y>N<\xc2\xbf{\xdeG\xa8\xca\x03\xc3\xbf\x95\x01X\xc9\x96\xdf\xc4\xbf\xa9\xc4\x02\xfb\x932\xc2\xbfy\x83\x96\x93\xa7\xcb\xdb?\x08\x85s\xc0\xef=\xaa\xbf \xf6\x7f\xad\x87\x0f\xa0\xbf\rP5\'\xfc\x1d\xa1\xbfH\x1e\x13\x14h\xad\xd1\xbf\xf5\xfb\xf7\x0b\xab\x81S?-\x91\x87D\x96b\xd0\xbf\xf0\xf4\x07Mh\xa3\x96?0\xd6H\xd7K5\xd1\xbfi\xb9\x88@\\n\x87?.\x1c\xd2s0\x1a\x87\xbfS^\xb8\xdb\xd5@\x92?\x1bXzC\xe8\xa3\xdb?\x0f\xfc1%\x1aH\xa0\xbf"\x80\x0f\xaf/\x98\xbd?t)\xe4\xfd\xa3\xe2\x84\xbf\xe8\xfesU\x89\xe4\xa8\xbf\xe4XK\xeem\xb9\x8e?\xd1\xc4\xedl\x07\xcd\xb1\xbfc\xda\xbb\xf5\x18\xdd\x9e?!\x1e\x96:T\xb4\xa7\xbfmW~\x07u\xdf\x8d?\xd5_d\xf6\xf1\\\xbb?4>\x87\x8e\xac\xe9s?m\xe6\xeb\xe9>\xff\xd3?\xcd\x8dv\xcf\x8fs\x9c?\xbat\xcbh\xff\xa6v\xbf\n\xb8q\x94\x92\x98\x7f?\xbf\xe6\x7f*\xfc\xba\xa0\xbf$\x89\x1d\x9d=u\x98?(V\x9bv\xff\x9b`?g.\x15C>~\x86?\x90%y\xbf\xb3\x96\xd4?\xe3\xf2\xb5\x10\xe1\x89\xb9\xbfJ\x97\xd6\x9bS\xc5\xcb\xbf!!!!\x9e\xf1k?_ \x83qqW\xcf\xbf*s\xb9a]\xf0\x95?5\x8bbQu\xba\xcb\xbf}:\xc0\xe8\x86\xd9\x8c?E\xf3\x82\\1\xdf\xc9\xbf\x9b\xc8H\xf3\xcf\xef\x8a\xbf\x8bg7\xad6:\xab\xbf\x0c\xb9Nu\xea\xab\xac?`w\x8d\x01\xe2^\xb2\xbf\x8e|\xc2\x98k"\xb6?\xd8\xca\xdf\xd9\x87w\x91\xbf\x0eP\x903\xae\xafD?j\xc3\xed\xdc8\xbb\xb1\xbf\xa8\xed \x11G\xc2\xba\xbf\xf6\xa0\x97Jm\x18\xaa\xbf\xe5\x96#\x18\xc9K\xb1\xbfx\xe0K`\xf2\x95\xc8\xbf\xfe\x8b\x06\xbb&\xa3\x8a?\xf1\x93\r\xa0D\xd4\xbf?I\xfa\xc4\x07\x8d\x80\xa7\xbf\xce\xc5\xa6\xe4t\xab\xd1?\xa5\xb7\xe5N\xa7\x04\xb1\xbfY_\x8fJX\xd6\xd2?\x86\xa3\xd4h\xa8\x8c\x98?\xae\xed\xed\xdeHO\xd2?F\xf8\xb7\x04\xf3\xf4\xb1?\xb7\x06\xc5\xbd3\x19\xc1?\xf1\xf6\x17OF\xb6\xa9?\x15;\xddI\xc8\n\xc0\xbf\xdb03\xee\xf0n\xae?\x93\xf5\xf8\xdd\xcc\xd3\xcf?\xa6\xab\x0ff.\r\xb7?y\xc2\xb7:#\xbc\xd0?\xf5\xed\xf9\x92\xb4{\x90?\x11\xa4\xd6\xf5w1\xd0?\xc6\x1eh\x98N\xd9\xb5\xbf\x19\xebX\x91o\xe2\xbc\xbf"g\xd9\xa2\xc4\xed\xb0\xbf\xb56\x96XG\x00\xd5\xbf\xbf\xabS}\xe1d\xbb\xbf2\xf0+\xc6\xad\xa3\xd4\xbf\xf9Bf\xb1\rv^?\xfb\xc6\xef\xf9gE\xd5\xbf\xa4\xc3\xb2,\x1b\x96\xb6?`WC\x02E\'\xa0\xbf\x8e\xc8l\xff!\x88\xce?\xce\xd07*\xb0\xb7\xa8\xbfO\x16#+\x93p\xb8\xbf\xd9\x08\xcfd\xf0\x8fz?;Y\xc7\x15c\xbd\xd0\xbf\x83\xe4\xd9e\xb1_\xab?\x98\x1e\xef\x84\x0eP\x80\xbf22\xeby\xe0]Y?\x97\xda\xa4\xe4\xdd\xb4\xd2?\xbfao\xf9\xb5\xd8\x9f\xbf\xa8\xec\x9c\xb1CV\xc0?R\x94\xc7\xf8Y\x97\xa0\xbf\xd0\xa8,\x07\xe2[\xd2\xbf\x16,\xadR\xa2\x07\xb0\xbf6\xbf\xdd7\xfe`\xc0?\xe7\xcf\xfe\x96\x93\xf6\xab?\x92r\r\x19\xd3F\xd2?x\xff\xb1(><\xbe?\x1c\x1f\\AN\xc6\x92\xbf\x93Q\xcb\x1e2\x07\xb1?\x0f\xc2\xf9\x06\xf0g\xd1\xbfk\xe1N\xd1l\xd8\xaa\xbf\xaco,F\xf7A\xbe\xbf&!\xf2Z\x9d\xcc\x88\xbfG\xa9\xe6\xdc\xa6|\xcd?_7\x90\x8a\xa5\x0f\xac?!\xd8\xd4\xd9\xfc\x0c\xd1\xbf6\x8bo\xdbxF\xb8?\x9aC\xbb\xdaV\xb8\x86\xbf\xb1\xbf[|\x98\xc0\xab?\xd0f\xe2=YS\xd2?Y\xabgp\x8a\xd7\x90\xbfv\r\xf8r\xd7h\xd0\xbfk\xcd\x98\x88\xa6\x8e\xb8\xbf\xd9\xd7\xeco\x9fP\xd2?{\x9d\xcc\xa0\x92\xb0\x9f\xbfL\x0e\x98\x0c\x87\xca\x8b\xbf\x0c\xd8m\xe81<\xb7\xbf\n:\xe2\xb9\x06\x17\xd1\xbfDu\x87<\xf5\x87\xc3\xbf\x19\xc8\xd7$\x93\xbf\xb0\xbf0\x9f4\xb3H\x87\xb1\xbf\x8e^t9I\xf6\xcc\xbfs\xd3\xf9\x10\xa2\x89\x8d?V\x08\xadwN\xe9\xd0\xbfP\x80\x92e\xdc$\x91?^={\xc5\xca\xbe\xcb\xbf\x19\x91\xc3\x8b^\xaa\xa4?"a\x8b\x12\x06\x86\xd0\xbf\xacxjPh\xd9\xb6?\xd0\x8d\x99\x1b`\x14\xc7\xbf\xc2\\T\x9b\x97\xfa\xc2?\x16\xb7+\xfb\xa4\xce\xb3\xbf\x92\x8b\xce\x0b\x9c\xaf\xc5?\xeeE\xe2Z\xf7+\xc9?\x18\xeaK\xb4R\xbf\xaa?\xfb\x85\xee\xffj4\xd6?>\xf8\x17\xe1\x15\xecy?\x04Dn\xbf/\xa3\xd8?\xed\xb4}\xc1\xd8\x8c\xa7\xbf"\x0c\xaai$\xc5\xd5?D:R3\x8b\r\xca\xbf\'\xbd\x908\xd3\xab\xc6?\x02\x07\xfeC\x95u\xc1\xbflzj\x1d\xf5Q\xb5\xbfQ^\x19\xa9\xdbj\x95\xbf\xac\xf8\xb4\xe6\x1c\xd6\xbb\xbfn\xdf\xb2\x88\xccR\x8d\xbf\x8d\xb0\x85TWq\xb5\xbf\x85\x84\xaa\x97\x89\xb7\x80\xbf\xea\xeb\x80\xa0g2\xbc\xbfg\xe7\x97\xd3\xf5\x99\xbc?\x8f\x81n\xdb\ns\xb6\xbf\xdet\xcbuP+\xbb?\xf4\xfc\xbez\xa0\xde\xb5?\xe1\xd2\xdc\x15\xf2\x9dp\xbf\x8d\xb7\xa4\xaay\xbb\xc0??\x05^\xf6Y\xb7\xb9\xbf\xb6>\x82\xb7(\xa5\xb9?\xb3/\xbc\x90\xadAp?}7\xd7_5\x05\xbc?\xf7\xaf\xae\xbd[\xfd\xc3\xbf\x0b#\xaaB\x1c\x81\xcc\xbfN\xa2[H\x94\xc2\xc8\xbf\x93\t\x03Fs\xea\xb4?-N\xb4_\xb3\xac\xc9\xbf\x1b\xfd\xe31RU\x85?\xe6\xc9\xb7\xdb>!\xc8\xbf\xae\xc5n\x00\xf9\xaf\xb8\xbf\x1fd\xf2[5\x15\xc7\xbf\xf1\xf8\xe3\x18CZ\xc7?\xf7\\H\xb9\x94\xd6w?\x91-h:l\xc8\xb7\xbf\x0c\xad\xdbJ\x05\xb7\xd1\xbf\x06\xa9\x1d\xda\xf9\xc9\xc1?\x8c\xdd\xb1\x1b\xea8\xa8\xbf\x05\xf7\xab\xaa\xe2\xa7\xb6\xbfE\x95\x19\xac\xd5\xa4\xa3\xbf\t\x0b\xb6\x86\x80\x8b\x89?"\x9d\xe5\xff\xef>\xb0\xbf\x88~J\x05\\G\xb1?etI\xed7\x96\xd3\xbf\x03\xea\\\x19`R\xc4\xbfw\xdbPQ\xf9\x01\xa4?\xc0\xdd\xcc\x0f\xd6\x0c\xa0?Z\x8bv\xd8`\xf3\xd5?Re0\xd8\xd9 \xb7?\xed\x9d\xdd\x18di\xd3??\xf8\xc5`@\xb2\x9d?)P\xc3\xa6]Q\xd5?\xb2\xdd\xdc\xf1\xcaI\xb5\xbf\x989\xb2j\x94\xb0\xa1?\x94\x80 #$\x9f\xa0\xbfI\xd4<\xf8$X\xca?\x8an\x026!$\xb8\xbfOt\xef\xdb\xf1\xcd\xc9?\xeaX\x99\xc5!\xaa\x95?\x84\x97\xecy\xb8$\xc7?\xc6\xa3\x16\x85\xc8*\xb8?\xe1WA\xae\x1f\xd6\xbc\xbf\xde\xdbw?\x05\x0f\xb2\xbf\xefC\xa2\xd7C\x82\xc5\xbf\xe8\x0c\xd5wU^\xd8?\xeb\xb3\xca$\x18\xa5\xbe\xbfy1`\xe7\x1d\x8c\xc1\xbf\xc7\xf6<$\x82\xf1\xc5\xbfU\xef\xdf\xce\xbb\xfd\x94\xbf\xcd\x08\x8c<X\xaf\xbf\xbf\xff\xfc\xe0\xf9I\x11\xb2?\x8a\x889\xd3Pq\xc3\xbfo\xca\xd5\xc2_h\xd1\xbf>e\xd9\x16k\xb6\xb4\xbf\x14\xff~(\x8a\x91\x89?f\xb2\xebW}6\xce?\x9c\xcb\x84F\xd8H\xc5\xbf*\x19\xeb\xf0vQ\xc3\xbf}\xe3d\x8e\xe5)\xbd?\xff\xac\xfe\xb9\x7f"\xc8\xbf"\xa5U\r\xff\xbc\x92?\x10\x04A\x12\xc4\xeb\xc5\xbf\xdd\xc3\xb5\x1a\xe8\xdb\xb5\xbf>\x0c\xcf>\x9d\xbf\xcb?v\x9f\xc2t\xe6\x8f\xd1?\x19\xaf\x95\x97X\xcf\x85?\xd2\xba}\xd3\xf8?\xc6\xbf& \xee\x96}\x8b\xcb?\x82q\xbd(\x9e\xef\xc3\xbfB\x89\x1a\x7f\x93B\xca?\xe9^\xb1-b\x88\x7f\xbfJ\xa3+]\xb7\x00\xcd?\xd2\x97\x9a\n\xd6\xdb\xbf?\xf6\xcb.\xc7G<{\xbf\xcc\xcc\x8b\xc4\xeaE\xc2?\xf1\x16E1T\xce\xc1?\n~P\xedj\xfe\xbd?\x89\x0b\x8f\x1b@R\xb2?.\xb7\xfe\xff5\xd2\x85\xbf\x87{\x81\x16\xc9\xeb\xbf?\xc8B\xda\x19\xf2\xd9\xc3\xbfz\xff\xd4\xc5\xd8\xa1\xb8\xbf\x90\xbcs\x9e\x0c\xde\xcd?~\x9aA\x16\xb4\xda\xb0?\xbd\xcf\xce":\xec\xcb\xbfx8h-\xb52\x97?\xeb\x82<\xe5\xa9-\xbb?d.fx\x92\xd8\xc1\xbf3\x8d\xa0D\t9\xac?\x1eh\xa9Pz\xb7\xb1?k \xbb\xb4\xf3\x03\xb1\xbfW\xab\x90"P\x02\xb8?\xab\xd7\xde\xec\xdc\xff\xb9\xbf\xdbW\xff\xeeM\xc5\xc6\xbf=\xbb7wK\xcb\xb3\xbf\xe1\xceg3\xd96\xdc?\xd9(\x1bs\xd7\x1f\xbf?\xdfW\xd4gF\x85\xc0\xbfWkw\xd9\xbc\xeb\x8d?\xe9\x98\x03\xb5\x11N\xd2\xbf\xe8\x1a\xfd2\x9e\x1e\xb3?h\xb0\x86I"&\xbc\xbf|5\xc5\x8e\xb4\xad\xba?Yp\x7f\x99\xbe\xbd\xd1?t\xd3\xcd\n,v\xe1\xbf\xbc>\xdb@\x8c\x02\x91?\x94#\xa3g\x8c\x93\xb9?|\xec\x02\x06U0c?\xc3\x9aZ1\xf7\x07\xae?\xfc\x05\xcaN\xef\xe7\x8d\xbf\xd3;h\xac\\\xfb\xaa?\x835\xbf\x15\x0b\x81\xb0?\xc6}\x8f~\x8dJ\x9d?\xf0\xf5(\x8b\xc7\xff\xad\xbfF_\xe0\x83\xee|\xa3?p\n\xa6\xaei\xfd\x9a?q\x1f\x08e:\x99a?\x9d\x01\xb2\x86W!\xc7\xbf\x03\xb8\x95\xf1\x8b#\x97?\x906m\xfc\t\xf8\xbc?\x8e\xfc \xe9\xd4^j\xbf \xc6\xd4\x9d\xc9\x19\xc9\xbfp\x05B\xea\x14\x9e\xa8\xbfg\xe5,p\xf3\xa1\xbc\xbf\x93\xbd\x1d\x14vF\xc8?J\x13\x969\xaf\x90\x8b?\x16*\x1a\xcfOg\x80?\x18\xc7\xd3\xd4\x1b\x94\xa3\xbf\xa5\x88\x04S\xe4\xba\xc2\xbfXCj\xf8\xe9!\xab?\xc3\xcc\xd8-\xa6\xf7\xb9\xbf\xaaS\xc5\x94W1\xc1?\x87\x00:T\x18W\xd8?4j\x86\x9e\xa3\xd7\xbc?\x8c\x06\xa3.\xd7S\xc7\xbf\x0f\xf6}\xfd\xf1\x08\xce\xbf\x0c\x02\x08\xfb\xc7\xee\xda?\xc6\xf9P\xd0\x81\xa9\xbe\xbf\x0es3\xb9MG\xa3\xbfz\x19J\xd8\xc3\x1a\xbf\xbf\x935V_/\xcd\xb2\xbfEX\xe6G\x1c\x9f\x98?\xed\x05)\xf41\xdb\xb7?cBQb\'\x99\xe0?\x06\xe1z\x9c\xa67\xc0?\x84\xa7D\xaa\xf0b\xba\xbf:\x0e\x13\xa2\xac \xb4\xbf=\xd7\x91\x8a\xdc\xcd\x97\xbf\x85t\xc7\xaapHg?\x05\xd6\x13\xf0_\xa2\x85\xbf\x88}t\x8d,\x8d\xc1\xbf:`(&\\|\xa0?\xc7\x1a\xac%\x94m\xaf\xbf*\xd4T|G\x89\xb3?n\xf7\xf4\xda?\x9b\xc3\xbf\xf4"\x8b\x88\x98\xde\x8e\xbfw\xeey\xd2\xa4\xfd\xaf\xbfZ\xa1\xfe-\xbd%\xb1\xbf\x19!\xa0\xabZ\x81\xc1\xbfTOm\xe4,\x8c\xb3?\xd5H6%\x9d\xe8f\xbf\xcb\xfb\x15}\xfd\xfd\xcb\xbf\x98d\xce*\xfe\x82\x8d\xbf\x06_*z\x8fCq?\r\xe6~\x00"\x86\xca\xbf\xcbmw\xf0\x1d\xf2\xb3\xbf\xdaS\xf5+\xfc\xf2\xab\xbf\xee\xda\xd1E\xbdV\x8e\xbfg\x90\xc0\xfe^\xb7\x9e?P\xaf\xce?{{\xa4\xbf2\xd6,K\xfd\x9ek?\x15\xf4=\xa7\xbc4\xba?\x9d\x1b5\x19\x0fr\xd3\xbfz\x91q\xd9H|\xc5?.\xe6k\x84t\x89\xd4?\x10\xc91\x84\x12\xbd\xdb\xbf\xb5?mBy\xd9\xd2\xbf)\x86\xfcI\xd2\x14\xcd\xbf\x7f\xe2\xbd\xb0\xe8\x14\xba?!(\xa4\x8a\n\x10\xa4?M\x7f\xf9\x12B\xbc\xbb?\xe2QZ\xc1\xd2\xd7\xc6?\x003A\xca\x0e\xcb\xa3?`\x89\x15\xd0}\xd4\xd3?7\xd4\xe3>!+\xc1\xbf\xdf\x98\xa3\x9dj\xc0\xc3\xbf\x17^U)jj\xc9?\xd3UO\xeck\xa1\xa1?\xc6\xef\x0e\x87\x1f\xde\x82?\xf2,\x8b2\xb6\xc8\x97?4\xd3\x0f\x1c\xb6\xbb\xb5?"\'|\x8c\xca!x?E?\x92\xb6W\xf7\xb0?W\xec\x9e\x91=\xec\xc8?8\xbb\x17\x89&\xfd\xae\xbf\x17\x97o}V\x88\xbd\xbf\xc9Q?M*\r\xae?\x90@\xe0\x8ds\xcf\xb1?\xc0\x12\xca\xce\x8b~\xac?\xda\x82\xf5,\xd8r\xc3? }T\xb9\xbf{}\xbf\xfb\xc5;t\xd7\xd3\xb3?7\x05\x02\xbd\x1b\x96\xde?J\xf2}\x03i\xeb\xa2\xbf\xc2\x83\xe4\xd4\xd0\x8d\xb4\xbf\xcb\xbeQ\xcfLQP?\xb3t\x8e\xa5\xc8ji?\x10\x1b\xab\x0eO(r\xbfC\x97\x9eg\xd8\xe7~?\x02\r\xf3[\xfb\x07\x9d?\x0e\xb9\xb7X#)\x84?a~S\xeeV5\x92?\xc2\xcb\x1f\x98\xc1a\xb4\xbf9\xf6T\x84\x19\xab\xc6?\\}\xd6+P\x0b\xd6\xbf\x82\xe7\xee\xde[!\xc7\xbf\xf1v\xa6\x18\x81\x99\xbc\xbf\xba\xf1\xdd\xf1\xaa<w?e\xcf\x1cc\x00!\x98?I\xe9Y\x11\x1c4\xb6?\x1dE[\x8a\xa1u\x99?P\xd1\xf4:\xb9\x9a\xc1?\x99\rfE\x97W\xa2?Y\xe2y\x1d\x1c\xa2\xb1?\x9b\x83<\xbbV,\x98\xbf\xfc\xcf\xdciA\n\xc1\xbf\x9f{\x13\x97W\xb8\xdf\xbfJ\x8fl\x19\xaf\xc3\x92\xbf\x83\xecW\xc7[7\x84?C\xeaz\xd1|M\x93?\x01\xa6w\x13W\n\x88?\xff~8\x88`\xf0\xa7\xbf \xf5$\x83\x82\xd0\x9f?\xdd\xe4\xe0z\xdd\x84\x91\xbf>{c{.W\xdf?9G\xd5[Q\x92\xb8\xbf%\xdc\x84\x93sN\x87?Lo\xf0pD&\xaa\xbf6\x0e\xc5\xa5\x0e\xc2z\xbf\xdf\xdd`\x92{\xdc\xa1\xbfq\xef^X\xe82v?S<\x8c\xce\x03f\x9d?X\xe0\n\xaa\x80H\xa6?o\x1c_AJ\xaf\xcb\xbf1\xd1\xb5l\x8f\xee\xda\xbf\xcd\xf6\xa3U\xdc\n\xc6?\x9b.\x7f\x19.\x02\xb0\xbf$^\x84X\x0fw\xd1?F\r\xaaB\xe4\x80f\xbfkm\x18\xdf\x1d(\xaa??\x1e\x92\xd6\x0c\xea\xc0?\x95\xef\x8bj>\xab\xde\xbf\x02P\x9f\xc62\xb6\xca?Gk\xbb\xaeR8\xbc?\xe0\xa6\xe1\xdb|\xed\x82?\xbf\x9aP\x9d\'\xbc\xcf?H\xbb\x98\xe5[\xb2\xc5\xbfC\xad\xb2\xb3\x9a\xba\xc1\xbf\xcc8\x97\x98\x98\xa9\xbb\xbf\xd6\xb6\x8852\'\xbb\xbf\xdd<\xf1\xe2\x11\x15\xb3\xbf\xb17\xfe\xea\xdc\xd2\xb1\xbfx\x1c\tx` b?=\xd7S3\x83\xc8\xce?AlRy\xdf\xad\xcb?\xb7L\xb0E\xc1\x93\xc3\xbf\xbc\xb6\x87\xd7"K\xae?lP\xb9\xee\x941\xbe?\xd0\xcc\x90\x9c\xb2>\xa8?\xea\x9c+F\x91mq\xbf\x7f\x82!\x8e\x0f\xa7~\xbf\x94\xdbfl\xb5\r\xb0\xbf\xdcN\xed\xec\xff\t\xa2\xbf\x10]\x13\x13Q}\x9a?\x90\x92s\xaa(?\x9c\xbfK\xd0\xa5Q\x17p\xb0\xbf\xb4\xdd\xee`TW\x88\xbf{\xc8\xa5)\x89\xc3\xc0?\xfc\xee\xab\r\xf7n\x9e?st\xac\xb4.\xc2\xba\xbf\xb0\'<\x9e\x10\x07\xc6?VR*\xbb\xc1\xc0\xaf\xbf\xb5%\x97ln-\xb5?h&lK\xb0)\xd7?8\xb0\xa7\xfb\xcc!\xd2\xbfn\x07\x9c\xb8]\x00\xd1\xbf\t\\"\x1f@\xfa\xc1\xbf\x86\xa8\xd8e\xcf\x8f\xb8\xbf\x8aJG\xcd\xd7\xe9\xb4?\xa1\xc9P{k^\xcc\xbf;\xcdB\xcb\xac\x82\xb5?b\xc5\xa1\x87\x18\x9b\xde?R\xb6\xeb\xa7\x06\x10\xd2?G\xd1\\4-\x17\xcc\xbfn\xf7\x0e%\xb8\x13\x9b\xbf\x84\xfd\xf0;\xfa\xf4\xb9?\x91S\xf6\xa1G\xb7\xc7\xbf<$\xe6\xb7V\xdb\xa9\xbf:\xeaF\xa0m\xdd\xb2\xbf\xbe\x960\xbdo_\xa5\xbff\x15h*\xde\x1b\x91?\xe5O\xc8i\x16\xc6\xb2\xbf\xd1?\'7\xe3\xa3\xbb\xbf\xbfd\xd4H\xbf\xb9\xb6?\x17\x8e\x7fn.6\xd4?\x01\x16aOI`\xb5\xbf\xc8!\xbd\x15;T\xb4\xbfE gj\x93J\xaa?\x98\x95m!\xda\x94\xac\xbf\x1dIO\xabcV\xa5\xbf\xf3\xf1\xd0[z\x1b\xb3?\x9b\x9c\x0c2\x8es\xa6?m}\x13\x8fT\xd7\xb4\xbf\xff\xd0\x08\x8d\xaf\\\xaf\xbf\xf8\xd3\xebZ\x1c\x1c\x9e\xbf\xf6\xe2\x07\xd4\x15\t\xa2?\x91h\x87Sh\x86\xa2\xbf\xe6\xbf\xfe\t\xfe\xc8\xc0?\x17\xff\xc9\xce\xa4,\xbb?\xa0k\x1e\x88O=\xb3\xbfP\xab\tg\xb8]\xac?\x032\r\x1f\xaa\x05\xb4\xbf\x15\xa9\x19\xcb\xc6\xda\x8c\xbf.\xee\x18+p(\xc7?\x8b\xd0\xc0\xb3\xb6\xe9\xb2\xbf\x18\x8b8(\x92\xbe\xaa\xbf{F5n:2\xc8?\x9c\xb9`\x8e7\xbe\xa4\xbf\x81\xed\xcc\x17F\xf3\xd8\xbf6|\xae6.\xa5\xc2\xbf8\xad\xc6\x9b\xed(\xc8?&F\xdd\xa0\xea\x1e\xad?2\x14m\xe0\x9ai\xb0\xbf\xe4$\xd1\xcb\xfc\xc2\xa3\xbf\xb5^\x9fC\x83Qz\xbf\xf6 \x06\x83\x88p\xb4?\x99W\x85V\x03\xbd\xb3\xbf\xf1U\x98%\xe4\xa2\xb0\xbf\xbf>\xbf<\x92G\xc3?\x84fV#Th\x8c?\xb2\xc2w!\xe6\xd1\xd4\xbf\xa2\xa9\x84\xf5\xc5\xa8\xad?zi\xac\xe5\x07F\xc9?\xd4\xdd\xfe\xd3\\\xd3\xbb\xbfLt"x}k\x8f?\xa4\xcf}y\xcc\xe3\x96?\xc4\x9cXx\x01\x14t\xbfl\xa2\x9fd\xaf\xbc\xb8?\x99\xc1\xe6\x10\xff\x84\xca?.\xd3\xf1\xd0\x9d`~?\xd1\xee\xc5f:;\xd9\xbf\xdf\x8a"q#6\xaf\xbf\x94\xf7]\x0b\xb5\xcc\xcb?\xf0\x8a\x9f\x18\x03\xe1\xa6?0P\x8f\x13\xb4\x81\x90?\xffmm\xd7\xe5\x8b\x9f\xbfG\xc4\xdd\\\n\x1f\xd0?e\x95\xb3\x02\xea\xc2\x93?cm\xf98\x81\'\xd5\xbf\x1c\'\x89\xbf\x03\xea\xa4?q"\x97]Y\x99\xcf?\xde\x86\xc14\xf0p\xd3\xbfE\xcb\xe1\xdd\r\xcd\xc9\xbf7%A\xc47T\xe2?\xce\x806\xa4y1\xbb?\xbe)\xb4h\t\xc6\xbe?\xb1\x88\xfa\xa1!B\xa2\xbfC0\\\x11\x04\xaf\xb4\xbf\x8a\xfb\xeb"\xad/\xaa?\x06\xbb$S\x94\xd7\xca\xbf\xe1\x132\xc4\x0f\xaa\xa5\xbf\xa0\xd48\x9d\xcc?\xd4\xbf\xe2\x8d\xae\r\xb4|\xa3?\xcd\xc5nh.&\xcd?\xc0Ga\xe4W\xea\xd1\xbf\x18\xbd\x99D\xa6\xd8\x8c?G\x18M\x1cp\xde\xaf?lAK\xfb\\&y\xbf\x9e\x89J\x08\xdf\xb9\xa8\xbf\xa8\xfe\xcb"\xf8\xad\x84\xbf\x90m\x8e\x0e\x10\xab\xa3?\xf3\xf8\x88\x96\x80\xaf\x99?\xb2\x9f\x12;h\xd0\xb3\xbfF\x93\xfd\xfd\xa0`\x93\xbf\xe7( \xe2<L\xb0\xbf\xc1m\x17\xf7\xe3\x04\xb3\xbf\xbc\x19.}*\x80\xcc?T\x18\x1b\\i^\xc0?\xe5\xf7pz\x98\xc7\xb3\xbfO\x88\xbam\x96\x82y\xbf\xfd\xfe)vG\x02\x97?q\\\x8cd\xafz\xc2\xbf\x9d\xc2\xd6G\x02\xf2\xb7\xbf\x0f\x00U\x93\xd9\xa8\xb8?\xed\xa2\xbd\xed^\xfd\xd1?v%\x94\xc0z\xfev\xbf4$\xa8N\xc11v?\xfe\xf1\xd8\r\xd5p\x89\xbf\xd0\xeb\xe2\xf6A\xc0\xb9?\x1bo\x15)_\x11s?\x82L\xebD<\xcb\x81\xbf\xa8\xfb@{2\x9c\xb0\xbfLAt/6g\xd2\xbf\x0b\xfc\xca\x8b>\x1c\xd4\xbf}\x92\x080\x8ao\xc1\xbf6\x118\xfe_\xf5\xa8\xbfNI\xf7OW\xda}\xbf\xd2\xc8\x0e)I\xa4\xfb>\xbe\x07m\xa7\x93\xe2t?\xcdh\xa8,\n\xbd\xc3?\x03hh\x18\xf2\x15\xb3?d\xa4\xc0Y\xd4\xc0\xc4?v\xde1\x08\x1f\xf8\x94\xbf\xf2s-\xe0\x00\xd9\xcb\xbfra\x11":\xcc\xd5\xbf\x92Y$\x1d\xc3A\xc1\xbf\x9fy\xfe\xa6\x1bR\xbe\xbf\xe6@\xa9\xe0\xdd\xc9\x90?\x9d\x96]\x0b\xfe#\xab\xbf\xa7\x01\xafEvO\x9d?1\xa8\x1fa\n;\x9a\xbfc`n\xe4\x9c\xa8{?<8\xd8\xa7h\xa3\x9c?r\xab?\xb5\x8c\x11\xb6?&$\xaa\x17\x94\x0f\xa0?R\xae\x80\x15\xc1\xd4\xd3?V\x12\xff\xd1\x1ei\xd5?\xed\xf4\xd211l\xb3\xbf\x08\xce\x01_\xfb)\xb5\xbf,\xac%\xe4\x14T\xb7\xbf^\x0f!\xc2\x03\xe1\xb9\xbfI\x95&\x18_5\xbb?@$\x8e\x82\x14\x1f\xb1\xbf{hE.\x991\xc0?\\P\x8e\xa5\xccG\xdb?\xe2d\xb6\xae\x7f\x88\xc0?Jw%\x8c\xf6h\xba?\xc3Yl\xadr\xee\xa9\xbf)\xbb\x82>oo\xb8?\xa0l\xe3\xfa\xc9k\xc0\xbf{\xdb(JP\x1a\xc2?\x99\xf5\xber\x9dS\xd5\xbf\xaa\x87\xf0\xbb\xe09\xcd?K\x0e\xbf\xa5\x87\xbb\xb5?\x82\x8a\xd0+yQ\xb3\xbf_\x90\xfds\xe1+\xbf?\xcc\x12h\xae\xe88\xac\xbf1\x08&r\x9as\xb2\xbf\x8e3~\xd9\x954\x9d?\x981P\x149\xed\xad?$<\x1b\xc3Q\xf5\xa3?[\x8fl\xfe\xac`\xc9\xbf8M\x88b\x968\xa9\xbfR\xd2e\xc4\xe6\xa7\xd1\xbf\x03\xd1\x8f\xd0z\xff\xbf?\x1b\xe6\xf2~t5\xb5\xbf\x1c\x08\xfd{48\xb2?Y+\xc0.\xa3\xe0\xb3?L\xfdR\x83\x01\x07\xa3\xbf\xd3/\xfd\xd5\xe2\xd8\x95?\xce{\xd1\x1fG\xe1\xa1\xbf\xf8\xa7\x82\xa2\xad\x16Y\xbfY\x84\xffX#I\xb3\xbf\x1a\xa8]&N>\x96\xbfd\xa1\xc4!\xcf\xf9\xba?/\xb8u\xa0\x0f\x9e\xd8?\xbeG\xf9\xb7v\x11\xd1\xbfG\xc1\x0e\xe3@\x08\xb4?\x882\xc9\xd71\x01\xaf?\xe7\xe6\xecR\xcc\xa9\xcf\xbf\xb7dP/\xe3\xd3\xb7?\xbf\x93\xcf\xa4\xdfRw\xbf7\xb0\x85\x93\xf2r\xa6?\xfcA\x8ab~w\xe0?\x1b\x9fF\x9ay4\xc1\xbf\xd2\xebg\xed%\xbe\xbb?\xc2\xbd\x91\xcdOe\xb0\xbf\x1aN\nv\xdb\xfd\xc0\xbf\x08\xd0\xd6,\xa4\x95\x86\xbf\xdf\xc7\xe1W\x94\x1e\xb4\xbfp+\x0f\x1by\x9a\x81?\x95a\xb66\x8b\x83\xb6\xbfc\xa7\xbd\xc0)\xdd\xa3\xbfF\xdc\x06\x87\x9d\xd4\x9c\xbf\x80\x03?s\x85h\xa9\xbf\x04\x84\x0f!\xd5\x91\xc7?\xd0\xf5\x1ae\x89\x85\xc2\xbf\x0bJ\xc9\xffl\x18\xd3\xbf\xbc\xd7\x1cF\xb7\xb5f?]\xea\xfb\xe5\xb7\xba\xc3?\xc7<H\xe0\xdf\xcf\xaf?\x92qk,J]\x8c\xbf\xb6*\x93\x91\xe6K\xd5?\xc2+N\xfat\x04\xb5?\x85w\xf2\x07\x14\x1a\x8c?l\xffp\x03O\x01\xb0?\xef2\xa4\x81\xe1g\xd5\xbf6\x03\xd8\xa0\xa6`y?\x06\xd6\xfe\xfc\xf1\xc4\xc3\xbf\x0f\\sb\xe6\x83o\xbf\t\x9d\xc7}r\x00\xbf?~\x05\x122m\x9e\xc2?\xda\xd9\x1b\x93\xd4\x8a\xd7?S\xcfFExR\xc6\xbf\xb3\x90\xb3\x08O\x9b\xbc?\x1e\x97["\xa4\xac\xb9?\'\xa8\x00Y\x98\xa0\x9b?-\xf3\xd3\xbe\x9a\x1b\x7f\xbfJ\xc7}@F\x00\xbe\xbfK\xbc\x91c\xee-\xa0\xbf(:\xb8\xb0\xd5V\x12\xbfZ\xeeF6\xdaP\xa4?\xc0^\xb2\xf4\x91\xbd\xc3?\xda\x12\xa9\xf0\xd4\x95\xb7\xbfJ\xc5J,\xa90_\xbf\xc2\x11\xe0%\xfb(\xbf\xbf\x8el\xba:\xe9\n\xa9\xbf/A\xa6\xa6\xf3#\xd2\xbfA\xdc\xb6FX"\xb9\xbfvc\x87\xc4\xe6\x95\xd7?\xe9\xc7^0\x0c=\xca\xbf\xcd3\xd0Rw+\xc3\xbf[L\xa1\xef\xe8[s\xbf\x9b\xbf\xf8Nf\xec\xc6\xbf\x990\xb6R]\xe0\xbd?\x89U~\x9eH\x0e\xbe\xbf\x93\xf1S\xd1&\xaa\x94\xbf\x0c/\x88\xddI\x82\xd5?\xec\x91\xda\xd8\x91\x81\x9e\xbf{7\xca\n8V\xc7\xbfF\x15\x10\x05\xde\xde\xc2\xbfw\x99)\xe7S\x92\xbc?\x84\x0f\xee:l\x06\xbf?X.2\xd0\xe6\xb9\xc2\xbf\xa8\x93{/\x15\x94\xbb\xbf\xd5I`\xf7\xb4\xf7\xc8?\xc0\x8cp`\xe2#u?l\xc5\x89\xdf\xf9\xf5\xc7\xbf)\xb6\x1e`\x8b\xea\xb1?\xa73\xf2\xbe\xe6a\x9f?\t\xbb\xae\x7f\x1f*\xba?\xbc\x03bb\xd2\xed\xb3?\xc3\xb0z\xb8\xces\xa6\xbf\xc7\xe9\x85\tw\xbb\xc2\xbf{\x1d \x91\xa8t\xac\xbf\x8e\xb4\x19\xc9\xfb\xd1\xcb?\xb9\xfbV0\xd3,\x83\xbf\x03\x16U_\x1e\x15\x8d?\xcf\xc4\xf9\x8c\x08n\xa9?\x85-\xa4\xe9\xed0\xc1?\xee\xb4\xa9\xa6\xde\x91\xb4?\x8c\x99mFM\xf4\xcd\xbf\xfe#\x05\xfb\xd9\xde\x9e\xbf\x90\xdb\xc0\xc1\xa0z\xcb?)\xb9\x9fu\xf0K\xb5?E\xe1\xcf8\xd2m\xdf\xbfX\xe0\x1a\xdc\x02\xdc\xbc\xbf\xbb\xe1\xf9q\xbbk\xcc?\xbc\x07\xdf\xf5\xe8\xb8\xa0\xbf\xcdp\xcfx\xa9\xe6\xd1?\xd7E\xf3D\x08\x8c\xa1\xbfQ\x1c\xff\x02\xdf\xa4\xc3?5AE=\x97\x10\xb8\xbf`fY\xf4\xe5\xbd\xba\xbf\x93\x85s\xe0\x0fM\x99\xbf\xd4\x19\x1c\xc8\xdf\n\xd0?8Fu#\x96\xbb\xb7\xbf\\\x04\xbb\xa7\xd3\xe7\xd5\xbf\x0bL~\xefk\x0e\xaf\xbf\xc7R\xf0\xaf\xac\x01\xbe?\xa8\xe6T\x02\x00\xd6\x96?\x95\xed1\x7f\xab&\xbc?\x8d\xed_\xc7\xd0H\xb7\xbf\xb6\xe9\x96\xe6-E\x8d\xbf\x81\'\xea\x0bc\x93\xb1\xbf\xb0\xdc<\x85\n\x83\xb1?\xd9\x8c\xf1\xc4\x0bn\xc0?.\x98\xe2\x16\xc2\x0e\xb9\xbfZ\x88\x8d\xc7\xd3\xe5\xc9?\xbe\xbb#\xb7\xc96\xa2?"\xd9\x15_\x93n\xab\xbf\xeeY\xf3\x12e\x9e\xb8?%1\xb6:\xad\xc2\xd6\xbf|(\xa1\xb1\xfe\x10\xb8\xbf\xb0\xaa\xb14\xb0\xe1\xb9?iq\xfa\xc0\x9e\xa7\xc9\xbf\xff\x02\x0f"\xa4\xcb\xb0?\xea\x11\xa8\xfe\x94\x19\xd2?d\xfc\x82\x83at\xcc?4\xcdA\xcf`\xc6\xd8\xbf\x16\x90\x8e\x1d8\xdf\xbe?\xa9+Vz\xbbh\xc1?\xba\xf9{P\x14\xb6\xb4\xbf\xf4G\xd6G\xeb\xa1\x7f?\xcf\xa5 \xc1\xbbV\xb0?M\xee\xf4\xf0\xef\xae\xcd\xbf8\x92J=-\x83\xbf\xbf\xdeA\xa3\xf0\xb8\xac\x9d?\x0f\xa4y*\xcf_\x9c\xbf\x98 \x1e\x08]\xba\xc7?\xca\x04P`b\xb6\xc2?\xd0k\xa5\xb5p\x86\xa4\xbf\xf0\nt\x88\x1c\xe3\xba\xbf\xd7\xffT\x9bW\xa0\xbd?L=\xd9`\xb8\xb8\xd1\xbfbo<EK\xe9\xc0\xbf\xd9\x99\xf9\xa3\x15\xb0\xb4?\x8b\xbe\xf6W\r\xad\xbf?\xf6h\x1d$ \xc6\xb6?\xdc\x1a0\xdbC\x8c\x91\xbf4J\xf7H\x9b\x95\xba?%\xa9\x0f\x0b\xb1 \xb3\xbfe\x1c\xaf\tO\xcd\xcb\xbf\x90\x1aS\xe7\x1fi\xa3?\xee\xcf\x87P\x8b|\xbe\xbf\xab\x0eFl~\xeb\x9a\xbflL\xfd\xd8\x0c\xa5\xc8?\x8ag\xbd\xbb\xfc\xcb\xc5?B\xe0\xef\x07\xf5\x14\xb9?5\xf5\xb0\x0e]\xbd\x97\xbf\xdb\xa5t\'\xf8\xed\x80?\xfc\xb1\xb4\'t\xa2\xc5\xbf\x93\xa2{\x93\xf2n\xb3?\xbf\xc9h\x886/\xa2?\xc4\xd6\x95&\x16g\xd0?\xe9\xb5\x8f\xd8\x9c\xccW\xbf\x9dq\xe3\x03D\x86\xb9?\xd8\x0b\xcdG\x0f\xe5\xd0\xbf\xc2\n\x8dHq\x00\xcb?QTxU&&\x89?m\xa7eNt\xcd\xc6?\x15\xc4\x97\xa2\xd5\x1a\xcf?\x85\xc5\xca\x16\\\xda\xc6?\x06Pu\xa2\x83\xa8\x97\xbf\xe2\xf8\xd5\x9b}U\xbc?@?\x02\xac\x1f~\xb7\xbf\r\xdc\xa8j\x17K\xd3\xbf\x19\xceM\xe7\xc8\xdc\x94?\xce\xdeG\xbd\xcak\xd7\xbf\x13\xe5-P4\xa1\xba?\x8a/[\xba\xdf\x01\xd3\xbf\xc6\xc9\xe1\x8e_\x81\x98?\xa8\xaee\xe2}\xa1<?$j>\x10I\xce\xad?\xc2F1\xe1\xdb\x00\xcd?O\x87\x83\x8e3\x81]\xbf\xce\xe9h\xb9\x88/\xb5\xbf A\x9c.\x8a\xee\xbe?\xe7}<h[\x12\xb6\xbf\x9foh\xf9\xac.\xb3\xbf]\x06\x8d\xe2\x9f\x98\xa4?I$W\xae\xa6)\xb8\xbfj\t7r\xf6s\xd1?,\xb5\x86\x92ga\xa0\xbfh\x02V\xcf\xfd\x05\x8b\xbf~\x82\x1c\xc1\xcfp\x9a?iy\xd4Q\x19\x17\xd2\xbf\xd7\xa45\xbe)\x83\xce\xbf\xf3u\xfa\xd7\x92\x1b\xd5?al\xd5\xadR\xd7\xa6?`\xb6\x1f\x1a\xa7\x8b\xca?c\xffo\x98\xe0\n\xc3?qU\x84IG\xcc\xb1?\x11o\xde\x96\x7f\x94o?\xe4\xe6\xc5\xfcBk\xcf\xbf\x06\x9d\x0e\x93!\\l?7\xa4\x90\x9b(ue?(\x96\x16\xb0e\xee\xb8\xbf\x16\x1e\xe0\xee\xec\xd5\xbc?4t\xfd\x1cMf\xcc\xbf\xf2\xb25\x15\xf7\x9b\xa1?\xd8\xa1^vP^\xd3?\xb8-\xcf\x9a8\xae\xb0\xbf\xeb\xaea9\x1b\xac\x8a?\xf5U&\xca\xb9F\x95?\xcc\x1d\x89\xd1\xbe\x7f\xca?^c\xe2\xb2\x15\xc4\xd0\xbf?\xd4p\x0b6S\xbc?T_\xfbfD\x81\xcf\xbf\xb4KQ\xd9\x10U\xd3\xbf\xba\xe5qp\xf9-\xa1\xbf\x8e\xb0\x9bkr\xf1\xd1?\xfe\x98\xfe\xfa\xd5\xf7\x96\xbf\xedy\xa4%KT\xc0?\x98a\xd6\xffx\x90\xb9?\x07\x04\xc7\xba\x86\x8c\xbc\xbf\x1b\x9a\x17\x89V\xf8\xbf\xbf\xfb\xa7i\xf5\x11a\xb1?\xaa\xde\x05\x9a+\xd4\xa9?e\xdd\x90\xe6[8\x95?\xaa\x9e\x10\x87&\xab\xca?\xa5\xfa\xc1\xd4\xd4\x97\xbd\xbfV\xd0\xdbD\xd4Z\xb8\xbf\xb3H\rT]i\xd2\xbf\x03\x8a_\xcf\xda\x8c\x9b\xbf\xea*\xf6\xa1\x92\xf7\xa4?}\xf1~\x12\xe8\xa0\xc5?y\xda\x86\xea\xa5%\xc2\xbf\xdeb\xc5\xcf\x08\xff\xd0\xbf\x0b\xf8\x8e\xdb\xd5+\x92\xbf\xe7\xc4\xae\x93|\xbe\x99\xbf+\x16b\xa3J\xde\xc8?5\xfb\xe8\xa9\xafE\xcc?2J\x16!\xe4\xf7\xb6\xbf\x8b\xc8\xa3\xe6\x8by\x9d\xbf\x80\xa9)\x8dU`\xd8\xbf\xd7\xe0Nk\xf6"X\xbfx\x8c\xd3\xbdO9\xc9\xbf\x0b\xdc}\x8dY\xd8\xca\xbf:\xbbpr\xcf\xbd\xa6\xbf\x0f~\xb9\']\x07\xb5\xbf\x99T\x0f\\BW\xd0?\xaaZ\xf0rK/\xa6\xbfA\xc9\xde#\xb0\x1a\xd9?o\x8f\x0b\t\x9f\xfc\x80?\xa5\x01A\x8ceP\xbc\xbf\x90}\xc0\xad\x9f\xf4\xa2?\x11\xb8\xdb\xcc\x0c}v?B\xed\x11\xdc\xeb\x10\xb0?\xbc\xf2\x81\xf5\xb6\xb5\xbc?q\xbb1L\xe3\xa5\xb1?6\xba\x97\xb3H\xd9\xb5\xbf\xb2\x918\x07g\xec\xa2?\x94:\x99+\x0f*\x9a?\x80\xda\x81\x1cD\xa9\xab\xbf\xe6\x086[F@\xc7\xbf\\\xea\xb2\xc89\x13\xbb?\x813\x19\xdd\xfa\xe3\xd8?: \xa4p1\x89\x8f?\xb6\xe2EH\xd3\x12\xc2\xbf\xe7\xad\xefu\xb5~\xbf\xbf-\xe8\n\x92[f\xb2\xbf\xd0\x17q[u\xe9\x83?\xc1\xa5\x02\xc5=-\xc3?\x84t\x85\xc2\xb8<\x98?\xfa0\x97(@\x8d\x9d?\xb9z\xc3\x7f#\xe7I?]M\xf7T\xeb\x1c\xb9\xbf\xfb=\x19\x14\n\xd2\xb1?^\xa1i\xb4;\\\xa4\xbf\xfb|Qvp\xb1\xaf\xbf\xff\xac\xa6\x83v\xc3\xc5??\xf37\x1a\x0eG\xce\xbf\x15\xdb\xd1\x1e1\xe1\xb3\xbf\x92,\x8f\x9f6v\xba?L\xe2\xb2\xce\x7f8\xb9?\xef\x03\xb9nQ\xd4\xa9\xbf7}_\xf0\x1c\xd8\xb7\xbf+\x91\xcc`\xfe\xcd\xa7\xbf(\x7fqs\x9cs\xcf\xbf\xd6\x97V\x03\x14\xc5\xb3\xbf\xbcG"\x06\xf0I\xd5?G\xa7\xccr\xe5\r\xba\xbf\xd4\xc1\xd5\x81\xbb\xc3\xc6\xbf\x88n\xa4\x96\'\xad\x9f\xbf\x87}sKO\xc9\xba?r\xe3\xf0\xa2\xbaw\xc4? \xf4\x97\xd3M\x18\xdb\xbf\x05\xe1\\\xbe\x03\xaf\xc3?R\xcd\x9c\xbdW\x8c\xd5?\xa5\xb3\xa1#\x1by\xba?\x14\xcb\xb1f\xf8\x9b\xb8?R\xf6\x08\xa3\xe4\xf8\x93\xbf\x941\xba\xfd\x8a}\xb4?\xe7\xf4A\x82\xfe:\xc0\xbf\xae\xad]\xe5\'\x8c\xad?\xa6\x11\x19\xa3\x89\x16\xda?\x8b?X<\x02\xeb\xcc\xbf]4\xcd\xc1\x0f\x0c\xad?Q\x04C\x8bj%\xc8?\xec\xff\xd4\xfd\xd9\x1d\xd6\xbfdE\x00\t\x8c\xf3\xbd\xbf|\xc6\xa7\x04\xd0x\xc4?\x8a\xe9\xe4\xd9\x1d\xd2\xc4\xbf\xf7\xc2`\x93\x05F\x8c\xbf\x9f\xdb\th\xdf\x14\xab?\xd8\x81\xa5\x97\xe1\xb9\xbf\xbf\xe3\x91\x9f\x10W\xb9\xcb\xbf\xba\xac&\xb7\x89\xf4\xd0?\xe1Q\x1f\x8c\x05Y\xc6?\x11\xa2%uIL\x90\xbf~p\x92\x930\xf1e\xbf\x00>\xea\xa49y\xca\xbf\x99{`%E_{\xbf/\xbfu\xa1\x15\xa3\xc4?\x83\x8d\xb9\xcf\x9b9\xc0\xbf\\\xaa\x19\x17\xc2\xd3\x80?\xc6\x18\xc73\x90\xed\xd0\xbfo\xe1\x99Z\x81\xacz\xbf\x01\x1b\xee\x13\xa7\x10\xd1?\x06\x87\xba\x1c\xa1-\xb8\xbf\xf6\xd0\x08\xf5|u|\xbfO\xfd\t{\xa71\xb4\xbf\n\x1bnh\xd9\x1f\xcd?\x7f\xf6\x8f\xa1\xeaZd?\xbc\xdf\x17\xa6R\x9b\x9e?o\xd9\xda\xd0\xda{\xc3?\xaa\x16\xdeY.L\xaa\xbf_\xdd\xd4\xc5o\x8c\x88?\x1fV\xc6GI\xcd|?\'m\xa4\x82n\xb9\xc8\xbf\x04\xe3\xd6au\x91\xca?l\x0f\x13\xe0u\x99\xb0\xbf\xe9$\x1a\x98~Y\xc0\xbf\x9d\xfds\x8aa\xff\x9f\xbf\xa8\xd0v}\xac\x99\xab?\xd7B\x90yoQ\xc2?\x85{\x022{n\xcd?]\xb3]2\x04\x06\xb5?md\x03/\xd0\xdf\xd0\xbfa!\xc2\xeebH\xa9\xbf\xdd\xcerR&\xcd\xbf?\xd1 {\xa2\xcf\x1f\x94?\xbb3\x13\xa3:\xab\xc4\xbf3n\xcf\xb49\xdb\xa6\xbfyB&\xbbo6\xa7\xbfT\'%,!\x86\xa3\xbf!\\\xd6H&\x96\xb0?[\x97\x05\x10v\x95\x9d?\x85\x05\x927W\xa4\xac\xbf\x1e\x14\x0bJ\x90\xc0\xb9?\x91\xdeZ\xff\x15\x83\x97?H\xb5\x1c\xf5cB\xab?\xd9\x81c\xe6\xb2\x19r\xbfe\x8e\xc6{@G\xa3?\xd3\x04L\x9f\xc7\x95\xd1\xbf\xae\xe0\xf2\x8b\xed\x9f\xb3?\xda%X2:V\xda?\xe5\xc9S\xf1\x15\xa7\x90?\x8f\xc1\x96\xa4?\xd3\xb9\xbf\t9J6-\x15\x82?e@F\x11\x88\xe7\xd3\xbf\xcb\xdf\n<\x8d\x81\xb4?\xee\xe1REq\xe1\xc9?\xd2\x97\xf2\x15\xa2,\xab?\xc1\x1a7+;\xf0\xd3?\xd0\xa1\xea\xba\xb2\xf3\xac\xbf\xf2\xb6w\x87\xed\xde\xd4\xbf\x12\xbe\xd5\xa3\xfd\xe5\xc2\xbf\xec\x05\xf1\xb8\xc9\xdc\xa5?\xeb\n\xc1\x0e\xf3"\xd1\xbf\xfe\x99\x02\x9c\x17|\xb7\xbf\xd0\xcbM\xc4\xcc\xd0\x94\xbfm\x86\xeb?\x16\xe8\xa4\xbf\x914\x8ck\xf6\xc8\xb7\xbf&\xf3\x8f\xe2\xd6\xa0\x8b\xbf\xa0\xed\xf7z\x91O\xa8?\xbca\x985\x98I\xab\xbfTBt\xfe[\x90\xc2?\x90\x95\x9f\x0c\xb2\xd8\xa6?\xe8U\xd6\x91\x90\x05\xb0?\xe0w8\x10`\xfc\xb3?\xeens\x85\xf8i\xc6\xbf\x13Aa=\xbeo\xbb?\x0be\x1a\x81n\xe7\x8e\xbfV\x8b\xf8+\xcd\x8a\xc2?1^\xea\xb1\xb4:\xd1?\x07\xe6@\xfd\xb3@\xe2\xbf|\x88\x8b\x89\xa0\xf4\xc9\xbfV\xec\x89@\xa1\t\xc0?\x95oUj\t>\xae\xbf{\x99\xe6\xfd\xb8k\xdb?\xb0\xc2\xd4K\xed\xd5\xa5?*3\x9d\r\xbc\x04\xc0\xbf3\xdca\xdc\xb5\xbb\xc2?\xd6\n\xd1e\xb7&\xc2?\xe1J\xb0\x842\x86f\xbf/JAC\xa8%\xb0?B\xaaL\xe1J\xf3\x80\xbfc\xd8"\xd9A\x91\xa8?\xe0\xb4\xa1\xec\x83\x1b\xb0?Ki\x00\x85yv\xbe\xbf\xd2\x01\x19\xdf\x8c\x9e\xb6?\xc9\xfe\x03\xffq\xea\xc5\xbf\x99\xb9\x06\x97_\xc2\x92\xbf\x17\x19\xeb\xca\xc1\xe3\xc8?W\x16\xba\xf3g\xf6\xb0\xbf<_\x86~R\xe5\x9e?\xfb&i\xa1\xf3y\xad\xbf\x93r\n\x8d\xa4D\xcc\xbf\x00\x08\xf11:\xb4\xc2\xbf\xe3\x83\xddO\\\xb8\xb3\xbf\xedp\xcfy\x1a\xb7\xad?x\xb0\xb3\xfb\xfd\xbf\x9b\xbf \xae:\xba<\xe4\x9c\xbf\xe7u\x00\rPz\x93?\x14*b\x8e6`\xd1?\xc6\xfa$\x9d)\xb5\xa6\xbfO\x0e\xff\xb7J\x94\xd4?E\xf2\x1f\x12\xbe\x80\x89?lK\xb3\xc6\xa2\x12\xdb?j*\xc5\xdf\xdd~\x8c?\x9b\xf5L\xf9\xdep\xb1\xbf\xce\xe7P(\x8b\xb8\xaa?G\x82C\x9fqE\xaf?\x0e\xa8\xcd\xec\xf4U\xf9>\x9e\x87\x94p\xb5l\xa7?\xd9\x06\xd5\xa0\x07]v?\xfb;_G\xd1f\xce?;\xe0\xf5\xa7\xdb\x08\xb1?\xc8\xc2\xd9\x92C\x08\xbb?\x04eQ\xf6\xa7\xb7\xb5\xbf\xac\xf1_f%\xc4\xb2?\xef\xb40\xc5;\x1br?\x85\xd1\xe3\x1aH\x87\x83?\xb1\x127\xb5\xad,\xb4?Ka\x0c\x1a\xa0\xe9\xa5\xbf\xe9\xde\x8f9\xc0:\xbe?\xf2t+\x90O\xfd\xd3\xbfU\xb9"\xac\xa4Y\xa2\xbf\'\x98\xe3r\x8a\x11\xd6\xbf\x83\xf8{}\xb8r\xad\xbf\xe5"\xe2\xe5xS\xde\xbf\xbe\xe1\xa9X\xe7d\xa7\xbf1G\xe5\x1a\xf1\xe9\xa5\xbf\x12\x18\x02\xc18I\xba\xbf\xd1g\n\xa605\xc6\xbf\xab\xb1\xc2 \xd3\xf1\x97?\xec\x834\xa0\\\x90\xbd\xbf|\xd8\x92\x8b\xce\xab\xb4?\xff\xa6~!SFt\xbf6w\xd3\xc6\xa2c\x94?I\xbdv\x19F\x03\x9b\xbf.\x16\xe3\xa0\x1f\xb9\xc2?\xdd\x8d\n\xee\x00C\xaa?y\x81z\xc6v\x85\xe4\xbf&\xb15\xe3\xa2\xb4\x8f\xbfH\x1f\x85?\xde\xbc\xa7?\xd1\xd8\x9c\xfdu\n\xae\xbf\xc6\xaf\x1a{\x17\xb6\xe3?\'r\xbd0\x90\x90\x92\xbf\xcemn\x87\x80\xd8\xc3\xbf\xd7{\\\x96\x99\x80\xaa?\x1f\xf1\xfd\xf0\xa0\x0f\x86?\x92C:#\xa5\xb5\x91\xbf\xc0(\xdb\xafh\xc7\x7f?\xef_\xbe$q@\x98\xbf\xda!b|\xe3;u?\x9dE\t\x86\x8c\xb6\xa0?\x90G\xda\x82D0a\xbf\xed)\xb7A[\xc1\xb5?*H`+[\xeef\xbf\xefg\xed/$\x11\xa1\xbf\x92\xdcK\xfa\x9b\xb0v\xbf\xd6\x97!-\x19\x96\x8b\xbf\\\xc5\xa2b\x94\n\x9f\xbf\x1f\x95)\xc4:\xdc\x92?\xe3\x0c\x13\x8b\x05\x93\xd2?s\xdd\x8d\xe9\xb3\xdc\x97?\xd5\x1d:W\x93\xac\xbb\xbf9h\x9c\xa9\xd8\xfe5\xbfd\x08\xd6\xbd\xb5\xdd\xc7\xbf\xfc^\x13&\x12\x90\xa1?\xbb\x86\x85\xb7w\xd9\x8a\xbfU\x17\xbbP\xc4\x01y?N\xdec\xb2\xab\xacr\xbfg\x99\xf7.\r\xf1\xa4\xbfp\x1c{\x00\x1d\x90\x9b\xbf\xb7\x1b$\xe1i\xfa\xac\xbfBb\x92\xc8\x91I\xa1?\x7f\x83\t\xe8\x94"X?\xe8\xe7c\x0f\xf0\xa0\x91?;{A\x9eK\x81\x96\xbf\xaa\xcf\x19\xf2\xd8vs\xbf\xf3\xa8r\xc75bp\xbfNf$T::\x84\xbf\xd1\xb7 ?\xd4\x86\xc7\xbf\xbc*\xbcz\x98L\xad\xbfV\x05q\xd5G\xf3\xb3\xbf\x85:_G\x12E\xa8?PZ\x12N\xa6\xaa\xcf?\'\xe3\xfbk\xc9\xa5v\xbf\x84h%\x99!8z\xbf\x01p"\xe3\xe0\xf5\xa1\xbf;u\x8f\x1d\xea\xa7{?\x84\xefD\x19 \x8c\x96\xbf\x1aW[+\x15=\x93\xbfyi9C-\xa7\xb8?.\rO\xdck\xcf\xc6?\x9b\x8aK\xd0\xd0\xdf\xd7\xbf\xdd\xb2{J\xc8\xf6\x89?\x95\xd6\x9a\x18\xff\x8c\xd4?\xa1B\xb1\xe4n\xd8\xcb\xbfG OuRF\xab\xbf:\x88N\x1b\xcc\x89\xa4?\xddn\xecv^\xfc\x80\xbf0rH\x1c\xbf\xd9\x8e?z\xa6\x07\xad\x08\x80\xcb\xbf\x13VJ>\xd7\xad\xbc?\x9f}\x9b\xb8<\xb5\xdc?\xb2.\xc9\xe5\xed\xd3\xb4?\x07J\x17\xfaUw\xcc\xbf\xc3\x9b\xb8\xcf\x97\xb4\xc0\xbfW?\x96\xd1\x81\xe5\xa7?\x93\xca\xf2}\xf8\x98]\xbf\x91\x82F\xf9!\t\xc7?\xd2\'\x98u?5\xcf\xbft\xe5\xb0_c\xed\xcd\xbf\xa4\xf0^\xe55\x04\xa5\xbf,\xef\x05\xf3\xeb8\xb5?\xae\xd9\xe7\x83\xf6A\xd0?\x8c\x8c\xb8\x9c\xb4\x89\x8f\xbfk\xb0e\xa2\xee%w\xbfbIb\xc5\xc8b|\xbf\xb6G\xd7\xd8\xb4\x0b\xa0\xbfh\t\xa7\xec\x85h\\\xbft\xd3y\x81\xd2\x03\xc8??h\x92O2\x0f\x91\xbf1w\x0e\n\xc9\x9b\xc2?yz\x98 \xc4\x81\x9d?70&\x0f\xae\xf3\xc9\xbf\'\xd9k\xd0{\x1bt\xbf\x10\x0e&\xaa<t\x8e?9\xc5\x17\x8f\xa0\xa6{?/\xe5\xb0\xdf)~\x84?\x88!{?_\xb4\x98\xbf\xf9\xc3?\x9d\xf0c\xa3\xbf\xd1\x8d\xaa\xe2\xca\xa4\xd0?\x8d\x9e\x99]\xf8\x19\xbe?<y\xe0Z\x04M\xe3\xbf\xbef\x14\xcf1#\xc4\xbf\x93y\x9f{\x12?\xdb?\x0b\xe8\x15\x7f\xe0\xfc\xb6?\xb4Mzl]\x7f\xb0\xbf\xf1\xc8\xb8\xb5T\xf4\xae?g\xa2 yqm\x9b?c\xc2\x93:\x07\xe8f\xbf\xbd8\xab\xfa]\xab\xb3?hc\xa9\xb42\xca\xc2\xbf\xc7\xdeBxp\x1b\xc4\xbf\xacY/\xb2\xdeEt?b\xd8\xb9\xff\x95\xfa\xb4?Y{\xb3z\x11j_\xbf\xb4\xbb\xf0y\xd3\xe91?\x01L\xda)4\xdce\xbf\x11\x8fR\xbbD8\xc1\xbf\x99\xb6\xe9\x9cC\xd7\xc0?)\x9bx\x98iF\xd2?~\xcd\x0b\x11\x06\xd6\x80\xbf\xfe4\x9b\x8aR\xf6\xc4\xbf\xf5\x19RKE\x1b\xc5\xbf\xb0\x98\xde\x93\xcd\x9a\x84\xbf\n\x1f\xa0\x0f}c\x86?\xb7\r\x97\xbek\x98K\xbf\xe4T\x85\x84b\xf1\xa4\xbf\xd4a\x17)`\t\xaa?\x9d\xe3\x0e\xd9\xa6K\xd5?\xf4\x82\xc0Y\xa6\x10\x9c\xbfj\x92W\x96\x10\x15\xd9\xbf\xbf\xce\x80\r\xe8h\x94\xbf\x05>\xb8\xea\xb1;\xc5?\x88\x01&\xe4\x0bDh?pBM\x8f\xd2U\x99\xbf\'\xb0)\xd9\xdf ~?\x0b3\xb2\x92@I\x88?\xb4\xbb\xac\xf1T\xc5\x87\xbfi\xbb8\xd9\xba?\x95?\xf5\xe0\x8c\xf08\xb2\xaa?\x94%e\xc8\x83D\xd5\xbfR\xa2\x94\xa1\xb3\x97\xc0\xbf\x85T\xa0\x9e\xf2\x82\xe4?\x8e\x86CW/\x81\xb5?\xc2H\xd6O\x87\x9a\xd3\xbfR\xcbV_^%Q\xbf\x965\xcf\xb4\xc6\xff\xa5?Tj\xd8\xe6\x97\x00\x91?\xc7\xd0\x96\xc54-\x80\xbf\x19s\xb3\x7f\x92\x07\x9e\xbf\x16\xc8\x17\xcf\xf1\x8f\xa1\xbf\xa6C\xc2{\x9c\xc6\xa3\xbf\xbes?\x005\xa3\xc2\xbf>\x86\x8c\xb0\x16_\xaf?\xd0)7@\xa8\xb2\xbc?\xa0\x87\xf8\xdf\xfa.\x81\xbf\x05+\xa4)wc\x82\xbf(`\xbe)\xd7\xe0\xa7\xbf\xc1\x98P\x7f\x04\x94\x99?\xb5\xa6\x1d\x14\tY\xb7?\x1d)\x93\xa9lb\x91\xbf\xd0U#\xb3\xa2\xf5\xa5\xbfr>\x02F\xfeE\xab\xbf(\xb5\xb0\x80z6}?\x94f\x01\xd6\x86\x83v\xbf\x0e\x81\x9d\xdd\xed\x15B\xbf\xccl\xc8\xdc\x03\x10\x8e\xbf0\xba\xc1\\R\x1a\x99?\xf7^Ni<\xfc\xc9?%}\xfd|\x04L\x82\xbf\x1c|a\xc7ty\xb9\xbf\x12\x93 \xa0\xc9,\x85\xbfR$\xde J\x00\xbb\xbf\x81\x86\x7f\x16\xd6\xc1\x81?V\xd2\xc3\xd4\x92?a\xbf\tr\x03\xb0\xf7@\x81?|+\x99\xaa\xf6\xd1A?\xc4PN\x90\x9a\xc3b?\x85\xfd\x1b\xce\x08\x0fq?0G1\x10\xa1\xcb\x91\xbf\x9d#(\x11\x17\xe9\x91?\x8e\xa7x\x04\xbe?\xb0?.\xda\xac\x0f\xcd*\x96\xbf#\xb4\xef\x0f\xfe\xa0\xa7\xbf\xda\x08t\xb71\x1f\x86\xbf\xee\xf6\xa4\t\xa6\x83g?\xc0\xd8?CX\x07\x83?\xa2\x9e\x008&0\x81\xbf\x81\x8b\xff2\x04*~?\x13G\xee\xd1\xc6$\x82?\x9a(15\xf2\xc8\xe2\xbf\x7f\xe2\x14\xa7\xf4q\x84\xbf\x9e\xc4%\x98\xcf\xfa\xdf?7e\xb0!\x03\x1b\x94\xbfD\x89\xf6\xe7xx\xb7?\n\x01l)0\xe7\x89\xbfZ\xc7\x15\xb0Xho\xbf\xfe-\xa7\xa25\x17\x96?bm\x1b\x91\xceMr?B\xd9\xees\xa6k\x9b\xbf,0T3iY\xd9\xbfj\xcd\xfblc\x96\x8a?\xc4\x93/$e,\xda?\x99\r\xcb\x83\xe2\xbef?\xa1?\x18s\x9c\x90S\xbfm\xa7\x0f\xd0\xdb\xcfh?{\xd5\xa0\t\xd9Z\x86?\xde\xdd\x95\x94(T\x93?\xc8 W\x97\x85~\xd0\xbf\x1f+\xe0\xaf\xfcb\x92\xbf\xfc\xc7C\xe2\xb0\x15\xe1?\xd4\xca\xfbPIbc\xbf\x0b\x02\x88\xaf\x0e\xa7\xce\xbf\xcb\xd6S\xf0\x0c\xf1j\xbf\x97Rz\xc0{fU\xbfc\xd01\x05:\x1dE?\x81<U\x9d\x18\x9ex?_[x(\x9f\nx\xbf]\xf6\x9b.\xaf\x1c\x81?\xe0\xbe=#\xc3[\x9c?1\xe8\xe0uY\x1b\xc1\xbfm\xa7\x98B\xad\n\x9f\xbfvl\xb4lR\x85\xd1?\x1e\xec\x84\x87\xc5\xd5}?\xf1\xeaI\xae\xec\x93\xc5\xbf^\x14W&\x8e1s\xbf\xb9Lr\xf5H2X\xbf\xfa\x10\xbb1\xa3nf\xbf\x07\xe4\x85\x1f\xa2#J\xbf\xb9\xc54v\xb0\xaa\x9f\xbf\x0c\xdb\xd9\x8a\xfc\xde\xbd?\xea\x04\x13\xdb)\xf0\x9b?ND^\xf0\xa2\x85\xd3\xbf*\xfb\x1bsY#y?\x92>\x8a\x89\xcb\xf0\xc0?\x12c(B\x90\xf4=\xbf\x9a\x1chDc9\x80\xbf\x81.\xb5m\xb6qz\xbf\x1f\xbb\xc2\t\xc2\x05\xcc?\xe1\x0cQ7Co\x90? v\x134\xd3\xa8\xdd\xbf\x1aW0q\xf5Qs\xbf,#.\xb0=\xe6\xd1?}\xd6\x83H\xb0v\x7f?\xfd\x91\x9e\x93u\xedz\xbf\xce\xb3wL\x9f\xaa\x85?\x83\xeaV\t3C\x80\xbf\xb7"\xe7\xd4\xd9 \x91?YHv\x08\x10\xfb\xb3?\xfd=\x82\xed\xea\xbeu\xbf\xa9?C\xd0\xd1~\xbb?t\xea\xd3\x1f\xbc\xc5\x8c\xbf\xd9\x82\xa1\xc0M`\xc1\xbfqlX\x00\x94\xe8h?Yqz\xc7\xf9\x9fP?\x08\xa2\xed\xd3\x7fhL\xbf3\x9e\xf5\x0fb\xd5l\xbf\x8ao\x16\xd0\xfa|g\xbfia\rJ\x9c\xa0`\xbf\'\x95\x04\x01\xc6np\xbf\xfb\xf9CN/\xf9\xbe?\xb9[\xd7\x0e\x87mv?\xe6[\xb2\x97\xe6\x1f\xab\xbf\x16i\xd9zQ@}\xbfC\xf5\x8e\xb4\x0b\n\xac\xbf3M\x1c\xe9cI\x80?2\x18\x074tpw?\xa2\x1d\xdcUY\xd2\x95\xbf\xee\xc4\xd8M\xed^\x84?\x8c\x03\x02\x0e\x8b\xc8[?5\x07Z\x12\xea\xda\xcd\xbf\xffS\xb76\xe8\xec\x97\xbf\xee\xb6PPi}\xd6\xbf\xec2\xae\xba\xed\x89t?\x8c\x8e;"\xdcA\xe2?\xc1\xbf\xbb]["s?\x9e\xe4^.\x0e\x94d?\xf6\xb8\xb9rfwW\xbf\xc3\xf7\xcem\x91\xaf\xe1\xbf\xa9\x81\xf4\xab\x13\xe1\x93?\xb7i\xed:\xfdB\xd3?E\xf6\xec\x1d\x07\x1b_\xbfP\x96u_M\x14\xca?'
-p179
-tp180
-bsg79
-g64
-(g65
-(I0
-tp181
-g67
-tp182
-Rp183
-(I1
-(I40
-tp184
-g74
-I00
-S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
-p185
-tp186
-bsS'n_samples'
-p187
-I3148
-sS'_n_active_components'
-p188
-I36
-sbsbasS'reference_shape'
-p189
-g0
-(g87
-g2
-Ntp190
-Rp191
-(dp192
-g91
-g64
-(g65
-(I0
-tp193
-g67
-tp194
-Rp195
-(I1
-(I20
-I2
-tp196
-g74
-I00
-S'\x1f\xd0\xa4\xc6\x16\x9dx@\xff\xe4\xc0F\x8f\xbek@\x92\x83\x8a\xda\xe1\xaew@\x9dy\rz\x0b\x0ep@\x1aM\x8e\xbd\x81:w@D\x89\xe3\x88*5r@\x89\x1dp1\x10\x98w@\xaa\xb7\x08\xaf\xdf\x9es@!\x96&j\x9c3w@\xd2\x9f\x96\x8af9u@xn\xba\xf6d\xa4w@\xbd`\xfcA\x0flw@9a\xf83\xc9ix@\xe9\xd4\x98\x81\x9e\x8ay@\xc9\xa0\x97lP\x88z@\xb9\x0f\xdbEQ\x85w@5\xa4u\xbd\xd0z{@n\x1b-R"nu@\x11\xbcJ%\xb2\xae{@\xf3\xd6K/\xe8\xb6s@\x18y0\xb1)\x8b{@\xe1\xfa\xfc\x8a\x1b&r@\x92\x05\x957&\xacz@=\xd8\xb9\x934\x05p@\xb6\xd5\xdc\xfdZ\xb4x@\x13\xe0D\x0f6\x87m@O\x9fW5\x82\x82x@\xbbX\x7f\xf2W4r@I\x9f\xccL\x0b\xa5x@\x92/\nC\x19\xa5s@\x94\xd8\xe66\xeatx@~\x1b\x14A\xb5Cu@#jk\x91\xa0\x8cx@B]\x13\x1cl\xa6x@x\x8ec\xceW\x8dy@\x11\x1e\xbe\xd3{Mu@K\xeb\xad\x00\x99\xc5y@\x11\x82\xb4GP\xa8s@\xfe\xda\xd7x\xb6\x9ey@5*0}\x03/r@'
-p197
-tp198
-bsg98
-Nsbsg48
-(lp199
-g49
-asg51
-g34
-sg46
+ccopy_reg
+_reconstructor
+p0
+(cmenpofit.clm.base
+CLM
+p1
+c__builtin__
+object
+p2
+Ntp3
+Rp4
+(dp5
+S'opt'
+p6
+(dp7
+S'ablation'
+p8
+(I01
+I01
+tp9
+sS'verbose'
+p10
+I00
+sS'rho2'
+p11
+I20
+sS'sigRate'
+p12
+F0.25
+sS'ratio2'
+p13
+F0.08
+sS'imgDir'
+p14
+S'/Users/arik/Desktop/artistic_faces/applications/AF_sample'
+p15
+sS'dataset'
+p16
+S'demo'
+p17
+sS'ratio1'
+p18
+F0.12
+sS'smooth'
+p19
+I01
+sS'pdm_rho'
+p20
+I20
+sS'sigOffset'
+p21
+I25
+sS'kernel_covariance'
+p22
+I10
+sS'numIter'
+p23
+I5
+ssS'_shape_model_cls'
+p24
+(lp25
+cmenpofit.modelinstance
+OrthoPDM
+p26
+asS'max_shape_components'
+p27
+(lp28
+NasS'scales'
+p29
+(lp30
+I1
+asS'diagonal'
+p31
+I200
+sS'holistic_features'
+p32
+(lp33
+cmenpo.feature.features
+no_op
+p34
+asS'patch_shape'
+p35
+(lp36
+(I8
+I8
+tp37
+asS'expert_ensemble_cls'
+p38
+(lp39
+cmenpofit.clm.expert.ensemble
+FcnFilterExpertEnsemble
+p40
+asS'expert_ensembles'
+p41
+(lp42
+g0
+(g40
+g2
+Ntp43
+Rp44
+(dp45
+S'sample_offsets'
+p46
+NsS'cosine_mask'
+p47
+I01
+sS'context_shape'
+p48
+(I8
+I8
+tp49
+sg35
+g37
+sS'response_covariance'
+p50
+I3
+sS'patch_normalisation'
+p51
+g34
+sS'_icf'
+p52
+Nsbasg47
+I01
+sS'shape_models'
+p53
+(lp54
+g0
+(g26
+g2
+Ntp55
+Rp56
+(dp57
+S'similarity_model'
+p58
+g0
+(cmenpofit.modelinstance
+_SimilarityModel
+p59
+g2
+Ntp60
+Rp61
+(dp62
+S'_components'
+p63
+cnumpy.core.multiarray
+_reconstruct
+p64
+(cnumpy
+ndarray
+p65
+(I0
+tp66
+S'b'
+p67
+tp68
+Rp69
+(I1
+(I4
+I40
+tp70
+cnumpy
+dtype
+p71
+(S'f8'
+p72
+I0
+I1
+tp73
+Rp74
+(I3
+S'<'
+p75
+NNNI-1
+I-1
+I0
+tp76
+bI00
+S'\xc0I\xb4\xb5\xa8\xc6\x9c\xbf\xd5J\xf4m\x93\xc6\xd8\xbf\xfe\xda\xff\x17\x85\x85\xb7\xbfQ\x02\x84\xbb0\xee\xce\xbf\xd0\xa6w]-\xbe\xbf\xbf\x9c\xd6FO\xbb\x8c\xb9\xbf\xdf\xd9\xdd^\x0c\\\xb9\xbf+M\x9f\x10\xfe\x0f|\xbf\x04pM0\xd2\x14\xc0\xbf\x925\x9b\xd1\x0b3\xb9?\xb8\xf6Y,\xaa-\xb8\xbf\x9a\xb4{\xfb\x137\xcf?\xb9\xc7\x9c\tdL\xa5\xbf\xe5\xc2\x8a\x17\x84\xaa\xd8?\xd7\xb4\xba\xc4\x80\xf1\xb7?\xc2\xd1\xcf$\x80\t\xd0?\x12\xd2\x9a\xfbD\xb2\xc3?;\x8e\x95;\x1d\xc3\xbc?V\xad\xb2\xf0\x97e\xc5?\xc9\xaa\x0f\xd4\x91!7\xbf\x9d\xb1\xbc+\xba?\xc4?\xefy\x89\xb1k\x82\xba\xbf\xc6\x8c\xdaE0U\xba?\x81\xea\xe5\x9a\xaa4\xcf\xbf\xbc\x87\xc0\xb6\xf1\x90\x97\xbf(\xe8\xdf\xb2b\xe7\xd4\xbf\xd0\x1a\x17\xbd*\xb8\xa2\xbf\xb4\x88\x0c\xf88\x98\xb9\xbf\xadCH\xd1\xb7+\x9c\xbf\x0c%]\xdf+\x1du\xbf\xffF\xa31\xcbq\xa4\xbf\xd3\xa1y\xe7\x99\xe9\xb9?\x85\x94=\xdb\xf9\x1c\xa1\xbf\x8e\xc1\x11n\xe3\xcb\xd4?C\xb5l0+(\x98?\xc6IN\xd9c\x83\xba?\xf9\x1a[\xb4\x17o\xa3?\xd6\x92CNp\xb8q\xbf\x91\xdfE\xe6W\xa8\x9c?\'\xe3\xe7\x0f\x83\xe6\xb9\xbf\xd7J\xf4m\x93\xc6\xd8?\x9eI\xb4\xb5\xa8\xc6\x9c\xbfQ\x02\x84\xbb0\xee\xce?\x00\xdb\xff\x17\x85\x85\xb7\xbf\x9c\xd6FO\xbb\x8c\xb9?\xd1\xa6w]-\xbe\xbf\xbf(M\x9f\x10\xfe\x0f|?\xdf\xd9\xdd^\x0c\\\xb9\xbf\x925\x9b\xd1\x0b3\xb9\xbf\x03pM0\xd2\x14\xc0\xbf\x99\xb4{\xfb\x137\xcf\xbf\xb8\xf6Y,\xaa-\xb8\xbf\xe5\xc2\x8a\x17\x84\xaa\xd8\xbf\xb8\xc7\x9c\tdL\xa5\xbf\xc2\xd1\xcf$\x80\t\xd0\xbf\xd7\xb4\xba\xc4\x80\xf1\xb7?;\x8e\x95;\x1d\xc3\xbc\xbf\x11\xd2\x9a\xfbD\xb2\xc3?P\xaa\x0f\xd4\x91!7?U\xad\xb2\xf0\x97e\xc5?\xefy\x89\xb1k\x82\xba?\x9e\xb1\xbc+\xba?\xc4?\x81\xea\xe5\x9a\xaa4\xcf?\xc6\x8c\xdaE0U\xba?(\xe8\xdf\xb2b\xe7\xd4?\xbd\x87\xc0\xb6\xf1\x90\x97\xbf\xb4\x88\x0c\xf88\x98\xb9?\xd1\x1a\x17\xbd*\xb8\xa2\xbf\x0b%]\xdf+\x1du?\xadCH\xd1\xb7+\x9c\xbf\xd3\xa1y\xe7\x99\xe9\xb9\xbf\xffF\xa31\xcbq\xa4\xbf\x8f\xc1\x11n\xe3\xcb\xd4\xbf\x85\x94=\xdb\xf9\x1c\xa1\xbf\xc6IN\xd9c\x83\xba\xbfD\xb5l0+(\x98?\xd6\x92CNp\xb8q?\xf9\x1a[\xb4\x17o\xa3?&\xe3\xe7\x0f\x83\xe6\xb9?\x91\xdfE\xe6W\xa8\x9c?\xd0\xed\xbf\xc5%\x9f\xcc\xbf\x08r\x97l\x01,\xa0<\xd9\xed\xbf\xc5%\x9f\xcc\xbf\xd6]\x7f+[Z\x88<\xd7\xed\xbf\xc5%\x9f\xcc\xbf$\xc2\xce\xb8\x10\x1dz\xbc\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x8bv\xc0\xdb^\xdf\x89\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf\xa6\xa4\x1a\xea\xd8\x83\x9b\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbfXk\x00C\xe3\x10\xa3\xbc\xdf\xed\xbf\xc5%\x9f\xcc\xbfM\x05_\\\xf6\x0f\xa6\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbf\n\x0cSg9a\x8d\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbf\x9b\xfb\xee\xcf\xbb\xd7\x85<\xdb\xed\xbf\xc5%\x9f\xcc\xbfg6\t\x98\x9eM\x97<\xda\xed\xbf\xc5%\x9f\xcc\xbf\'R\x8b\xa6\x07\x12\xa0<\xd8\xed\xbf\xc5%\x9f\xcc\xbf\xa7L\xb9\xeda^\xa2<\xd4\xed\xbf\xc5%\x9f\xcc\xbf\x08\xfaJ\xff\xa0v\x9d<\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x84>E\xae+\xe5t<\xd9\xed\xbf\xc5%\x9f\xcc\xbf\x1d\xb3\x9fq\x04\tj\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf7\xcc\x1bE3\xdb\x8d\xbc\xde\xed\xbf\xc5%\x9f\xcc\xbfx\\\x95\x05\xac\xb5\xa2\xbc\xdd\xed\xbf\xc5%\x9f\xcc\xbfL\x00F\x0e\x8c`~\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf+HV}\xa2\tw<\xd6\xed\xbf\xc5%\x9f\xcc\xbfs\x16[\xd0\x04\xa2\x8b<\xb9n&\xb8\xfc\xb1\x9c\xbc\xd6\xed\xbf\xc5%\x9f\xcc\xbf\x1fv|\xc5\t=y\xbc\xd3\xed\xbf\xc5%\x9f\xcc\xbf\t\x8f\xf37"#{<\xd7\xed\xbf\xc5%\x9f\xcc\xbf\xb3\x86o?\xc2\xee\x86<\xd9\xed\xbf\xc5%\x9f\xcc\xbfY\xa3j[\x19\xd3\x97<\xdc\xed\xbf\xc5%\x9f\xcc\xbf\xeb\xe3\xdb0\xd3\x99\x9e<\xdc\xed\xbf\xc5%\x9f\xcc\xbf\xf2\xa8\xd8P\xc6V\xa3<\xe0\xed\xbf\xc5%\x9f\xcc\xbfo\x83\xf4\xdf`\xf6\x80<\xe1\xed\xbf\xc5%\x9f\xcc\xbfE$\xd3%\xe6\xfc\x84\xbc\xe0\xed\xbf\xc5%\x9f\xcc\xbfjw\xa8\xf2\nx\x95\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbf\xfd\x17U\xee\xe3\xf1\x9b\xbc\xda\xed\xbf\xc5%\x9f\xcc\xbf\x7fm\xbeQt\x07\xa1\xbc\xd8\xed\xbf\xc5%\x9f\xcc\xbf\xb3\xa8\xd9N\r\xd7\x99\xbc\xd3\xed\xbf\xc5%\x9f\xcc\xbfqd\x01\xfb\xd9\xcar\xbc\xd7\xed\xbf\xc5%\x9f\xcc\xbf\x98?\xbeC\'5g<\xda\xed\xbf\xc5%\x9f\xcc\xbf!d\xa0\t\x05\xc2\x8e<\xdd\xed\xbf\xc5%\x9f\xcc\xbf\xa5\xe5\x8f1\xdbJ\x9f<\xde\xed\xbf\xc5%\x9f\xcc\xbf\x1a\x0b*\xce\xca\x0ft<\xdd\xed\xbf\xc5%\x9f\xcc\xbf\x7fc\xff\xed\xc5\x9bv\xbc\xdb\xed\xbf\xc5%\x9f\xcc\xbf\xc0 \xeaA(p\x88\xbc\xd8\xed\xbf\xc5%\x9f\xcc\xbf'
+p77
+tp78
+bsS'_mean'
+p79
+g64
+(g65
+(I0
+tp80
+g67
+tp81
+Rp82
+(I1
+(I40
+tp83
+g74
+I00
+S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
+p84
+tp85
+bsS'template_instance'
+p86
+g0
+(cmenpo.shape.pointcloud
+PointCloud
+p87
+g2
+Ntp88
+Rp89
+(dp90
+S'points'
+p91
+g64
+(g65
+(I0
+tp92
+g67
+tp93
+Rp94
+(I1
+(I20
+I2
+tp95
+g74
+I00
+S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
+p96
+tp97
+bsS'_landmarks'
+p98
+NsbsbsS'similarity_weights'
+p99
+g64
+(g65
+(I0
+tp100
+g67
+tp101
+Rp102
+(I1
+(I4
+tp103
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p104
+tp105
+bsS'_weights'
+p106
+g64
+(g65
+(I0
+tp107
+g67
+tp108
+Rp109
+(I1
+(I36
+tp110
+g74
+I00
+S'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+p111
+tp112
+bsS'_target'
+p113
+g0
+(g87
+g2
+Ntp114
+Rp115
+(dp116
+g91
+g64
+(g65
+(I0
+tp117
+g67
+tp118
+Rp119
+(I1
+(I20
+I2
+tp120
+g74
+I00
+S'(\xc4\xbcx\x90\x9b\x19\xc0\xf6\xc2:\x7f<\x0cV\xc09%\x19\x9a\x87\xee4\xc0\x0b\xc6r\xc3^\x86K\xc0N`B\xfat?<\xc0mI\xd2\x0f\x93\xbc6\xc0\xdf\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x04!\x9c\xee\x16\x9f<\xc0@u\x8a}\xc3l6@tN\xe1D)\x845\xc0D\xa7\xb6\x90;\xc7K@N!\xe1K\x10\xf4"\xc0\xc4\xfa\xdd\x11D\xf3U@~\x8c\xc0\x9c\x9fN5@\x8fw\t\x03\xf1\x8aL@m\x9f\xdc\x1e\x19\x87A@f\xf04\xe9h\x989@\x18\x9a~\xd2}\nC@/\xebG\x95\x95\x95\xb4\xbfm\xa4q\x1c\xfb\x04B@`]\xfbU6\x977\xc0\xb1\xa4|\xd9\xf5n7@\x85=\xd3)\x16\xc5K\xc0\xb6z\x156\xb2\xf8\x14\xc0m\x16\xaf\xf0-\x9aR\xc0\x8b\xda=c\x88\xa8 \xc0\x06\xa2\x8d\xd5\xcc\xc66\xc0\x13PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf=\xfd}\xef\x881"\xc0g\xeb\xb8\xfd7\x0f7@\xc9\x1f<\x11;u\x1e\xc0\x04\xc1"\xb8\xb5\x81R@\x0cV\xe42E\x7f\x15@|\x8d\x1f+\x13\x987@\xd3 yRQK!@&\x17W\x12\xec\x89\xef\xbf\xfe\x8eH\'\x96\x80\x19@$n69x\x0c7\xc0'
+p121
+tp122
+bsg98
+NsbsS'global_transform'
+p123
+g0
+(cmenpofit.transform.homogeneous
+DifferentiableAlignmentSimilarity
+p124
+g2
+Ntp125
+Rp126
+(dp127
+S'_h_matrix'
+p128
+g64
+(g65
+(I0
+tp129
+g67
+tp130
+Rp131
+(I1
+(I3
+I3
+tp132
+g74
+I00
+S'\xfb\xff\xff\xff\xff\xff\xef?D\xbc\xd8\x8bG\xe0k<\x00\x00\x00\x00\x00\x00\xe8\xb9F\x87\xeb\x1b:`_<\xff\xff\xff\xff\xff\xff\xef?\x00\x00\x00\x00\x00\x00\xd0\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0?'
+p133
+tp134
+bsg113
+g0
+(g87
+g2
+Ntp135
+Rp136
+(dp137
+g91
+g64
+(g65
+(I0
+tp138
+g67
+tp139
+Rp140
+(I1
+(I20
+I2
+tp141
+g74
+I00
+S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
+p142
+tp143
+bsg98
+NsbsS'allow_mirror'
+p144
+I00
+sS'_source'
+p145
+g136
+sbsS'model'
+p146
+g0
+(cmenpo.model.pca
+PCAModel
+p147
+g2
+Ntp148
+Rp149
+(dp150
+S'centred'
+p151
+I01
+sg86
+g0
+(g87
+g2
+Ntp152
+Rp153
+(dp154
+g91
+g64
+(g65
+(I0
+tp155
+g67
+tp156
+Rp157
+(I1
+(I20
+I2
+tp158
+g74
+I00
+S'\n\x10\xa7&WA$@X\xde\x0f\xf5\xdesU\xc0j*\xf7\x87\x1a\xbf6\xc0\xec\xd1\xdaw\xe1\xa9K\xc0\xf9\xaa\x1aC\xb2pB\xc0k2\xe7r\xc8\'8\xc0\xf6\x90\x08\x1b\xd6\xc8@\xc0\x91\x88g@\xdfK\t\xc0\xf6\xcd\x8d\xf1\xe9\x87B\xc0\x0c\xe9h\xae\xb8\xfb3@\xf1\x0f_\xb4\x7fI6\xc0\xa7\x9dC\xb1\xe7KL@(\xf2(V\xe1}\x14@\x0e\x05n]\x7f\xc8W@b\x15%\xa4b15@A\xbc&\x9a\x04dL@O5\xf38N=?@\xc8\\\xd4\x14\xa6\xe35@\xdb\xa8-\xe7\xa6\xc1@@\x15\xddg\xb6jX\xd0\xbf\x1e\xb3o\x10\xe4\xf2@@S\xfd\xfd\xea,{8\xc0~\xb7\xd8\x9a?\x878@g\x97`\xadH\xc2K\xc0r\xd4i0Y\n @F\x04{\xa6v\xb3R\xc0\xc3x\xac\x11\xcf\xa9\x1b\xc0\xb5\xa4f\x06n\x8a7\xc00\x04\xcf\xbfH\x89"\xc0\xb2&"\xb8\x9b\xe4\xe4\xbf~+V*\x13\xd0"\xc0\xc5j\xf9\xfeu%4@\xe4\xb9\x0e\xf6D\xc6\x19@uk\xa1\xe0p\x85T@S\xec\x0b\x93@R\xd8\xbf\xd9JD\r\xdd=4@wG\xe3\x88\x0c\x00\x10@\xc6\x18\xd9\xf3Vr\xf2\xbfb\x92\xd2\xe1\x93\x7f\xdb?\xac\x0c\xbaa\x15\xfe7\xc0'
+p159
+tp160
+bsg98
+NsbsS'_eigenvalues'
+p161
+g64
+(g65
+(I0
+tp162
+g67
+tp163
+Rp164
+(I1
+(I36
+tp165
+g74
+I00
+S's\xebe\x0f^\x07\x90@q\xb5\xf4|\x96\xc6\x8f@\xb4\xac!`@D\x80@Ud X\xc2\x9fb@\xedv\x8f\xee\xc0R[@v\xe8O\x95\xe6\x9eD@\x9a\xc0\xbc\xcb\xf0\x04A@\xcb\xfb\xfch)\xa5<@~A\xc5\x0bs\x837@\xb7\xf8a\x97\x8aL4@\xe1g\x89\xf7\xf8\xeb/@1{&\xdfD\x94,@MB\xeb\x82?u*@nr\x81\x8d\xd6\xb9!@\xb8\xf6`\xaa\x9f[ @]\xbe\r\xbe\x15?\x1a@\xd7\xcc\xa8\xe7\x87\x8b\x18@:\x98\xc5\x83\xdf\x02\x15@\xfd\xb5(CNV\x12@.\xa4\x8a\xf7\'\x1c\x11@\xb2\xc2\xe8L"\xab\x0e@Aw\xd6\x11\xb9\xb7\n@\xbe\xf1\xae\xb2\xa5\x8c\x04@e\xf0\x99\xffU\x7f\x02@\xf2\xd5X\x92\xb4\xcb\x01@p@\x1f\xf0F\x9e\x00@MR\x15\xd8\x9a(\x00@]\xf5\xbd\xdfy\x04\xff?\x9c3 \xa9\xf3\x9f\xf6?\x81\xab\xf2\\\xef\x8f\xf5?\x86\xd9\xe6\x17\x7f4\xf3?\xfey[b\xe4\xfc\xf0?\nx\xc8\x91F3\xee?\x1etI^0\xba\xea?\x8eh("\x98\xcf\xe0?\xef\xf5\xcdhz\x95\xd8?'
+p166
+tp167
+bsS'_trimmed_eigenvalues'
+p168
+g64
+(g65
+(I0
+tp169
+g67
+tp170
+Rp171
+(I1
+(I1
+tp172
+g74
+I00
+S'j\xd0r@\xe9=\xca?'
+p173
+tp174
+bsg63
+g64
+(g65
+(I0
+tp175
+g67
+tp176
+Rp177
+(I1
+(I36
+I40
+tp178
+g74
+I00
+S'\x98\x8a\xbb\xd6\x0c!p\xbfCJ_41\x93\xd7?\x7f\xd9J\xdesU\xc4\xbf\xb1\x85/\xd3~\x11\xab?@m\xcdETS\xcb\xbf\xc6ey8\x05O\xb3\xbf\xd0\n\xa2\x9ffA\xcd\xbf\xa1e\xb3-\xdd\xaf\xbd\xbf\x90\x04(\x88\xfc-\xcb\xbf\xdad\x9c_07\xc2\xbf\xf6\xa7\xacU\x07\x89\xc3\xbf"\x91\xa5k\xf9.\xa7\xbf"F\xd1!\x06\x8c\x88\xbf\x0b\xe6\x05:\x86\x8e\xa8?\xbc\x1c\xac\xde\xaeZ\xc6?\xa6\xc4\x06\xb69\x19\x90?\xd3\xac*Y_\xdf\xce?9\xdd\x16\xcd\x89\xb8\xae\xbf\xf0U\x8e{Y1\xce?\xb4\xec\x0cjIb\xa6\xbf0\xbd\xbe\xe6\xfc\x00\xcd?\x12p\xd6@\x0cB\x84\xbf\xaa\xf6\xb69\xa3\x1f\xc3?\x12^Nid\x85\xba?k\xca\xfd\x8a\xef#\x95\xbfw^\xbfOZE\xd5?u\xba\x1f5\xf7O\xc9\xbf\x0f?SD\x880\xa8\xbf\x0f\xba\x89WU\xcc\xca\xbfO\xc1\xc8\xecWD\xb8\xbfE\xf8\xf9\x9c\x04\x13\xc8\xbf\xd9}Y`\xce\x1d\xbf\xbfI/\xfa\x07\xc7\xbc\x99\xbf\x9c\x9d\x96\x93\x8d\x96\xa4?-0(\x88\xc5h\xcb?\xee\x02\x81\xack3\xb8\xbf\x18\xbfS\xcbW\x1a\xc9?\x12\xec\xf6B\x16\xe1\xb2\xbf2\x98\r?>\xa7\xc7?\x01\xb1\x0f\xb4\xa5\xbf\xa2\xbfCjX+\xd2\xf1\xad?mZ8\xdbX\x18\xd2?eCt<\x146\xb6?\x81\xb0\xd1\xd5\x04B\x8b\xbfA\xb6-\x1e\xf5(\xb8?\x13\xc8\xe9Q\xae\xa7\xca\xbf\xd3M\x95\x1cld\xba?H\x16\xab`\xa3\xa0\xca\xbfJ\xe0\x89\tCD\xb7?X\xa2\x12\xc4\xd8\xe9\xc3\xbf\xc1\xc8k\x0e$\x05\xb8?*\x15aA\xbc\x8d\xb0?D\xaauS\xba{\xa2?\xb0{\xdd\x0cI\xcc\xdb?\xb4\xd6\xf5\xc5\x15=\xad\xbf\xa9[\xcd\xf2\xc8Q\xc3?e$\x1f\x0et\x19\xbe\xbf\xadp\xf5\x05\xbf\xb9\xa6\xbf\x00\x12\xe9\xed"y\xc1\xbf\xc6\xb9\x07\xab\xb9\x03\xb9\xbf\xbf^i\x8ez9\xc3\xbfD\xeb\xf7\x85\x95m\xb7\xbf\xd7\xbaHm\x99S\xbc\xbf\xf3\xb3U\xff\xcc\xe6\xb3?\xd2\xb6T8\x94\xf0\xac?G\xd9\xd8\xda\x1e\x8f\xd0?W\xac\x07\x1f\x99\xce\xbb?\x16\x8aU\xf4~\xec\xc5\xbf[U\xf7;\xd3x\xbe?ybA\t\xaa\xf7\xc5\xbf\xda\xf3\x83\xe7\xe4\xde\xbd?\xb9\x00\n\xc0\xf1\xab\xbc\xbf\xecA\xb7\x94\x96*\xa0?F\xb9\xbe\'\x04\x14\xd9?\xac\xec\xf2\x10\xecN\xbe\xbf0n6\x93i\xbb\xb8\xbfg(y>N<\xc2\xbf{\xdeG\xa8\xca\x03\xc3\xbf\x95\x01X\xc9\x96\xdf\xc4\xbf\xa9\xc4\x02\xfb\x932\xc2\xbfy\x83\x96\x93\xa7\xcb\xdb?\x08\x85s\xc0\xef=\xaa\xbf \xf6\x7f\xad\x87\x0f\xa0\xbf\rP5\'\xfc\x1d\xa1\xbfH\x1e\x13\x14h\xad\xd1\xbf\xf5\xfb\xf7\x0b\xab\x81S?-\x91\x87D\x96b\xd0\xbf\xf0\xf4\x07Mh\xa3\x96?0\xd6H\xd7K5\xd1\xbfi\xb9\x88@\\n\x87?.\x1c\xd2s0\x1a\x87\xbfS^\xb8\xdb\xd5@\x92?\x1bXzC\xe8\xa3\xdb?\x0f\xfc1%\x1aH\xa0\xbf"\x80\x0f\xaf/\x98\xbd?t)\xe4\xfd\xa3\xe2\x84\xbf\xe8\xfesU\x89\xe4\xa8\xbf\xe4XK\xeem\xb9\x8e?\xd1\xc4\xedl\x07\xcd\xb1\xbfc\xda\xbb\xf5\x18\xdd\x9e?!\x1e\x96:T\xb4\xa7\xbfmW~\x07u\xdf\x8d?\xd5_d\xf6\xf1\\\xbb?4>\x87\x8e\xac\xe9s?m\xe6\xeb\xe9>\xff\xd3?\xcd\x8dv\xcf\x8fs\x9c?\xbat\xcbh\xff\xa6v\xbf\n\xb8q\x94\x92\x98\x7f?\xbf\xe6\x7f*\xfc\xba\xa0\xbf$\x89\x1d\x9d=u\x98?(V\x9bv\xff\x9b`?g.\x15C>~\x86?\x90%y\xbf\xb3\x96\xd4?\xe3\xf2\xb5\x10\xe1\x89\xb9\xbfJ\x97\xd6\x9bS\xc5\xcb\xbf!!!!\x9e\xf1k?_ \x83qqW\xcf\xbf*s\xb9a]\xf0\x95?5\x8bbQu\xba\xcb\xbf}:\xc0\xe8\x86\xd9\x8c?E\xf3\x82\\1\xdf\xc9\xbf\x9b\xc8H\xf3\xcf\xef\x8a\xbf\x8bg7\xad6:\xab\xbf\x0c\xb9Nu\xea\xab\xac?`w\x8d\x01\xe2^\xb2\xbf\x8e|\xc2\x98k"\xb6?\xd8\xca\xdf\xd9\x87w\x91\xbf\x0eP\x903\xae\xafD?j\xc3\xed\xdc8\xbb\xb1\xbf\xa8\xed \x11G\xc2\xba\xbf\xf6\xa0\x97Jm\x18\xaa\xbf\xe5\x96#\x18\xc9K\xb1\xbfx\xe0K`\xf2\x95\xc8\xbf\xfe\x8b\x06\xbb&\xa3\x8a?\xf1\x93\r\xa0D\xd4\xbf?I\xfa\xc4\x07\x8d\x80\xa7\xbf\xce\xc5\xa6\xe4t\xab\xd1?\xa5\xb7\xe5N\xa7\x04\xb1\xbfY_\x8fJX\xd6\xd2?\x86\xa3\xd4h\xa8\x8c\x98?\xae\xed\xed\xdeHO\xd2?F\xf8\xb7\x04\xf3\xf4\xb1?\xb7\x06\xc5\xbd3\x19\xc1?\xf1\xf6\x17OF\xb6\xa9?\x15;\xddI\xc8\n\xc0\xbf\xdb03\xee\xf0n\xae?\x93\xf5\xf8\xdd\xcc\xd3\xcf?\xa6\xab\x0ff.\r\xb7?y\xc2\xb7:#\xbc\xd0?\xf5\xed\xf9\x92\xb4{\x90?\x11\xa4\xd6\xf5w1\xd0?\xc6\x1eh\x98N\xd9\xb5\xbf\x19\xebX\x91o\xe2\xbc\xbf"g\xd9\xa2\xc4\xed\xb0\xbf\xb56\x96XG\x00\xd5\xbf\xbf\xabS}\xe1d\xbb\xbf2\xf0+\xc6\xad\xa3\xd4\xbf\xf9Bf\xb1\rv^?\xfb\xc6\xef\xf9gE\xd5\xbf\xa4\xc3\xb2,\x1b\x96\xb6?`WC\x02E\'\xa0\xbf\x8e\xc8l\xff!\x88\xce?\xce\xd07*\xb0\xb7\xa8\xbfO\x16#+\x93p\xb8\xbf\xd9\x08\xcfd\xf0\x8fz?;Y\xc7\x15c\xbd\xd0\xbf\x83\xe4\xd9e\xb1_\xab?\x98\x1e\xef\x84\x0eP\x80\xbf22\xeby\xe0]Y?\x97\xda\xa4\xe4\xdd\xb4\xd2?\xbfao\xf9\xb5\xd8\x9f\xbf\xa8\xec\x9c\xb1CV\xc0?R\x94\xc7\xf8Y\x97\xa0\xbf\xd0\xa8,\x07\xe2[\xd2\xbf\x16,\xadR\xa2\x07\xb0\xbf6\xbf\xdd7\xfe`\xc0?\xe7\xcf\xfe\x96\x93\xf6\xab?\x92r\r\x19\xd3F\xd2?x\xff\xb1(><\xbe?\x1c\x1f\\AN\xc6\x92\xbf\x93Q\xcb\x1e2\x07\xb1?\x0f\xc2\xf9\x06\xf0g\xd1\xbfk\xe1N\xd1l\xd8\xaa\xbf\xaco,F\xf7A\xbe\xbf&!\xf2Z\x9d\xcc\x88\xbfG\xa9\xe6\xdc\xa6|\xcd?_7\x90\x8a\xa5\x0f\xac?!\xd8\xd4\xd9\xfc\x0c\xd1\xbf6\x8bo\xdbxF\xb8?\x9aC\xbb\xdaV\xb8\x86\xbf\xb1\xbf[|\x98\xc0\xab?\xd0f\xe2=YS\xd2?Y\xabgp\x8a\xd7\x90\xbfv\r\xf8r\xd7h\xd0\xbfk\xcd\x98\x88\xa6\x8e\xb8\xbf\xd9\xd7\xeco\x9fP\xd2?{\x9d\xcc\xa0\x92\xb0\x9f\xbfL\x0e\x98\x0c\x87\xca\x8b\xbf\x0c\xd8m\xe81<\xb7\xbf\n:\xe2\xb9\x06\x17\xd1\xbfDu\x87<\xf5\x87\xc3\xbf\x19\xc8\xd7$\x93\xbf\xb0\xbf0\x9f4\xb3H\x87\xb1\xbf\x8e^t9I\xf6\xcc\xbfs\xd3\xf9\x10\xa2\x89\x8d?V\x08\xadwN\xe9\xd0\xbfP\x80\x92e\xdc$\x91?^={\xc5\xca\xbe\xcb\xbf\x19\x91\xc3\x8b^\xaa\xa4?"a\x8b\x12\x06\x86\xd0\xbf\xacxjPh\xd9\xb6?\xd0\x8d\x99\x1b`\x14\xc7\xbf\xc2\\T\x9b\x97\xfa\xc2?\x16\xb7+\xfb\xa4\xce\xb3\xbf\x92\x8b\xce\x0b\x9c\xaf\xc5?\xeeE\xe2Z\xf7+\xc9?\x18\xeaK\xb4R\xbf\xaa?\xfb\x85\xee\xffj4\xd6?>\xf8\x17\xe1\x15\xecy?\x04Dn\xbf/\xa3\xd8?\xed\xb4}\xc1\xd8\x8c\xa7\xbf"\x0c\xaai$\xc5\xd5?D:R3\x8b\r\xca\xbf\'\xbd\x908\xd3\xab\xc6?\x02\x07\xfeC\x95u\xc1\xbflzj\x1d\xf5Q\xb5\xbfQ^\x19\xa9\xdbj\x95\xbf\xac\xf8\xb4\xe6\x1c\xd6\xbb\xbfn\xdf\xb2\x88\xccR\x8d\xbf\x8d\xb0\x85TWq\xb5\xbf\x85\x84\xaa\x97\x89\xb7\x80\xbf\xea\xeb\x80\xa0g2\xbc\xbfg\xe7\x97\xd3\xf5\x99\xbc?\x8f\x81n\xdb\ns\xb6\xbf\xdet\xcbuP+\xbb?\xf4\xfc\xbez\xa0\xde\xb5?\xe1\xd2\xdc\x15\xf2\x9dp\xbf\x8d\xb7\xa4\xaay\xbb\xc0??\x05^\xf6Y\xb7\xb9\xbf\xb6>\x82\xb7(\xa5\xb9?\xb3/\xbc\x90\xadAp?}7\xd7_5\x05\xbc?\xf7\xaf\xae\xbd[\xfd\xc3\xbf\x0b#\xaaB\x1c\x81\xcc\xbfN\xa2[H\x94\xc2\xc8\xbf\x93\t\x03Fs\xea\xb4?-N\xb4_\xb3\xac\xc9\xbf\x1b\xfd\xe31RU\x85?\xe6\xc9\xb7\xdb>!\xc8\xbf\xae\xc5n\x00\xf9\xaf\xb8\xbf\x1fd\xf2[5\x15\xc7\xbf\xf1\xf8\xe3\x18CZ\xc7?\xf7\\H\xb9\x94\xd6w?\x91-h:l\xc8\xb7\xbf\x0c\xad\xdbJ\x05\xb7\xd1\xbf\x06\xa9\x1d\xda\xf9\xc9\xc1?\x8c\xdd\xb1\x1b\xea8\xa8\xbf\x05\xf7\xab\xaa\xe2\xa7\xb6\xbfE\x95\x19\xac\xd5\xa4\xa3\xbf\t\x0b\xb6\x86\x80\x8b\x89?"\x9d\xe5\xff\xef>\xb0\xbf\x88~J\x05\\G\xb1?etI\xed7\x96\xd3\xbf\x03\xea\\\x19`R\xc4\xbfw\xdbPQ\xf9\x01\xa4?\xc0\xdd\xcc\x0f\xd6\x0c\xa0?Z\x8bv\xd8`\xf3\xd5?Re0\xd8\xd9 \xb7?\xed\x9d\xdd\x18di\xd3??\xf8\xc5`@\xb2\x9d?)P\xc3\xa6]Q\xd5?\xb2\xdd\xdc\xf1\xcaI\xb5\xbf\x989\xb2j\x94\xb0\xa1?\x94\x80 #$\x9f\xa0\xbfI\xd4<\xf8$X\xca?\x8an\x026!$\xb8\xbfOt\xef\xdb\xf1\xcd\xc9?\xeaX\x99\xc5!\xaa\x95?\x84\x97\xecy\xb8$\xc7?\xc6\xa3\x16\x85\xc8*\xb8?\xe1WA\xae\x1f\xd6\xbc\xbf\xde\xdbw?\x05\x0f\xb2\xbf\xefC\xa2\xd7C\x82\xc5\xbf\xe8\x0c\xd5wU^\xd8?\xeb\xb3\xca$\x18\xa5\xbe\xbfy1`\xe7\x1d\x8c\xc1\xbf\xc7\xf6<$\x82\xf1\xc5\xbfU\xef\xdf\xce\xbb\xfd\x94\xbf\xcd\x08\x8c<X\xaf\xbf\xbf\xff\xfc\xe0\xf9I\x11\xb2?\x8a\x889\xd3Pq\xc3\xbfo\xca\xd5\xc2_h\xd1\xbf>e\xd9\x16k\xb6\xb4\xbf\x14\xff~(\x8a\x91\x89?f\xb2\xebW}6\xce?\x9c\xcb\x84F\xd8H\xc5\xbf*\x19\xeb\xf0vQ\xc3\xbf}\xe3d\x8e\xe5)\xbd?\xff\xac\xfe\xb9\x7f"\xc8\xbf"\xa5U\r\xff\xbc\x92?\x10\x04A\x12\xc4\xeb\xc5\xbf\xdd\xc3\xb5\x1a\xe8\xdb\xb5\xbf>\x0c\xcf>\x9d\xbf\xcb?v\x9f\xc2t\xe6\x8f\xd1?\x19\xaf\x95\x97X\xcf\x85?\xd2\xba}\xd3\xf8?\xc6\xbf& \xee\x96}\x8b\xcb?\x82q\xbd(\x9e\xef\xc3\xbfB\x89\x1a\x7f\x93B\xca?\xe9^\xb1-b\x88\x7f\xbfJ\xa3+]\xb7\x00\xcd?\xd2\x97\x9a\n\xd6\xdb\xbf?\xf6\xcb.\xc7G<{\xbf\xcc\xcc\x8b\xc4\xeaE\xc2?\xf1\x16E1T\xce\xc1?\n~P\xedj\xfe\xbd?\x89\x0b\x8f\x1b@R\xb2?.\xb7\xfe\xff5\xd2\x85\xbf\x87{\x81\x16\xc9\xeb\xbf?\xc8B\xda\x19\xf2\xd9\xc3\xbfz\xff\xd4\xc5\xd8\xa1\xb8\xbf\x90\xbcs\x9e\x0c\xde\xcd?~\x9aA\x16\xb4\xda\xb0?\xbd\xcf\xce":\xec\xcb\xbfx8h-\xb52\x97?\xeb\x82<\xe5\xa9-\xbb?d.fx\x92\xd8\xc1\xbf3\x8d\xa0D\t9\xac?\x1eh\xa9Pz\xb7\xb1?k \xbb\xb4\xf3\x03\xb1\xbfW\xab\x90"P\x02\xb8?\xab\xd7\xde\xec\xdc\xff\xb9\xbf\xdbW\xff\xeeM\xc5\xc6\xbf=\xbb7wK\xcb\xb3\xbf\xe1\xceg3\xd96\xdc?\xd9(\x1bs\xd7\x1f\xbf?\xdfW\xd4gF\x85\xc0\xbfWkw\xd9\xbc\xeb\x8d?\xe9\x98\x03\xb5\x11N\xd2\xbf\xe8\x1a\xfd2\x9e\x1e\xb3?h\xb0\x86I"&\xbc\xbf|5\xc5\x8e\xb4\xad\xba?Yp\x7f\x99\xbe\xbd\xd1?t\xd3\xcd\n,v\xe1\xbf\xbc>\xdb@\x8c\x02\x91?\x94#\xa3g\x8c\x93\xb9?|\xec\x02\x06U0c?\xc3\x9aZ1\xf7\x07\xae?\xfc\x05\xcaN\xef\xe7\x8d\xbf\xd3;h\xac\\\xfb\xaa?\x835\xbf\x15\x0b\x81\xb0?\xc6}\x8f~\x8dJ\x9d?\xf0\xf5(\x8b\xc7\xff\xad\xbfF_\xe0\x83\xee|\xa3?p\n\xa6\xaei\xfd\x9a?q\x1f\x08e:\x99a?\x9d\x01\xb2\x86W!\xc7\xbf\x03\xb8\x95\xf1\x8b#\x97?\x906m\xfc\t\xf8\xbc?\x8e\xfc \xe9\xd4^j\xbf \xc6\xd4\x9d\xc9\x19\xc9\xbfp\x05B\xea\x14\x9e\xa8\xbfg\xe5,p\xf3\xa1\xbc\xbf\x93\xbd\x1d\x14vF\xc8?J\x13\x969\xaf\x90\x8b?\x16*\x1a\xcfOg\x80?\x18\xc7\xd3\xd4\x1b\x94\xa3\xbf\xa5\x88\x04S\xe4\xba\xc2\xbfXCj\xf8\xe9!\xab?\xc3\xcc\xd8-\xa6\xf7\xb9\xbf\xaaS\xc5\x94W1\xc1?\x87\x00:T\x18W\xd8?4j\x86\x9e\xa3\xd7\xbc?\x8c\x06\xa3.\xd7S\xc7\xbf\x0f\xf6}\xfd\xf1\x08\xce\xbf\x0c\x02\x08\xfb\xc7\xee\xda?\xc6\xf9P\xd0\x81\xa9\xbe\xbf\x0es3\xb9MG\xa3\xbfz\x19J\xd8\xc3\x1a\xbf\xbf\x935V_/\xcd\xb2\xbfEX\xe6G\x1c\x9f\x98?\xed\x05)\xf41\xdb\xb7?cBQb\'\x99\xe0?\x06\xe1z\x9c\xa67\xc0?\x84\xa7D\xaa\xf0b\xba\xbf:\x0e\x13\xa2\xac \xb4\xbf=\xd7\x91\x8a\xdc\xcd\x97\xbf\x85t\xc7\xaapHg?\x05\xd6\x13\xf0_\xa2\x85\xbf\x88}t\x8d,\x8d\xc1\xbf:`(&\\|\xa0?\xc7\x1a\xac%\x94m\xaf\xbf*\xd4T|G\x89\xb3?n\xf7\xf4\xda?\x9b\xc3\xbf\xf4"\x8b\x88\x98\xde\x8e\xbfw\xeey\xd2\xa4\xfd\xaf\xbfZ\xa1\xfe-\xbd%\xb1\xbf\x19!\xa0\xabZ\x81\xc1\xbfTOm\xe4,\x8c\xb3?\xd5H6%\x9d\xe8f\xbf\xcb\xfb\x15}\xfd\xfd\xcb\xbf\x98d\xce*\xfe\x82\x8d\xbf\x06_*z\x8fCq?\r\xe6~\x00"\x86\xca\xbf\xcbmw\xf0\x1d\xf2\xb3\xbf\xdaS\xf5+\xfc\xf2\xab\xbf\xee\xda\xd1E\xbdV\x8e\xbfg\x90\xc0\xfe^\xb7\x9e?P\xaf\xce?{{\xa4\xbf2\xd6,K\xfd\x9ek?\x15\xf4=\xa7\xbc4\xba?\x9d\x1b5\x19\x0fr\xd3\xbfz\x91q\xd9H|\xc5?.\xe6k\x84t\x89\xd4?\x10\xc91\x84\x12\xbd\xdb\xbf\xb5?mBy\xd9\xd2\xbf)\x86\xfcI\xd2\x14\xcd\xbf\x7f\xe2\xbd\xb0\xe8\x14\xba?!(\xa4\x8a\n\x10\xa4?M\x7f\xf9\x12B\xbc\xbb?\xe2QZ\xc1\xd2\xd7\xc6?\x003A\xca\x0e\xcb\xa3?`\x89\x15\xd0}\xd4\xd3?7\xd4\xe3>!+\xc1\xbf\xdf\x98\xa3\x9dj\xc0\xc3\xbf\x17^U)jj\xc9?\xd3UO\xeck\xa1\xa1?\xc6\xef\x0e\x87\x1f\xde\x82?\xf2,\x8b2\xb6\xc8\x97?4\xd3\x0f\x1c\xb6\xbb\xb5?"\'|\x8c\xca!x?E?\x92\xb6W\xf7\xb0?W\xec\x9e\x91=\xec\xc8?8\xbb\x17\x89&\xfd\xae\xbf\x17\x97o}V\x88\xbd\xbf\xc9Q?M*\r\xae?\x90@\xe0\x8ds\xcf\xb1?\xc0\x12\xca\xce\x8b~\xac?\xda\x82\xf5,\xd8r\xc3? }T\xb9\xbf{}\xbf\xfb\xc5;t\xd7\xd3\xb3?7\x05\x02\xbd\x1b\x96\xde?J\xf2}\x03i\xeb\xa2\xbf\xc2\x83\xe4\xd4\xd0\x8d\xb4\xbf\xcb\xbeQ\xcfLQP?\xb3t\x8e\xa5\xc8ji?\x10\x1b\xab\x0eO(r\xbfC\x97\x9eg\xd8\xe7~?\x02\r\xf3[\xfb\x07\x9d?\x0e\xb9\xb7X#)\x84?a~S\xeeV5\x92?\xc2\xcb\x1f\x98\xc1a\xb4\xbf9\xf6T\x84\x19\xab\xc6?\\}\xd6+P\x0b\xd6\xbf\x82\xe7\xee\xde[!\xc7\xbf\xf1v\xa6\x18\x81\x99\xbc\xbf\xba\xf1\xdd\xf1\xaa<w?e\xcf\x1cc\x00!\x98?I\xe9Y\x11\x1c4\xb6?\x1dE[\x8a\xa1u\x99?P\xd1\xf4:\xb9\x9a\xc1?\x99\rfE\x97W\xa2?Y\xe2y\x1d\x1c\xa2\xb1?\x9b\x83<\xbbV,\x98\xbf\xfc\xcf\xdciA\n\xc1\xbf\x9f{\x13\x97W\xb8\xdf\xbfJ\x8fl\x19\xaf\xc3\x92\xbf\x83\xecW\xc7[7\x84?C\xeaz\xd1|M\x93?\x01\xa6w\x13W\n\x88?\xff~8\x88`\xf0\xa7\xbf \xf5$\x83\x82\xd0\x9f?\xdd\xe4\xe0z\xdd\x84\x91\xbf>{c{.W\xdf?9G\xd5[Q\x92\xb8\xbf%\xdc\x84\x93sN\x87?Lo\xf0pD&\xaa\xbf6\x0e\xc5\xa5\x0e\xc2z\xbf\xdf\xdd`\x92{\xdc\xa1\xbfq\xef^X\xe82v?S<\x8c\xce\x03f\x9d?X\xe0\n\xaa\x80H\xa6?o\x1c_AJ\xaf\xcb\xbf1\xd1\xb5l\x8f\xee\xda\xbf\xcd\xf6\xa3U\xdc\n\xc6?\x9b.\x7f\x19.\x02\xb0\xbf$^\x84X\x0fw\xd1?F\r\xaaB\xe4\x80f\xbfkm\x18\xdf\x1d(\xaa??\x1e\x92\xd6\x0c\xea\xc0?\x95\xef\x8bj>\xab\xde\xbf\x02P\x9f\xc62\xb6\xca?Gk\xbb\xaeR8\xbc?\xe0\xa6\xe1\xdb|\xed\x82?\xbf\x9aP\x9d\'\xbc\xcf?H\xbb\x98\xe5[\xb2\xc5\xbfC\xad\xb2\xb3\x9a\xba\xc1\xbf\xcc8\x97\x98\x98\xa9\xbb\xbf\xd6\xb6\x8852\'\xbb\xbf\xdd<\xf1\xe2\x11\x15\xb3\xbf\xb17\xfe\xea\xdc\xd2\xb1\xbfx\x1c\tx` b?=\xd7S3\x83\xc8\xce?AlRy\xdf\xad\xcb?\xb7L\xb0E\xc1\x93\xc3\xbf\xbc\xb6\x87\xd7"K\xae?lP\xb9\xee\x941\xbe?\xd0\xcc\x90\x9c\xb2>\xa8?\xea\x9c+F\x91mq\xbf\x7f\x82!\x8e\x0f\xa7~\xbf\x94\xdbfl\xb5\r\xb0\xbf\xdcN\xed\xec\xff\t\xa2\xbf\x10]\x13\x13Q}\x9a?\x90\x92s\xaa(?\x9c\xbfK\xd0\xa5Q\x17p\xb0\xbf\xb4\xdd\xee`TW\x88\xbf{\xc8\xa5)\x89\xc3\xc0?\xfc\xee\xab\r\xf7n\x9e?st\xac\xb4.\xc2\xba\xbf\xb0\'<\x9e\x10\x07\xc6?VR*\xbb\xc1\xc0\xaf\xbf\xb5%\x97ln-\xb5?h&lK\xb0)\xd7?8\xb0\xa7\xfb\xcc!\xd2\xbfn\x07\x9c\xb8]\x00\xd1\xbf\t\\"\x1f@\xfa\xc1\xbf\x86\xa8\xd8e\xcf\x8f\xb8\xbf\x8aJG\xcd\xd7\xe9\xb4?\xa1\xc9P{k^\xcc\xbf;\xcdB\xcb\xac\x82\xb5?b\xc5\xa1\x87\x18\x9b\xde?R\xb6\xeb\xa7\x06\x10\xd2?G\xd1\\4-\x17\xcc\xbfn\xf7\x0e%\xb8\x13\x9b\xbf\x84\xfd\xf0;\xfa\xf4\xb9?\x91S\xf6\xa1G\xb7\xc7\xbf<$\xe6\xb7V\xdb\xa9\xbf:\xeaF\xa0m\xdd\xb2\xbf\xbe\x960\xbdo_\xa5\xbff\x15h*\xde\x1b\x91?\xe5O\xc8i\x16\xc6\xb2\xbf\xd1?\'7\xe3\xa3\xbb\xbf\xbfd\xd4H\xbf\xb9\xb6?\x17\x8e\x7fn.6\xd4?\x01\x16aOI`\xb5\xbf\xc8!\xbd\x15;T\xb4\xbfE gj\x93J\xaa?\x98\x95m!\xda\x94\xac\xbf\x1dIO\xabcV\xa5\xbf\xf3\xf1\xd0[z\x1b\xb3?\x9b\x9c\x0c2\x8es\xa6?m}\x13\x8fT\xd7\xb4\xbf\xff\xd0\x08\x8d\xaf\\\xaf\xbf\xf8\xd3\xebZ\x1c\x1c\x9e\xbf\xf6\xe2\x07\xd4\x15\t\xa2?\x91h\x87Sh\x86\xa2\xbf\xe6\xbf\xfe\t\xfe\xc8\xc0?\x17\xff\xc9\xce\xa4,\xbb?\xa0k\x1e\x88O=\xb3\xbfP\xab\tg\xb8]\xac?\x032\r\x1f\xaa\x05\xb4\xbf\x15\xa9\x19\xcb\xc6\xda\x8c\xbf.\xee\x18+p(\xc7?\x8b\xd0\xc0\xb3\xb6\xe9\xb2\xbf\x18\x8b8(\x92\xbe\xaa\xbf{F5n:2\xc8?\x9c\xb9`\x8e7\xbe\xa4\xbf\x81\xed\xcc\x17F\xf3\xd8\xbf6|\xae6.\xa5\xc2\xbf8\xad\xc6\x9b\xed(\xc8?&F\xdd\xa0\xea\x1e\xad?2\x14m\xe0\x9ai\xb0\xbf\xe4$\xd1\xcb\xfc\xc2\xa3\xbf\xb5^\x9fC\x83Qz\xbf\xf6 \x06\x83\x88p\xb4?\x99W\x85V\x03\xbd\xb3\xbf\xf1U\x98%\xe4\xa2\xb0\xbf\xbf>\xbf<\x92G\xc3?\x84fV#Th\x8c?\xb2\xc2w!\xe6\xd1\xd4\xbf\xa2\xa9\x84\xf5\xc5\xa8\xad?zi\xac\xe5\x07F\xc9?\xd4\xdd\xfe\xd3\\\xd3\xbb\xbfLt"x}k\x8f?\xa4\xcf}y\xcc\xe3\x96?\xc4\x9cXx\x01\x14t\xbfl\xa2\x9fd\xaf\xbc\xb8?\x99\xc1\xe6\x10\xff\x84\xca?.\xd3\xf1\xd0\x9d`~?\xd1\xee\xc5f:;\xd9\xbf\xdf\x8a"q#6\xaf\xbf\x94\xf7]\x0b\xb5\xcc\xcb?\xf0\x8a\x9f\x18\x03\xe1\xa6?0P\x8f\x13\xb4\x81\x90?\xffmm\xd7\xe5\x8b\x9f\xbfG\xc4\xdd\\\n\x1f\xd0?e\x95\xb3\x02\xea\xc2\x93?cm\xf98\x81\'\xd5\xbf\x1c\'\x89\xbf\x03\xea\xa4?q"\x97]Y\x99\xcf?\xde\x86\xc14\xf0p\xd3\xbfE\xcb\xe1\xdd\r\xcd\xc9\xbf7%A\xc47T\xe2?\xce\x806\xa4y1\xbb?\xbe)\xb4h\t\xc6\xbe?\xb1\x88\xfa\xa1!B\xa2\xbfC0\\\x11\x04\xaf\xb4\xbf\x8a\xfb\xeb"\xad/\xaa?\x06\xbb$S\x94\xd7\xca\xbf\xe1\x132\xc4\x0f\xaa\xa5\xbf\xa0\xd48\x9d\xcc?\xd4\xbf\xe2\x8d\xae\r\xb4|\xa3?\xcd\xc5nh.&\xcd?\xc0Ga\xe4W\xea\xd1\xbf\x18\xbd\x99D\xa6\xd8\x8c?G\x18M\x1cp\xde\xaf?lAK\xfb\\&y\xbf\x9e\x89J\x08\xdf\xb9\xa8\xbf\xa8\xfe\xcb"\xf8\xad\x84\xbf\x90m\x8e\x0e\x10\xab\xa3?\xf3\xf8\x88\x96\x80\xaf\x99?\xb2\x9f\x12;h\xd0\xb3\xbfF\x93\xfd\xfd\xa0`\x93\xbf\xe7( \xe2<L\xb0\xbf\xc1m\x17\xf7\xe3\x04\xb3\xbf\xbc\x19.}*\x80\xcc?T\x18\x1b\\i^\xc0?\xe5\xf7pz\x98\xc7\xb3\xbfO\x88\xbam\x96\x82y\xbf\xfd\xfe)vG\x02\x97?q\\\x8cd\xafz\xc2\xbf\x9d\xc2\xd6G\x02\xf2\xb7\xbf\x0f\x00U\x93\xd9\xa8\xb8?\xed\xa2\xbd\xed^\xfd\xd1?v%\x94\xc0z\xfev\xbf4$\xa8N\xc11v?\xfe\xf1\xd8\r\xd5p\x89\xbf\xd0\xeb\xe2\xf6A\xc0\xb9?\x1bo\x15)_\x11s?\x82L\xebD<\xcb\x81\xbf\xa8\xfb@{2\x9c\xb0\xbfLAt/6g\xd2\xbf\x0b\xfc\xca\x8b>\x1c\xd4\xbf}\x92\x080\x8ao\xc1\xbf6\x118\xfe_\xf5\xa8\xbfNI\xf7OW\xda}\xbf\xd2\xc8\x0e)I\xa4\xfb>\xbe\x07m\xa7\x93\xe2t?\xcdh\xa8,\n\xbd\xc3?\x03hh\x18\xf2\x15\xb3?d\xa4\xc0Y\xd4\xc0\xc4?v\xde1\x08\x1f\xf8\x94\xbf\xf2s-\xe0\x00\xd9\xcb\xbfra\x11":\xcc\xd5\xbf\x92Y$\x1d\xc3A\xc1\xbf\x9fy\xfe\xa6\x1bR\xbe\xbf\xe6@\xa9\xe0\xdd\xc9\x90?\x9d\x96]\x0b\xfe#\xab\xbf\xa7\x01\xafEvO\x9d?1\xa8\x1fa\n;\x9a\xbfc`n\xe4\x9c\xa8{?<8\xd8\xa7h\xa3\x9c?r\xab?\xb5\x8c\x11\xb6?&$\xaa\x17\x94\x0f\xa0?R\xae\x80\x15\xc1\xd4\xd3?V\x12\xff\xd1\x1ei\xd5?\xed\xf4\xd211l\xb3\xbf\x08\xce\x01_\xfb)\xb5\xbf,\xac%\xe4\x14T\xb7\xbf^\x0f!\xc2\x03\xe1\xb9\xbfI\x95&\x18_5\xbb?@$\x8e\x82\x14\x1f\xb1\xbf{hE.\x991\xc0?\\P\x8e\xa5\xccG\xdb?\xe2d\xb6\xae\x7f\x88\xc0?Jw%\x8c\xf6h\xba?\xc3Yl\xadr\xee\xa9\xbf)\xbb\x82>oo\xb8?\xa0l\xe3\xfa\xc9k\xc0\xbf{\xdb(JP\x1a\xc2?\x99\xf5\xber\x9dS\xd5\xbf\xaa\x87\xf0\xbb\xe09\xcd?K\x0e\xbf\xa5\x87\xbb\xb5?\x82\x8a\xd0+yQ\xb3\xbf_\x90\xfds\xe1+\xbf?\xcc\x12h\xae\xe88\xac\xbf1\x08&r\x9as\xb2\xbf\x8e3~\xd9\x954\x9d?\x981P\x149\xed\xad?$<\x1b\xc3Q\xf5\xa3?[\x8fl\xfe\xac`\xc9\xbf8M\x88b\x968\xa9\xbfR\xd2e\xc4\xe6\xa7\xd1\xbf\x03\xd1\x8f\xd0z\xff\xbf?\x1b\xe6\xf2~t5\xb5\xbf\x1c\x08\xfd{48\xb2?Y+\xc0.\xa3\xe0\xb3?L\xfdR\x83\x01\x07\xa3\xbf\xd3/\xfd\xd5\xe2\xd8\x95?\xce{\xd1\x1fG\xe1\xa1\xbf\xf8\xa7\x82\xa2\xad\x16Y\xbfY\x84\xffX#I\xb3\xbf\x1a\xa8]&N>\x96\xbfd\xa1\xc4!\xcf\xf9\xba?/\xb8u\xa0\x0f\x9e\xd8?\xbeG\xf9\xb7v\x11\xd1\xbfG\xc1\x0e\xe3@\x08\xb4?\x882\xc9\xd71\x01\xaf?\xe7\xe6\xecR\xcc\xa9\xcf\xbf\xb7dP/\xe3\xd3\xb7?\xbf\x93\xcf\xa4\xdfRw\xbf7\xb0\x85\x93\xf2r\xa6?\xfcA\x8ab~w\xe0?\x1b\x9fF\x9ay4\xc1\xbf\xd2\xebg\xed%\xbe\xbb?\xc2\xbd\x91\xcdOe\xb0\xbf\x1aN\nv\xdb\xfd\xc0\xbf\x08\xd0\xd6,\xa4\x95\x86\xbf\xdf\xc7\xe1W\x94\x1e\xb4\xbfp+\x0f\x1by\x9a\x81?\x95a\xb66\x8b\x83\xb6\xbfc\xa7\xbd\xc0)\xdd\xa3\xbfF\xdc\x06\x87\x9d\xd4\x9c\xbf\x80\x03?s\x85h\xa9\xbf\x04\x84\x0f!\xd5\x91\xc7?\xd0\xf5\x1ae\x89\x85\xc2\xbf\x0bJ\xc9\xffl\x18\xd3\xbf\xbc\xd7\x1cF\xb7\xb5f?]\xea\xfb\xe5\xb7\xba\xc3?\xc7<H\xe0\xdf\xcf\xaf?\x92qk,J]\x8c\xbf\xb6*\x93\x91\xe6K\xd5?\xc2+N\xfat\x04\xb5?\x85w\xf2\x07\x14\x1a\x8c?l\xffp\x03O\x01\xb0?\xef2\xa4\x81\xe1g\xd5\xbf6\x03\xd8\xa0\xa6`y?\x06\xd6\xfe\xfc\xf1\xc4\xc3\xbf\x0f\\sb\xe6\x83o\xbf\t\x9d\xc7}r\x00\xbf?~\x05\x122m\x9e\xc2?\xda\xd9\x1b\x93\xd4\x8a\xd7?S\xcfFExR\xc6\xbf\xb3\x90\xb3\x08O\x9b\xbc?\x1e\x97["\xa4\xac\xb9?\'\xa8\x00Y\x98\xa0\x9b?-\xf3\xd3\xbe\x9a\x1b\x7f\xbfJ\xc7}@F\x00\xbe\xbfK\xbc\x91c\xee-\xa0\xbf(:\xb8\xb0\xd5V\x12\xbfZ\xeeF6\xdaP\xa4?\xc0^\xb2\xf4\x91\xbd\xc3?\xda\x12\xa9\xf0\xd4\x95\xb7\xbfJ\xc5J,\xa90_\xbf\xc2\x11\xe0%\xfb(\xbf\xbf\x8el\xba:\xe9\n\xa9\xbf/A\xa6\xa6\xf3#\xd2\xbfA\xdc\xb6FX"\xb9\xbfvc\x87\xc4\xe6\x95\xd7?\xe9\xc7^0\x0c=\xca\xbf\xcd3\xd0Rw+\xc3\xbf[L\xa1\xef\xe8[s\xbf\x9b\xbf\xf8Nf\xec\xc6\xbf\x990\xb6R]\xe0\xbd?\x89U~\x9eH\x0e\xbe\xbf\x93\xf1S\xd1&\xaa\x94\xbf\x0c/\x88\xddI\x82\xd5?\xec\x91\xda\xd8\x91\x81\x9e\xbf{7\xca\n8V\xc7\xbfF\x15\x10\x05\xde\xde\xc2\xbfw\x99)\xe7S\x92\xbc?\x84\x0f\xee:l\x06\xbf?X.2\xd0\xe6\xb9\xc2\xbf\xa8\x93{/\x15\x94\xbb\xbf\xd5I`\xf7\xb4\xf7\xc8?\xc0\x8cp`\xe2#u?l\xc5\x89\xdf\xf9\xf5\xc7\xbf)\xb6\x1e`\x8b\xea\xb1?\xa73\xf2\xbe\xe6a\x9f?\t\xbb\xae\x7f\x1f*\xba?\xbc\x03bb\xd2\xed\xb3?\xc3\xb0z\xb8\xces\xa6\xbf\xc7\xe9\x85\tw\xbb\xc2\xbf{\x1d \x91\xa8t\xac\xbf\x8e\xb4\x19\xc9\xfb\xd1\xcb?\xb9\xfbV0\xd3,\x83\xbf\x03\x16U_\x1e\x15\x8d?\xcf\xc4\xf9\x8c\x08n\xa9?\x85-\xa4\xe9\xed0\xc1?\xee\xb4\xa9\xa6\xde\x91\xb4?\x8c\x99mFM\xf4\xcd\xbf\xfe#\x05\xfb\xd9\xde\x9e\xbf\x90\xdb\xc0\xc1\xa0z\xcb?)\xb9\x9fu\xf0K\xb5?E\xe1\xcf8\xd2m\xdf\xbfX\xe0\x1a\xdc\x02\xdc\xbc\xbf\xbb\xe1\xf9q\xbbk\xcc?\xbc\x07\xdf\xf5\xe8\xb8\xa0\xbf\xcdp\xcfx\xa9\xe6\xd1?\xd7E\xf3D\x08\x8c\xa1\xbfQ\x1c\xff\x02\xdf\xa4\xc3?5AE=\x97\x10\xb8\xbf`fY\xf4\xe5\xbd\xba\xbf\x93\x85s\xe0\x0fM\x99\xbf\xd4\x19\x1c\xc8\xdf\n\xd0?8Fu#\x96\xbb\xb7\xbf\\\x04\xbb\xa7\xd3\xe7\xd5\xbf\x0bL~\xefk\x0e\xaf\xbf\xc7R\xf0\xaf\xac\x01\xbe?\xa8\xe6T\x02\x00\xd6\x96?\x95\xed1\x7f\xab&\xbc?\x8d\xed_\xc7\xd0H\xb7\xbf\xb6\xe9\x96\xe6-E\x8d\xbf\x81\'\xea\x0bc\x93\xb1\xbf\xb0\xdc<\x85\n\x83\xb1?\xd9\x8c\xf1\xc4\x0bn\xc0?.\x98\xe2\x16\xc2\x0e\xb9\xbfZ\x88\x8d\xc7\xd3\xe5\xc9?\xbe\xbb#\xb7\xc96\xa2?"\xd9\x15_\x93n\xab\xbf\xeeY\xf3\x12e\x9e\xb8?%1\xb6:\xad\xc2\xd6\xbf|(\xa1\xb1\xfe\x10\xb8\xbf\xb0\xaa\xb14\xb0\xe1\xb9?iq\xfa\xc0\x9e\xa7\xc9\xbf\xff\x02\x0f"\xa4\xcb\xb0?\xea\x11\xa8\xfe\x94\x19\xd2?d\xfc\x82\x83at\xcc?4\xcdA\xcf`\xc6\xd8\xbf\x16\x90\x8e\x1d8\xdf\xbe?\xa9+Vz\xbbh\xc1?\xba\xf9{P\x14\xb6\xb4\xbf\xf4G\xd6G\xeb\xa1\x7f?\xcf\xa5 \xc1\xbbV\xb0?M\xee\xf4\xf0\xef\xae\xcd\xbf8\x92J=-\x83\xbf\xbf\xdeA\xa3\xf0\xb8\xac\x9d?\x0f\xa4y*\xcf_\x9c\xbf\x98 \x1e\x08]\xba\xc7?\xca\x04P`b\xb6\xc2?\xd0k\xa5\xb5p\x86\xa4\xbf\xf0\nt\x88\x1c\xe3\xba\xbf\xd7\xffT\x9bW\xa0\xbd?L=\xd9`\xb8\xb8\xd1\xbfbo<EK\xe9\xc0\xbf\xd9\x99\xf9\xa3\x15\xb0\xb4?\x8b\xbe\xf6W\r\xad\xbf?\xf6h\x1d$ \xc6\xb6?\xdc\x1a0\xdbC\x8c\x91\xbf4J\xf7H\x9b\x95\xba?%\xa9\x0f\x0b\xb1 \xb3\xbfe\x1c\xaf\tO\xcd\xcb\xbf\x90\x1aS\xe7\x1fi\xa3?\xee\xcf\x87P\x8b|\xbe\xbf\xab\x0eFl~\xeb\x9a\xbflL\xfd\xd8\x0c\xa5\xc8?\x8ag\xbd\xbb\xfc\xcb\xc5?B\xe0\xef\x07\xf5\x14\xb9?5\xf5\xb0\x0e]\xbd\x97\xbf\xdb\xa5t\'\xf8\xed\x80?\xfc\xb1\xb4\'t\xa2\xc5\xbf\x93\xa2{\x93\xf2n\xb3?\xbf\xc9h\x886/\xa2?\xc4\xd6\x95&\x16g\xd0?\xe9\xb5\x8f\xd8\x9c\xccW\xbf\x9dq\xe3\x03D\x86\xb9?\xd8\x0b\xcdG\x0f\xe5\xd0\xbf\xc2\n\x8dHq\x00\xcb?QTxU&&\x89?m\xa7eNt\xcd\xc6?\x15\xc4\x97\xa2\xd5\x1a\xcf?\x85\xc5\xca\x16\\\xda\xc6?\x06Pu\xa2\x83\xa8\x97\xbf\xe2\xf8\xd5\x9b}U\xbc?@?\x02\xac\x1f~\xb7\xbf\r\xdc\xa8j\x17K\xd3\xbf\x19\xceM\xe7\xc8\xdc\x94?\xce\xdeG\xbd\xcak\xd7\xbf\x13\xe5-P4\xa1\xba?\x8a/[\xba\xdf\x01\xd3\xbf\xc6\xc9\xe1\x8e_\x81\x98?\xa8\xaee\xe2}\xa1<?$j>\x10I\xce\xad?\xc2F1\xe1\xdb\x00\xcd?O\x87\x83\x8e3\x81]\xbf\xce\xe9h\xb9\x88/\xb5\xbf A\x9c.\x8a\xee\xbe?\xe7}<h[\x12\xb6\xbf\x9foh\xf9\xac.\xb3\xbf]\x06\x8d\xe2\x9f\x98\xa4?I$W\xae\xa6)\xb8\xbfj\t7r\xf6s\xd1?,\xb5\x86\x92ga\xa0\xbfh\x02V\xcf\xfd\x05\x8b\xbf~\x82\x1c\xc1\xcfp\x9a?iy\xd4Q\x19\x17\xd2\xbf\xd7\xa45\xbe)\x83\xce\xbf\xf3u\xfa\xd7\x92\x1b\xd5?al\xd5\xadR\xd7\xa6?`\xb6\x1f\x1a\xa7\x8b\xca?c\xffo\x98\xe0\n\xc3?qU\x84IG\xcc\xb1?\x11o\xde\x96\x7f\x94o?\xe4\xe6\xc5\xfcBk\xcf\xbf\x06\x9d\x0e\x93!\\l?7\xa4\x90\x9b(ue?(\x96\x16\xb0e\xee\xb8\xbf\x16\x1e\xe0\xee\xec\xd5\xbc?4t\xfd\x1cMf\xcc\xbf\xf2\xb25\x15\xf7\x9b\xa1?\xd8\xa1^vP^\xd3?\xb8-\xcf\x9a8\xae\xb0\xbf\xeb\xaea9\x1b\xac\x8a?\xf5U&\xca\xb9F\x95?\xcc\x1d\x89\xd1\xbe\x7f\xca?^c\xe2\xb2\x15\xc4\xd0\xbf?\xd4p\x0b6S\xbc?T_\xfbfD\x81\xcf\xbf\xb4KQ\xd9\x10U\xd3\xbf\xba\xe5qp\xf9-\xa1\xbf\x8e\xb0\x9bkr\xf1\xd1?\xfe\x98\xfe\xfa\xd5\xf7\x96\xbf\xedy\xa4%KT\xc0?\x98a\xd6\xffx\x90\xb9?\x07\x04\xc7\xba\x86\x8c\xbc\xbf\x1b\x9a\x17\x89V\xf8\xbf\xbf\xfb\xa7i\xf5\x11a\xb1?\xaa\xde\x05\x9a+\xd4\xa9?e\xdd\x90\xe6[8\x95?\xaa\x9e\x10\x87&\xab\xca?\xa5\xfa\xc1\xd4\xd4\x97\xbd\xbfV\xd0\xdbD\xd4Z\xb8\xbf\xb3H\rT]i\xd2\xbf\x03\x8a_\xcf\xda\x8c\x9b\xbf\xea*\xf6\xa1\x92\xf7\xa4?}\xf1~\x12\xe8\xa0\xc5?y\xda\x86\xea\xa5%\xc2\xbf\xdeb\xc5\xcf\x08\xff\xd0\xbf\x0b\xf8\x8e\xdb\xd5+\x92\xbf\xe7\xc4\xae\x93|\xbe\x99\xbf+\x16b\xa3J\xde\xc8?5\xfb\xe8\xa9\xafE\xcc?2J\x16!\xe4\xf7\xb6\xbf\x8b\xc8\xa3\xe6\x8by\x9d\xbf\x80\xa9)\x8dU`\xd8\xbf\xd7\xe0Nk\xf6"X\xbfx\x8c\xd3\xbdO9\xc9\xbf\x0b\xdc}\x8dY\xd8\xca\xbf:\xbbpr\xcf\xbd\xa6\xbf\x0f~\xb9\']\x07\xb5\xbf\x99T\x0f\\BW\xd0?\xaaZ\xf0rK/\xa6\xbfA\xc9\xde#\xb0\x1a\xd9?o\x8f\x0b\t\x9f\xfc\x80?\xa5\x01A\x8ceP\xbc\xbf\x90}\xc0\xad\x9f\xf4\xa2?\x11\xb8\xdb\xcc\x0c}v?B\xed\x11\xdc\xeb\x10\xb0?\xbc\xf2\x81\xf5\xb6\xb5\xbc?q\xbb1L\xe3\xa5\xb1?6\xba\x97\xb3H\xd9\xb5\xbf\xb2\x918\x07g\xec\xa2?\x94:\x99+\x0f*\x9a?\x80\xda\x81\x1cD\xa9\xab\xbf\xe6\x086[F@\xc7\xbf\\\xea\xb2\xc89\x13\xbb?\x813\x19\xdd\xfa\xe3\xd8?: \xa4p1\x89\x8f?\xb6\xe2EH\xd3\x12\xc2\xbf\xe7\xad\xefu\xb5~\xbf\xbf-\xe8\n\x92[f\xb2\xbf\xd0\x17q[u\xe9\x83?\xc1\xa5\x02\xc5=-\xc3?\x84t\x85\xc2\xb8<\x98?\xfa0\x97(@\x8d\x9d?\xb9z\xc3\x7f#\xe7I?]M\xf7T\xeb\x1c\xb9\xbf\xfb=\x19\x14\n\xd2\xb1?^\xa1i\xb4;\\\xa4\xbf\xfb|Qvp\xb1\xaf\xbf\xff\xac\xa6\x83v\xc3\xc5??\xf37\x1a\x0eG\xce\xbf\x15\xdb\xd1\x1e1\xe1\xb3\xbf\x92,\x8f\x9f6v\xba?L\xe2\xb2\xce\x7f8\xb9?\xef\x03\xb9nQ\xd4\xa9\xbf7}_\xf0\x1c\xd8\xb7\xbf+\x91\xcc`\xfe\xcd\xa7\xbf(\x7fqs\x9cs\xcf\xbf\xd6\x97V\x03\x14\xc5\xb3\xbf\xbcG"\x06\xf0I\xd5?G\xa7\xccr\xe5\r\xba\xbf\xd4\xc1\xd5\x81\xbb\xc3\xc6\xbf\x88n\xa4\x96\'\xad\x9f\xbf\x87}sKO\xc9\xba?r\xe3\xf0\xa2\xbaw\xc4? \xf4\x97\xd3M\x18\xdb\xbf\x05\xe1\\\xbe\x03\xaf\xc3?R\xcd\x9c\xbdW\x8c\xd5?\xa5\xb3\xa1#\x1by\xba?\x14\xcb\xb1f\xf8\x9b\xb8?R\xf6\x08\xa3\xe4\xf8\x93\xbf\x941\xba\xfd\x8a}\xb4?\xe7\xf4A\x82\xfe:\xc0\xbf\xae\xad]\xe5\'\x8c\xad?\xa6\x11\x19\xa3\x89\x16\xda?\x8b?X<\x02\xeb\xcc\xbf]4\xcd\xc1\x0f\x0c\xad?Q\x04C\x8bj%\xc8?\xec\xff\xd4\xfd\xd9\x1d\xd6\xbfdE\x00\t\x8c\xf3\xbd\xbf|\xc6\xa7\x04\xd0x\xc4?\x8a\xe9\xe4\xd9\x1d\xd2\xc4\xbf\xf7\xc2`\x93\x05F\x8c\xbf\x9f\xdb\th\xdf\x14\xab?\xd8\x81\xa5\x97\xe1\xb9\xbf\xbf\xe3\x91\x9f\x10W\xb9\xcb\xbf\xba\xac&\xb7\x89\xf4\xd0?\xe1Q\x1f\x8c\x05Y\xc6?\x11\xa2%uIL\x90\xbf~p\x92\x930\xf1e\xbf\x00>\xea\xa49y\xca\xbf\x99{`%E_{\xbf/\xbfu\xa1\x15\xa3\xc4?\x83\x8d\xb9\xcf\x9b9\xc0\xbf\\\xaa\x19\x17\xc2\xd3\x80?\xc6\x18\xc73\x90\xed\xd0\xbfo\xe1\x99Z\x81\xacz\xbf\x01\x1b\xee\x13\xa7\x10\xd1?\x06\x87\xba\x1c\xa1-\xb8\xbf\xf6\xd0\x08\xf5|u|\xbfO\xfd\t{\xa71\xb4\xbf\n\x1bnh\xd9\x1f\xcd?\x7f\xf6\x8f\xa1\xeaZd?\xbc\xdf\x17\xa6R\x9b\x9e?o\xd9\xda\xd0\xda{\xc3?\xaa\x16\xdeY.L\xaa\xbf_\xdd\xd4\xc5o\x8c\x88?\x1fV\xc6GI\xcd|?\'m\xa4\x82n\xb9\xc8\xbf\x04\xe3\xd6au\x91\xca?l\x0f\x13\xe0u\x99\xb0\xbf\xe9$\x1a\x98~Y\xc0\xbf\x9d\xfds\x8aa\xff\x9f\xbf\xa8\xd0v}\xac\x99\xab?\xd7B\x90yoQ\xc2?\x85{\x022{n\xcd?]\xb3]2\x04\x06\xb5?md\x03/\xd0\xdf\xd0\xbfa!\xc2\xeebH\xa9\xbf\xdd\xcerR&\xcd\xbf?\xd1 {\xa2\xcf\x1f\x94?\xbb3\x13\xa3:\xab\xc4\xbf3n\xcf\xb49\xdb\xa6\xbfyB&\xbbo6\xa7\xbfT\'%,!\x86\xa3\xbf!\\\xd6H&\x96\xb0?[\x97\x05\x10v\x95\x9d?\x85\x05\x927W\xa4\xac\xbf\x1e\x14\x0bJ\x90\xc0\xb9?\x91\xdeZ\xff\x15\x83\x97?H\xb5\x1c\xf5cB\xab?\xd9\x81c\xe6\xb2\x19r\xbfe\x8e\xc6{@G\xa3?\xd3\x04L\x9f\xc7\x95\xd1\xbf\xae\xe0\xf2\x8b\xed\x9f\xb3?\xda%X2:V\xda?\xe5\xc9S\xf1\x15\xa7\x90?\x8f\xc1\x96\xa4?\xd3\xb9\xbf\t9J6-\x15\x82?e@F\x11\x88\xe7\xd3\xbf\xcb\xdf\n<\x8d\x81\xb4?\xee\xe1REq\xe1\xc9?\xd2\x97\xf2\x15\xa2,\xab?\xc1\x1a7+;\xf0\xd3?\xd0\xa1\xea\xba\xb2\xf3\xac\xbf\xf2\xb6w\x87\xed\xde\xd4\xbf\x12\xbe\xd5\xa3\xfd\xe5\xc2\xbf\xec\x05\xf1\xb8\xc9\xdc\xa5?\xeb\n\xc1\x0e\xf3"\xd1\xbf\xfe\x99\x02\x9c\x17|\xb7\xbf\xd0\xcbM\xc4\xcc\xd0\x94\xbfm\x86\xeb?\x16\xe8\xa4\xbf\x914\x8ck\xf6\xc8\xb7\xbf&\xf3\x8f\xe2\xd6\xa0\x8b\xbf\xa0\xed\xf7z\x91O\xa8?\xbca\x985\x98I\xab\xbfTBt\xfe[\x90\xc2?\x90\x95\x9f\x0c\xb2\xd8\xa6?\xe8U\xd6\x91\x90\x05\xb0?\xe0w8\x10`\xfc\xb3?\xeens\x85\xf8i\xc6\xbf\x13Aa=\xbeo\xbb?\x0be\x1a\x81n\xe7\x8e\xbfV\x8b\xf8+\xcd\x8a\xc2?1^\xea\xb1\xb4:\xd1?\x07\xe6@\xfd\xb3@\xe2\xbf|\x88\x8b\x89\xa0\xf4\xc9\xbfV\xec\x89@\xa1\t\xc0?\x95oUj\t>\xae\xbf{\x99\xe6\xfd\xb8k\xdb?\xb0\xc2\xd4K\xed\xd5\xa5?*3\x9d\r\xbc\x04\xc0\xbf3\xdca\xdc\xb5\xbb\xc2?\xd6\n\xd1e\xb7&\xc2?\xe1J\xb0\x842\x86f\xbf/JAC\xa8%\xb0?B\xaaL\xe1J\xf3\x80\xbfc\xd8"\xd9A\x91\xa8?\xe0\xb4\xa1\xec\x83\x1b\xb0?Ki\x00\x85yv\xbe\xbf\xd2\x01\x19\xdf\x8c\x9e\xb6?\xc9\xfe\x03\xffq\xea\xc5\xbf\x99\xb9\x06\x97_\xc2\x92\xbf\x17\x19\xeb\xca\xc1\xe3\xc8?W\x16\xba\xf3g\xf6\xb0\xbf<_\x86~R\xe5\x9e?\xfb&i\xa1\xf3y\xad\xbf\x93r\n\x8d\xa4D\xcc\xbf\x00\x08\xf11:\xb4\xc2\xbf\xe3\x83\xddO\\\xb8\xb3\xbf\xedp\xcfy\x1a\xb7\xad?x\xb0\xb3\xfb\xfd\xbf\x9b\xbf \xae:\xba<\xe4\x9c\xbf\xe7u\x00\rPz\x93?\x14*b\x8e6`\xd1?\xc6\xfa$\x9d)\xb5\xa6\xbfO\x0e\xff\xb7J\x94\xd4?E\xf2\x1f\x12\xbe\x80\x89?lK\xb3\xc6\xa2\x12\xdb?j*\xc5\xdf\xdd~\x8c?\x9b\xf5L\xf9\xdep\xb1\xbf\xce\xe7P(\x8b\xb8\xaa?G\x82C\x9fqE\xaf?\x0e\xa8\xcd\xec\xf4U\xf9>\x9e\x87\x94p\xb5l\xa7?\xd9\x06\xd5\xa0\x07]v?\xfb;_G\xd1f\xce?;\xe0\xf5\xa7\xdb\x08\xb1?\xc8\xc2\xd9\x92C\x08\xbb?\x04eQ\xf6\xa7\xb7\xb5\xbf\xac\xf1_f%\xc4\xb2?\xef\xb40\xc5;\x1br?\x85\xd1\xe3\x1aH\x87\x83?\xb1\x127\xb5\xad,\xb4?Ka\x0c\x1a\xa0\xe9\xa5\xbf\xe9\xde\x8f9\xc0:\xbe?\xf2t+\x90O\xfd\xd3\xbfU\xb9"\xac\xa4Y\xa2\xbf\'\x98\xe3r\x8a\x11\xd6\xbf\x83\xf8{}\xb8r\xad\xbf\xe5"\xe2\xe5xS\xde\xbf\xbe\xe1\xa9X\xe7d\xa7\xbf1G\xe5\x1a\xf1\xe9\xa5\xbf\x12\x18\x02\xc18I\xba\xbf\xd1g\n\xa605\xc6\xbf\xab\xb1\xc2 \xd3\xf1\x97?\xec\x834\xa0\\\x90\xbd\xbf|\xd8\x92\x8b\xce\xab\xb4?\xff\xa6~!SFt\xbf6w\xd3\xc6\xa2c\x94?I\xbdv\x19F\x03\x9b\xbf.\x16\xe3\xa0\x1f\xb9\xc2?\xdd\x8d\n\xee\x00C\xaa?y\x81z\xc6v\x85\xe4\xbf&\xb15\xe3\xa2\xb4\x8f\xbfH\x1f\x85?\xde\xbc\xa7?\xd1\xd8\x9c\xfdu\n\xae\xbf\xc6\xaf\x1a{\x17\xb6\xe3?\'r\xbd0\x90\x90\x92\xbf\xcemn\x87\x80\xd8\xc3\xbf\xd7{\\\x96\x99\x80\xaa?\x1f\xf1\xfd\xf0\xa0\x0f\x86?\x92C:#\xa5\xb5\x91\xbf\xc0(\xdb\xafh\xc7\x7f?\xef_\xbe$q@\x98\xbf\xda!b|\xe3;u?\x9dE\t\x86\x8c\xb6\xa0?\x90G\xda\x82D0a\xbf\xed)\xb7A[\xc1\xb5?*H`+[\xeef\xbf\xefg\xed/$\x11\xa1\xbf\x92\xdcK\xfa\x9b\xb0v\xbf\xd6\x97!-\x19\x96\x8b\xbf\\\xc5\xa2b\x94\n\x9f\xbf\x1f\x95)\xc4:\xdc\x92?\xe3\x0c\x13\x8b\x05\x93\xd2?s\xdd\x8d\xe9\xb3\xdc\x97?\xd5\x1d:W\x93\xac\xbb\xbf9h\x9c\xa9\xd8\xfe5\xbfd\x08\xd6\xbd\xb5\xdd\xc7\xbf\xfc^\x13&\x12\x90\xa1?\xbb\x86\x85\xb7w\xd9\x8a\xbfU\x17\xbbP\xc4\x01y?N\xdec\xb2\xab\xacr\xbfg\x99\xf7.\r\xf1\xa4\xbfp\x1c{\x00\x1d\x90\x9b\xbf\xb7\x1b$\xe1i\xfa\xac\xbfBb\x92\xc8\x91I\xa1?\x7f\x83\t\xe8\x94"X?\xe8\xe7c\x0f\xf0\xa0\x91?;{A\x9eK\x81\x96\xbf\xaa\xcf\x19\xf2\xd8vs\xbf\xf3\xa8r\xc75bp\xbfNf$T::\x84\xbf\xd1\xb7 ?\xd4\x86\xc7\xbf\xbc*\xbcz\x98L\xad\xbfV\x05q\xd5G\xf3\xb3\xbf\x85:_G\x12E\xa8?PZ\x12N\xa6\xaa\xcf?\'\xe3\xfbk\xc9\xa5v\xbf\x84h%\x99!8z\xbf\x01p"\xe3\xe0\xf5\xa1\xbf;u\x8f\x1d\xea\xa7{?\x84\xefD\x19 \x8c\x96\xbf\x1aW[+\x15=\x93\xbfyi9C-\xa7\xb8?.\rO\xdck\xcf\xc6?\x9b\x8aK\xd0\xd0\xdf\xd7\xbf\xdd\xb2{J\xc8\xf6\x89?\x95\xd6\x9a\x18\xff\x8c\xd4?\xa1B\xb1\xe4n\xd8\xcb\xbfG OuRF\xab\xbf:\x88N\x1b\xcc\x89\xa4?\xddn\xecv^\xfc\x80\xbf0rH\x1c\xbf\xd9\x8e?z\xa6\x07\xad\x08\x80\xcb\xbf\x13VJ>\xd7\xad\xbc?\x9f}\x9b\xb8<\xb5\xdc?\xb2.\xc9\xe5\xed\xd3\xb4?\x07J\x17\xfaUw\xcc\xbf\xc3\x9b\xb8\xcf\x97\xb4\xc0\xbfW?\x96\xd1\x81\xe5\xa7?\x93\xca\xf2}\xf8\x98]\xbf\x91\x82F\xf9!\t\xc7?\xd2\'\x98u?5\xcf\xbft\xe5\xb0_c\xed\xcd\xbf\xa4\xf0^\xe55\x04\xa5\xbf,\xef\x05\xf3\xeb8\xb5?\xae\xd9\xe7\x83\xf6A\xd0?\x8c\x8c\xb8\x9c\xb4\x89\x8f\xbfk\xb0e\xa2\xee%w\xbfbIb\xc5\xc8b|\xbf\xb6G\xd7\xd8\xb4\x0b\xa0\xbfh\t\xa7\xec\x85h\\\xbft\xd3y\x81\xd2\x03\xc8??h\x92O2\x0f\x91\xbf1w\x0e\n\xc9\x9b\xc2?yz\x98 \xc4\x81\x9d?70&\x0f\xae\xf3\xc9\xbf\'\xd9k\xd0{\x1bt\xbf\x10\x0e&\xaa<t\x8e?9\xc5\x17\x8f\xa0\xa6{?/\xe5\xb0\xdf)~\x84?\x88!{?_\xb4\x98\xbf\xf9\xc3?\x9d\xf0c\xa3\xbf\xd1\x8d\xaa\xe2\xca\xa4\xd0?\x8d\x9e\x99]\xf8\x19\xbe?<y\xe0Z\x04M\xe3\xbf\xbef\x14\xcf1#\xc4\xbf\x93y\x9f{\x12?\xdb?\x0b\xe8\x15\x7f\xe0\xfc\xb6?\xb4Mzl]\x7f\xb0\xbf\xf1\xc8\xb8\xb5T\xf4\xae?g\xa2 yqm\x9b?c\xc2\x93:\x07\xe8f\xbf\xbd8\xab\xfa]\xab\xb3?hc\xa9\xb42\xca\xc2\xbf\xc7\xdeBxp\x1b\xc4\xbf\xacY/\xb2\xdeEt?b\xd8\xb9\xff\x95\xfa\xb4?Y{\xb3z\x11j_\xbf\xb4\xbb\xf0y\xd3\xe91?\x01L\xda)4\xdce\xbf\x11\x8fR\xbbD8\xc1\xbf\x99\xb6\xe9\x9cC\xd7\xc0?)\x9bx\x98iF\xd2?~\xcd\x0b\x11\x06\xd6\x80\xbf\xfe4\x9b\x8aR\xf6\xc4\xbf\xf5\x19RKE\x1b\xc5\xbf\xb0\x98\xde\x93\xcd\x9a\x84\xbf\n\x1f\xa0\x0f}c\x86?\xb7\r\x97\xbek\x98K\xbf\xe4T\x85\x84b\xf1\xa4\xbf\xd4a\x17)`\t\xaa?\x9d\xe3\x0e\xd9\xa6K\xd5?\xf4\x82\xc0Y\xa6\x10\x9c\xbfj\x92W\x96\x10\x15\xd9\xbf\xbf\xce\x80\r\xe8h\x94\xbf\x05>\xb8\xea\xb1;\xc5?\x88\x01&\xe4\x0bDh?pBM\x8f\xd2U\x99\xbf\'\xb0)\xd9\xdf ~?\x0b3\xb2\x92@I\x88?\xb4\xbb\xac\xf1T\xc5\x87\xbfi\xbb8\xd9\xba?\x95?\xf5\xe0\x8c\xf08\xb2\xaa?\x94%e\xc8\x83D\xd5\xbfR\xa2\x94\xa1\xb3\x97\xc0\xbf\x85T\xa0\x9e\xf2\x82\xe4?\x8e\x86CW/\x81\xb5?\xc2H\xd6O\x87\x9a\xd3\xbfR\xcbV_^%Q\xbf\x965\xcf\xb4\xc6\xff\xa5?Tj\xd8\xe6\x97\x00\x91?\xc7\xd0\x96\xc54-\x80\xbf\x19s\xb3\x7f\x92\x07\x9e\xbf\x16\xc8\x17\xcf\xf1\x8f\xa1\xbf\xa6C\xc2{\x9c\xc6\xa3\xbf\xbes?\x005\xa3\xc2\xbf>\x86\x8c\xb0\x16_\xaf?\xd0)7@\xa8\xb2\xbc?\xa0\x87\xf8\xdf\xfa.\x81\xbf\x05+\xa4)wc\x82\xbf(`\xbe)\xd7\xe0\xa7\xbf\xc1\x98P\x7f\x04\x94\x99?\xb5\xa6\x1d\x14\tY\xb7?\x1d)\x93\xa9lb\x91\xbf\xd0U#\xb3\xa2\xf5\xa5\xbfr>\x02F\xfeE\xab\xbf(\xb5\xb0\x80z6}?\x94f\x01\xd6\x86\x83v\xbf\x0e\x81\x9d\xdd\xed\x15B\xbf\xccl\xc8\xdc\x03\x10\x8e\xbf0\xba\xc1\\R\x1a\x99?\xf7^Ni<\xfc\xc9?%}\xfd|\x04L\x82\xbf\x1c|a\xc7ty\xb9\xbf\x12\x93 \xa0\xc9,\x85\xbfR$\xde J\x00\xbb\xbf\x81\x86\x7f\x16\xd6\xc1\x81?V\xd2\xc3\xd4\x92?a\xbf\tr\x03\xb0\xf7@\x81?|+\x99\xaa\xf6\xd1A?\xc4PN\x90\x9a\xc3b?\x85\xfd\x1b\xce\x08\x0fq?0G1\x10\xa1\xcb\x91\xbf\x9d#(\x11\x17\xe9\x91?\x8e\xa7x\x04\xbe?\xb0?.\xda\xac\x0f\xcd*\x96\xbf#\xb4\xef\x0f\xfe\xa0\xa7\xbf\xda\x08t\xb71\x1f\x86\xbf\xee\xf6\xa4\t\xa6\x83g?\xc0\xd8?CX\x07\x83?\xa2\x9e\x008&0\x81\xbf\x81\x8b\xff2\x04*~?\x13G\xee\xd1\xc6$\x82?\x9a(15\xf2\xc8\xe2\xbf\x7f\xe2\x14\xa7\xf4q\x84\xbf\x9e\xc4%\x98\xcf\xfa\xdf?7e\xb0!\x03\x1b\x94\xbfD\x89\xf6\xe7xx\xb7?\n\x01l)0\xe7\x89\xbfZ\xc7\x15\xb0Xho\xbf\xfe-\xa7\xa25\x17\x96?bm\x1b\x91\xceMr?B\xd9\xees\xa6k\x9b\xbf,0T3iY\xd9\xbfj\xcd\xfblc\x96\x8a?\xc4\x93/$e,\xda?\x99\r\xcb\x83\xe2\xbef?\xa1?\x18s\x9c\x90S\xbfm\xa7\x0f\xd0\xdb\xcfh?{\xd5\xa0\t\xd9Z\x86?\xde\xdd\x95\x94(T\x93?\xc8 W\x97\x85~\xd0\xbf\x1f+\xe0\xaf\xfcb\x92\xbf\xfc\xc7C\xe2\xb0\x15\xe1?\xd4\xca\xfbPIbc\xbf\x0b\x02\x88\xaf\x0e\xa7\xce\xbf\xcb\xd6S\xf0\x0c\xf1j\xbf\x97Rz\xc0{fU\xbfc\xd01\x05:\x1dE?\x81<U\x9d\x18\x9ex?_[x(\x9f\nx\xbf]\xf6\x9b.\xaf\x1c\x81?\xe0\xbe=#\xc3[\x9c?1\xe8\xe0uY\x1b\xc1\xbfm\xa7\x98B\xad\n\x9f\xbfvl\xb4lR\x85\xd1?\x1e\xec\x84\x87\xc5\xd5}?\xf1\xeaI\xae\xec\x93\xc5\xbf^\x14W&\x8e1s\xbf\xb9Lr\xf5H2X\xbf\xfa\x10\xbb1\xa3nf\xbf\x07\xe4\x85\x1f\xa2#J\xbf\xb9\xc54v\xb0\xaa\x9f\xbf\x0c\xdb\xd9\x8a\xfc\xde\xbd?\xea\x04\x13\xdb)\xf0\x9b?ND^\xf0\xa2\x85\xd3\xbf*\xfb\x1bsY#y?\x92>\x8a\x89\xcb\xf0\xc0?\x12c(B\x90\xf4=\xbf\x9a\x1chDc9\x80\xbf\x81.\xb5m\xb6qz\xbf\x1f\xbb\xc2\t\xc2\x05\xcc?\xe1\x0cQ7Co\x90? v\x134\xd3\xa8\xdd\xbf\x1aW0q\xf5Qs\xbf,#.\xb0=\xe6\xd1?}\xd6\x83H\xb0v\x7f?\xfd\x91\x9e\x93u\xedz\xbf\xce\xb3wL\x9f\xaa\x85?\x83\xeaV\t3C\x80\xbf\xb7"\xe7\xd4\xd9 \x91?YHv\x08\x10\xfb\xb3?\xfd=\x82\xed\xea\xbeu\xbf\xa9?C\xd0\xd1~\xbb?t\xea\xd3\x1f\xbc\xc5\x8c\xbf\xd9\x82\xa1\xc0M`\xc1\xbfqlX\x00\x94\xe8h?Yqz\xc7\xf9\x9fP?\x08\xa2\xed\xd3\x7fhL\xbf3\x9e\xf5\x0fb\xd5l\xbf\x8ao\x16\xd0\xfa|g\xbfia\rJ\x9c\xa0`\xbf\'\x95\x04\x01\xc6np\xbf\xfb\xf9CN/\xf9\xbe?\xb9[\xd7\x0e\x87mv?\xe6[\xb2\x97\xe6\x1f\xab\xbf\x16i\xd9zQ@}\xbfC\xf5\x8e\xb4\x0b\n\xac\xbf3M\x1c\xe9cI\x80?2\x18\x074tpw?\xa2\x1d\xdcUY\xd2\x95\xbf\xee\xc4\xd8M\xed^\x84?\x8c\x03\x02\x0e\x8b\xc8[?5\x07Z\x12\xea\xda\xcd\xbf\xffS\xb76\xe8\xec\x97\xbf\xee\xb6PPi}\xd6\xbf\xec2\xae\xba\xed\x89t?\x8c\x8e;"\xdcA\xe2?\xc1\xbf\xbb]["s?\x9e\xe4^.\x0e\x94d?\xf6\xb8\xb9rfwW\xbf\xc3\xf7\xcem\x91\xaf\xe1\xbf\xa9\x81\xf4\xab\x13\xe1\x93?\xb7i\xed:\xfdB\xd3?E\xf6\xec\x1d\x07\x1b_\xbfP\x96u_M\x14\xca?'
+p179
+tp180
+bsg79
+g64
+(g65
+(I0
+tp181
+g67
+tp182
+Rp183
+(I1
+(I40
+tp184
+g74
+I00
+S'+\xc4\xbcx\x90\x9b\x19\xc0\xf7\xc2:\x7f<\x0cV\xc0<%\x19\x9a\x87\xee4\xc0\x0c\xc6r\xc3^\x86K\xc0R`B\xfat?<\xc0nI\xd2\x0f\x93\xbc6\xc0\xe3\x99\xe1U@\x916\xc0\x99\'U\x8e\x02\xf9\xf8\xbf\x08!\x9c\xee\x16\x9f<\xc0Au\x8a}\xc3l6@wN\xe1D)\x845\xc0E\xa7\xb6\x90;\xc7K@R!\xe1K\x10\xf4"\xc0\xc5\xfa\xdd\x11D\xf3U@\x81\x8c\xc0\x9c\x9fN5@\x90w\t\x03\xf1\x8aL@p\x9f\xdc\x1e\x19\x87A@g\xf04\xe9h\x989@\x1b\x9a~\xd2}\nC@B\xebG\x95\x95\x95\xb4\xbfp\xa4q\x1c\xfb\x04B@a]\xfbU6\x977\xc0\xb5\xa4|\xd9\xf5n7@\x86=\xd3)\x16\xc5K\xc0\xb8z\x156\xb2\xf8\x14\xc0n\x16\xaf\xf0-\x9aR\xc0\x8e\xda=c\x88\xa8 \xc0\x07\xa2\x8d\xd5\xcc\xc66\xc0\x17PH\xd2\xae\x11\x19\xc0\xccP\x89\x14\x0b\xca\xf2\xbf@\xfd}\xef\x881"\xc0h\xeb\xb8\xfd7\x0f7@\xcf\x1f<\x11;u\x1e\xc0\x05\xc1"\xb8\xb5\x81R@\x0fV\xe42E\x7f\x15@}\x8d\x1f+\x13\x987@\xd6 yRQK!@(\x17W\x12\xec\x89\xef\xbf\x02\x8fH\'\x96\x80\x19@%n69x\x0c7\xc0'
+p185
+tp186
+bsS'n_samples'
+p187
+I3148
+sS'_n_active_components'
+p188
+I36
+sbsbasS'reference_shape'
+p189
+g0
+(g87
+g2
+Ntp190
+Rp191
+(dp192
+g91
+g64
+(g65
+(I0
+tp193
+g67
+tp194
+Rp195
+(I1
+(I20
+I2
+tp196
+g74
+I00
+S'\x1f\xd0\xa4\xc6\x16\x9dx@\xff\xe4\xc0F\x8f\xbek@\x92\x83\x8a\xda\xe1\xaew@\x9dy\rz\x0b\x0ep@\x1aM\x8e\xbd\x81:w@D\x89\xe3\x88*5r@\x89\x1dp1\x10\x98w@\xaa\xb7\x08\xaf\xdf\x9es@!\x96&j\x9c3w@\xd2\x9f\x96\x8af9u@xn\xba\xf6d\xa4w@\xbd`\xfcA\x0flw@9a\xf83\xc9ix@\xe9\xd4\x98\x81\x9e\x8ay@\xc9\xa0\x97lP\x88z@\xb9\x0f\xdbEQ\x85w@5\xa4u\xbd\xd0z{@n\x1b-R"nu@\x11\xbcJ%\xb2\xae{@\xf3\xd6K/\xe8\xb6s@\x18y0\xb1)\x8b{@\xe1\xfa\xfc\x8a\x1b&r@\x92\x05\x957&\xacz@=\xd8\xb9\x934\x05p@\xb6\xd5\xdc\xfdZ\xb4x@\x13\xe0D\x0f6\x87m@O\x9fW5\x82\x82x@\xbbX\x7f\xf2W4r@I\x9f\xccL\x0b\xa5x@\x92/\nC\x19\xa5s@\x94\xd8\xe66\xeatx@~\x1b\x14A\xb5Cu@#jk\x91\xa0\x8cx@B]\x13\x1cl\xa6x@x\x8ec\xceW\x8dy@\x11\x1e\xbe\xd3{Mu@K\xeb\xad\x00\x99\xc5y@\x11\x82\xb4GP\xa8s@\xfe\xda\xd7x\xb6\x9ey@5*0}\x03/r@'
+p197
+tp198
+bsg98
+Nsbsg48
+(lp199
+g49
+asg51
+g34
+sg46
 Nsb.