diff --git a/OmniPart/.gitattributes b/OmniPart/.gitattributes
new file mode 100644
index 0000000..de87618
--- /dev/null
+++ b/OmniPart/.gitattributes
@@ -0,0 +1,44 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/example_data/Batman.png filter=lfs diff=lfs merge=lfs -text
+assets/example_data/astronaut.png filter=lfs diff=lfs merge=lfs -text
+assets/example_data/car.png filter=lfs diff=lfs merge=lfs -text
+assets/example_data/knight.png filter=lfs diff=lfs merge=lfs -text
+assets/example_data/robot1.jpeg filter=lfs diff=lfs merge=lfs -text
+assets/example_data/snake.png filter=lfs diff=lfs merge=lfs -text
+assets/example_data/warhammer.png filter=lfs diff=lfs merge=lfs -text
+modules/part_synthesis/representations/mesh/flexicubes/images/block_init.png filter=lfs diff=lfs merge=lfs -text
+modules/part_synthesis/representations/mesh/flexicubes/images/teaser_top.png filter=lfs diff=lfs merge=lfs -text
diff --git a/OmniPart/.gitignore b/OmniPart/.gitignore
new file mode 100644
index 0000000..1891956
--- /dev/null
+++ b/OmniPart/.gitignore
@@ -0,0 +1,6 @@
+__pycache__/
+output/
+ckpt/
+.DS_Store
+tmp/
+debug_images/
\ No newline at end of file
diff --git a/OmniPart/DATASET.md b/OmniPart/DATASET.md
new file mode 100644
index 0000000..e69de29
diff --git a/OmniPart/LICENSE b/OmniPart/LICENSE
new file mode 100644
index 0000000..439823b
--- /dev/null
+++ b/OmniPart/LICENSE
@@ -0,0 +1,22 @@
+# MIT License
+
+# Copyright (c) 2025 VAST-AI-Research and contributors.
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE
+
diff --git a/OmniPart/NOTICE b/OmniPart/NOTICE
new file mode 100644
index 0000000..ddbc95f
--- /dev/null
+++ b/OmniPart/NOTICE
@@ -0,0 +1,15 @@
+OmniPart
+Copyright (c) 2025 VAST-AI-Research and contributors
+
+This project includes code from the following open source projects:
+
+RMBG
+Copyright (c) BRIA AI
+License: bria-rmbg-2.0
+Source: https://huggingface.co/briaai/RMBG-2.0
+
+This software contains code derived from 🤗 Diffusers (https://github.com/huggingface/diffusers), available under the Apache License 2.0.
+
+This software contains code derived from TRELLIS (https://github.com/Microsoft/TRELLIS), available under the MIT License.
+
+This software contains code derived from PartField (https://github.com/nv-tlabs/PartField), available under the NVIDIA Source Code License.
\ No newline at end of file
diff --git a/OmniPart/README.md b/OmniPart/README.md
new file mode 100644
index 0000000..d19e254
--- /dev/null
+++ b/OmniPart/README.md
@@ -0,0 +1,99 @@
+# OmniPart: Part-Aware 3D Generation with Semantic Decoupling and Structural Cohesion [SIGGRAPH Asia 2025]
+
+
+
+[](https://omnipart.github.io/)
+[](https://arxiv.org/abs/2507.06165)
+[](https://huggingface.co/omnipart)
+[](https://huggingface.co/spaces/omnipart/OmniPart)
+
+
+
+
+
+## 🔥 Updates
+
+### 📅 October 2025
+- Pretrained models, interactive demo, training code and data processing.
+
+## 🔨 Installation
+
+Clone the repo:
+```bash
+git clone https://github.com/HKU-MMLab/OmniPart
+cd OmniPart
+```
+
+Create a conda environment (optional):
+```bash
+conda create -n omnipart python=3.10
+conda activate omnipart
+```
+
+Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## 💡 Usage
+
+### Launch Demo
+
+```bash
+python app.py
+```
+
+### Inference Scripts
+
+If running OmniPart with command lines, you need to obtain the segmentation mask of the input image first. The mask is saved as a .exr file with the shape [h, w, 3], where the last dimension contains the 2D part_id replicated across all three channels.
+
+```bash
+python -m scripts.inference_omnipart --image_input {IMAGE_PATH} --mask_input {MASK_PATH}
+```
+
+The required model weights will be automatically downloaded:
+- OmniPart model from [OmniPart](https://huggingface.co/omnipart) → local directory `ckpt/`
+
+### Training
+
+#### Data processing
+
+Step 1: Render multi-view images of parts and overall shapes, following [TRELLIS Step 4](https://github.com/microsoft/TRELLIS/blob/main/DATASET.md#step-4-render-multiview-images).
+
+Step 2: Voxelize parts and overall shapes with `dataset_toolkits/voxelize_part.py` and `dataset_toolkits/voxelize_overall.py`.
+
+Step 3: Extract DINO features of parts and overall shapes, following [TRELLIS Step 6](https://github.com/microsoft/TRELLIS/blob/main/DATASET.md#step-6-extract-dino-features).
+
+Step 4: Encode SLat of parts and overall shapes, following [TRELLIS Step 8](https://github.com/microsoft/TRELLIS/blob/main/DATASET.md#step-8-encode-slat).
+
+Step 5: Merge SLat of parts and overall shapes with `dataset_toolkits/merge_slat.py`.
+
+Step 6: Render image and mask conditions with `dataset_toolkits/blender_render_img_mask.py`.
+
+#### Training code
+Fill in the values for `data_root`, `train_mesh_list`, `val_mesh_list` and `denoiser` in `configs/training_part_synthesis.json`. The `denoiser` field requires the path to a diffusion model checkpoint in `.pt` format (using `training/utils/transfer_st_pt.py`) that you wish to finetune, for example: `ckpt/slat_flow_img_dit_L_64l8p2_fp16.pt`.
+
+```bash
+python train.py --config configs/training_part_synthesis.json --output_dir {OUTPUT_PATH} --data_dir {SLat_PATH}
+```
+
+## ⭐ Acknowledgements
+
+We would like to thank the following open-source projects and research works that made OmniPart possible:
+
+- [TRELLIS](https://github.com/microsoft/TRELLIS)
+- [PartField](https://github.com/nv-tlabs/PartField)
+- [FlexiCubes](https://github.com/nv-tlabs/FlexiCubes)
+
+We are grateful to the broader research community for their open exploration and contributions to the field of 3D generation.
+
+## 📚 Citation
+
+```
+@article{yang2025omnipart,
+ title={Omnipart: Part-aware 3d generation with semantic decoupling and structural cohesion},
+ author={Yang, Yunhan and Zhou, Yufan and Guo, Yuan-Chen and Zou, Zi-Xin and Huang, Yukun and Liu, Ying-Tian and Xu, Hao and Liang, Ding and Cao, Yan-Pei and Liu, Xihui},
+ journal={arXiv preprint arXiv:2507.06165},
+ year={2025}
+}
+```
diff --git a/OmniPart/app.py b/OmniPart/app.py
new file mode 100644
index 0000000..5798e6e
--- /dev/null
+++ b/OmniPart/app.py
@@ -0,0 +1,185 @@
+import gradio as gr
+import spaces
+import os
+import shutil
+os.environ['SPCONV_ALGO'] = 'native'
+from huggingface_hub import hf_hub_download
+
+from app_utils import (
+ generate_parts,
+ prepare_models,
+ process_image,
+ apply_merge,
+ DEFAULT_SIZE_TH,
+ TMP_ROOT,
+)
+
+EXAMPLES = [
+ ["assets/example_data/knight.png", 1800, "6,0,26,20,7;13,1,22,11,12,2,21,27,3,24,23;5,18;4,17;19,16,14,25,28", 42],
+ ["assets/example_data/car.png", 2000, "12,10,2,11;1,7", 42],
+ ["assets/example_data/warhammer.png", 1800, "7,1,0,8", 0],
+ ["assets/example_data/snake.png", 3000, "2,3;0,1;4,5,6,7", 42],
+ ["assets/example_data/Batman.png", 1800, "4,5", 42],
+ ["assets/example_data/robot1.jpeg", 1600, "0,5;10,14,3;1,12,2;13,11,4;7,15", 42],
+ ["assets/example_data/astronaut.png", 2000, "0,4,6;1,8,9,7;2,5", 42],
+ ["assets/example_data/crossbow.jpg", 2000, "2,9;10,12,0,7,11,8,13;4,3", 42],
+ ["assets/example_data/robot.jpg", 1600, "7,19;15,0;6,18", 42],
+ ["assets/example_data/robot_dog.jpg", 1000, "21,9;2,12,10,15,17;11,7;1,0;13,19;4,16", 0],
+ ["assets/example_data/crossbow.jpg", 1600, "9,2;10,15,13;7,14,8,11;0,12,16;5,3,1", 42],
+ ["assets/example_data/robot.jpg", 1800, "1,2,3,5,4,16,17;11,7,19;10,14;18,6,0,15;13,9;12,8", 0],
+ ["assets/example_data/robot_dog.jpg", 1000, "2,12,10,15,17,8,3,5,13,19,6,14;11,7;1,0,21,9,11;4,16", 0],
+]
+
+HEADER = """
+
+# OmniPart: Part-Aware 3D Generation with Semantic Decoupling and Structural Cohesion
+
+🔮 Generate **part-aware 3D content** from a single 2D image with **2D mask control**.
+
+## How to Use
+
+**🚀 Quick Start**: Select an example below and click **"▶️ Run Example"**
+
+
+**📋 Custom Image Processing**:
+1. **Upload Image** - Select your image file
+2. **Click "Segment Image"** - Get initial 2D segmentation
+3. **Merge Segments** - Enter merge groups like `0,1;3,4` and click **"Apply Merge"** (Recommend keeping **2-15 parts**)
+4. **Click "Generate 3D Model"** - Create the final 3D results
+"""
+
+
+def start_session(req: gr.Request):
+ user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ os.makedirs(user_dir, exist_ok=True)
+
+
+def end_session(req: gr.Request):
+ user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ shutil.rmtree(user_dir)
+
+
+with gr.Blocks(title="OmniPart") as demo:
+ gr.Markdown(HEADER)
+
+ state = gr.State({})
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ gr.Markdown("\n\n## Input\n\n
")
+
+ input_image = gr.Image(label="Upload Image", type="filepath", height=250, width=250)
+
+ with gr.Row():
+ segment_btn = gr.Button("Segment Image", variant="primary", size="lg")
+ run_example_btn = gr.Button("▶️ Run Example", variant="secondary", size="lg")
+
+ size_threshold = gr.Slider(
+ minimum=600,
+ maximum=4000,
+ value=DEFAULT_SIZE_TH,
+ step=200,
+ label="Minimum Segment Size (pixels)",
+ info="Segments smaller than this will be ignored"
+ )
+
+ gr.Markdown("### Merge Controls")
+ merge_input = gr.Textbox(
+ label="Merge Groups",
+ placeholder="0,1;3,4",
+ lines=2,
+ info="Specify which segments to merge (e.g., '0,1;3,4' merges segments 0&1 together and 3&4 together)"
+ )
+ merge_btn = gr.Button("Apply Merge", variant="primary", size="lg")
+
+ gr.Markdown("### 3D Generation Controls")
+
+ seed_slider = gr.Slider(
+ minimum=0,
+ maximum=10000,
+ value=42,
+ step=1,
+ label="Generation Seed",
+ info="Random seed for 3D model generation"
+ )
+
+ cfg_slider = gr.Slider(
+ minimum=0.0,
+ maximum=15.0,
+ value=7.5,
+ step=0.5,
+ label="CFG Strength",
+ info="Classifier-Free Guidance strength"
+ )
+
+ generate_mesh_btn = gr.Button("Generate 3D Model", variant="secondary", size="lg")
+
+ with gr.Column(scale=2):
+ gr.Markdown("\n\n## Results Display\n\n
")
+
+ with gr.Row():
+ initial_seg = gr.Image(label="Init Seg", height=220, width=220)
+ pre_merge_vis = gr.Image(label="Pre-merge", height=220, width=220)
+ merged_seg = gr.Image(label="Merged Seg", height=220, width=220)
+
+ with gr.Row():
+ bbox_mesh = gr.Model3D(label="Bounding Boxes", height=350)
+ whole_mesh = gr.Model3D(label="Combined Parts", height=350)
+ exploded_mesh = gr.Model3D(label="Exploded Parts", height=350)
+
+ with gr.Row():
+ combined_gs = gr.Model3D(label="Combined 3D Gaussians", clear_color=(0.0, 0.0, 0.0, 0.0), height=350)
+ exploded_gs = gr.Model3D(label="Exploded 3D Gaussians", clear_color=(0.0, 0.0, 0.0, 0.0), height=350)
+
+ with gr.Row():
+ examples = gr.Examples(
+ examples=EXAMPLES,
+ inputs=[input_image, size_threshold, merge_input, seed_slider],
+ cache_examples=False,
+ )
+
+ demo.load(start_session)
+ demo.unload(end_session)
+
+ segment_btn.click(
+ process_image,
+ inputs=[input_image, size_threshold],
+ outputs=[initial_seg, pre_merge_vis, state]
+ )
+
+ merge_btn.click(
+ apply_merge,
+ inputs=[merge_input, state],
+ outputs=[merged_seg, state]
+ )
+
+ generate_mesh_btn.click(
+ generate_parts,
+ inputs=[state, seed_slider, cfg_slider],
+ outputs=[bbox_mesh, whole_mesh, exploded_mesh, combined_gs, exploded_gs]
+ )
+
+ run_example_btn.click(
+ fn=process_image,
+ inputs=[input_image, size_threshold],
+ outputs=[initial_seg, pre_merge_vis, state]
+ ).then(
+ fn=apply_merge,
+ inputs=[merge_input, state],
+ outputs=[merged_seg, state]
+ ).then(
+ fn=generate_parts,
+ inputs=[state, seed_slider, cfg_slider],
+ outputs=[bbox_mesh, whole_mesh, exploded_mesh, combined_gs, exploded_gs]
+ )
+
+if __name__ == "__main__":
+ os.makedirs("ckpt", exist_ok=True)
+ sam_ckpt_path = hf_hub_download(repo_id="omnipart/OmniPart_modules", filename="sam_vit_h_4b8939.pth", local_dir="ckpt")
+ partfield_ckpt_path = hf_hub_download(repo_id="omnipart/OmniPart_modules", filename="partfield_encoder.ckpt", local_dir="ckpt")
+ bbox_gen_ckpt_path = hf_hub_download(repo_id="omnipart/OmniPart_modules", filename="bbox_gen.ckpt", local_dir="ckpt")
+
+ prepare_models(sam_ckpt_path, partfield_ckpt_path, bbox_gen_ckpt_path)
+
+ port = int(os.getenv("PORT", "8080"))
+ demo.launch(share=False, server_name="0.0.0.0", server_port=port)
\ No newline at end of file
diff --git a/OmniPart/app_utils.py b/OmniPart/app_utils.py
new file mode 100644
index 0000000..37df8bc
--- /dev/null
+++ b/OmniPart/app_utils.py
@@ -0,0 +1,412 @@
+import gradio as gr
+import spaces
+import os
+import numpy as np
+import trimesh
+import time
+import traceback
+import torch
+from PIL import Image
+import cv2
+import shutil
+from segment_anything import SamAutomaticMaskGenerator, build_sam
+from omegaconf import OmegaConf
+
+from modules.bbox_gen.models.autogressive_bbox_gen import BboxGen
+from modules.part_synthesis.process_utils import save_parts_outputs
+from modules.inference_utils import load_img_mask, prepare_bbox_gen_input, prepare_part_synthesis_input, gen_mesh_from_bounds, vis_voxel_coords, merge_parts
+from modules.part_synthesis.pipelines import OmniPartImageTo3DPipeline
+from modules.label_2d_mask.visualizer import Visualizer
+from transformers import AutoModelForImageSegmentation
+
+from modules.label_2d_mask.label_parts import (
+ prepare_image,
+ get_sam_mask,
+ get_mask,
+ clean_segment_edges,
+ resize_and_pad_to_square,
+ size_th as DEFAULT_SIZE_TH
+)
+
+# Constants
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DTYPE = torch.float16
+MAX_SEED = np.iinfo(np.int32).max
+TMP_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tmp")
+os.makedirs(TMP_ROOT, exist_ok=True)
+
+sam_mask_generator = None
+rmbg_model = None
+bbox_gen_model = None
+part_synthesis_pipeline = None
+
+size_th = DEFAULT_SIZE_TH
+
+
+def prepare_models(sam_ckpt_path, partfield_ckpt_path, bbox_gen_ckpt_path):
+ global sam_mask_generator, rmbg_model, bbox_gen_model, part_synthesis_pipeline
+ if sam_mask_generator is None:
+ print("Loading SAM model...")
+ sam_model = build_sam(checkpoint=sam_ckpt_path).to(device=DEVICE)
+ sam_mask_generator = SamAutomaticMaskGenerator(sam_model)
+
+ if rmbg_model is None:
+ print("Loading BriaRMBG 2.0 model...")
+ rmbg_model = AutoModelForImageSegmentation.from_pretrained('briaai/RMBG-2.0', trust_remote_code=True)
+ rmbg_model.to(DEVICE)
+ rmbg_model.eval()
+
+ if part_synthesis_pipeline is None:
+ print("Loading PartSynthesis model...")
+ part_synthesis_pipeline = OmniPartImageTo3DPipeline.from_pretrained('omnipart/OmniPart')
+ part_synthesis_pipeline.to(DEVICE)
+
+ if bbox_gen_model is None:
+ print("Loading BboxGen model...")
+ bbox_gen_config = OmegaConf.load("configs/bbox_gen.yaml").model.args
+ bbox_gen_config.partfield_encoder_path = partfield_ckpt_path
+ bbox_gen_model = BboxGen(bbox_gen_config)
+ bbox_gen_model.load_state_dict(torch.load(bbox_gen_ckpt_path), strict=False)
+ bbox_gen_model.to(DEVICE)
+ bbox_gen_model.eval().half()
+
+ print("Models ready")
+
+
+@spaces.GPU
+def process_image(image_path, threshold, req: gr.Request):
+ """Process image and generate initial segmentation"""
+ global size_th
+
+ user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ os.makedirs(user_dir, exist_ok=True)
+
+ img_name = os.path.basename(image_path).split(".")[0]
+
+ size_th = threshold
+
+ img = Image.open(image_path).convert("RGB")
+ processed_image = prepare_image(img, rmbg_net=rmbg_model.to(DEVICE))
+
+ processed_image = resize_and_pad_to_square(processed_image)
+ white_bg = Image.new("RGBA", processed_image.size, (255, 255, 255, 255))
+ white_bg_img = Image.alpha_composite(white_bg, processed_image.convert("RGBA"))
+ image = np.array(white_bg_img.convert('RGB'))
+
+ rgba_path = os.path.join(user_dir, f"{img_name}_processed.png")
+ processed_image.save(rgba_path)
+
+ print("Generating raw SAM masks without post-processing...")
+ raw_masks = sam_mask_generator.generate(image)
+
+ raw_sam_vis = np.copy(image)
+ raw_sam_vis = np.ones_like(image) * 255
+
+ sorted_masks = sorted(raw_masks, key=lambda x: x["area"], reverse=True)
+
+ for i, mask_data in enumerate(sorted_masks):
+ if mask_data["area"] < size_th:
+ continue
+
+ color_r = (i * 50 + 80) % 256
+ color_g = (i * 120 + 40) % 256
+ color_b = (i * 180 + 20) % 256
+ color = np.array([color_r, color_g, color_b])
+
+ mask = mask_data["segmentation"]
+ raw_sam_vis[mask] = color
+
+ visual = Visualizer(image)
+
+ group_ids, pre_merge_im = get_sam_mask(
+ image,
+ sam_mask_generator,
+ visual,
+ merge_groups=None,
+ rgba_image=processed_image,
+ img_name=img_name,
+ save_dir=user_dir,
+ size_threshold=size_th
+ )
+
+ pre_merge_path = os.path.join(user_dir, f"{img_name}_mask_pre_merge.png")
+ Image.fromarray(pre_merge_im).save(pre_merge_path)
+ pre_split_vis = np.ones_like(image) * 255
+
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0]
+
+ for i, unique_id in enumerate(unique_ids):
+ color_r = (i * 50 + 80) % 256
+ color_g = (i * 120 + 40) % 256
+ color_b = (i * 180 + 20) % 256
+ color = np.array([color_r, color_g, color_b])
+
+ mask = (group_ids == unique_id)
+ pre_split_vis[mask] = color
+
+ y_indices, x_indices = np.where(mask)
+ if len(y_indices) > 0:
+ center_y = int(np.mean(y_indices))
+ center_x = int(np.mean(x_indices))
+ cv2.putText(pre_split_vis, str(unique_id),
+ (center_x, center_y), cv2.FONT_HERSHEY_SIMPLEX,
+ 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+
+ pre_split_path = os.path.join(user_dir, f"{img_name}_pre_split.png")
+ Image.fromarray(pre_split_vis).save(pre_split_path)
+ print(f"Pre-split segmentation (before disconnected parts handling) saved to {pre_split_path}")
+
+ get_mask(group_ids, image, ids=2, img_name=img_name, save_dir=user_dir)
+
+ init_seg_path = os.path.join(user_dir, f"{img_name}_mask_segments_2.png")
+
+ seg_img = Image.open(init_seg_path)
+ if seg_img.mode == 'RGBA':
+ white_bg = Image.new('RGBA', seg_img.size, (255, 255, 255, 255))
+ seg_img = Image.alpha_composite(white_bg, seg_img)
+ seg_img.save(init_seg_path)
+
+ state = {
+ "image": image.tolist(),
+ "processed_image": rgba_path,
+ "group_ids": group_ids.tolist() if isinstance(group_ids, np.ndarray) else group_ids,
+ "original_group_ids": group_ids.tolist() if isinstance(group_ids, np.ndarray) else group_ids,
+ "img_name": img_name,
+ "pre_split_path": pre_split_path,
+ }
+
+ return init_seg_path, pre_merge_path, state
+
+
+def apply_merge(merge_input, state, req: gr.Request):
+ """Apply merge parameters and generate merged segmentation"""
+ global sam_mask_generator
+
+ if not state:
+ return None, None, state
+
+ user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+
+ # Convert back from list to numpy array
+ image = np.array(state["image"])
+ # Use original group IDs instead of the most recent ones
+ group_ids = np.array(state["original_group_ids"])
+ img_name = state["img_name"]
+
+ # Load processed image from path
+ processed_image = Image.open(state["processed_image"])
+
+ # Display the original IDs before merging, SORTED for easier reading
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0] # Exclude background
+ print(f"Original segment IDs (used for merging): {sorted(unique_ids.tolist())}")
+
+ # Parse merge groups
+ merge_groups = None
+ try:
+ if merge_input:
+ merge_groups = []
+ group_sets = merge_input.split(';')
+ for group_set in group_sets:
+ ids = [int(x) for x in group_set.split(',')]
+ if ids:
+ # Validate if these IDs exist in the segmentation
+ existing_ids = [id for id in ids if id in unique_ids]
+ missing_ids = [id for id in ids if id not in unique_ids]
+
+ if missing_ids:
+ print(f"Warning: These IDs don't exist in the segmentation: {missing_ids}")
+
+ # Only add group if it has valid IDs
+ if existing_ids:
+ merge_groups.append(ids)
+ print(f"Valid merge group: {ids} (missing: {missing_ids if missing_ids else 'none'})")
+ else:
+ print(f"Skipping merge group with no valid IDs: {ids}")
+
+ print(f"Using merge groups: {merge_groups}")
+ except Exception as e:
+ print(f"Error parsing merge groups: {e}")
+ return None, None, state
+
+ # Initialize visualizer
+ visual = Visualizer(image)
+
+ # Generate merged segmentation starting from original IDs
+ # Add skip_split=True to prevent splitting after merging
+ new_group_ids, merged_im = get_sam_mask(
+ image,
+ sam_mask_generator,
+ visual,
+ merge_groups=merge_groups,
+ existing_group_ids=group_ids,
+ rgba_image=processed_image,
+ skip_split=True,
+ img_name=img_name,
+ save_dir=user_dir,
+ size_threshold=size_th
+ )
+
+ # Display the new IDs after merging for future reference
+ new_unique_ids = np.unique(new_group_ids)
+ new_unique_ids = new_unique_ids[new_unique_ids >= 0] # Exclude background
+ print(f"New segment IDs (after merging): {new_unique_ids.tolist()}")
+
+ # Clean edges
+ new_group_ids = clean_segment_edges(new_group_ids)
+
+ # Save merged segmentation visualization
+ get_mask(new_group_ids, image, ids=3, img_name=img_name, save_dir=user_dir)
+
+ # Path to merged segmentation
+ merged_seg_path = os.path.join(user_dir, f"{img_name}_mask_segments_3.png")
+
+ save_mask = new_group_ids + 1
+ save_mask = save_mask.reshape(518, 518, 1).repeat(3, axis=-1)
+ cv2.imwrite(os.path.join(user_dir, f"{img_name}_mask.exr"), save_mask.astype(np.float32))
+
+ # Update state with the new group IDs but keep original IDs unchanged
+ state["group_ids"] = new_group_ids.tolist() if isinstance(new_group_ids, np.ndarray) else new_group_ids
+ state["save_mask_path"] = os.path.join(user_dir, f"{img_name}_mask.exr")
+
+ return merged_seg_path, state
+
+
+def explode_mesh(mesh, explosion_scale=0.4):
+
+ if isinstance(mesh, trimesh.Scene):
+ scene = mesh
+ elif isinstance(mesh, trimesh.Trimesh):
+ print("Warning: Single mesh provided, can't create exploded view")
+ scene = trimesh.Scene(mesh)
+ return scene
+ else:
+ print(f"Warning: Unexpected mesh type: {type(mesh)}")
+ scene = mesh
+
+ if len(scene.geometry) <= 1:
+ print("Only one geometry found - nothing to explode")
+ return scene
+
+ print(f"[EXPLODE_MESH] Starting mesh explosion with scale {explosion_scale}")
+ print(f"[EXPLODE_MESH] Processing {len(scene.geometry)} parts")
+
+ exploded_scene = trimesh.Scene()
+
+ part_centers = []
+ geometry_names = []
+
+ for geometry_name, geometry in scene.geometry.items():
+ if hasattr(geometry, 'vertices'):
+ transform = scene.graph[geometry_name][0]
+ vertices_global = trimesh.transformations.transform_points(
+ geometry.vertices, transform)
+ center = np.mean(vertices_global, axis=0)
+ part_centers.append(center)
+ geometry_names.append(geometry_name)
+ print(f"[EXPLODE_MESH] Part {geometry_name}: center = {center}")
+
+ if not part_centers:
+ print("No valid geometries with vertices found")
+ return scene
+
+ part_centers = np.array(part_centers)
+ global_center = np.mean(part_centers, axis=0)
+
+ print(f"[EXPLODE_MESH] Global center: {global_center}")
+
+ for i, (geometry_name, geometry) in enumerate(scene.geometry.items()):
+ if hasattr(geometry, 'vertices'):
+ if i < len(part_centers):
+ part_center = part_centers[i]
+ direction = part_center - global_center
+
+ direction_norm = np.linalg.norm(direction)
+ if direction_norm > 1e-6:
+ direction = direction / direction_norm
+ else:
+ direction = np.random.randn(3)
+ direction = direction / np.linalg.norm(direction)
+
+ offset = direction * explosion_scale
+ else:
+ offset = np.zeros(3)
+
+ original_transform = scene.graph[geometry_name][0].copy()
+
+ new_transform = original_transform.copy()
+ new_transform[:3, 3] = new_transform[:3, 3] + offset
+
+ exploded_scene.add_geometry(
+ geometry,
+ transform=new_transform,
+ geom_name=geometry_name
+ )
+
+ print(f"[EXPLODE_MESH] Part {geometry_name}: moved by {np.linalg.norm(offset):.4f}")
+
+ print("[EXPLODE_MESH] Mesh explosion complete")
+ return exploded_scene
+
+@spaces.GPU(duration=90)
+def generate_parts(state, seed, cfg_strength, req: gr.Request):
+ explode_factor=0.3
+ img_path = state["processed_image"]
+ mask_path = state["save_mask_path"]
+ user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ img_white_bg, img_black_bg, ordered_mask_input, img_mask_vis = load_img_mask(img_path, mask_path)
+ img_mask_vis.save(os.path.join(user_dir, "img_mask_vis.png"))
+
+ voxel_coords = part_synthesis_pipeline.get_coords(img_black_bg, num_samples=1, seed=seed, sparse_structure_sampler_params={"steps": 25, "cfg_strength": 7.5})
+ voxel_coords = voxel_coords.cpu().numpy()
+ np.save(os.path.join(user_dir, "voxel_coords.npy"), voxel_coords)
+ voxel_coords_ply = vis_voxel_coords(voxel_coords)
+ voxel_coords_ply.export(os.path.join(user_dir, "voxel_coords_vis.ply"))
+ print("[INFO] Voxel coordinates saved")
+
+ bbox_gen_input = prepare_bbox_gen_input(os.path.join(user_dir, "voxel_coords.npy"), img_white_bg, ordered_mask_input)
+ bbox_gen_output = bbox_gen_model.generate(bbox_gen_input)
+ np.save(os.path.join(user_dir, "bboxes.npy"), bbox_gen_output['bboxes'][0])
+ bboxes_vis = gen_mesh_from_bounds(bbox_gen_output['bboxes'][0])
+ bboxes_vis.export(os.path.join(user_dir, "bboxes_vis.glb"))
+ print("[INFO] BboxGen output saved")
+
+
+ part_synthesis_input = prepare_part_synthesis_input(os.path.join(user_dir, "voxel_coords.npy"), os.path.join(user_dir, "bboxes.npy"), ordered_mask_input)
+
+ torch.cuda.empty_cache()
+
+ part_synthesis_output = part_synthesis_pipeline.get_slat(
+ img_black_bg,
+ part_synthesis_input['coords'],
+ [part_synthesis_input['part_layouts']],
+ part_synthesis_input['masks'],
+ seed=seed,
+ slat_sampler_params={"steps": 25, "cfg_strength": cfg_strength},
+ formats=['mesh', 'gaussian'],
+ preprocess_image=False,
+ )
+ save_parts_outputs(
+ part_synthesis_output,
+ output_dir=user_dir,
+ simplify_ratio=0.0,
+ save_video=False,
+ save_glb=True,
+ textured=False,
+ )
+ merge_parts(user_dir)
+ print("[INFO] PartSynthesis output saved")
+
+ bbox_mesh_path = os.path.join(user_dir, "bboxes_vis.glb")
+ whole_mesh_path = os.path.join(user_dir, "mesh_segment.glb")
+
+ combined_mesh = trimesh.load(whole_mesh_path)
+ exploded_mesh_result = explode_mesh(combined_mesh, explosion_scale=explode_factor)
+ exploded_mesh_result.export(os.path.join(user_dir, "exploded_parts.glb"))
+
+ exploded_mesh_path = os.path.join(user_dir, "exploded_parts.glb")
+ combined_gs_path = os.path.join(user_dir, "merged_gs.ply")
+ exploded_gs_path = os.path.join(user_dir, "exploded_gs.ply")
+
+ return bbox_mesh_path, whole_mesh_path, exploded_mesh_path, combined_gs_path, exploded_gs_path
diff --git a/OmniPart/assets/doc/teaser.jpg b/OmniPart/assets/doc/teaser.jpg
new file mode 100644
index 0000000..fafbfe2
Binary files /dev/null and b/OmniPart/assets/doc/teaser.jpg differ
diff --git a/OmniPart/assets/example_data/crossbow.jpg b/OmniPart/assets/example_data/crossbow.jpg
new file mode 100644
index 0000000..97e9b64
Binary files /dev/null and b/OmniPart/assets/example_data/crossbow.jpg differ
diff --git a/OmniPart/assets/example_data/robot.jpg b/OmniPart/assets/example_data/robot.jpg
new file mode 100644
index 0000000..d08622b
Binary files /dev/null and b/OmniPart/assets/example_data/robot.jpg differ
diff --git a/OmniPart/assets/example_data/robot_dog.jpg b/OmniPart/assets/example_data/robot_dog.jpg
new file mode 100644
index 0000000..0f3e87a
Binary files /dev/null and b/OmniPart/assets/example_data/robot_dog.jpg differ
diff --git a/OmniPart/assets/example_data/ship.jpg b/OmniPart/assets/example_data/ship.jpg
new file mode 100644
index 0000000..14e27fa
Binary files /dev/null and b/OmniPart/assets/example_data/ship.jpg differ
diff --git a/OmniPart/configs/RMBG/BiRefNet_config.py b/OmniPart/configs/RMBG/BiRefNet_config.py
new file mode 100644
index 0000000..37c8ac5
--- /dev/null
+++ b/OmniPart/configs/RMBG/BiRefNet_config.py
@@ -0,0 +1,11 @@
+from transformers import PretrainedConfig
+
+class BiRefNetConfig(PretrainedConfig):
+ model_type = "SegformerForSemanticSegmentation"
+ def __init__(
+ self,
+ bb_pretrained=False,
+ **kwargs
+ ):
+ self.bb_pretrained = bb_pretrained
+ super().__init__(**kwargs)
diff --git a/OmniPart/configs/RMBG/birefnet.py b/OmniPart/configs/RMBG/birefnet.py
new file mode 100644
index 0000000..1ed28de
--- /dev/null
+++ b/OmniPart/configs/RMBG/birefnet.py
@@ -0,0 +1,2244 @@
+### config.py
+
+import os
+import math
+
+
+class Config():
+ def __init__(self) -> None:
+ # PATH settings
+ self.sys_home_dir = os.path.expanduser('~') # Make up your file system as: SYS_HOME_DIR/codes/dis/BiRefNet, SYS_HOME_DIR/datasets/dis/xx, SYS_HOME_DIR/weights/xx
+
+ # TASK settings
+ self.task = ['DIS5K', 'COD', 'HRSOD', 'DIS5K+HRSOD+HRS10K', 'P3M-10k'][0]
+ self.training_set = {
+ 'DIS5K': ['DIS-TR', 'DIS-TR+DIS-TE1+DIS-TE2+DIS-TE3+DIS-TE4'][0],
+ 'COD': 'TR-COD10K+TR-CAMO',
+ 'HRSOD': ['TR-DUTS', 'TR-HRSOD', 'TR-UHRSD', 'TR-DUTS+TR-HRSOD', 'TR-DUTS+TR-UHRSD', 'TR-HRSOD+TR-UHRSD', 'TR-DUTS+TR-HRSOD+TR-UHRSD'][5],
+ 'DIS5K+HRSOD+HRS10K': 'DIS-TE1+DIS-TE2+DIS-TE3+DIS-TE4+DIS-TR+TE-HRS10K+TE-HRSOD+TE-UHRSD+TR-HRS10K+TR-HRSOD+TR-UHRSD', # leave DIS-VD for evaluation.
+ 'P3M-10k': 'TR-P3M-10k',
+ }[self.task]
+ self.prompt4loc = ['dense', 'sparse'][0]
+
+ # Faster-Training settings
+ self.load_all = True
+ self.compile = True # 1. Trigger CPU memory leak in some extend, which is an inherent problem of PyTorch.
+ # Machines with > 70GB CPU memory can run the whole training on DIS5K with default setting.
+ # 2. Higher PyTorch version may fix it: https://github.com/pytorch/pytorch/issues/119607.
+ # 3. But compile in Pytorch > 2.0.1 seems to bring no acceleration for training.
+ self.precisionHigh = True
+
+ # MODEL settings
+ self.ms_supervision = True
+ self.out_ref = self.ms_supervision and True
+ self.dec_ipt = True
+ self.dec_ipt_split = True
+ self.cxt_num = [0, 3][1] # multi-scale skip connections from encoder
+ self.mul_scl_ipt = ['', 'add', 'cat'][2]
+ self.dec_att = ['', 'ASPP', 'ASPPDeformable'][2]
+ self.squeeze_block = ['', 'BasicDecBlk_x1', 'ResBlk_x4', 'ASPP_x3', 'ASPPDeformable_x3'][1]
+ self.dec_blk = ['BasicDecBlk', 'ResBlk', 'HierarAttDecBlk'][0]
+
+ # TRAINING settings
+ self.batch_size = 4
+ self.IoU_finetune_last_epochs = [
+ 0,
+ {
+ 'DIS5K': -50,
+ 'COD': -20,
+ 'HRSOD': -20,
+ 'DIS5K+HRSOD+HRS10K': -20,
+ 'P3M-10k': -20,
+ }[self.task]
+ ][1] # choose 0 to skip
+ self.lr = (1e-4 if 'DIS5K' in self.task else 1e-5) * math.sqrt(self.batch_size / 4) # DIS needs high lr to converge faster. Adapt the lr linearly
+ self.size = 1024
+ self.num_workers = max(4, self.batch_size) # will be decrease to min(it, batch_size) at the initialization of the data_loader
+
+ # Backbone settings
+ self.bb = [
+ 'vgg16', 'vgg16bn', 'resnet50', # 0, 1, 2
+ 'swin_v1_t', 'swin_v1_s', # 3, 4
+ 'swin_v1_b', 'swin_v1_l', # 5-bs9, 6-bs4
+ 'pvt_v2_b0', 'pvt_v2_b1', # 7, 8
+ 'pvt_v2_b2', 'pvt_v2_b5', # 9-bs10, 10-bs5
+ ][6]
+ self.lateral_channels_in_collection = {
+ 'vgg16': [512, 256, 128, 64], 'vgg16bn': [512, 256, 128, 64], 'resnet50': [1024, 512, 256, 64],
+ 'pvt_v2_b2': [512, 320, 128, 64], 'pvt_v2_b5': [512, 320, 128, 64],
+ 'swin_v1_b': [1024, 512, 256, 128], 'swin_v1_l': [1536, 768, 384, 192],
+ 'swin_v1_t': [768, 384, 192, 96], 'swin_v1_s': [768, 384, 192, 96],
+ 'pvt_v2_b0': [256, 160, 64, 32], 'pvt_v2_b1': [512, 320, 128, 64],
+ }[self.bb]
+ if self.mul_scl_ipt == 'cat':
+ self.lateral_channels_in_collection = [channel * 2 for channel in self.lateral_channels_in_collection]
+ self.cxt = self.lateral_channels_in_collection[1:][::-1][-self.cxt_num:] if self.cxt_num else []
+
+ # MODEL settings - inactive
+ self.lat_blk = ['BasicLatBlk'][0]
+ self.dec_channels_inter = ['fixed', 'adap'][0]
+ self.refine = ['', 'itself', 'RefUNet', 'Refiner', 'RefinerPVTInChannels4'][0]
+ self.progressive_ref = self.refine and True
+ self.ender = self.progressive_ref and False
+ self.scale = self.progressive_ref and 2
+ self.auxiliary_classification = False # Only for DIS5K, where class labels are saved in `dataset.py`.
+ self.refine_iteration = 1
+ self.freeze_bb = False
+ self.model = [
+ 'BiRefNet',
+ ][0]
+ if self.dec_blk == 'HierarAttDecBlk':
+ self.batch_size = 2 ** [0, 1, 2, 3, 4][2]
+
+ # TRAINING settings - inactive
+ self.preproc_methods = ['flip', 'enhance', 'rotate', 'pepper', 'crop'][:4]
+ self.optimizer = ['Adam', 'AdamW'][1]
+ self.lr_decay_epochs = [1e5] # Set to negative N to decay the lr in the last N-th epoch.
+ self.lr_decay_rate = 0.5
+ # Loss
+ self.lambdas_pix_last = {
+ # not 0 means opening this loss
+ # original rate -- 1 : 30 : 1.5 : 0.2, bce x 30
+ 'bce': 30 * 1, # high performance
+ 'iou': 0.5 * 1, # 0 / 255
+ 'iou_patch': 0.5 * 0, # 0 / 255, win_size = (64, 64)
+ 'mse': 150 * 0, # can smooth the saliency map
+ 'triplet': 3 * 0,
+ 'reg': 100 * 0,
+ 'ssim': 10 * 1, # help contours,
+ 'cnt': 5 * 0, # help contours
+ 'structure': 5 * 0, # structure loss from codes of MVANet. A little improvement on DIS-TE[1,2,3], a bit more decrease on DIS-TE4.
+ }
+ self.lambdas_cls = {
+ 'ce': 5.0
+ }
+ # Adv
+ self.lambda_adv_g = 10. * 0 # turn to 0 to avoid adv training
+ self.lambda_adv_d = 3. * (self.lambda_adv_g > 0)
+
+ # PATH settings - inactive
+ self.data_root_dir = os.path.join(self.sys_home_dir, 'datasets/dis')
+ self.weights_root_dir = os.path.join(self.sys_home_dir, 'weights')
+ self.weights = {
+ 'pvt_v2_b2': os.path.join(self.weights_root_dir, 'pvt_v2_b2.pth'),
+ 'pvt_v2_b5': os.path.join(self.weights_root_dir, ['pvt_v2_b5.pth', 'pvt_v2_b5_22k.pth'][0]),
+ 'swin_v1_b': os.path.join(self.weights_root_dir, ['swin_base_patch4_window12_384_22kto1k.pth', 'swin_base_patch4_window12_384_22k.pth'][0]),
+ 'swin_v1_l': os.path.join(self.weights_root_dir, ['swin_large_patch4_window12_384_22kto1k.pth', 'swin_large_patch4_window12_384_22k.pth'][0]),
+ 'swin_v1_t': os.path.join(self.weights_root_dir, ['swin_tiny_patch4_window7_224_22kto1k_finetune.pth'][0]),
+ 'swin_v1_s': os.path.join(self.weights_root_dir, ['swin_small_patch4_window7_224_22kto1k_finetune.pth'][0]),
+ 'pvt_v2_b0': os.path.join(self.weights_root_dir, ['pvt_v2_b0.pth'][0]),
+ 'pvt_v2_b1': os.path.join(self.weights_root_dir, ['pvt_v2_b1.pth'][0]),
+ }
+
+ # Callbacks - inactive
+ self.verbose_eval = True
+ self.only_S_MAE = False
+ self.use_fp16 = False # Bugs. It may cause nan in training.
+ self.SDPA_enabled = False # Bugs. Slower and errors occur in multi-GPUs
+
+ # others
+ self.device = [0, 'cpu'][0] # .to(0) == .to('cuda:0')
+
+ self.batch_size_valid = 1
+ self.rand_seed = 7
+ # run_sh_file = [f for f in os.listdir('.') if 'train.sh' == f] + [os.path.join('..', f) for f in os.listdir('..') if 'train.sh' == f]
+ # with open(run_sh_file[0], 'r') as f:
+ # lines = f.readlines()
+ # self.save_last = int([l.strip() for l in lines if '"{}")'.format(self.task) in l and 'val_last=' in l][0].split('val_last=')[-1].split()[0])
+ # self.save_step = int([l.strip() for l in lines if '"{}")'.format(self.task) in l and 'step=' in l][0].split('step=')[-1].split()[0])
+ # self.val_step = [0, self.save_step][0]
+
+ def print_task(self) -> None:
+ # Return task for choosing settings in shell scripts.
+ print(self.task)
+
+
+
+### models/backbones/pvt_v2.py
+
+import torch
+import torch.nn as nn
+from functools import partial
+
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+from timm.models.registry import register_model
+
+import math
+
+# from config import Config
+
+# config = Config()
+
+class Mlp(nn.Module):
+ def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.fc1 = nn.Linear(in_features, hidden_features)
+ self.dwconv = DWConv(hidden_features)
+ self.act = act_layer()
+ self.fc2 = nn.Linear(hidden_features, out_features)
+ self.drop = nn.Dropout(drop)
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def forward(self, x, H, W):
+ x = self.fc1(x)
+ x = self.dwconv(x, H, W)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
+
+
+class Attention(nn.Module):
+ def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1):
+ super().__init__()
+ assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
+
+ self.dim = dim
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = qk_scale or head_dim ** -0.5
+
+ self.q = nn.Linear(dim, dim, bias=qkv_bias)
+ self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
+ self.attn_drop_prob = attn_drop
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop)
+
+ self.sr_ratio = sr_ratio
+ if sr_ratio > 1:
+ self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
+ self.norm = nn.LayerNorm(dim)
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def forward(self, x, H, W):
+ B, N, C = x.shape
+ q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
+
+ if self.sr_ratio > 1:
+ x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
+ x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
+ x_ = self.norm(x_)
+ kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+ else:
+ kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+ k, v = kv[0], kv[1]
+
+ if config.SDPA_enabled:
+ x = torch.nn.functional.scaled_dot_product_attention(
+ q, k, v,
+ attn_mask=None, dropout_p=self.attn_drop_prob, is_causal=False
+ ).transpose(1, 2).reshape(B, N, C)
+ else:
+ attn = (q @ k.transpose(-2, -1)) * self.scale
+ attn = attn.softmax(dim=-1)
+ attn = self.attn_drop(attn)
+
+ x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+
+ return x
+
+
+class Block(nn.Module):
+
+ def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
+ drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, sr_ratio=1):
+ super().__init__()
+ self.norm1 = norm_layer(dim)
+ self.attn = Attention(
+ dim,
+ num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
+ attn_drop=attn_drop, proj_drop=drop, sr_ratio=sr_ratio)
+ # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
+ self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+ self.norm2 = norm_layer(dim)
+ mlp_hidden_dim = int(dim * mlp_ratio)
+ self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def forward(self, x, H, W):
+ x = x + self.drop_path(self.attn(self.norm1(x), H, W))
+ x = x + self.drop_path(self.mlp(self.norm2(x), H, W))
+
+ return x
+
+
+class OverlapPatchEmbed(nn.Module):
+ """ Image to Patch Embedding
+ """
+
+ def __init__(self, img_size=224, patch_size=7, stride=4, in_channels=3, embed_dim=768):
+ super().__init__()
+ img_size = to_2tuple(img_size)
+ patch_size = to_2tuple(patch_size)
+
+ self.img_size = img_size
+ self.patch_size = patch_size
+ self.H, self.W = img_size[0] // patch_size[0], img_size[1] // patch_size[1]
+ self.num_patches = self.H * self.W
+ self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=stride,
+ padding=(patch_size[0] // 2, patch_size[1] // 2))
+ self.norm = nn.LayerNorm(embed_dim)
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def forward(self, x):
+ x = self.proj(x)
+ _, _, H, W = x.shape
+ x = x.flatten(2).transpose(1, 2)
+ x = self.norm(x)
+
+ return x, H, W
+
+
+class PyramidVisionTransformerImpr(nn.Module):
+ def __init__(self, img_size=224, patch_size=16, in_channels=3, num_classes=1000, embed_dims=[64, 128, 256, 512],
+ num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
+ attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,
+ depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1]):
+ super().__init__()
+ self.num_classes = num_classes
+ self.depths = depths
+
+ # patch_embed
+ self.patch_embed1 = OverlapPatchEmbed(img_size=img_size, patch_size=7, stride=4, in_channels=in_channels,
+ embed_dim=embed_dims[0])
+ self.patch_embed2 = OverlapPatchEmbed(img_size=img_size // 4, patch_size=3, stride=2, in_channels=embed_dims[0],
+ embed_dim=embed_dims[1])
+ self.patch_embed3 = OverlapPatchEmbed(img_size=img_size // 8, patch_size=3, stride=2, in_channels=embed_dims[1],
+ embed_dim=embed_dims[2])
+ self.patch_embed4 = OverlapPatchEmbed(img_size=img_size // 16, patch_size=3, stride=2, in_channels=embed_dims[2],
+ embed_dim=embed_dims[3])
+
+ # transformer encoder
+ dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
+ cur = 0
+ self.block1 = nn.ModuleList([Block(
+ dim=embed_dims[0], num_heads=num_heads[0], mlp_ratio=mlp_ratios[0], qkv_bias=qkv_bias, qk_scale=qk_scale,
+ drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
+ sr_ratio=sr_ratios[0])
+ for i in range(depths[0])])
+ self.norm1 = norm_layer(embed_dims[0])
+
+ cur += depths[0]
+ self.block2 = nn.ModuleList([Block(
+ dim=embed_dims[1], num_heads=num_heads[1], mlp_ratio=mlp_ratios[1], qkv_bias=qkv_bias, qk_scale=qk_scale,
+ drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
+ sr_ratio=sr_ratios[1])
+ for i in range(depths[1])])
+ self.norm2 = norm_layer(embed_dims[1])
+
+ cur += depths[1]
+ self.block3 = nn.ModuleList([Block(
+ dim=embed_dims[2], num_heads=num_heads[2], mlp_ratio=mlp_ratios[2], qkv_bias=qkv_bias, qk_scale=qk_scale,
+ drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
+ sr_ratio=sr_ratios[2])
+ for i in range(depths[2])])
+ self.norm3 = norm_layer(embed_dims[2])
+
+ cur += depths[2]
+ self.block4 = nn.ModuleList([Block(
+ dim=embed_dims[3], num_heads=num_heads[3], mlp_ratio=mlp_ratios[3], qkv_bias=qkv_bias, qk_scale=qk_scale,
+ drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
+ sr_ratio=sr_ratios[3])
+ for i in range(depths[3])])
+ self.norm4 = norm_layer(embed_dims[3])
+
+ # classification head
+ # self.head = nn.Linear(embed_dims[3], num_classes) if num_classes > 0 else nn.Identity()
+
+ self.apply(self._init_weights)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def init_weights(self, pretrained=None):
+ if isinstance(pretrained, str):
+ logger = 1
+ #load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger)
+
+ def reset_drop_path(self, drop_path_rate):
+ dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(self.depths))]
+ cur = 0
+ for i in range(self.depths[0]):
+ self.block1[i].drop_path.drop_prob = dpr[cur + i]
+
+ cur += self.depths[0]
+ for i in range(self.depths[1]):
+ self.block2[i].drop_path.drop_prob = dpr[cur + i]
+
+ cur += self.depths[1]
+ for i in range(self.depths[2]):
+ self.block3[i].drop_path.drop_prob = dpr[cur + i]
+
+ cur += self.depths[2]
+ for i in range(self.depths[3]):
+ self.block4[i].drop_path.drop_prob = dpr[cur + i]
+
+ def freeze_patch_emb(self):
+ self.patch_embed1.requires_grad = False
+
+ @torch.jit.ignore
+ def no_weight_decay(self):
+ return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'} # has pos_embed may be better
+
+ def get_classifier(self):
+ return self.head
+
+ def reset_classifier(self, num_classes, global_pool=''):
+ self.num_classes = num_classes
+ self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
+
+ def forward_features(self, x):
+ B = x.shape[0]
+ outs = []
+
+ # stage 1
+ x, H, W = self.patch_embed1(x)
+ for i, blk in enumerate(self.block1):
+ x = blk(x, H, W)
+ x = self.norm1(x)
+ x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
+ outs.append(x)
+
+ # stage 2
+ x, H, W = self.patch_embed2(x)
+ for i, blk in enumerate(self.block2):
+ x = blk(x, H, W)
+ x = self.norm2(x)
+ x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
+ outs.append(x)
+
+ # stage 3
+ x, H, W = self.patch_embed3(x)
+ for i, blk in enumerate(self.block3):
+ x = blk(x, H, W)
+ x = self.norm3(x)
+ x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
+ outs.append(x)
+
+ # stage 4
+ x, H, W = self.patch_embed4(x)
+ for i, blk in enumerate(self.block4):
+ x = blk(x, H, W)
+ x = self.norm4(x)
+ x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
+ outs.append(x)
+
+ return outs
+
+ # return x.mean(dim=1)
+
+ def forward(self, x):
+ x = self.forward_features(x)
+ # x = self.head(x)
+
+ return x
+
+
+class DWConv(nn.Module):
+ def __init__(self, dim=768):
+ super(DWConv, self).__init__()
+ self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim)
+
+ def forward(self, x, H, W):
+ B, N, C = x.shape
+ x = x.transpose(1, 2).view(B, C, H, W).contiguous()
+ x = self.dwconv(x)
+ x = x.flatten(2).transpose(1, 2)
+
+ return x
+
+
+def _conv_filter(state_dict, patch_size=16):
+ """ convert patch embedding weight from manual patchify + linear proj to conv"""
+ out_dict = {}
+ for k, v in state_dict.items():
+ if 'patch_embed.proj.weight' in k:
+ v = v.reshape((v.shape[0], 3, patch_size, patch_size))
+ out_dict[k] = v
+
+ return out_dict
+
+
+## @register_model
+class pvt_v2_b0(PyramidVisionTransformerImpr):
+ def __init__(self, **kwargs):
+ super(pvt_v2_b0, self).__init__(
+ patch_size=4, embed_dims=[32, 64, 160, 256], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 2, 2], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1)
+
+
+
+## @register_model
+class pvt_v2_b1(PyramidVisionTransformerImpr):
+ def __init__(self, **kwargs):
+ super(pvt_v2_b1, self).__init__(
+ patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 2, 2], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1)
+
+## @register_model
+class pvt_v2_b2(PyramidVisionTransformerImpr):
+ def __init__(self, in_channels=3, **kwargs):
+ super(pvt_v2_b2, self).__init__(
+ patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1, in_channels=in_channels)
+
+## @register_model
+class pvt_v2_b3(PyramidVisionTransformerImpr):
+ def __init__(self, **kwargs):
+ super(pvt_v2_b3, self).__init__(
+ patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 4, 18, 3], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1)
+
+## @register_model
+class pvt_v2_b4(PyramidVisionTransformerImpr):
+ def __init__(self, **kwargs):
+ super(pvt_v2_b4, self).__init__(
+ patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 8, 27, 3], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1)
+
+
+## @register_model
+class pvt_v2_b5(PyramidVisionTransformerImpr):
+ def __init__(self, **kwargs):
+ super(pvt_v2_b5, self).__init__(
+ patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[4, 4, 4, 4],
+ qkv_bias=True, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 6, 40, 3], sr_ratios=[8, 4, 2, 1],
+ drop_rate=0.0, drop_path_rate=0.1)
+
+
+
+### models/backbones/swin_v1.py
+
+# --------------------------------------------------------
+# Swin Transformer
+# Copyright (c) 2021 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ze Liu, Yutong Lin, Yixuan Wei
+# --------------------------------------------------------
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import numpy as np
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+# from config import Config
+
+
+# config = Config()
+
+class Mlp(nn.Module):
+ """ Multilayer perceptron."""
+
+ def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.fc1 = nn.Linear(in_features, hidden_features)
+ self.act = act_layer()
+ self.fc2 = nn.Linear(hidden_features, out_features)
+ self.drop = nn.Dropout(drop)
+
+ def forward(self, x):
+ x = self.fc1(x)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
+
+
+def window_partition(x, window_size):
+ """
+ Args:
+ x: (B, H, W, C)
+ window_size (int): window size
+
+ Returns:
+ windows: (num_windows*B, window_size, window_size, C)
+ """
+ B, H, W, C = x.shape
+ x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+ windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+ return windows
+
+
+def window_reverse(windows, window_size, H, W):
+ """
+ Args:
+ windows: (num_windows*B, window_size, window_size, C)
+ window_size (int): Window size
+ H (int): Height of image
+ W (int): Width of image
+
+ Returns:
+ x: (B, H, W, C)
+ """
+ B = int(windows.shape[0] / (H * W / window_size / window_size))
+ x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+ x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+ return x
+
+
+class WindowAttention(nn.Module):
+ """ Window based multi-head self attention (W-MSA) module with relative position bias.
+ It supports both of shifted and non-shifted window.
+
+ Args:
+ dim (int): Number of input channels.
+ window_size (tuple[int]): The height and width of the window.
+ num_heads (int): Number of attention heads.
+ qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+ qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+ attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+ proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+ """
+
+ def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+ super().__init__()
+ self.dim = dim
+ self.window_size = window_size # Wh, Ww
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = qk_scale or head_dim ** -0.5
+
+ # define a parameter table of relative position bias
+ self.relative_position_bias_table = nn.Parameter(
+ torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2*Wh-1 * 2*Ww-1, nH
+
+ # get pair-wise relative position index for each token inside the window
+ coords_h = torch.arange(self.window_size[0])
+ coords_w = torch.arange(self.window_size[1])
+ coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing='ij')) # 2, Wh, Ww
+ coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
+ relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
+ relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0
+ relative_coords[:, :, 1] += self.window_size[1] - 1
+ relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+ relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww
+ self.register_buffer("relative_position_index", relative_position_index)
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.attn_drop_prob = attn_drop
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop)
+
+ trunc_normal_(self.relative_position_bias_table, std=.02)
+ self.softmax = nn.Softmax(dim=-1)
+
+ def forward(self, x, mask=None):
+ """ Forward function.
+
+ Args:
+ x: input features with shape of (num_windows*B, N, C)
+ mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+ """
+ B_, N, C = x.shape
+ qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+ q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
+
+ q = q * self.scale
+
+ if config.SDPA_enabled:
+ x = torch.nn.functional.scaled_dot_product_attention(
+ q, k, v,
+ attn_mask=None, dropout_p=self.attn_drop_prob, is_causal=False
+ ).transpose(1, 2).reshape(B_, N, C)
+ else:
+ attn = (q @ k.transpose(-2, -1))
+
+ relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+ self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH
+ relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
+ attn = attn + relative_position_bias.unsqueeze(0)
+
+ if mask is not None:
+ nW = mask.shape[0]
+ attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+ attn = attn.view(-1, self.num_heads, N, N)
+ attn = self.softmax(attn)
+ else:
+ attn = self.softmax(attn)
+
+ attn = self.attn_drop(attn)
+
+ x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
+
+
+class SwinTransformerBlock(nn.Module):
+ """ Swin Transformer Block.
+
+ Args:
+ dim (int): Number of input channels.
+ num_heads (int): Number of attention heads.
+ window_size (int): Window size.
+ shift_size (int): Shift size for SW-MSA.
+ mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+ qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+ qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+ drop (float, optional): Dropout rate. Default: 0.0
+ attn_drop (float, optional): Attention dropout rate. Default: 0.0
+ drop_path (float, optional): Stochastic depth rate. Default: 0.0
+ act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+ norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+ """
+
+ def __init__(self, dim, num_heads, window_size=7, shift_size=0,
+ mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+ act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+ super().__init__()
+ self.dim = dim
+ self.num_heads = num_heads
+ self.window_size = window_size
+ self.shift_size = shift_size
+ self.mlp_ratio = mlp_ratio
+ assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+ self.norm1 = norm_layer(dim)
+ self.attn = WindowAttention(
+ dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
+ qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+ self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+ self.norm2 = norm_layer(dim)
+ mlp_hidden_dim = int(dim * mlp_ratio)
+ self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+ self.H = None
+ self.W = None
+
+ def forward(self, x, mask_matrix):
+ """ Forward function.
+
+ Args:
+ x: Input feature, tensor size (B, H*W, C).
+ H, W: Spatial resolution of the input feature.
+ mask_matrix: Attention mask for cyclic shift.
+ """
+ B, L, C = x.shape
+ H, W = self.H, self.W
+ assert L == H * W, "input feature has wrong size"
+
+ shortcut = x
+ x = self.norm1(x)
+ x = x.view(B, H, W, C)
+
+ # pad feature maps to multiples of window size
+ pad_l = pad_t = 0
+ pad_r = (self.window_size - W % self.window_size) % self.window_size
+ pad_b = (self.window_size - H % self.window_size) % self.window_size
+ x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
+ _, Hp, Wp, _ = x.shape
+
+ # cyclic shift
+ if self.shift_size > 0:
+ shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+ attn_mask = mask_matrix
+ else:
+ shifted_x = x
+ attn_mask = None
+
+ # partition windows
+ x_windows = window_partition(shifted_x, self.window_size) # nW*B, window_size, window_size, C
+ x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C
+
+ # W-MSA/SW-MSA
+ attn_windows = self.attn(x_windows, mask=attn_mask) # nW*B, window_size*window_size, C
+
+ # merge windows
+ attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
+ shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp) # B H' W' C
+
+ # reverse cyclic shift
+ if self.shift_size > 0:
+ x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+ else:
+ x = shifted_x
+
+ if pad_r > 0 or pad_b > 0:
+ x = x[:, :H, :W, :].contiguous()
+
+ x = x.view(B, H * W, C)
+
+ # FFN
+ x = shortcut + self.drop_path(x)
+ x = x + self.drop_path(self.mlp(self.norm2(x)))
+
+ return x
+
+
+class PatchMerging(nn.Module):
+ """ Patch Merging Layer
+
+ Args:
+ dim (int): Number of input channels.
+ norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+ """
+ def __init__(self, dim, norm_layer=nn.LayerNorm):
+ super().__init__()
+ self.dim = dim
+ self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+ self.norm = norm_layer(4 * dim)
+
+ def forward(self, x, H, W):
+ """ Forward function.
+
+ Args:
+ x: Input feature, tensor size (B, H*W, C).
+ H, W: Spatial resolution of the input feature.
+ """
+ B, L, C = x.shape
+ assert L == H * W, "input feature has wrong size"
+
+ x = x.view(B, H, W, C)
+
+ # padding
+ pad_input = (H % 2 == 1) or (W % 2 == 1)
+ if pad_input:
+ x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
+
+ x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C
+ x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C
+ x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C
+ x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C
+ x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C
+ x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C
+
+ x = self.norm(x)
+ x = self.reduction(x)
+
+ return x
+
+
+class BasicLayer(nn.Module):
+ """ A basic Swin Transformer layer for one stage.
+
+ Args:
+ dim (int): Number of feature channels
+ depth (int): Depths of this stage.
+ num_heads (int): Number of attention head.
+ window_size (int): Local window size. Default: 7.
+ mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
+ qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+ qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+ drop (float, optional): Dropout rate. Default: 0.0
+ attn_drop (float, optional): Attention dropout rate. Default: 0.0
+ drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+ norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+ downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+ use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+ """
+
+ def __init__(self,
+ dim,
+ depth,
+ num_heads,
+ window_size=7,
+ mlp_ratio=4.,
+ qkv_bias=True,
+ qk_scale=None,
+ drop=0.,
+ attn_drop=0.,
+ drop_path=0.,
+ norm_layer=nn.LayerNorm,
+ downsample=None,
+ use_checkpoint=False):
+ super().__init__()
+ self.window_size = window_size
+ self.shift_size = window_size // 2
+ self.depth = depth
+ self.use_checkpoint = use_checkpoint
+
+ # build blocks
+ self.blocks = nn.ModuleList([
+ SwinTransformerBlock(
+ dim=dim,
+ num_heads=num_heads,
+ window_size=window_size,
+ shift_size=0 if (i % 2 == 0) else window_size // 2,
+ mlp_ratio=mlp_ratio,
+ qkv_bias=qkv_bias,
+ qk_scale=qk_scale,
+ drop=drop,
+ attn_drop=attn_drop,
+ drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+ norm_layer=norm_layer)
+ for i in range(depth)])
+
+ # patch merging layer
+ if downsample is not None:
+ self.downsample = downsample(dim=dim, norm_layer=norm_layer)
+ else:
+ self.downsample = None
+
+ def forward(self, x, H, W):
+ """ Forward function.
+
+ Args:
+ x: Input feature, tensor size (B, H*W, C).
+ H, W: Spatial resolution of the input feature.
+ """
+
+ # calculate attention mask for SW-MSA
+ Hp = int(np.ceil(H / self.window_size)) * self.window_size
+ Wp = int(np.ceil(W / self.window_size)) * self.window_size
+ img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device) # 1 Hp Wp 1
+ h_slices = (slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None))
+ w_slices = (slice(0, -self.window_size),
+ slice(-self.window_size, -self.shift_size),
+ slice(-self.shift_size, None))
+ cnt = 0
+ for h in h_slices:
+ for w in w_slices:
+ img_mask[:, h, w, :] = cnt
+ cnt += 1
+
+ mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1
+ mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+ attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+ attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+
+ for blk in self.blocks:
+ blk.H, blk.W = H, W
+ if self.use_checkpoint:
+ x = checkpoint.checkpoint(blk, x, attn_mask)
+ else:
+ x = blk(x, attn_mask)
+ if self.downsample is not None:
+ x_down = self.downsample(x, H, W)
+ Wh, Ww = (H + 1) // 2, (W + 1) // 2
+ return x, H, W, x_down, Wh, Ww
+ else:
+ return x, H, W, x, H, W
+
+
+class PatchEmbed(nn.Module):
+ """ Image to Patch Embedding
+
+ Args:
+ patch_size (int): Patch token size. Default: 4.
+ in_channels (int): Number of input image channels. Default: 3.
+ embed_dim (int): Number of linear projection output channels. Default: 96.
+ norm_layer (nn.Module, optional): Normalization layer. Default: None
+ """
+
+ def __init__(self, patch_size=4, in_channels=3, embed_dim=96, norm_layer=None):
+ super().__init__()
+ patch_size = to_2tuple(patch_size)
+ self.patch_size = patch_size
+
+ self.in_channels = in_channels
+ self.embed_dim = embed_dim
+
+ self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size)
+ if norm_layer is not None:
+ self.norm = norm_layer(embed_dim)
+ else:
+ self.norm = None
+
+ def forward(self, x):
+ """Forward function."""
+ # padding
+ _, _, H, W = x.size()
+ if W % self.patch_size[1] != 0:
+ x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1]))
+ if H % self.patch_size[0] != 0:
+ x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0]))
+
+ x = self.proj(x) # B C Wh Ww
+ if self.norm is not None:
+ Wh, Ww = x.size(2), x.size(3)
+ x = x.flatten(2).transpose(1, 2)
+ x = self.norm(x)
+ x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww)
+
+ return x
+
+
+class SwinTransformer(nn.Module):
+ """ Swin Transformer backbone.
+ A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -
+ https://arxiv.org/pdf/2103.14030
+
+ Args:
+ pretrain_img_size (int): Input image size for training the pretrained model,
+ used in absolute postion embedding. Default 224.
+ patch_size (int | tuple(int)): Patch size. Default: 4.
+ in_channels (int): Number of input image channels. Default: 3.
+ embed_dim (int): Number of linear projection output channels. Default: 96.
+ depths (tuple[int]): Depths of each Swin Transformer stage.
+ num_heads (tuple[int]): Number of attention head of each stage.
+ window_size (int): Window size. Default: 7.
+ mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
+ qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+ qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
+ drop_rate (float): Dropout rate.
+ attn_drop_rate (float): Attention dropout rate. Default: 0.
+ drop_path_rate (float): Stochastic depth rate. Default: 0.2.
+ norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+ ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
+ patch_norm (bool): If True, add normalization after patch embedding. Default: True.
+ out_indices (Sequence[int]): Output from which stages.
+ frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+ -1 means not freezing any parameters.
+ use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+ """
+
+ def __init__(self,
+ pretrain_img_size=224,
+ patch_size=4,
+ in_channels=3,
+ embed_dim=96,
+ depths=[2, 2, 6, 2],
+ num_heads=[3, 6, 12, 24],
+ window_size=7,
+ mlp_ratio=4.,
+ qkv_bias=True,
+ qk_scale=None,
+ drop_rate=0.,
+ attn_drop_rate=0.,
+ drop_path_rate=0.2,
+ norm_layer=nn.LayerNorm,
+ ape=False,
+ patch_norm=True,
+ out_indices=(0, 1, 2, 3),
+ frozen_stages=-1,
+ use_checkpoint=False):
+ super().__init__()
+
+ self.pretrain_img_size = pretrain_img_size
+ self.num_layers = len(depths)
+ self.embed_dim = embed_dim
+ self.ape = ape
+ self.patch_norm = patch_norm
+ self.out_indices = out_indices
+ self.frozen_stages = frozen_stages
+
+ # split image into non-overlapping patches
+ self.patch_embed = PatchEmbed(
+ patch_size=patch_size, in_channels=in_channels, embed_dim=embed_dim,
+ norm_layer=norm_layer if self.patch_norm else None)
+
+ # absolute position embedding
+ if self.ape:
+ pretrain_img_size = to_2tuple(pretrain_img_size)
+ patch_size = to_2tuple(patch_size)
+ patches_resolution = [pretrain_img_size[0] // patch_size[0], pretrain_img_size[1] // patch_size[1]]
+
+ self.absolute_pos_embed = nn.Parameter(torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1]))
+ trunc_normal_(self.absolute_pos_embed, std=.02)
+
+ self.pos_drop = nn.Dropout(p=drop_rate)
+
+ # stochastic depth
+ dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
+
+ # build layers
+ self.layers = nn.ModuleList()
+ for i_layer in range(self.num_layers):
+ layer = BasicLayer(
+ dim=int(embed_dim * 2 ** i_layer),
+ depth=depths[i_layer],
+ num_heads=num_heads[i_layer],
+ window_size=window_size,
+ mlp_ratio=mlp_ratio,
+ qkv_bias=qkv_bias,
+ qk_scale=qk_scale,
+ drop=drop_rate,
+ attn_drop=attn_drop_rate,
+ drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+ norm_layer=norm_layer,
+ downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
+ use_checkpoint=use_checkpoint)
+ self.layers.append(layer)
+
+ num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
+ self.num_features = num_features
+
+ # add a norm layer for each output
+ for i_layer in out_indices:
+ layer = norm_layer(num_features[i_layer])
+ layer_name = f'norm{i_layer}'
+ self.add_module(layer_name, layer)
+
+ self._freeze_stages()
+
+ def _freeze_stages(self):
+ if self.frozen_stages >= 0:
+ self.patch_embed.eval()
+ for param in self.patch_embed.parameters():
+ param.requires_grad = False
+
+ if self.frozen_stages >= 1 and self.ape:
+ self.absolute_pos_embed.requires_grad = False
+
+ if self.frozen_stages >= 2:
+ self.pos_drop.eval()
+ for i in range(0, self.frozen_stages - 1):
+ m = self.layers[i]
+ m.eval()
+ for param in m.parameters():
+ param.requires_grad = False
+
+
+ def forward(self, x):
+ """Forward function."""
+ x = self.patch_embed(x)
+
+ Wh, Ww = x.size(2), x.size(3)
+ if self.ape:
+ # interpolate the position embedding to the corresponding size
+ absolute_pos_embed = F.interpolate(self.absolute_pos_embed, size=(Wh, Ww), mode='bicubic')
+ x = (x + absolute_pos_embed) # B Wh*Ww C
+
+ outs = []#x.contiguous()]
+ x = x.flatten(2).transpose(1, 2)
+ x = self.pos_drop(x)
+ for i in range(self.num_layers):
+ layer = self.layers[i]
+ x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
+
+ if i in self.out_indices:
+ norm_layer = getattr(self, f'norm{i}')
+ x_out = norm_layer(x_out)
+
+ out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
+ outs.append(out)
+
+ return tuple(outs)
+
+ def train(self, mode=True):
+ """Convert the model into training mode while keep layers freezed."""
+ super(SwinTransformer, self).train(mode)
+ self._freeze_stages()
+
+def swin_v1_t():
+ model = SwinTransformer(embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], window_size=7)
+ return model
+
+def swin_v1_s():
+ model = SwinTransformer(embed_dim=96, depths=[2, 2, 18, 2], num_heads=[3, 6, 12, 24], window_size=7)
+ return model
+
+def swin_v1_b():
+ model = SwinTransformer(embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32], window_size=12)
+ return model
+
+def swin_v1_l():
+ model = SwinTransformer(embed_dim=192, depths=[2, 2, 18, 2], num_heads=[6, 12, 24, 48], window_size=12)
+ return model
+
+
+
+### models/modules/deform_conv.py
+
+import torch
+import torch.nn as nn
+from torchvision.ops import deform_conv2d
+
+
+class DeformableConv2d(nn.Module):
+ def __init__(self,
+ in_channels,
+ out_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ bias=False):
+
+ super(DeformableConv2d, self).__init__()
+
+ assert type(kernel_size) == tuple or type(kernel_size) == int
+
+ kernel_size = kernel_size if type(kernel_size) == tuple else (kernel_size, kernel_size)
+ self.stride = stride if type(stride) == tuple else (stride, stride)
+ self.padding = padding
+
+ self.offset_conv = nn.Conv2d(in_channels,
+ 2 * kernel_size[0] * kernel_size[1],
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=self.padding,
+ bias=True)
+
+ nn.init.constant_(self.offset_conv.weight, 0.)
+ nn.init.constant_(self.offset_conv.bias, 0.)
+
+ self.modulator_conv = nn.Conv2d(in_channels,
+ 1 * kernel_size[0] * kernel_size[1],
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=self.padding,
+ bias=True)
+
+ nn.init.constant_(self.modulator_conv.weight, 0.)
+ nn.init.constant_(self.modulator_conv.bias, 0.)
+
+ self.regular_conv = nn.Conv2d(in_channels,
+ out_channels=out_channels,
+ kernel_size=kernel_size,
+ stride=stride,
+ padding=self.padding,
+ bias=bias)
+
+ def forward(self, x):
+ #h, w = x.shape[2:]
+ #max_offset = max(h, w)/4.
+
+ offset = self.offset_conv(x)#.clamp(-max_offset, max_offset)
+ modulator = 2. * torch.sigmoid(self.modulator_conv(x))
+
+ x = deform_conv2d(
+ input=x,
+ offset=offset,
+ weight=self.regular_conv.weight,
+ bias=self.regular_conv.bias,
+ padding=self.padding,
+ mask=modulator,
+ stride=self.stride,
+ )
+ return x
+
+
+
+
+### utils.py
+
+import torch.nn as nn
+
+
+def build_act_layer(act_layer):
+ if act_layer == 'ReLU':
+ return nn.ReLU(inplace=True)
+ elif act_layer == 'SiLU':
+ return nn.SiLU(inplace=True)
+ elif act_layer == 'GELU':
+ return nn.GELU()
+
+ raise NotImplementedError(f'build_act_layer does not support {act_layer}')
+
+
+def build_norm_layer(dim,
+ norm_layer,
+ in_format='channels_last',
+ out_format='channels_last',
+ eps=1e-6):
+ layers = []
+ if norm_layer == 'BN':
+ if in_format == 'channels_last':
+ layers.append(to_channels_first())
+ layers.append(nn.BatchNorm2d(dim))
+ if out_format == 'channels_last':
+ layers.append(to_channels_last())
+ elif norm_layer == 'LN':
+ if in_format == 'channels_first':
+ layers.append(to_channels_last())
+ layers.append(nn.LayerNorm(dim, eps=eps))
+ if out_format == 'channels_first':
+ layers.append(to_channels_first())
+ else:
+ raise NotImplementedError(
+ f'build_norm_layer does not support {norm_layer}')
+ return nn.Sequential(*layers)
+
+
+class to_channels_first(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ return x.permute(0, 3, 1, 2)
+
+
+class to_channels_last(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+
+ def forward(self, x):
+ return x.permute(0, 2, 3, 1)
+
+
+
+### dataset.py
+
+_class_labels_TR_sorted = (
+ 'Airplane, Ant, Antenna, Archery, Axe, BabyCarriage, Bag, BalanceBeam, Balcony, Balloon, Basket, BasketballHoop, Beatle, Bed, Bee, Bench, Bicycle, '
+ 'BicycleFrame, BicycleStand, Boat, Bonsai, BoomLift, Bridge, BunkBed, Butterfly, Button, Cable, CableLift, Cage, Camcorder, Cannon, Canoe, Car, '
+ 'CarParkDropArm, Carriage, Cart, Caterpillar, CeilingLamp, Centipede, Chair, Clip, Clock, Clothes, CoatHanger, Comb, ConcretePumpTruck, Crack, Crane, '
+ 'Cup, DentalChair, Desk, DeskChair, Diagram, DishRack, DoorHandle, Dragonfish, Dragonfly, Drum, Earphone, Easel, ElectricIron, Excavator, Eyeglasses, '
+ 'Fan, Fence, Fencing, FerrisWheel, FireExtinguisher, Fishing, Flag, FloorLamp, Forklift, GasStation, Gate, Gear, Goal, Golf, GymEquipment, Hammock, '
+ 'Handcart, Handcraft, Handrail, HangGlider, Harp, Harvester, Headset, Helicopter, Helmet, Hook, HorizontalBar, Hydrovalve, IroningTable, Jewelry, Key, '
+ 'KidsPlayground, Kitchenware, Kite, Knife, Ladder, LaundryRack, Lightning, Lobster, Locust, Machine, MachineGun, MagazineRack, Mantis, Medal, MemorialArchway, '
+ 'Microphone, Missile, MobileHolder, Monitor, Mosquito, Motorcycle, MovingTrolley, Mower, MusicPlayer, MusicStand, ObservationTower, Octopus, OilWell, '
+ 'OlympicLogo, OperatingTable, OutdoorFitnessEquipment, Parachute, Pavilion, Piano, Pipe, PlowHarrow, PoleVault, Punchbag, Rack, Racket, Rifle, Ring, Robot, '
+ 'RockClimbing, Rope, Sailboat, Satellite, Scaffold, Scale, Scissor, Scooter, Sculpture, Seadragon, Seahorse, Seal, SewingMachine, Ship, Shoe, ShoppingCart, '
+ 'ShoppingTrolley, Shower, Shrimp, Signboard, Skateboarding, Skeleton, Skiing, Spade, SpeedBoat, Spider, Spoon, Stair, Stand, Stationary, SteeringWheel, '
+ 'Stethoscope, Stool, Stove, StreetLamp, SweetStand, Swing, Sword, TV, Table, TableChair, TableLamp, TableTennis, Tank, Tapeline, Teapot, Telescope, Tent, '
+ 'TobaccoPipe, Toy, Tractor, TrafficLight, TrafficSign, Trampoline, TransmissionTower, Tree, Tricycle, TrimmerCover, Tripod, Trombone, Truck, Trumpet, Tuba, '
+ 'UAV, Umbrella, UnevenBars, UtilityPole, VacuumCleaner, Violin, Wakesurfing, Watch, WaterTower, WateringPot, Well, WellLid, Wheel, Wheelchair, WindTurbine, Windmill, WineGlass, WireWhisk, Yacht'
+)
+class_labels_TR_sorted = _class_labels_TR_sorted.split(', ')
+
+
+### models/backbones/build_backbones.py
+
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+from torchvision.models import vgg16, vgg16_bn, VGG16_Weights, VGG16_BN_Weights, resnet50, ResNet50_Weights
+# from models.pvt_v2 import pvt_v2_b0, pvt_v2_b1, pvt_v2_b2, pvt_v2_b5
+# from models.swin_v1 import swin_v1_t, swin_v1_s, swin_v1_b, swin_v1_l
+# from config import Config
+
+
+config = Config()
+
+def build_backbone(bb_name, pretrained=True, params_settings=''):
+ if bb_name == 'vgg16':
+ bb_net = list(vgg16(pretrained=VGG16_Weights.DEFAULT if pretrained else None).children())[0]
+ bb = nn.Sequential(OrderedDict({'conv1': bb_net[:4], 'conv2': bb_net[4:9], 'conv3': bb_net[9:16], 'conv4': bb_net[16:23]}))
+ elif bb_name == 'vgg16bn':
+ bb_net = list(vgg16_bn(pretrained=VGG16_BN_Weights.DEFAULT if pretrained else None).children())[0]
+ bb = nn.Sequential(OrderedDict({'conv1': bb_net[:6], 'conv2': bb_net[6:13], 'conv3': bb_net[13:23], 'conv4': bb_net[23:33]}))
+ elif bb_name == 'resnet50':
+ bb_net = list(resnet50(pretrained=ResNet50_Weights.DEFAULT if pretrained else None).children())
+ bb = nn.Sequential(OrderedDict({'conv1': nn.Sequential(*bb_net[0:3]), 'conv2': bb_net[4], 'conv3': bb_net[5], 'conv4': bb_net[6]}))
+ else:
+ bb = eval('{}({})'.format(bb_name, params_settings))
+ if pretrained:
+ bb = load_weights(bb, bb_name)
+ return bb
+
+def load_weights(model, model_name):
+ save_model = torch.load(config.weights[model_name], map_location='cpu')
+ model_dict = model.state_dict()
+ state_dict = {k: v if v.size() == model_dict[k].size() else model_dict[k] for k, v in save_model.items() if k in model_dict.keys()}
+ # to ignore the weights with mismatched size when I modify the backbone itself.
+ if not state_dict:
+ save_model_keys = list(save_model.keys())
+ sub_item = save_model_keys[0] if len(save_model_keys) == 1 else None
+ state_dict = {k: v if v.size() == model_dict[k].size() else model_dict[k] for k, v in save_model[sub_item].items() if k in model_dict.keys()}
+ if not state_dict or not sub_item:
+ print('Weights are not successully loaded. Check the state dict of weights file.')
+ return None
+ else:
+ print('Found correct weights in the "{}" item of loaded state_dict.'.format(sub_item))
+ model_dict.update(state_dict)
+ model.load_state_dict(model_dict)
+ return model
+
+
+
+### models/modules/decoder_blocks.py
+
+import torch
+import torch.nn as nn
+# from models.aspp import ASPP, ASPPDeformable
+# from config import Config
+
+
+# config = Config()
+
+
+class BasicDecBlk(nn.Module):
+ def __init__(self, in_channels=64, out_channels=64, inter_channels=64):
+ super(BasicDecBlk, self).__init__()
+ inter_channels = in_channels // 4 if config.dec_channels_inter == 'adap' else 64
+ self.conv_in = nn.Conv2d(in_channels, inter_channels, 3, 1, padding=1)
+ self.relu_in = nn.ReLU(inplace=True)
+ if config.dec_att == 'ASPP':
+ self.dec_att = ASPP(in_channels=inter_channels)
+ elif config.dec_att == 'ASPPDeformable':
+ self.dec_att = ASPPDeformable(in_channels=inter_channels)
+ self.conv_out = nn.Conv2d(inter_channels, out_channels, 3, 1, padding=1)
+ self.bn_in = nn.BatchNorm2d(inter_channels) if config.batch_size > 1 else nn.Identity()
+ self.bn_out = nn.BatchNorm2d(out_channels) if config.batch_size > 1 else nn.Identity()
+
+ def forward(self, x):
+ x = self.conv_in(x)
+ x = self.bn_in(x)
+ x = self.relu_in(x)
+ if hasattr(self, 'dec_att'):
+ x = self.dec_att(x)
+ x = self.conv_out(x)
+ x = self.bn_out(x)
+ return x
+
+
+class ResBlk(nn.Module):
+ def __init__(self, in_channels=64, out_channels=None, inter_channels=64):
+ super(ResBlk, self).__init__()
+ if out_channels is None:
+ out_channels = in_channels
+ inter_channels = in_channels // 4 if config.dec_channels_inter == 'adap' else 64
+
+ self.conv_in = nn.Conv2d(in_channels, inter_channels, 3, 1, padding=1)
+ self.bn_in = nn.BatchNorm2d(inter_channels) if config.batch_size > 1 else nn.Identity()
+ self.relu_in = nn.ReLU(inplace=True)
+
+ if config.dec_att == 'ASPP':
+ self.dec_att = ASPP(in_channels=inter_channels)
+ elif config.dec_att == 'ASPPDeformable':
+ self.dec_att = ASPPDeformable(in_channels=inter_channels)
+
+ self.conv_out = nn.Conv2d(inter_channels, out_channels, 3, 1, padding=1)
+ self.bn_out = nn.BatchNorm2d(out_channels) if config.batch_size > 1 else nn.Identity()
+
+ self.conv_resi = nn.Conv2d(in_channels, out_channels, 1, 1, 0)
+
+ def forward(self, x):
+ _x = self.conv_resi(x)
+ x = self.conv_in(x)
+ x = self.bn_in(x)
+ x = self.relu_in(x)
+ if hasattr(self, 'dec_att'):
+ x = self.dec_att(x)
+ x = self.conv_out(x)
+ x = self.bn_out(x)
+ return x + _x
+
+
+
+### models/modules/lateral_blocks.py
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from functools import partial
+
+# from config import Config
+
+
+# config = Config()
+
+
+class BasicLatBlk(nn.Module):
+ def __init__(self, in_channels=64, out_channels=64, inter_channels=64):
+ super(BasicLatBlk, self).__init__()
+ inter_channels = in_channels // 4 if config.dec_channels_inter == 'adap' else 64
+ self.conv = nn.Conv2d(in_channels, out_channels, 1, 1, 0)
+
+ def forward(self, x):
+ x = self.conv(x)
+ return x
+
+
+
+### models/modules/aspp.py
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+# from models.deform_conv import DeformableConv2d
+# from config import Config
+
+
+# config = Config()
+
+
+class _ASPPModule(nn.Module):
+ def __init__(self, in_channels, planes, kernel_size, padding, dilation):
+ super(_ASPPModule, self).__init__()
+ self.atrous_conv = nn.Conv2d(in_channels, planes, kernel_size=kernel_size,
+ stride=1, padding=padding, dilation=dilation, bias=False)
+ self.bn = nn.BatchNorm2d(planes) if config.batch_size > 1 else nn.Identity()
+ self.relu = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ x = self.atrous_conv(x)
+ x = self.bn(x)
+
+ return self.relu(x)
+
+
+class ASPP(nn.Module):
+ def __init__(self, in_channels=64, out_channels=None, output_stride=16):
+ super(ASPP, self).__init__()
+ self.down_scale = 1
+ if out_channels is None:
+ out_channels = in_channels
+ self.in_channelster = 256 // self.down_scale
+ if output_stride == 16:
+ dilations = [1, 6, 12, 18]
+ elif output_stride == 8:
+ dilations = [1, 12, 24, 36]
+ else:
+ raise NotImplementedError
+
+ self.aspp1 = _ASPPModule(in_channels, self.in_channelster, 1, padding=0, dilation=dilations[0])
+ self.aspp2 = _ASPPModule(in_channels, self.in_channelster, 3, padding=dilations[1], dilation=dilations[1])
+ self.aspp3 = _ASPPModule(in_channels, self.in_channelster, 3, padding=dilations[2], dilation=dilations[2])
+ self.aspp4 = _ASPPModule(in_channels, self.in_channelster, 3, padding=dilations[3], dilation=dilations[3])
+
+ self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
+ nn.Conv2d(in_channels, self.in_channelster, 1, stride=1, bias=False),
+ nn.BatchNorm2d(self.in_channelster) if config.batch_size > 1 else nn.Identity(),
+ nn.ReLU(inplace=True))
+ self.conv1 = nn.Conv2d(self.in_channelster * 5, out_channels, 1, bias=False)
+ self.bn1 = nn.BatchNorm2d(out_channels) if config.batch_size > 1 else nn.Identity()
+ self.relu = nn.ReLU(inplace=True)
+ self.dropout = nn.Dropout(0.5)
+
+ def forward(self, x):
+ x1 = self.aspp1(x)
+ x2 = self.aspp2(x)
+ x3 = self.aspp3(x)
+ x4 = self.aspp4(x)
+ x5 = self.global_avg_pool(x)
+ x5 = F.interpolate(x5, size=x1.size()[2:], mode='bilinear', align_corners=True)
+ x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+ x = self.conv1(x)
+ x = self.bn1(x)
+ x = self.relu(x)
+
+ return self.dropout(x)
+
+
+##################### Deformable
+class _ASPPModuleDeformable(nn.Module):
+ def __init__(self, in_channels, planes, kernel_size, padding):
+ super(_ASPPModuleDeformable, self).__init__()
+ self.atrous_conv = DeformableConv2d(in_channels, planes, kernel_size=kernel_size,
+ stride=1, padding=padding, bias=False)
+ self.bn = nn.BatchNorm2d(planes) if config.batch_size > 1 else nn.Identity()
+ self.relu = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ x = self.atrous_conv(x)
+ x = self.bn(x)
+
+ return self.relu(x)
+
+
+class ASPPDeformable(nn.Module):
+ def __init__(self, in_channels, out_channels=None, parallel_block_sizes=[1, 3, 7]):
+ super(ASPPDeformable, self).__init__()
+ self.down_scale = 1
+ if out_channels is None:
+ out_channels = in_channels
+ self.in_channelster = 256 // self.down_scale
+
+ self.aspp1 = _ASPPModuleDeformable(in_channels, self.in_channelster, 1, padding=0)
+ self.aspp_deforms = nn.ModuleList([
+ _ASPPModuleDeformable(in_channels, self.in_channelster, conv_size, padding=int(conv_size//2)) for conv_size in parallel_block_sizes
+ ])
+
+ self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
+ nn.Conv2d(in_channels, self.in_channelster, 1, stride=1, bias=False),
+ nn.BatchNorm2d(self.in_channelster) if config.batch_size > 1 else nn.Identity(),
+ nn.ReLU(inplace=True))
+ self.conv1 = nn.Conv2d(self.in_channelster * (2 + len(self.aspp_deforms)), out_channels, 1, bias=False)
+ self.bn1 = nn.BatchNorm2d(out_channels) if config.batch_size > 1 else nn.Identity()
+ self.relu = nn.ReLU(inplace=True)
+ self.dropout = nn.Dropout(0.5)
+
+ def forward(self, x):
+ x1 = self.aspp1(x)
+ x_aspp_deforms = [aspp_deform(x) for aspp_deform in self.aspp_deforms]
+ x5 = self.global_avg_pool(x)
+ x5 = F.interpolate(x5, size=x1.size()[2:], mode='bilinear', align_corners=True)
+ x = torch.cat((x1, *x_aspp_deforms, x5), dim=1)
+
+ x = self.conv1(x)
+ x = self.bn1(x)
+ x = self.relu(x)
+
+ return self.dropout(x)
+
+
+
+### models/refinement/refiner.py
+
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.models import vgg16, vgg16_bn
+from torchvision.models import resnet50
+
+# from config import Config
+# from dataset import class_labels_TR_sorted
+# from models.build_backbone import build_backbone
+# from models.decoder_blocks import BasicDecBlk
+# from models.lateral_blocks import BasicLatBlk
+# from models.ing import *
+# from models.stem_layer import StemLayer
+
+
+class RefinerPVTInChannels4(nn.Module):
+ def __init__(self, in_channels=3+1):
+ super(RefinerPVTInChannels4, self).__init__()
+ self.config = Config()
+ self.epoch = 1
+ self.bb = build_backbone(self.config.bb, params_settings='in_channels=4')
+
+ lateral_channels_in_collection = {
+ 'vgg16': [512, 256, 128, 64], 'vgg16bn': [512, 256, 128, 64], 'resnet50': [1024, 512, 256, 64],
+ 'pvt_v2_b2': [512, 320, 128, 64], 'pvt_v2_b5': [512, 320, 128, 64],
+ 'swin_v1_b': [1024, 512, 256, 128], 'swin_v1_l': [1536, 768, 384, 192],
+ }
+ channels = lateral_channels_in_collection[self.config.bb]
+ self.squeeze_module = BasicDecBlk(channels[0], channels[0])
+
+ self.decoder = Decoder(channels)
+
+ if 0:
+ for key, value in self.named_parameters():
+ if 'bb.' in key:
+ value.requires_grad = False
+
+ def forward(self, x):
+ if isinstance(x, list):
+ x = torch.cat(x, dim=1)
+ ########## Encoder ##########
+ if self.config.bb in ['vgg16', 'vgg16bn', 'resnet50']:
+ x1 = self.bb.conv1(x)
+ x2 = self.bb.conv2(x1)
+ x3 = self.bb.conv3(x2)
+ x4 = self.bb.conv4(x3)
+ else:
+ x1, x2, x3, x4 = self.bb(x)
+
+ x4 = self.squeeze_module(x4)
+
+ ########## Decoder ##########
+
+ features = [x, x1, x2, x3, x4]
+ scaled_preds = self.decoder(features)
+
+ return scaled_preds
+
+
+class Refiner(nn.Module):
+ def __init__(self, in_channels=3+1):
+ super(Refiner, self).__init__()
+ self.config = Config()
+ self.epoch = 1
+ self.stem_layer = StemLayer(in_channels=in_channels, inter_channels=48, out_channels=3, norm_layer='BN' if self.config.batch_size > 1 else 'LN')
+ self.bb = build_backbone(self.config.bb)
+
+ lateral_channels_in_collection = {
+ 'vgg16': [512, 256, 128, 64], 'vgg16bn': [512, 256, 128, 64], 'resnet50': [1024, 512, 256, 64],
+ 'pvt_v2_b2': [512, 320, 128, 64], 'pvt_v2_b5': [512, 320, 128, 64],
+ 'swin_v1_b': [1024, 512, 256, 128], 'swin_v1_l': [1536, 768, 384, 192],
+ }
+ channels = lateral_channels_in_collection[self.config.bb]
+ self.squeeze_module = BasicDecBlk(channels[0], channels[0])
+
+ self.decoder = Decoder(channels)
+
+ if 0:
+ for key, value in self.named_parameters():
+ if 'bb.' in key:
+ value.requires_grad = False
+
+ def forward(self, x):
+ if isinstance(x, list):
+ x = torch.cat(x, dim=1)
+ x = self.stem_layer(x)
+ ########## Encoder ##########
+ if self.config.bb in ['vgg16', 'vgg16bn', 'resnet50']:
+ x1 = self.bb.conv1(x)
+ x2 = self.bb.conv2(x1)
+ x3 = self.bb.conv3(x2)
+ x4 = self.bb.conv4(x3)
+ else:
+ x1, x2, x3, x4 = self.bb(x)
+
+ x4 = self.squeeze_module(x4)
+
+ ########## Decoder ##########
+
+ features = [x, x1, x2, x3, x4]
+ scaled_preds = self.decoder(features)
+
+ return scaled_preds
+
+
+class Decoder(nn.Module):
+ def __init__(self, channels):
+ super(Decoder, self).__init__()
+ self.config = Config()
+ DecoderBlock = eval('BasicDecBlk')
+ LateralBlock = eval('BasicLatBlk')
+
+ self.decoder_block4 = DecoderBlock(channels[0], channels[1])
+ self.decoder_block3 = DecoderBlock(channels[1], channels[2])
+ self.decoder_block2 = DecoderBlock(channels[2], channels[3])
+ self.decoder_block1 = DecoderBlock(channels[3], channels[3]//2)
+
+ self.lateral_block4 = LateralBlock(channels[1], channels[1])
+ self.lateral_block3 = LateralBlock(channels[2], channels[2])
+ self.lateral_block2 = LateralBlock(channels[3], channels[3])
+
+ if self.config.ms_supervision:
+ self.conv_ms_spvn_4 = nn.Conv2d(channels[1], 1, 1, 1, 0)
+ self.conv_ms_spvn_3 = nn.Conv2d(channels[2], 1, 1, 1, 0)
+ self.conv_ms_spvn_2 = nn.Conv2d(channels[3], 1, 1, 1, 0)
+ self.conv_out1 = nn.Sequential(nn.Conv2d(channels[3]//2, 1, 1, 1, 0))
+
+ def forward(self, features):
+ x, x1, x2, x3, x4 = features
+ outs = []
+ p4 = self.decoder_block4(x4)
+ _p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
+ _p3 = _p4 + self.lateral_block4(x3)
+
+ p3 = self.decoder_block3(_p3)
+ _p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
+ _p2 = _p3 + self.lateral_block3(x2)
+
+ p2 = self.decoder_block2(_p2)
+ _p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
+ _p1 = _p2 + self.lateral_block2(x1)
+
+ _p1 = self.decoder_block1(_p1)
+ _p1 = F.interpolate(_p1, size=x.shape[2:], mode='bilinear', align_corners=True)
+ p1_out = self.conv_out1(_p1)
+
+ if self.config.ms_supervision:
+ outs.append(self.conv_ms_spvn_4(p4))
+ outs.append(self.conv_ms_spvn_3(p3))
+ outs.append(self.conv_ms_spvn_2(p2))
+ outs.append(p1_out)
+ return outs
+
+
+class RefUNet(nn.Module):
+ # Refinement
+ def __init__(self, in_channels=3+1):
+ super(RefUNet, self).__init__()
+ self.encoder_1 = nn.Sequential(
+ nn.Conv2d(in_channels, 64, 3, 1, 1),
+ nn.Conv2d(64, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.encoder_2 = nn.Sequential(
+ nn.MaxPool2d(2, 2, ceil_mode=True),
+ nn.Conv2d(64, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.encoder_3 = nn.Sequential(
+ nn.MaxPool2d(2, 2, ceil_mode=True),
+ nn.Conv2d(64, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.encoder_4 = nn.Sequential(
+ nn.MaxPool2d(2, 2, ceil_mode=True),
+ nn.Conv2d(64, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)
+ #####
+ self.decoder_5 = nn.Sequential(
+ nn.Conv2d(64, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+ #####
+ self.decoder_4 = nn.Sequential(
+ nn.Conv2d(128, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.decoder_3 = nn.Sequential(
+ nn.Conv2d(128, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.decoder_2 = nn.Sequential(
+ nn.Conv2d(128, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.decoder_1 = nn.Sequential(
+ nn.Conv2d(128, 64, 3, 1, 1),
+ nn.BatchNorm2d(64),
+ nn.ReLU(inplace=True)
+ )
+
+ self.conv_d0 = nn.Conv2d(64, 1, 3, 1, 1)
+
+ self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
+
+ def forward(self, x):
+ outs = []
+ if isinstance(x, list):
+ x = torch.cat(x, dim=1)
+ hx = x
+
+ hx1 = self.encoder_1(hx)
+ hx2 = self.encoder_2(hx1)
+ hx3 = self.encoder_3(hx2)
+ hx4 = self.encoder_4(hx3)
+
+ hx = self.decoder_5(self.pool4(hx4))
+ hx = torch.cat((self.upscore2(hx), hx4), 1)
+
+ d4 = self.decoder_4(hx)
+ hx = torch.cat((self.upscore2(d4), hx3), 1)
+
+ d3 = self.decoder_3(hx)
+ hx = torch.cat((self.upscore2(d3), hx2), 1)
+
+ d2 = self.decoder_2(hx)
+ hx = torch.cat((self.upscore2(d2), hx1), 1)
+
+ d1 = self.decoder_1(hx)
+
+ x = self.conv_d0(d1)
+ outs.append(x)
+ return outs
+
+
+
+### models/stem_layer.py
+
+import torch.nn as nn
+# from utils import build_act_layer, build_norm_layer
+
+
+class StemLayer(nn.Module):
+ r""" Stem layer of InternImage
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ act_layer (str): activation layer
+ norm_layer (str): normalization layer
+ """
+
+ def __init__(self,
+ in_channels=3+1,
+ inter_channels=48,
+ out_channels=96,
+ act_layer='GELU',
+ norm_layer='BN'):
+ super().__init__()
+ self.conv1 = nn.Conv2d(in_channels,
+ inter_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1)
+ self.norm1 = build_norm_layer(
+ inter_channels, norm_layer, 'channels_first', 'channels_first'
+ )
+ self.act = build_act_layer(act_layer)
+ self.conv2 = nn.Conv2d(inter_channels,
+ out_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1)
+ self.norm2 = build_norm_layer(
+ out_channels, norm_layer, 'channels_first', 'channels_first'
+ )
+
+ def forward(self, x):
+ x = self.conv1(x)
+ x = self.norm1(x)
+ x = self.act(x)
+ x = self.conv2(x)
+ x = self.norm2(x)
+ return x
+
+
+### models/birefnet.py
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from kornia.filters import laplacian
+from transformers import PreTrainedModel
+
+# from config import Config
+# from dataset import class_labels_TR_sorted
+# from models.build_backbone import build_backbone
+# from models.decoder_blocks import BasicDecBlk, ResBlk, HierarAttDecBlk
+# from models.lateral_blocks import BasicLatBlk
+# from models.aspp import ASPP, ASPPDeformable
+# from models.ing import *
+# from models.refiner import Refiner, RefinerPVTInChannels4, RefUNet
+# from models.stem_layer import StemLayer
+from .BiRefNet_config import BiRefNetConfig
+
+
+class BiRefNet(
+ PreTrainedModel
+):
+ config_class = BiRefNetConfig
+ def __init__(self, bb_pretrained=True, config=BiRefNetConfig()):
+ super(BiRefNet, self).__init__(config)
+ bb_pretrained = config.bb_pretrained
+ self.config = Config()
+ self.epoch = 1
+ self.bb = build_backbone(self.config.bb, pretrained=bb_pretrained)
+
+ channels = self.config.lateral_channels_in_collection
+
+ if self.config.auxiliary_classification:
+ self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+ self.cls_head = nn.Sequential(
+ nn.Linear(channels[0], len(class_labels_TR_sorted))
+ )
+
+ if self.config.squeeze_block:
+ self.squeeze_module = nn.Sequential(*[
+ eval(self.config.squeeze_block.split('_x')[0])(channels[0]+sum(self.config.cxt), channels[0])
+ for _ in range(eval(self.config.squeeze_block.split('_x')[1]))
+ ])
+
+ self.decoder = Decoder(channels)
+
+ if self.config.ender:
+ self.dec_end = nn.Sequential(
+ nn.Conv2d(1, 16, 3, 1, 1),
+ nn.Conv2d(16, 1, 3, 1, 1),
+ nn.ReLU(inplace=True),
+ )
+
+ # refine patch-level segmentation
+ if self.config.refine:
+ if self.config.refine == 'itself':
+ self.stem_layer = StemLayer(in_channels=3+1, inter_channels=48, out_channels=3, norm_layer='BN' if self.config.batch_size > 1 else 'LN')
+ else:
+ self.refiner = eval('{}({})'.format(self.config.refine, 'in_channels=3+1'))
+
+ if self.config.freeze_bb:
+ # Freeze the backbone...
+ print(self.named_parameters())
+ for key, value in self.named_parameters():
+ if 'bb.' in key and 'refiner.' not in key:
+ value.requires_grad = False
+
+ def forward_enc(self, x):
+ if self.config.bb in ['vgg16', 'vgg16bn', 'resnet50']:
+ x1 = self.bb.conv1(x); x2 = self.bb.conv2(x1); x3 = self.bb.conv3(x2); x4 = self.bb.conv4(x3)
+ else:
+ x1, x2, x3, x4 = self.bb(x)
+ if self.config.mul_scl_ipt == 'cat':
+ B, C, H, W = x.shape
+ x1_, x2_, x3_, x4_ = self.bb(F.interpolate(x, size=(H//2, W//2), mode='bilinear', align_corners=True))
+ x1 = torch.cat([x1, F.interpolate(x1_, size=x1.shape[2:], mode='bilinear', align_corners=True)], dim=1)
+ x2 = torch.cat([x2, F.interpolate(x2_, size=x2.shape[2:], mode='bilinear', align_corners=True)], dim=1)
+ x3 = torch.cat([x3, F.interpolate(x3_, size=x3.shape[2:], mode='bilinear', align_corners=True)], dim=1)
+ x4 = torch.cat([x4, F.interpolate(x4_, size=x4.shape[2:], mode='bilinear', align_corners=True)], dim=1)
+ elif self.config.mul_scl_ipt == 'add':
+ B, C, H, W = x.shape
+ x1_, x2_, x3_, x4_ = self.bb(F.interpolate(x, size=(H//2, W//2), mode='bilinear', align_corners=True))
+ x1 = x1 + F.interpolate(x1_, size=x1.shape[2:], mode='bilinear', align_corners=True)
+ x2 = x2 + F.interpolate(x2_, size=x2.shape[2:], mode='bilinear', align_corners=True)
+ x3 = x3 + F.interpolate(x3_, size=x3.shape[2:], mode='bilinear', align_corners=True)
+ x4 = x4 + F.interpolate(x4_, size=x4.shape[2:], mode='bilinear', align_corners=True)
+ class_preds = self.cls_head(self.avgpool(x4).view(x4.shape[0], -1)) if self.training and self.config.auxiliary_classification else None
+ if self.config.cxt:
+ x4 = torch.cat(
+ (
+ *[
+ F.interpolate(x1, size=x4.shape[2:], mode='bilinear', align_corners=True),
+ F.interpolate(x2, size=x4.shape[2:], mode='bilinear', align_corners=True),
+ F.interpolate(x3, size=x4.shape[2:], mode='bilinear', align_corners=True),
+ ][-len(self.config.cxt):],
+ x4
+ ),
+ dim=1
+ )
+ return (x1, x2, x3, x4), class_preds
+
+ def forward_ori(self, x):
+ ########## Encoder ##########
+ (x1, x2, x3, x4), class_preds = self.forward_enc(x)
+ if self.config.squeeze_block:
+ x4 = self.squeeze_module(x4)
+ ########## Decoder ##########
+ features = [x, x1, x2, x3, x4]
+ if self.training and self.config.out_ref:
+ features.append(laplacian(torch.mean(x, dim=1).unsqueeze(1), kernel_size=5))
+ scaled_preds = self.decoder(features)
+ return scaled_preds, class_preds
+
+ def forward(self, x):
+ scaled_preds, class_preds = self.forward_ori(x)
+ class_preds_lst = [class_preds]
+ return [scaled_preds, class_preds_lst] if self.training else scaled_preds
+
+
+class Decoder(nn.Module):
+ def __init__(self, channels):
+ super(Decoder, self).__init__()
+ self.config = Config()
+ DecoderBlock = eval(self.config.dec_blk)
+ LateralBlock = eval(self.config.lat_blk)
+
+ if self.config.dec_ipt:
+ self.split = self.config.dec_ipt_split
+ N_dec_ipt = 64
+ DBlock = SimpleConvs
+ ic = 64
+ ipt_cha_opt = 1
+ self.ipt_blk5 = DBlock(2**10*3 if self.split else 3, [N_dec_ipt, channels[0]//8][ipt_cha_opt], inter_channels=ic)
+ self.ipt_blk4 = DBlock(2**8*3 if self.split else 3, [N_dec_ipt, channels[0]//8][ipt_cha_opt], inter_channels=ic)
+ self.ipt_blk3 = DBlock(2**6*3 if self.split else 3, [N_dec_ipt, channels[1]//8][ipt_cha_opt], inter_channels=ic)
+ self.ipt_blk2 = DBlock(2**4*3 if self.split else 3, [N_dec_ipt, channels[2]//8][ipt_cha_opt], inter_channels=ic)
+ self.ipt_blk1 = DBlock(2**0*3 if self.split else 3, [N_dec_ipt, channels[3]//8][ipt_cha_opt], inter_channels=ic)
+ else:
+ self.split = None
+
+ self.decoder_block4 = DecoderBlock(channels[0]+([N_dec_ipt, channels[0]//8][ipt_cha_opt] if self.config.dec_ipt else 0), channels[1])
+ self.decoder_block3 = DecoderBlock(channels[1]+([N_dec_ipt, channels[0]//8][ipt_cha_opt] if self.config.dec_ipt else 0), channels[2])
+ self.decoder_block2 = DecoderBlock(channels[2]+([N_dec_ipt, channels[1]//8][ipt_cha_opt] if self.config.dec_ipt else 0), channels[3])
+ self.decoder_block1 = DecoderBlock(channels[3]+([N_dec_ipt, channels[2]//8][ipt_cha_opt] if self.config.dec_ipt else 0), channels[3]//2)
+ self.conv_out1 = nn.Sequential(nn.Conv2d(channels[3]//2+([N_dec_ipt, channels[3]//8][ipt_cha_opt] if self.config.dec_ipt else 0), 1, 1, 1, 0))
+
+ self.lateral_block4 = LateralBlock(channels[1], channels[1])
+ self.lateral_block3 = LateralBlock(channels[2], channels[2])
+ self.lateral_block2 = LateralBlock(channels[3], channels[3])
+
+ if self.config.ms_supervision:
+ self.conv_ms_spvn_4 = nn.Conv2d(channels[1], 1, 1, 1, 0)
+ self.conv_ms_spvn_3 = nn.Conv2d(channels[2], 1, 1, 1, 0)
+ self.conv_ms_spvn_2 = nn.Conv2d(channels[3], 1, 1, 1, 0)
+
+ if self.config.out_ref:
+ _N = 16
+ self.gdt_convs_4 = nn.Sequential(nn.Conv2d(channels[1], _N, 3, 1, 1), nn.BatchNorm2d(_N) if self.config.batch_size > 1 else nn.Identity(), nn.ReLU(inplace=True))
+ self.gdt_convs_3 = nn.Sequential(nn.Conv2d(channels[2], _N, 3, 1, 1), nn.BatchNorm2d(_N) if self.config.batch_size > 1 else nn.Identity(), nn.ReLU(inplace=True))
+ self.gdt_convs_2 = nn.Sequential(nn.Conv2d(channels[3], _N, 3, 1, 1), nn.BatchNorm2d(_N) if self.config.batch_size > 1 else nn.Identity(), nn.ReLU(inplace=True))
+
+ self.gdt_convs_pred_4 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+ self.gdt_convs_pred_3 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+ self.gdt_convs_pred_2 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+
+ self.gdt_convs_attn_4 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+ self.gdt_convs_attn_3 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+ self.gdt_convs_attn_2 = nn.Sequential(nn.Conv2d(_N, 1, 1, 1, 0))
+
+ def get_patches_batch(self, x, p):
+ _size_h, _size_w = p.shape[2:]
+ patches_batch = []
+ for idx in range(x.shape[0]):
+ columns_x = torch.split(x[idx], split_size_or_sections=_size_w, dim=-1)
+ patches_x = []
+ for column_x in columns_x:
+ patches_x += [p.unsqueeze(0) for p in torch.split(column_x, split_size_or_sections=_size_h, dim=-2)]
+ patch_sample = torch.cat(patches_x, dim=1)
+ patches_batch.append(patch_sample)
+ return torch.cat(patches_batch, dim=0)
+
+ def forward(self, features):
+ if self.training and self.config.out_ref:
+ outs_gdt_pred = []
+ outs_gdt_label = []
+ x, x1, x2, x3, x4, gdt_gt = features
+ else:
+ x, x1, x2, x3, x4 = features
+ outs = []
+
+ if self.config.dec_ipt:
+ patches_batch = self.get_patches_batch(x, x4) if self.split else x
+ x4 = torch.cat((x4, self.ipt_blk5(F.interpolate(patches_batch, size=x4.shape[2:], mode='bilinear', align_corners=True))), 1)
+ p4 = self.decoder_block4(x4)
+ m4 = self.conv_ms_spvn_4(p4) if self.config.ms_supervision else None
+ if self.config.out_ref:
+ p4_gdt = self.gdt_convs_4(p4)
+ if self.training:
+ # >> GT:
+ m4_dia = m4
+ gdt_label_main_4 = gdt_gt * F.interpolate(m4_dia, size=gdt_gt.shape[2:], mode='bilinear', align_corners=True)
+ outs_gdt_label.append(gdt_label_main_4)
+ # >> Pred:
+ gdt_pred_4 = self.gdt_convs_pred_4(p4_gdt)
+ outs_gdt_pred.append(gdt_pred_4)
+ gdt_attn_4 = self.gdt_convs_attn_4(p4_gdt).sigmoid()
+ # >> Finally:
+ p4 = p4 * gdt_attn_4
+ _p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
+ _p3 = _p4 + self.lateral_block4(x3)
+
+ if self.config.dec_ipt:
+ patches_batch = self.get_patches_batch(x, _p3) if self.split else x
+ _p3 = torch.cat((_p3, self.ipt_blk4(F.interpolate(patches_batch, size=x3.shape[2:], mode='bilinear', align_corners=True))), 1)
+ p3 = self.decoder_block3(_p3)
+ m3 = self.conv_ms_spvn_3(p3) if self.config.ms_supervision else None
+ if self.config.out_ref:
+ p3_gdt = self.gdt_convs_3(p3)
+ if self.training:
+ # >> GT:
+ # m3 --dilation--> m3_dia
+ # G_3^gt * m3_dia --> G_3^m, which is the label of gradient
+ m3_dia = m3
+ gdt_label_main_3 = gdt_gt * F.interpolate(m3_dia, size=gdt_gt.shape[2:], mode='bilinear', align_corners=True)
+ outs_gdt_label.append(gdt_label_main_3)
+ # >> Pred:
+ # p3 --conv--BN--> F_3^G, where F_3^G predicts the \hat{G_3} with xx
+ # F_3^G --sigmoid--> A_3^G
+ gdt_pred_3 = self.gdt_convs_pred_3(p3_gdt)
+ outs_gdt_pred.append(gdt_pred_3)
+ gdt_attn_3 = self.gdt_convs_attn_3(p3_gdt).sigmoid()
+ # >> Finally:
+ # p3 = p3 * A_3^G
+ p3 = p3 * gdt_attn_3
+ _p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
+ _p2 = _p3 + self.lateral_block3(x2)
+
+ if self.config.dec_ipt:
+ patches_batch = self.get_patches_batch(x, _p2) if self.split else x
+ _p2 = torch.cat((_p2, self.ipt_blk3(F.interpolate(patches_batch, size=x2.shape[2:], mode='bilinear', align_corners=True))), 1)
+ p2 = self.decoder_block2(_p2)
+ m2 = self.conv_ms_spvn_2(p2) if self.config.ms_supervision else None
+ if self.config.out_ref:
+ p2_gdt = self.gdt_convs_2(p2)
+ if self.training:
+ # >> GT:
+ m2_dia = m2
+ gdt_label_main_2 = gdt_gt * F.interpolate(m2_dia, size=gdt_gt.shape[2:], mode='bilinear', align_corners=True)
+ outs_gdt_label.append(gdt_label_main_2)
+ # >> Pred:
+ gdt_pred_2 = self.gdt_convs_pred_2(p2_gdt)
+ outs_gdt_pred.append(gdt_pred_2)
+ gdt_attn_2 = self.gdt_convs_attn_2(p2_gdt).sigmoid()
+ # >> Finally:
+ p2 = p2 * gdt_attn_2
+ _p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
+ _p1 = _p2 + self.lateral_block2(x1)
+
+ if self.config.dec_ipt:
+ patches_batch = self.get_patches_batch(x, _p1) if self.split else x
+ _p1 = torch.cat((_p1, self.ipt_blk2(F.interpolate(patches_batch, size=x1.shape[2:], mode='bilinear', align_corners=True))), 1)
+ _p1 = self.decoder_block1(_p1)
+ _p1 = F.interpolate(_p1, size=x.shape[2:], mode='bilinear', align_corners=True)
+
+ if self.config.dec_ipt:
+ patches_batch = self.get_patches_batch(x, _p1) if self.split else x
+ _p1 = torch.cat((_p1, self.ipt_blk1(F.interpolate(patches_batch, size=x.shape[2:], mode='bilinear', align_corners=True))), 1)
+ p1_out = self.conv_out1(_p1)
+
+ if self.config.ms_supervision:
+ outs.append(m4)
+ outs.append(m3)
+ outs.append(m2)
+ outs.append(p1_out)
+ return outs if not (self.config.out_ref and self.training) else ([outs_gdt_pred, outs_gdt_label], outs)
+
+
+class SimpleConvs(nn.Module):
+ def __init__(
+ self, in_channels: int, out_channels: int, inter_channels=64
+ ) -> None:
+ super().__init__()
+ self.conv1 = nn.Conv2d(in_channels, inter_channels, 3, 1, 1)
+ self.conv_out = nn.Conv2d(inter_channels, out_channels, 3, 1, 1)
+
+ def forward(self, x):
+ return self.conv_out(self.conv1(x))
diff --git a/OmniPart/configs/RMBG/config.json b/OmniPart/configs/RMBG/config.json
new file mode 100644
index 0000000..06d8fa9
--- /dev/null
+++ b/OmniPart/configs/RMBG/config.json
@@ -0,0 +1,20 @@
+{
+ "_name_or_path": "ZhengPeng7/BiRefNet",
+ "architectures": [
+ "BiRefNet"
+ ],
+ "auto_map": {
+ "AutoConfig": "BiRefNet_config.BiRefNetConfig",
+ "AutoModelForImageSegmentation": "birefnet.BiRefNet"
+ },
+ "custom_pipelines": {
+ "image-segmentation": {
+ "pt": [
+ "AutoModelForImageSegmentation"
+ ],
+ "tf": [],
+ "type": "image"
+ }
+ },
+ "bb_pretrained": false
+}
\ No newline at end of file
diff --git a/OmniPart/configs/bbox_gen.yaml b/OmniPart/configs/bbox_gen.yaml
new file mode 100644
index 0000000..d8ac030
--- /dev/null
+++ b/OmniPart/configs/bbox_gen.yaml
@@ -0,0 +1,34 @@
+model:
+ name: bbox_gen
+ args:
+ encoder_dim_feat: 448
+ encoder_dim: 64
+ encoder_heads: 4
+ encoder_token_num: 2048
+ encoder_qkv_bias: false
+ encoder_use_ln_post: true
+ encoder_use_checkpoint: true
+ encoder_num_embed_freqs: 8
+ encoder_embed_include_pi: false
+ encoder_init_scale: 0.25
+ encoder_random_fps: true
+ encoder_learnable_query: true
+ encoder_layers: 8
+
+ max_group_size: 50
+
+ vocab_size: 67
+ decoder_hidden_size: 1024
+ decoder_num_hidden_layers: 24
+ decoder_ffn_dim: 4096
+ decoder_heads: 16
+ decoder_use_flash_attention: true
+ decoder_gradient_checkpointing: false
+
+ bins: 64
+ BOS_id: 64
+ EOS_id: 65
+ PAD_id: 66
+ max_length: 2187
+ voxel_token_length: 1886
+ voxel_token_placeholder: -1
\ No newline at end of file
diff --git a/OmniPart/configs/dinov2-with-registers-large/config.json b/OmniPart/configs/dinov2-with-registers-large/config.json
new file mode 100644
index 0000000..dc71d43
--- /dev/null
+++ b/OmniPart/configs/dinov2-with-registers-large/config.json
@@ -0,0 +1,50 @@
+{
+ "apply_layernorm": true,
+ "architectures": [
+ "Dinov2WithRegistersModel"
+ ],
+ "attention_probs_dropout_prob": 0.0,
+ "drop_path_rate": 0.0,
+ "hidden_act": "gelu",
+ "hidden_dropout_prob": 0.0,
+ "hidden_size": 1024,
+ "image_size": 518,
+ "initializer_range": 0.02,
+ "interpolate_antialias": true,
+ "interpolate_offset": 0.0,
+ "layer_norm_eps": 1e-06,
+ "layerscale_value": 1.0,
+ "mlp_ratio": 4,
+ "model_type": "dinov2_with_registers",
+ "num_attention_heads": 16,
+ "num_channels": 3,
+ "num_hidden_layers": 24,
+ "num_register_tokens": 4,
+ "out_features": [
+ "stage12"
+ ],
+ "out_indices": [
+ 12
+ ],
+ "patch_size": 14,
+ "qkv_bias": true,
+ "reshape_hidden_states": true,
+ "stage_names": [
+ "stem",
+ "stage1",
+ "stage2",
+ "stage3",
+ "stage4",
+ "stage5",
+ "stage6",
+ "stage7",
+ "stage8",
+ "stage9",
+ "stage10",
+ "stage11",
+ "stage12"
+ ],
+ "torch_dtype": "float32",
+ "transformers_version": "4.48.0.dev0",
+ "use_swiglu_ffn": false
+}
diff --git a/OmniPart/configs/dinov2-with-registers-large/preprocessor_config.json b/OmniPart/configs/dinov2-with-registers-large/preprocessor_config.json
new file mode 100644
index 0000000..ff5b47c
--- /dev/null
+++ b/OmniPart/configs/dinov2-with-registers-large/preprocessor_config.json
@@ -0,0 +1,27 @@
+{
+ "crop_size": {
+ "height": 224,
+ "width": 224
+ },
+ "do_center_crop": true,
+ "do_convert_rgb": true,
+ "do_normalize": true,
+ "do_rescale": true,
+ "do_resize": true,
+ "image_mean": [
+ 0.485,
+ 0.456,
+ 0.406
+ ],
+ "image_processor_type": "BitImageProcessor",
+ "image_std": [
+ 0.229,
+ 0.224,
+ 0.225
+ ],
+ "resample": 3,
+ "rescale_factor": 0.00392156862745098,
+ "size": {
+ "shortest_edge": 256
+ }
+}
diff --git a/OmniPart/configs/training_part_synthesis.json b/OmniPart/configs/training_part_synthesis.json
new file mode 100644
index 0000000..7518982
--- /dev/null
+++ b/OmniPart/configs/training_part_synthesis.json
@@ -0,0 +1,114 @@
+{
+ "models": {
+ "denoiser": {
+ "name": "ElasticSLatFlowModel",
+ "args": {
+ "resolution": 64,
+ "in_channels": 9,
+ "out_channels": 9,
+ "model_channels": 1024,
+ "cond_channels": 1024,
+ "num_blocks": 24,
+ "num_heads": 16,
+ "mlp_ratio": 4,
+ "patch_size": 2,
+ "num_io_res_blocks": 2,
+ "io_block_channels": [
+ 128
+ ],
+ "pe_mode": "ape",
+ "qk_rms_norm": true,
+ "use_fp16": true
+ }
+ }
+ },
+ "dataset": {
+ "name": "ImageConditionedSLat",
+ "args": {
+ "data_root": "",
+ "train_mesh_list": "",
+ "val_mesh_list": "",
+ "aug_bbox": "0 2",
+ "latent_model": "dinov2_vitl14_reg_slat_enc_swin8_B_64l8_fp16",
+ "min_aesthetic_score": 4.5,
+ "max_num_voxels": 65536,
+ "image_size": 518,
+ "normalization": {
+ "mean": [
+ -2.1687545776367188,
+ -0.004347046371549368,
+ -0.13352349400520325,
+ -0.08418072760105133,
+ -0.5271206498146057,
+ 0.7238689064979553,
+ -1.1414450407028198,
+ 1.2039363384246826,
+ 0.0
+ ],
+ "std": [
+ 2.377650737762451,
+ 2.386378288269043,
+ 2.124418020248413,
+ 2.1748552322387695,
+ 2.663944721221924,
+ 2.371192216873169,
+ 2.6217446327209473,
+ 2.684523105621338,
+ 1.0
+ ]
+ },
+ "pretrained_slat_dec": "JeffreyXiang/TRELLIS-image-large/ckpts/slat_dec_gs_swin8_B_64l8gs32_fp16"
+ }
+ },
+ "trainer": {
+ "name": "ImageConditionedSparseFlowMatchingCFGTrainer",
+ "args": {
+ "max_steps": 1000000,
+ "batch_size_per_gpu": 12,
+ "batch_split": 4,
+ "optimizer": {
+ "name": "AdamW",
+ "args": {
+ "lr": 0.0001,
+ "weight_decay": 0.0
+ }
+ },
+ "ema_rate": [
+ 0.9999
+ ],
+ "fp16_mode": "inflat_all",
+ "fp16_scale_growth": 0.001,
+ "elastic": {
+ "name": "LinearMemoryController",
+ "args": {
+ "target_ratio": 0.75,
+ "max_mem_ratio_start": 0.5
+ }
+ },
+ "grad_clip": {
+ "name": "AdaptiveGradClipper",
+ "args": {
+ "max_norm": 1.0,
+ "clip_percentile": 95
+ }
+ },
+ "i_print": 50,
+ "i_log": 500,
+ "i_sample": 2000,
+ "i_save": 10000,
+ "p_uncond": 0.1,
+ "t_schedule": {
+ "name": "logitNormal",
+ "args": {
+ "mean": 1.0,
+ "std": 1.0
+ }
+ },
+ "sigma_min": 1e-5,
+ "image_cond_model": "dinov2_vitl14_reg",
+ "finetune_ckpt": {
+ "denoiser": "TRELLIS-image-large-pt/slat_flow_img_dit_L_64l8p2_fp16.pt"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/OmniPart/dataset_toolkits/blender_render_img_mask.py b/OmniPart/dataset_toolkits/blender_render_img_mask.py
new file mode 100644
index 0000000..4d4000e
--- /dev/null
+++ b/OmniPart/dataset_toolkits/blender_render_img_mask.py
@@ -0,0 +1,646 @@
+import bpy
+import random
+import sys
+from mathutils import Vector
+import os
+os.environ["OPENCV_IO_ENABLE_OPENEXR"] = "1"
+import glob
+import math
+import json
+import mathutils
+from mathutils import Matrix, Vector, Euler
+from typing import List, Optional
+import numpy as np
+import cv2
+from PIL import Image
+
+
+META_FILENAME = "meta.json"
+RESOLUTION = 512
+RENDER_SAMPLES = 64
+ENGINE = "EEVEE"
+CLOSE_SHADOW = False
+RENDER_DEPTH = False
+
+
+if os.environ.get("ENGINE"):
+ ENGINE = os.environ.get("ENGINE")
+
+if os.environ.get("RENDER_SAMPLES"):
+ RENDER_SAMPLES = int(os.environ.get("RENDER_SAMPLES"))
+
+if os.environ.get("RESOLUTION"):
+ RESOLUTION = int(os.environ.get("RESOLUTION"))
+
+def generate_random(left, right):
+ while True:
+ val = random.gauss(0, (right-left)/5)
+ if val >= left and val <= right:
+ return val
+
+
+def generate_frames(name):
+ render_type_list = [
+ {'name': "depth", "suffix": ".exr", "enable": RENDER_DEPTH},
+ {'name': "render_opaque", "suffix": ".webp",
+ "enable": RENDER_DEPTH},
+ ]
+ param = [
+ {
+ "type": "render",
+ "name": "{}",
+ "height": RESOLUTION,
+ "width": RESOLUTION,
+ }
+ ]
+ variables = ["render_"+name+".webp"]
+
+ for render_type in render_type_list:
+ if render_type["enable"]:
+ param.append({
+ "type": render_type["name"],
+ "name": "{}",
+ "height": RESOLUTION,
+ "width": RESOLUTION,
+ })
+ variables.append(render_type["name"] +
+ "_"+name+render_type["suffix"])
+
+ for i in range(len(variables)):
+ param[i]["name"] = variables[i]
+ return param
+
+
+def build_transformation_mat(translation,
+ rotation) -> np.ndarray:
+ """ Build a transformation matrix from translation and rotation parts.
+
+ :param translation: A (3,) vector representing the translation part.
+ :param rotation: A 3x3 rotation matrix or Euler angles of shape (3,).
+ :return: The 4x4 transformation matrix.
+ """
+ translation = np.array(translation)
+ rotation = np.array(rotation)
+
+ mat = np.eye(4)
+ if translation.shape[0] == 3:
+ mat[:3, 3] = translation
+ else:
+ raise RuntimeError(
+ f"Translation has invalid shape: {translation.shape}. Must be (3,) or (3,1) vector.")
+ if rotation.shape == (3, 3):
+ mat[:3, :3] = rotation
+ elif rotation.shape[0] == 3:
+ mat[:3, :3] = np.array(Euler(rotation).to_matrix())
+ else:
+ raise RuntimeError(f"Rotation has invalid shape: {rotation.shape}. Must be rotation matrix of shape "
+ f"(3,3) or Euler angles of shape (3,) or (3,1).")
+
+ return mat
+
+
+def reset_keyframes() -> None:
+ """ Removes registered keyframes from all objects and resets frame_start and frame_end """
+ bpy.context.scene.frame_start = 0
+ bpy.context.scene.frame_end = 0
+ for a in bpy.data.actions:
+ bpy.data.actions.remove(a)
+
+
+def get_local2world_mat(blender_obj) -> np.ndarray:
+ """ Returns the pose of the object in the form of a local2world matrix.
+ :return: The 4x4 local2world matrix.
+ """
+ obj = blender_obj
+ # Start with local2parent matrix (if obj has no parent, that equals local2world)
+ matrix_world = obj.matrix_basis
+
+ # Go up the scene graph along all parents
+ while obj.parent is not None:
+ # Add transformation to parent frame
+ matrix_world = obj.parent.matrix_basis @ obj.matrix_parent_inverse @ matrix_world
+ obj = obj.parent
+
+ return np.array(matrix_world)
+
+
+def add_camera(cam2world_matrix,camera_params) -> int:
+ if not isinstance(cam2world_matrix, Matrix):
+ cam2world_matrix = Matrix(cam2world_matrix)
+
+ bpy.ops.object.camera_add(location=(0, 0, 0))
+ cam_ob = bpy.context.object
+ cam_ob.matrix_world = cam2world_matrix
+ cam_ob_data = cam_ob.data
+ cam_ob_data.type = camera_params['camera_type']
+ cam_ob_data.sensor_width = camera_params['camera_sensor_width']
+ if camera_params['camera_type'] == 'ORTHO':
+ cam_ob_data.ortho_scale = camera_params['camera_ortho_scale']
+ elif camera_params['camera_type'] == 'PERSP':
+ cam_ob_data.lens = camera_params['camera_lens']
+
+
+def add_camera_pose(cam2world_matrix, camera_params) -> int:
+ if not isinstance(cam2world_matrix, Matrix):
+ cam2world_matrix = Matrix(cam2world_matrix)
+
+ cam_ob = bpy.context.scene.camera
+ cam_ob.matrix_world = cam2world_matrix
+ cam_ob_data = cam_ob.data
+ cam_ob_data.type = camera_params['camera_type']
+ cam_ob_data.sensor_width = camera_params['camera_sensor_width']
+ if camera_params['camera_type'] == 'ORTHO':
+ cam_ob_data.ortho_scale = camera_params['camera_ortho_scale']
+ elif camera_params['camera_type'] == 'PERSP':
+ cam_ob_data.lens = camera_params['camera_lens']
+
+ frame = bpy.context.scene.frame_end
+ if bpy.context.scene.frame_end < frame + 1:
+ bpy.context.scene.frame_end = frame + 1
+
+ cam_ob.keyframe_insert(data_path='location', frame=frame)
+ cam_ob.keyframe_insert(data_path='rotation_euler', frame=frame)
+ cam_ob_data.keyframe_insert(data_path='type', frame=frame)
+ cam_ob_data.keyframe_insert(data_path='sensor_width', frame=frame)
+
+ if camera_params['camera_type'] == 'ORTHO':
+ cam_ob_data.keyframe_insert(data_path='ortho_scale', frame=frame)
+ elif camera_params['camera_type'] == 'PERSP':
+ cam_ob_data.keyframe_insert(data_path='lens', frame=frame)
+ return frame
+
+
+def clear_normal_map():
+ for material in bpy.data.materials:
+ material.use_nodes = True
+ node_tree = material.node_tree
+ try:
+ bsdf = node_tree.nodes["Principled BSDF"]
+ if bsdf.inputs["Normal"].is_linked:
+ for link in bsdf.inputs["Normal"].links:
+ node_tree.links.remove(link)
+ except:
+ pass
+
+
+def enable_depth_output(output_dir: Optional[str] = '', file_prefix: str = "depth_"):
+
+ bpy.context.scene.render.use_compositing = True
+ bpy.context.scene.use_nodes = True
+
+ tree = bpy.context.scene.node_tree
+ links = tree.links
+
+ if "Render Layers" not in tree.nodes:
+ rl = tree.nodes.new('CompositorNodeRLayers')
+ else:
+ rl = tree.nodes["Render Layers"]
+ bpy.context.view_layer.use_pass_z = True
+
+ depth_output = tree.nodes.new('CompositorNodeOutputFile')
+ depth_output.base_path = output_dir
+ depth_output.name = 'DepthOutput'
+ depth_output.format.file_format = 'OPEN_EXR'
+ depth_output.format.color_depth = '32'
+ depth_output.file_slots.values()[0].path = file_prefix
+
+ links.new(rl.outputs["Depth"], depth_output.inputs['Image'])
+
+
+def scene_mesh_objects(override_context: bool = False):
+ bpy.ops.object.select_all(action="DESELECT")
+ for obj in bpy.context.scene.objects:
+ if obj.type == 'MESH' and obj.visible_get() is True and obj.hide_get() is False:
+ yield obj
+
+
+def enable_mask_output(output_dir: Optional[str] = '', file_prefix: str = "mask_"):
+ bpy.context.view_layer.use_pass_cryptomatte_object = True
+ tree = bpy.context.scene.node_tree
+ links = tree.links
+ for obj in scene_mesh_objects():
+ crypto_node = tree.nodes.new('CompositorNodeCryptomatteV2')
+ crypto_node.name = f"Cryptomatte_{obj.name}"
+ crypto_node.matte_id = obj.name
+ id_mask_output_node = tree.nodes.new('CompositorNodeOutputFile')
+ id_mask_output_node.name = f'Mask Output_{obj.name}'
+ id_mask_output_node.format.file_format = 'WEBP'
+ id_mask_output_node.format.quality = 100
+ id_mask_output_node.format.color_depth = '8'
+ id_mask_output_node.base_path = output_dir
+ id_mask_output_node.file_slots.values()[0].path = f"{file_prefix}{obj.name}_"
+ links.new(crypto_node.outputs['Matte'], id_mask_output_node.inputs['Image'])
+
+def format_mask_output(output_dir):
+
+ scene = bpy.context.scene
+ h, w = scene.render.resolution_y, scene.render.resolution_x
+
+ webp_list = os.listdir(output_dir)
+ mask_list = [img for img in webp_list if img.startswith("mask_") and img.endswith(".webp")]
+
+ frame_groups = {}
+ for mask_file in mask_list:
+ parts = mask_file.replace(".webp", "").split("_")
+ frame_idx = int(parts[-1])
+ part_name = "_".join(parts[1:-1])
+
+ if frame_idx not in frame_groups:
+ frame_groups[frame_idx] = []
+ frame_groups[frame_idx].append((part_name, mask_file))
+
+ for frame_idx in sorted(frame_groups.keys()):
+ save_mask = np.zeros((h, w, 3), dtype=np.float32)
+ part_to_index = {}
+ parts_in_frame = sorted(frame_groups[frame_idx], key=lambda x: x[0])
+
+ for i, (part_name, mask_file) in enumerate(parts_in_frame):
+ mask_index = i + 1
+ part_to_index[part_name] = mask_index
+ mask_path = os.path.join(output_dir, mask_file)
+ mask_img = np.array(Image.open(mask_path))
+ if mask_img.shape[-1] == 4:
+ valid_region = mask_img[..., 3] > 0
+ else:
+ valid_region = mask_img.sum(axis=-1) > 0
+
+ save_mask[valid_region] = [mask_index, mask_index, mask_index]
+
+ output_file = os.path.join(output_dir, f"mask_{frame_idx:04d}.exr")
+ cv2.imwrite(output_file, save_mask)
+
+ print(f"Mask output saved to {output_dir}")
+ for mask_path in mask_list:
+ os.remove(os.path.join(output_dir, mask_path))
+
+def render():
+ bpy.context.scene.render.use_compositing = True
+ bpy.context.scene.use_nodes = True
+
+ tree = bpy.context.scene.node_tree
+ links = tree.links
+
+ if "Render Layers" not in tree.nodes:
+ rl = tree.nodes.new('CompositorNodeRLayers')
+ else:
+ rl = tree.nodes["Render Layers"]
+ if bpy.context.scene.frame_end != bpy.context.scene.frame_start:
+ bpy.context.scene.frame_end -= 1
+ bpy.ops.render.render(animation=True, write_still=True)
+ bpy.context.scene.frame_end += 1
+ else:
+ raise RuntimeError("No camera poses have been registered, therefore nothing can be rendered. A camera "
+ "pose can be registered via bproc.camera.add_camera_pose().")
+
+
+def convert_position(location, center):
+ position = ""
+ axis = ['x', 'y', 'z']
+ sub = location-center
+ for i in range(len(axis)):
+ if sub[i] > 0:
+ position = position + "+" + axis[i]
+ elif sub[i] < 0:
+ position = position + "-" + axis[i]
+ return position
+
+
+def set_color_output(output_dir: Optional[str] = '', file_prefix: str = "render_"):
+ scene = bpy.context.scene
+ scene.render.use_compositing = True
+ scene.use_nodes = True
+ scene.render.resolution_x = RESOLUTION
+ scene.render.resolution_y = RESOLUTION
+ scene.render.image_settings.file_format = 'WEBP'
+ scene.render.image_settings.quality = 100
+ scene.render.image_settings.color_mode = 'RGBA'
+ # scene.render.image_settings.color_depth = '16'
+ scene.render.film_transparent = True
+ scene.render.filepath = os.path.join(output_dir, file_prefix)
+ pass
+
+
+def eevee_init():
+ bpy.context.scene.render.engine = 'BLENDER_EEVEE'
+ bpy.context.scene.eevee.taa_render_samples = RENDER_SAMPLES
+ if CLOSE_SHADOW == False:
+ bpy.context.scene.eevee.use_gtao = True
+ bpy.context.scene.eevee.use_ssr = True
+ bpy.context.scene.render.use_high_quality_normals = True
+
+
+def clear_scene(NOT_CLEAR_LIGHT=False):
+ bpy.ops.object.select_all(action="DESELECT")
+ if NOT_CLEAR_LIGHT:
+ for obj in bpy.data.objects:
+ if obj.type not in {"CAMERA", "LIGHT"}:
+ bpy.data.objects.remove(obj, do_unlink=True)
+ else:
+ bpy.ops.object.select_all(action='SELECT')
+ bpy.ops.object.delete()
+ bpy.context.scene.use_nodes = True
+ node_tree = bpy.context.scene.node_tree
+
+ for node in node_tree.nodes:
+ node_tree.nodes.remove(node)
+ reset_keyframes()
+
+
+def import_models(filepath, types):
+ if types == "glb":
+ bpy.ops.import_scene.gltf(
+ filepath=filepath)
+ elif types == "obj":
+ forward_axis = os.environ.get('FORWARD_AXIS', 'NEGATIVE_Z')
+ up_axis = os.environ.get('UP_AXIS', 'Y')
+ bpy.ops.wm.obj_import(filepath=filepath, directory=os.path.dirname(filepath),forward_axis=forward_axis, up_axis=up_axis)
+
+
+def rotation_matrix(x_left, x_right, y_left, y_right):
+ x_rotation = math.radians(generate_random(x_left, x_right))
+ y_rotation = math.radians(generate_random(y_left, y_right))
+ x_rotation_matrix = mathutils.Matrix.Rotation(x_rotation, 4, 'X')
+ y_rotation_matrix = mathutils.Matrix.Rotation(y_rotation, 4, 'Y')
+ final_rotation_matrix = y_rotation_matrix @ x_rotation_matrix
+ return final_rotation_matrix
+
+
+def scene_bbox(objects=None, ignore_small_obj=False, ignore_matrix=False):
+ bbox_min = (math.inf,) * 3
+ bbox_max = (-math.inf,) * 3
+ found = False
+ for obj in objects:
+ # print(max(obj.dimensions*100))
+ if max(obj.dimensions*100) < 0.1 and ignore_small_obj:
+ print("ignore_small_obj", obj.name,max(obj.dimensions*100))
+ continue
+ found = True
+ for coord in obj.bound_box:
+ # print(coord[0], coord[1], coord[2])
+ coord = Vector(coord)
+ if not ignore_matrix:
+ coord = obj.matrix_world @ coord
+
+ bbox_min = Vector(
+ (min(bbox_min[i], coord[i]) for i in range(3)))
+ bbox_max = Vector(
+ (max(bbox_max[i], coord[i]) for i in range(3)))
+
+ if not found:
+ raise RuntimeError("no objects in scene to compute bounding box for")
+ return Vector(bbox_min), Vector(bbox_max)
+
+
+def scene_root_objects():
+ for obj in bpy.context.scene.objects.values():
+ if not obj.parent:
+ yield obj
+
+
+def set_global_light(env_light=0.5):
+ world_tree = bpy.context.scene.world.node_tree
+ back_node = world_tree.nodes["Background"]
+ back_node.inputs["Color"].default_value = Vector(
+ [env_light, env_light, env_light, 1.0]
+ )
+ back_node.inputs["Strength"].default_value = 1.0
+
+
+def normalize_scene(normalization_range, objects):
+ bpy.ops.object.empty_add(type='PLAIN_AXES')
+ root_object = bpy.context.object
+ for obj in scene_root_objects():
+ if obj != root_object:
+ _matrix_world = obj.matrix_world.copy()
+ obj.parent = root_object
+ obj.matrix_world = _matrix_world
+ bpy.context.view_layer.update()
+
+ bbox_min, bbox_max = scene_bbox(objects)
+ scale = normalization_range / max(bbox_max - bbox_min)
+ root_object.scale *= scale
+ bpy.context.view_layer.update()
+
+ bbox_min, bbox_max = scene_bbox(objects,True)
+ mesh_offset = - (bbox_min + bbox_max) / 2
+ root_object.matrix_local.translation = mesh_offset
+ bpy.context.view_layer.update()
+
+ bpy.ops.object.select_all(action="DESELECT")
+ return root_object, bbox_max - bbox_min, scale, mesh_offset
+
+
+def compute_bounding_box(mesh_objects):
+ min_coords = Vector((float('inf'), float('inf'), float('inf')))
+ max_coords = Vector((float('-inf'), float('-inf'), float('-inf')))
+
+ for obj in mesh_objects:
+ matrix_world = obj.matrix_world
+ mesh = obj.data
+
+ for vert in mesh.vertices:
+ global_coord = matrix_world @ vert.co
+
+ min_coords = Vector(
+ (min(min_coords[i], global_coord[i]) for i in range(3)))
+ max_coords = Vector(
+ (max(max_coords[i], global_coord[i]) for i in range(3)))
+
+ bbox_center = (min_coords + max_coords) / 2
+ bbox_size = max_coords - min_coords
+
+ return bbox_center, bbox_size
+
+
+def change_material_blend_mode():
+ for material in bpy.data.materials:
+ material.use_nodes = True
+ node_tree = material.node_tree
+ material.blend_method = 'OPAQUE'
+
+def change_material_blend_show_transparent(value):
+ for material in bpy.data.materials:
+ material.use_nodes = True
+ if material.blend_method == 'BLEND':
+ material.show_transparent_back = value
+
+
+def get_random_points_on_sphere(center, radius, num_points=8):
+ points = []
+ for i in range(num_points):
+
+ r = radius
+ theta = random.uniform(0, 2*math.pi)
+ phi = random.uniform(0, 0.5*math.pi)
+
+ x = center[0] + r * math.sin(phi) * math.cos(theta)
+ y = center[1] + r * math.sin(phi) * math.sin(theta)
+ z = center[2] + r * math.cos(phi)
+
+ flag = -1 if bool(random.randint(0, 1)) else 1
+ points.append(Vector((x, y, z*flag)))
+
+ return points
+
+
+def get_solid_points_on_sphere(center, radius):
+ points = []
+ elev_list = [25., 25., 25., 25., 25., 25., 25., 25.]
+ azim_list = [0, 45, 90, 135, 180, 225, 270, 315]
+
+ for i in range(len(elev_list)):
+ x = center[0] + radius * math.cos(math.radians(elev_list[i])) * math.cos(math.radians(azim_list[i]))
+ y = center[1] + radius * math.cos(math.radians(elev_list[i])) * math.sin(math.radians(azim_list[i]))
+ z = center[2] + radius * math.sin(math.radians(elev_list[i]))
+ points.append(Vector((x, y, z)))
+
+ return points
+
+
+def listify_matrix(matrix):
+ matrix_list = []
+ for row in matrix:
+ matrix_list.append(list(row))
+ return matrix_list
+
+
+def process(filepath, types, output_path):
+
+ random.seed()
+ eevee_init()
+ clear_scene()
+ import_models(filepath, types)
+ reset_keyframes()
+
+ bpy.ops.object.select_by_type(type='MESH')
+ os.makedirs(output_path, exist_ok=True)
+
+ mesh_objects = []
+ for obj in bpy.context.scene.objects:
+ if obj.type == 'MESH' and obj.visible_get() == True and obj.hide_get() == False:
+ mesh_objects.append(obj)
+ bpy.ops.object.select_all(action="DESELECT")
+ bpy.ops.object.select_pattern(pattern=obj.name)
+
+ for obj in mesh_objects:
+ obj.data.use_auto_smooth = True
+ obj.data.auto_smooth_angle = np.deg2rad(30)
+
+ for obj in bpy.data.objects:
+ if obj.animation_data is not None:
+ obj.animation_data_clear()
+
+ clear_normal_map()
+ change_material_blend_show_transparent(False)
+
+
+ normalization_range = 1.0
+ root_object, bbox_size, scale, mesh_offset = normalize_scene(normalization_range,mesh_objects)
+ bpy.context.view_layer.update()
+ root_object.rotation_euler[2] = math.radians(int(os.environ.get("FORCE_ROTATION", 0)))
+ bbox_center = Vector((0,0,0))
+
+ bpy.ops.object.camera_add(location=(0, 0, 0))
+ bpy.context.scene.camera = bpy.context.object
+
+
+ default_camera_lens = 50
+ default_camera_senser_width = 36
+ default_camera_ortho_scale = 1.4
+
+ ratio = 1
+ distance = ratio * default_camera_lens / default_camera_senser_width * \
+ math.sqrt(bbox_size.x**2 + bbox_size.y**2+bbox_size.z**2)
+ idx = 0
+
+ env_texture = "null"
+ set_global_light(env_light=0.5)
+
+ camera_angle_x = 2.0*math.atan(default_camera_senser_width/2/default_camera_lens)
+ out_data = {
+ 'camera_angle_x': camera_angle_x,
+ 'camera_lens': default_camera_lens,
+ 'sensor_width': default_camera_senser_width,
+ 'env_texture': env_texture,
+ 'bbox_size': list(bbox_size),
+ 'scaling_factor': scale,
+ 'mesh_offset': list(mesh_offset),
+ 'transforms': []
+ }
+
+ parent_matrix_list = [
+ rotation_matrix(0, 0, 0, 0),
+ ]
+
+ camera_locations = get_solid_points_on_sphere(
+ bbox_center, distance)
+
+ camera_locations_random = get_random_points_on_sphere(bbox_center, distance)
+
+ camera_locations = camera_locations + camera_locations_random
+
+ positon_tag = [convert_position(camera_location,bbox_center) for camera_location in camera_locations]
+
+ for parent_matrix in parent_matrix_list:
+ camera_idx = 0
+
+ for camera_location in camera_locations:
+ _lens = 50
+ _camera_location = camera_location * \
+ (_lens / default_camera_lens)
+ _rotation_euler = (
+ bbox_center - _camera_location).to_track_quat('-Z', 'Y').to_euler()
+ cam_matrix = build_transformation_mat(
+ _camera_location, _rotation_euler)
+ cam_matrix = listify_matrix(parent_matrix) @ cam_matrix
+ camera_params = {
+ 'camera_type': 'PERSP',
+ 'camera_lens': _lens,
+ 'camera_sensor_width': default_camera_senser_width,
+ }
+ # add_camera(cam_matrix,camera_params)
+ add_camera_pose(cam_matrix, camera_params)
+ index = "{0:04d}".format(idx)
+ out_data['transforms'].append(listify_matrix(cam_matrix))
+ idx += 1
+ camera_idx += 1
+
+ set_color_output(output_dir=output_path)
+ enable_mask_output(output_dir=output_path, file_prefix="mask_")
+ render()
+ format_mask_output(output_dir=output_path)
+
+ render_opaque_flag = RENDER_DEPTH
+ if render_opaque_flag:
+ change_material_blend_mode()
+ set_color_output(output_dir=output_path, file_prefix="render_opaque_")
+
+ if RENDER_DEPTH:
+ enable_depth_output(output_dir=output_path)
+ if render_opaque_flag:
+ render()
+
+ with open(os.path.join(output_path, META_FILENAME), 'w') as out_file:
+ json.dump(out_data, out_file, indent=4)
+
+ file_prefix = "render_opaque_"
+ pattern = os.path.join(output_path, f'{file_prefix}*')
+ files_to_delete = glob.glob(pattern)
+ for file in files_to_delete:
+ os.remove(file)
+
+
+if __name__ == "__main__":
+ if len(sys.argv) < 1:
+ print(
+ "Usage: [path_to_blender] -b -P blender_render_img_mask.py [mesh_path] [types] [output_path]")
+ exit(1)
+ else:
+ mesh_path = sys.argv[4]
+ types = sys.argv[5]
+ output_path = sys.argv[6]
+ ret = process(mesh_path, types, output_path)
+ if ret:
+ exit(0)
+ else:
+ exit(1)
diff --git a/OmniPart/dataset_toolkits/merge_slat.py b/OmniPart/dataset_toolkits/merge_slat.py
new file mode 100644
index 0000000..a8ef244
--- /dev/null
+++ b/OmniPart/dataset_toolkits/merge_slat.py
@@ -0,0 +1,51 @@
+from tqdm import tqdm
+from multiprocessing import Pool
+import os
+import numpy as np
+
+def merge_part_latents(args):
+
+ uuid, output_dir = args
+ part_dir = os.path.join(output_dir, uuid[:2], uuid)
+ valid_part_id_path = os.path.join(part_dir, 'overall', 'part_id.txt')
+ with open(valid_part_id_path, 'r') as f:
+ part_ids = f.read().strip().splitlines()
+ all_data_coord = []
+ all_data_feat = []
+ all_data_offset = [0]
+ overall_save_path = os.path.join(part_dir, 'overall', 'latent.npz')
+ overall_latent = np.load(overall_save_path)
+ all_data_coord.append(overall_latent['coords'])
+ all_data_feat.append(overall_latent['feats'])
+ all_data_offset.append(overall_latent['coords'].shape[0])
+ for part_id in part_ids:
+ part_latent_path = os.path.join(part_dir, part_id, 'latent.npz')
+ part_latent = np.load(part_latent_path)
+ all_data_coord.append(part_latent['coords'])
+ all_data_feat.append(part_latent['feats'])
+ all_data_offset.append(all_data_offset[-1] + part_latent['coords'].shape[0])
+
+ all_data_coord = np.concatenate(all_data_coord, axis=0)
+ all_data_feat = np.concatenate(all_data_feat, axis=0)
+ all_data_offset = np.array(all_data_offset)
+ save_dict = {
+ 'coords': all_data_coord,
+ 'feats': all_data_feat,
+ 'offsets': all_data_offset
+ }
+ save_path = os.path.join(part_dir, 'all_latent.npz')
+ np.savez_compressed(save_path, **save_dict)
+
+
+if __name__ == "__main__":
+
+ valid_uuid_path = ''
+ output_dir = ''
+ with open(valid_uuid_path, 'r') as f:
+ valid_uuids = [line.strip() for line in f.readlines()]
+ args_list = []
+ for uuid in valid_uuids:
+ args_list.append((uuid, output_dir))
+
+ with Pool(64) as p:
+ results = list(tqdm(p.imap(merge_part_latents, args_list), total=len(args_list)))
\ No newline at end of file
diff --git a/OmniPart/dataset_toolkits/voxelize_overall.py b/OmniPart/dataset_toolkits/voxelize_overall.py
new file mode 100644
index 0000000..6a14dfa
--- /dev/null
+++ b/OmniPart/dataset_toolkits/voxelize_overall.py
@@ -0,0 +1,68 @@
+import os
+import copy
+import sys
+import importlib
+import argparse
+from easydict import EasyDict as edict
+import pandas as pd
+from functools import partial
+import numpy as np
+import open3d as o3d
+import utils3d
+from multiprocessing import Pool
+from tqdm import tqdm
+import json
+import glob
+
+import utils3d
+
+def _voxelize(args):
+ sha256, output_dir = args
+ uuid_path = os.path.join(output_dir, sha256[:2], sha256)
+ pattern = os.path.join(uuid_path, "[0-9][0-9][0-9][0-9]")
+ matching_dirs = glob.glob(pattern)
+ part_id_list = [os.path.basename(dir_path) for dir_path in matching_dirs]
+ part_num = len(part_id_list)
+ filter_small_part_th = 5
+
+ part_voxel_list = []
+ new_part_id_list = []
+
+ for i, (dir_path, part_id) in enumerate(zip(matching_dirs, part_id_list)):
+ part_path = os.path.join(dir_path, 'voxel.ply')
+ voxel = utils3d.io.read_ply(part_path)[0]
+ if len(voxel) <= filter_small_part_th:
+ continue
+ part_voxel_list.append(voxel)
+ new_part_id_list.append(part_id)
+
+ if len(part_voxel_list) == 0:
+ print(f"Error: No valid parts found for {sha256}")
+ return
+
+ combined = list(zip(part_voxel_list, new_part_id_list))
+ sorted_combined = sorted(combined, key=lambda x: x[0].min(axis=0)[2])
+ part_voxel_list, new_part_id_list = zip(*sorted_combined)
+
+ overall_voxel = np.vstack(part_voxel_list)
+ overall_voxel = np.unique(overall_voxel, axis=0)
+
+ utils3d.io.write_ply(os.path.join(uuid_path, 'overall', f'voxel.ply'), overall_voxel)
+ with open(os.path.join(uuid_path, 'overall', f'part_id.txt'), 'w') as f:
+ for part_id in new_part_id_list:
+ f.write(f"{part_id}\n")
+
+
+
+
+if __name__ == '__main__':
+ data_path = ''
+ output_dir = ''
+
+ with open(data_path, 'r') as f:
+ data_list = [json.loads(line.strip()) for line in f.readlines()]
+
+ args_list = [(sha256, output_dir) for sha256 in data_list]
+
+ with Pool(128) as p:
+ results = list(tqdm(p.imap(_voxelize, args_list), total=len(args_list)))
\ No newline at end of file
diff --git a/OmniPart/dataset_toolkits/voxelize_part.py b/OmniPart/dataset_toolkits/voxelize_part.py
new file mode 100644
index 0000000..10600e5
--- /dev/null
+++ b/OmniPart/dataset_toolkits/voxelize_part.py
@@ -0,0 +1,49 @@
+import os
+import copy
+import sys
+import importlib
+import argparse
+from easydict import EasyDict as edict
+import pandas as pd
+from functools import partial
+import numpy as np
+import open3d as o3d
+import utils3d
+from multiprocessing import Pool
+from tqdm import tqdm
+import json
+import glob
+
+def _voxelize(args):
+ sha256, output_dir = args
+ uuid_path = os.path.join(output_dir, sha256[:2], sha256)
+ pattern = os.path.join(uuid_path, "[0-9][0-9][0-9][0-9]")
+ matching_dirs = glob.glob(pattern)
+
+ for dir_path in matching_dirs:
+
+ mesh = o3d.io.read_triangle_mesh(os.path.join(dir_path, 'mesh.stl'))
+ # clamp vertices to the range [-0.5, 0.5]
+ vertices = np.clip(np.asarray(mesh.vertices), -0.5 + 1e-6, 0.5 - 1e-6)
+ assert len(vertices)>0, "Error loading mesh.stl, no vertices found"
+ mesh.vertices = o3d.utility.Vector3dVector(vertices)
+ voxel_grid = o3d.geometry.VoxelGrid.create_from_triangle_mesh_within_bounds(mesh, voxel_size=1/64, min_bound=(-0.5, -0.5, -0.5), max_bound=(0.5, 0.5, 0.5))
+ vertices = np.array([voxel.grid_index for voxel in voxel_grid.get_voxels()])
+ assert np.all(vertices >= 0) and np.all(vertices < 64), "Some vertices are out of bounds"
+ vertices = (vertices + 0.5) / 64 - 0.5
+ utils3d.io.write_ply(os.path.join(dir_path, f'voxel.ply'), vertices)
+ # return {'sha256': sha256, 'voxelized': True, 'num_voxels': len(vertices)}
+
+
+if __name__ == '__main__':
+
+ data_path = ''
+ output_dir = ''
+
+ with open(data_path, 'r') as f:
+ data_list = [json.loads(line.strip()) for line in f.readlines()]
+
+ args_list = [(sha256, output_dir) for sha256 in data_list]
+
+ with Pool(128) as p:
+ results = list(tqdm(p.imap(_voxelize, args_list), total=len(args_list)))
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/configs/final/correspondence_demo.yaml b/OmniPart/modules/PartField/configs/final/correspondence_demo.yaml
new file mode 100644
index 0000000..f4e07ae
--- /dev/null
+++ b/OmniPart/modules/PartField/configs/final/correspondence_demo.yaml
@@ -0,0 +1,44 @@
+result_name: partfield_features/correspondence_demo
+
+continue_ckpt: model/model.ckpt
+
+triplane_channels_low: 128
+triplane_channels_high: 512
+triplane_resolution: 128
+
+vertex_feature: True
+n_point_per_face: 1000
+n_sample_each: 10000
+is_pc: True
+remesh_demo: False
+correspondence_demo: True
+
+preprocess_mesh: True
+
+dataset:
+ type: "Mix"
+ data_path: data/DenseCorr3D
+ train_batch_size: 1
+ val_batch_size: 1
+ train_num_workers: 8
+ all_files:
+ # pairs of example to run correspondence
+ - animals/071b8_toy_animals_017/simple_mesh.obj
+ - animals/bdfd0_toy_animals_016/simple_mesh.obj
+ - animals/2d6b3_toy_animals_009/simple_mesh.obj
+ - animals/96615_toy_animals_018/simple_mesh.obj
+ - chairs/063d1_chair_006/simple_mesh.obj
+ - chairs/bea57_chair_012/simple_mesh.obj
+ - chairs/fe0fe_chair_004/simple_mesh.obj
+ - chairs/288dc_chair_011/simple_mesh.obj
+ # consider decimating animals/../color_mesh.obj yourself for better mesh topology than the provided simple_mesh.obj
+ # (e.g. <50k vertices for functional map efficiency).
+
+loss:
+ triplet: 1.0
+
+use_2d_feat: False
+pvcnn:
+ point_encoder_type: 'pvcnn'
+ z_triplane_channels: 256
+ z_triplane_resolution: 128
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/configs/final/demo.yaml b/OmniPart/modules/PartField/configs/final/demo.yaml
new file mode 100644
index 0000000..818558b
--- /dev/null
+++ b/OmniPart/modules/PartField/configs/final/demo.yaml
@@ -0,0 +1,28 @@
+result_name: demo_test
+
+continue_ckpt: model/model.ckpt
+
+triplane_channels_low: 128
+triplane_channels_high: 512
+triplane_resolution: 128
+
+n_point_per_face: 1000
+n_sample_each: 10000
+is_pc : True
+remesh_demo : False
+
+dataset:
+ type: "Mix"
+ data_path: "objaverse_data"
+ train_batch_size: 1
+ val_batch_size: 1
+ train_num_workers: 8
+
+loss:
+ triplet: 1.0
+
+use_2d_feat: False
+pvcnn:
+ point_encoder_type: 'pvcnn'
+ z_triplane_channels: 256
+ z_triplane_resolution: 128
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/config/__init__.py b/OmniPart/modules/PartField/partfield/config/__init__.py
new file mode 100644
index 0000000..3958250
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/config/__init__.py
@@ -0,0 +1,26 @@
+import argparse
+import os.path as osp
+from datetime import datetime
+import pytz
+
+def default_argument_parser(add_help=True, default_config_file=""):
+ parser = argparse.ArgumentParser(add_help=add_help)
+ parser.add_argument("--config-file", '-c', default=default_config_file, metavar="FILE", help="path to config file")
+ parser.add_argument(
+ "--opts",
+ help="Modify config options using the command-line",
+ default=None,
+ nargs=argparse.REMAINDER,
+ )
+ return parser
+
+def setup(args, freeze=True):
+ from .defaults import _C as cfg
+ cfg = cfg.clone()
+ cfg.merge_from_file(args.config_file)
+ cfg.merge_from_list(args.opts)
+ dt = datetime.now(pytz.timezone('America/Los_Angeles')).strftime('%y%m%d-%H%M%S')
+ cfg.output_dir = osp.join(cfg.output_dir, cfg.name, dt)
+ if freeze:
+ cfg.freeze()
+ return cfg
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/config/defaults.py b/OmniPart/modules/PartField/partfield/config/defaults.py
new file mode 100644
index 0000000..14f82ed
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/config/defaults.py
@@ -0,0 +1,92 @@
+from yacs.config import CfgNode as CN
+
+_C = CN()
+_C.seed = 0
+_C.output_dir = "results"
+_C.result_name = "test_all"
+
+_C.triplet_sampling = "random"
+_C.load_original_mesh = False
+
+_C.num_pos = 64
+_C.num_neg_random = 256
+_C.num_neg_hard_pc = 128
+_C.num_neg_hard_emb = 128
+
+_C.vertex_feature = False # if true, sample feature on vertices; if false, sample feature on faces
+_C.n_point_per_face = 2000
+_C.n_sample_each = 10000
+_C.preprocess_mesh = False
+
+_C.regress_2d_feat = False
+
+_C.is_pc = False
+
+_C.cut_manifold = False
+_C.remesh_demo = False
+_C.correspondence_demo = False
+
+_C.save_every_epoch = 10
+_C.training_epochs = 30
+_C.continue_training = False
+
+_C.continue_ckpt = None
+_C.epoch_selected = "epoch=50.ckpt"
+
+_C.triplane_resolution = 128
+_C.triplane_channels_low = 128
+_C.triplane_channels_high = 512
+_C.lr = 1e-3
+_C.train = True
+_C.test = False
+
+_C.inference_save_pred_sdf_to_mesh=True
+_C.inference_save_feat_pca=True
+_C.name = "test"
+_C.test_subset = False
+_C.test_corres = False
+_C.test_partobjaversetiny = False
+
+_C.dataset = CN()
+_C.dataset.type = "Demo_Dataset"
+_C.dataset.data_path = "objaverse_data/"
+_C.dataset.train_num_workers = 64
+_C.dataset.val_num_workers = 32
+_C.dataset.train_batch_size = 2
+_C.dataset.val_batch_size = 2
+_C.dataset.all_files = [] # only used for correspondence demo
+
+_C.voxel2triplane = CN()
+_C.voxel2triplane.transformer_dim = 1024
+_C.voxel2triplane.transformer_layers = 6
+_C.voxel2triplane.transformer_heads = 8
+_C.voxel2triplane.triplane_low_res = 32
+_C.voxel2triplane.triplane_high_res = 256
+_C.voxel2triplane.triplane_dim = 64
+_C.voxel2triplane.normalize_vox_feat = False
+
+
+_C.loss = CN()
+_C.loss.triplet = 0.0
+_C.loss.sdf = 1.0
+_C.loss.feat = 10.0
+_C.loss.l1 = 0.0
+
+_C.use_pvcnn = False
+_C.use_pvcnnonly = True
+
+_C.pvcnn = CN()
+_C.pvcnn.point_encoder_type = 'pvcnn'
+_C.pvcnn.use_point_scatter = True
+_C.pvcnn.z_triplane_channels = 64
+_C.pvcnn.z_triplane_resolution = 256
+_C.pvcnn.unet_cfg = CN()
+_C.pvcnn.unet_cfg.depth = 3
+_C.pvcnn.unet_cfg.enabled = True
+_C.pvcnn.unet_cfg.rolled = True
+_C.pvcnn.unet_cfg.use_3d_aware = True
+_C.pvcnn.unet_cfg.start_hidden_channels = 32
+_C.pvcnn.unet_cfg.use_initial_conv = False
+
+_C.use_2d_feat = False
+_C.inference_metrics_only = False
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/conv_pointnet.py b/OmniPart/modules/PartField/partfield/model/PVCNN/conv_pointnet.py
new file mode 100644
index 0000000..8c5c806
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/conv_pointnet.py
@@ -0,0 +1,251 @@
+"""
+Taken from gensdf
+https://github.com/princeton-computational-imaging/gensdf
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+# from dnnlib.util import printarr
+try:
+ from torch_scatter import scatter_mean, scatter_max
+except:
+ pass
+# from .unet import UNet
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+# Resnet Blocks
+class ResnetBlockFC(nn.Module):
+ ''' Fully connected ResNet Block class.
+ Args:
+ size_in (int): input dimension
+ size_out (int): output dimension
+ size_h (int): hidden dimension
+ '''
+
+ def __init__(self, size_in, size_out=None, size_h=None):
+ super().__init__()
+ # Attributes
+ if size_out is None:
+ size_out = size_in
+
+ if size_h is None:
+ size_h = min(size_in, size_out)
+
+ self.size_in = size_in
+ self.size_h = size_h
+ self.size_out = size_out
+ # Submodules
+ self.fc_0 = nn.Linear(size_in, size_h)
+ self.fc_1 = nn.Linear(size_h, size_out)
+ self.actvn = nn.ReLU()
+
+ if size_in == size_out:
+ self.shortcut = None
+ else:
+ self.shortcut = nn.Linear(size_in, size_out, bias=False)
+ # Initialization
+ nn.init.zeros_(self.fc_1.weight)
+
+ def forward(self, x):
+ net = self.fc_0(self.actvn(x))
+ dx = self.fc_1(self.actvn(net))
+
+ if self.shortcut is not None:
+ x_s = self.shortcut(x)
+ else:
+ x_s = x
+
+ return x_s + dx
+
+
+class ConvPointnet(nn.Module):
+ ''' PointNet-based encoder network with ResNet blocks for each point.
+ Number of input points are fixed.
+
+ Args:
+ c_dim (int): dimension of latent code c
+ dim (int): input points dimension
+ hidden_dim (int): hidden dimension of the network
+ scatter_type (str): feature aggregation when doing local pooling
+ unet (bool): weather to use U-Net
+ unet_kwargs (str): U-Net parameters
+ plane_resolution (int): defined resolution for plane feature
+ plane_type (str): feature type, 'xz' - 1-plane, ['xz', 'xy', 'yz'] - 3-plane, ['grid'] - 3D grid volume
+ padding (float): conventional padding paramter of ONet for unit cube, so [-0.5, 0.5] -> [-0.55, 0.55]
+ n_blocks (int): number of blocks ResNetBlockFC layers
+ '''
+
+ def __init__(self, c_dim=128, dim=3, hidden_dim=128, scatter_type='max',
+ # unet=False, unet_kwargs=None,
+ plane_resolution=None, plane_type=['xz', 'xy', 'yz'], padding=0.1, n_blocks=5):
+ super().__init__()
+ self.c_dim = c_dim
+
+ self.fc_pos = nn.Linear(dim, 2*hidden_dim)
+ self.blocks = nn.ModuleList([
+ ResnetBlockFC(2*hidden_dim, hidden_dim) for i in range(n_blocks)
+ ])
+ self.fc_c = nn.Linear(hidden_dim, c_dim)
+
+ self.actvn = nn.ReLU()
+ self.hidden_dim = hidden_dim
+
+ # if unet:
+ # self.unet = UNet(c_dim, in_channels=c_dim, **unet_kwargs)
+ # else:
+ # self.unet = None
+
+ self.reso_plane = plane_resolution
+ self.plane_type = plane_type
+ self.padding = padding
+
+ if scatter_type == 'max':
+ self.scatter = scatter_max
+ elif scatter_type == 'mean':
+ self.scatter = scatter_mean
+
+
+ # takes in "p": point cloud and "query": sdf_xyz
+ # sample plane features for unlabeled_query as well
+ def forward(self, p):#, query2):
+ batch_size, T, D = p.size()
+
+ # acquire the index for each point
+ coord = {}
+ index = {}
+ if 'xz' in self.plane_type:
+ coord['xz'] = self.normalize_coordinate(p.clone(), plane='xz', padding=self.padding)
+ index['xz'] = self.coordinate2index(coord['xz'], self.reso_plane)
+ if 'xy' in self.plane_type:
+ coord['xy'] = self.normalize_coordinate(p.clone(), plane='xy', padding=self.padding)
+ index['xy'] = self.coordinate2index(coord['xy'], self.reso_plane)
+ if 'yz' in self.plane_type:
+ coord['yz'] = self.normalize_coordinate(p.clone(), plane='yz', padding=self.padding)
+ index['yz'] = self.coordinate2index(coord['yz'], self.reso_plane)
+
+
+ net = self.fc_pos(p)
+
+ net = self.blocks[0](net)
+ for block in self.blocks[1:]:
+ pooled = self.pool_local(coord, index, net)
+ net = torch.cat([net, pooled], dim=2)
+ net = block(net)
+
+ c = self.fc_c(net)
+
+ fea = {}
+ plane_feat_sum = 0
+ #second_sum = 0
+ if 'xz' in self.plane_type:
+ fea['xz'] = self.generate_plane_features(p, c, plane='xz') # shape: batch, latent size, resolution, resolution (e.g. 16, 256, 64, 64)
+ # plane_feat_sum += self.sample_plane_feature(query, fea['xz'], 'xz')
+ #second_sum += self.sample_plane_feature(query2, fea['xz'], 'xz')
+ if 'xy' in self.plane_type:
+ fea['xy'] = self.generate_plane_features(p, c, plane='xy')
+ # plane_feat_sum += self.sample_plane_feature(query, fea['xy'], 'xy')
+ #second_sum += self.sample_plane_feature(query2, fea['xy'], 'xy')
+ if 'yz' in self.plane_type:
+ fea['yz'] = self.generate_plane_features(p, c, plane='yz')
+ # plane_feat_sum += self.sample_plane_feature(query, fea['yz'], 'yz')
+ #second_sum += self.sample_plane_feature(query2, fea['yz'], 'yz')
+ return fea
+
+ # return plane_feat_sum.transpose(2,1)#, second_sum.transpose(2,1)
+
+
+ def normalize_coordinate(self, p, padding=0.1, plane='xz'):
+ ''' Normalize coordinate to [0, 1] for unit cube experiments
+
+ Args:
+ p (tensor): point
+ padding (float): conventional padding paramter of ONet for unit cube, so [-0.5, 0.5] -> [-0.55, 0.55]
+ plane (str): plane feature type, ['xz', 'xy', 'yz']
+ '''
+ if plane == 'xz':
+ xy = p[:, :, [0, 2]]
+ elif plane =='xy':
+ xy = p[:, :, [0, 1]]
+ else:
+ xy = p[:, :, [1, 2]]
+
+ xy_new = xy / (1 + padding + 10e-6) # (-0.5, 0.5)
+ xy_new = xy_new + 0.5 # range (0, 1)
+
+ # f there are outliers out of the range
+ if xy_new.max() >= 1:
+ xy_new[xy_new >= 1] = 1 - 10e-6
+ if xy_new.min() < 0:
+ xy_new[xy_new < 0] = 0.0
+ return xy_new
+
+
+ def coordinate2index(self, x, reso):
+ ''' Normalize coordinate to [0, 1] for unit cube experiments.
+ Corresponds to our 3D model
+
+ Args:
+ x (tensor): coordinate
+ reso (int): defined resolution
+ coord_type (str): coordinate type
+ '''
+ x = (x * reso).long()
+ index = x[:, :, 0] + reso * x[:, :, 1]
+ index = index[:, None, :]
+ return index
+
+
+ # xy is the normalized coordinates of the point cloud of each plane
+ # I'm pretty sure the keys of xy are the same as those of index, so xy isn't needed here as input
+ def pool_local(self, xy, index, c):
+ bs, fea_dim = c.size(0), c.size(2)
+ keys = xy.keys()
+
+ c_out = 0
+ for key in keys:
+ # scatter plane features from points
+ fea = self.scatter(c.permute(0, 2, 1), index[key], dim_size=self.reso_plane**2)
+ if self.scatter == scatter_max:
+ fea = fea[0]
+ # gather feature back to points
+ fea = fea.gather(dim=2, index=index[key].expand(-1, fea_dim, -1))
+ c_out += fea
+ return c_out.permute(0, 2, 1)
+
+
+ def generate_plane_features(self, p, c, plane='xz'):
+ # acquire indices of features in plane
+ xy = self.normalize_coordinate(p.clone(), plane=plane, padding=self.padding) # normalize to the range of (0, 1)
+ index = self.coordinate2index(xy, self.reso_plane)
+
+ # scatter plane features from points
+ fea_plane = c.new_zeros(p.size(0), self.c_dim, self.reso_plane**2)
+ c = c.permute(0, 2, 1) # B x 512 x T
+ fea_plane = scatter_mean(c, index, out=fea_plane) # B x 512 x reso^2
+ fea_plane = fea_plane.reshape(p.size(0), self.c_dim, self.reso_plane, self.reso_plane) # sparce matrix (B x 512 x reso x reso)
+
+ # printarr(fea_plane, c, p, xy, index)
+ # import pdb; pdb.set_trace()
+
+ # process the plane features with UNet
+ # if self.unet is not None:
+ # fea_plane = self.unet(fea_plane)
+
+ return fea_plane
+
+
+ # sample_plane_feature function copied from /src/conv_onet/models/decoder.py
+ # uses values from plane_feature and pixel locations from vgrid to interpolate feature
+ def sample_plane_feature(self, query, plane_feature, plane):
+ xy = self.normalize_coordinate(query.clone(), plane=plane, padding=self.padding)
+ xy = xy[:, :, None].float()
+ vgrid = 2.0 * xy - 1.0 # normalize to (-1, 1)
+ sampled_feat = F.grid_sample(plane_feature, vgrid, padding_mode='border', align_corners=True, mode='bilinear').squeeze(-1)
+ return sampled_feat
+
+
+
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/dnnlib_util.py b/OmniPart/modules/PartField/partfield/model/PVCNN/dnnlib_util.py
new file mode 100644
index 0000000..9514fe6
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/dnnlib_util.py
@@ -0,0 +1,1074 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+
+"""Miscellaneous utility classes and functions."""
+from collections import namedtuple
+import time
+import ctypes
+import fnmatch
+import importlib
+import inspect
+import numpy as np
+import json
+import os
+import shutil
+import sys
+import types
+import io
+import pickle
+import re
+# import requests
+import html
+import hashlib
+import glob
+import tempfile
+import urllib
+import urllib.request
+import uuid
+import boto3
+import threading
+from contextlib import ContextDecorator
+from contextlib import contextmanager, nullcontext
+
+from distutils.util import strtobool
+from typing import Any, List, Tuple, Union
+import importlib
+from loguru import logger
+# import wandb
+import torch
+import psutil
+import subprocess
+
+import random
+import string
+import pdb
+
+# Util classes
+# ------------------------------------------------------------------------------------------
+
+
+class EasyDict(dict):
+ """Convenience class that behaves like a dict but allows access with the attribute syntax."""
+
+ def __getattr__(self, name: str) -> Any:
+ try:
+ return self[name]
+ except KeyError:
+ raise AttributeError(name)
+
+ def __setattr__(self, name: str, value: Any) -> None:
+ self[name] = value
+
+ def __delattr__(self, name: str) -> None:
+ del self[name]
+
+
+class Logger(object):
+ """Redirect stderr to stdout, optionally print stdout to a file, and optionally force flushing on both stdout and the file."""
+
+ def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True):
+ self.file = None
+
+ if file_name is not None:
+ self.file = open(file_name, file_mode)
+
+ self.should_flush = should_flush
+ self.stdout = sys.stdout
+ self.stderr = sys.stderr
+
+ sys.stdout = self
+ sys.stderr = self
+
+ def __enter__(self) -> "Logger":
+ return self
+
+ def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+ self.close()
+
+ def write(self, text: Union[str, bytes]) -> None:
+ """Write text to stdout (and a file) and optionally flush."""
+ if isinstance(text, bytes):
+ text = text.decode()
+ if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash
+ return
+
+ if self.file is not None:
+ self.file.write(text)
+
+ self.stdout.write(text)
+
+ if self.should_flush:
+ self.flush()
+
+ def flush(self) -> None:
+ """Flush written text to both stdout and a file, if open."""
+ if self.file is not None:
+ self.file.flush()
+
+ self.stdout.flush()
+
+ def close(self) -> None:
+ """Flush, close possible files, and remove stdout/stderr mirroring."""
+ self.flush()
+
+ # if using multiple loggers, prevent closing in wrong order
+ if sys.stdout is self:
+ sys.stdout = self.stdout
+ if sys.stderr is self:
+ sys.stderr = self.stderr
+
+ if self.file is not None:
+ self.file.close()
+ self.file = None
+
+
+# Cache directories
+# ------------------------------------------------------------------------------------------
+
+_dnnlib_cache_dir = None
+
+
+def set_cache_dir(path: str) -> None:
+ global _dnnlib_cache_dir
+ _dnnlib_cache_dir = path
+
+
+def make_cache_dir_path(*paths: str) -> str:
+ if _dnnlib_cache_dir is not None:
+ return os.path.join(_dnnlib_cache_dir, *paths)
+ if 'DNNLIB_CACHE_DIR' in os.environ:
+ return os.path.join(os.environ['DNNLIB_CACHE_DIR'], *paths)
+ if 'HOME' in os.environ:
+ return os.path.join(os.environ['HOME'], '.cache', 'dnnlib', *paths)
+ if 'USERPROFILE' in os.environ:
+ return os.path.join(os.environ['USERPROFILE'], '.cache', 'dnnlib', *paths)
+ return os.path.join(tempfile.gettempdir(), '.cache', 'dnnlib', *paths)
+
+
+# Small util functions
+# ------------------------------------------------------------------------------------------
+
+
+def format_time(seconds: Union[int, float]) -> str:
+ """Convert the seconds to human readable string with days, hours, minutes and seconds."""
+ s = int(np.rint(seconds))
+
+ if s < 60:
+ return "{0}s".format(s)
+ elif s < 60 * 60:
+ return "{0}m {1:02}s".format(s // 60, s % 60)
+ elif s < 24 * 60 * 60:
+ return "{0}h {1:02}m {2:02}s".format(s // (60 * 60), (s // 60) % 60, s % 60)
+ else:
+ return "{0}d {1:02}h {2:02}m".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24, (s // 60) % 60)
+
+
+def format_time_brief(seconds: Union[int, float]) -> str:
+ """Convert the seconds to human readable string with days, hours, minutes and seconds."""
+ s = int(np.rint(seconds))
+
+ if s < 60:
+ return "{0}s".format(s)
+ elif s < 60 * 60:
+ return "{0}m {1:02}s".format(s // 60, s % 60)
+ elif s < 24 * 60 * 60:
+ return "{0}h {1:02}m".format(s // (60 * 60), (s // 60) % 60)
+ else:
+ return "{0}d {1:02}h".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24)
+
+
+def ask_yes_no(question: str) -> bool:
+ """Ask the user the question until the user inputs a valid answer."""
+ while True:
+ try:
+ print("{0} [y/n]".format(question))
+ return strtobool(input().lower())
+ except ValueError:
+ pass
+
+
+def tuple_product(t: Tuple) -> Any:
+ """Calculate the product of the tuple elements."""
+ result = 1
+
+ for v in t:
+ result *= v
+
+ return result
+
+
+_str_to_ctype = {
+ "uint8": ctypes.c_ubyte,
+ "uint16": ctypes.c_uint16,
+ "uint32": ctypes.c_uint32,
+ "uint64": ctypes.c_uint64,
+ "int8": ctypes.c_byte,
+ "int16": ctypes.c_int16,
+ "int32": ctypes.c_int32,
+ "int64": ctypes.c_int64,
+ "float32": ctypes.c_float,
+ "float64": ctypes.c_double
+}
+
+
+def get_dtype_and_ctype(type_obj: Any) -> Tuple[np.dtype, Any]:
+ """Given a type name string (or an object having a __name__ attribute), return matching Numpy and ctypes types that have the same size in bytes."""
+ type_str = None
+
+ if isinstance(type_obj, str):
+ type_str = type_obj
+ elif hasattr(type_obj, "__name__"):
+ type_str = type_obj.__name__
+ elif hasattr(type_obj, "name"):
+ type_str = type_obj.name
+ else:
+ raise RuntimeError("Cannot infer type name from input")
+
+ assert type_str in _str_to_ctype.keys()
+
+ my_dtype = np.dtype(type_str)
+ my_ctype = _str_to_ctype[type_str]
+
+ assert my_dtype.itemsize == ctypes.sizeof(my_ctype)
+
+ return my_dtype, my_ctype
+
+
+def is_pickleable(obj: Any) -> bool:
+ try:
+ with io.BytesIO() as stream:
+ pickle.dump(obj, stream)
+ return True
+ except:
+ return False
+
+
+# Functionality to import modules/objects by name, and call functions by name
+# ------------------------------------------------------------------------------------------
+
+def get_module_from_obj_name(obj_name: str) -> Tuple[types.ModuleType, str]:
+ """Searches for the underlying module behind the name to some python object.
+ Returns the module and the object name (original name with module part removed)."""
+
+ # allow convenience shorthands, substitute them by full names
+ obj_name = re.sub("^np.", "numpy.", obj_name)
+ obj_name = re.sub("^tf.", "tensorflow.", obj_name)
+
+ # list alternatives for (module_name, local_obj_name)
+ parts = obj_name.split(".")
+ name_pairs = [(".".join(parts[:i]), ".".join(parts[i:])) for i in range(len(parts), 0, -1)]
+
+ # try each alternative in turn
+ for module_name, local_obj_name in name_pairs:
+ try:
+ module = importlib.import_module(module_name) # may raise ImportError
+ get_obj_from_module(module, local_obj_name) # may raise AttributeError
+ return module, local_obj_name
+ except:
+ pass
+
+ # maybe some of the modules themselves contain errors?
+ for module_name, _local_obj_name in name_pairs:
+ try:
+ importlib.import_module(module_name) # may raise ImportError
+ except ImportError:
+ if not str(sys.exc_info()[1]).startswith("No module named '" + module_name + "'"):
+ raise
+
+ # maybe the requested attribute is missing?
+ for module_name, local_obj_name in name_pairs:
+ try:
+ module = importlib.import_module(module_name) # may raise ImportError
+ get_obj_from_module(module, local_obj_name) # may raise AttributeError
+ except ImportError:
+ pass
+
+ # we are out of luck, but we have no idea why
+ raise ImportError(obj_name)
+
+
+def get_obj_from_module(module: types.ModuleType, obj_name: str) -> Any:
+ """Traverses the object name and returns the last (rightmost) python object."""
+ if obj_name == '':
+ return module
+ obj = module
+ for part in obj_name.split("."):
+ obj = getattr(obj, part)
+ return obj
+
+
+def get_obj_by_name(name: str) -> Any:
+ """Finds the python object with the given name."""
+ module, obj_name = get_module_from_obj_name(name)
+ return get_obj_from_module(module, obj_name)
+
+
+def call_func_by_name(*args, func_name: str = None, **kwargs) -> Any:
+ """Finds the python object with the given name and calls it as a function."""
+ assert func_name is not None
+ func_obj = get_obj_by_name(func_name)
+ assert callable(func_obj)
+ return func_obj(*args, **kwargs)
+
+
+def construct_class_by_name(*args, class_name: str = None, **kwargs) -> Any:
+ """Finds the python class with the given name and constructs it with the given arguments."""
+ return call_func_by_name(*args, func_name=class_name, **kwargs)
+
+
+def get_module_dir_by_obj_name(obj_name: str) -> str:
+ """Get the directory path of the module containing the given object name."""
+ module, _ = get_module_from_obj_name(obj_name)
+ return os.path.dirname(inspect.getfile(module))
+
+
+def is_top_level_function(obj: Any) -> bool:
+ """Determine whether the given object is a top-level function, i.e., defined at module scope using 'def'."""
+ return callable(obj) and obj.__name__ in sys.modules[obj.__module__].__dict__
+
+
+def get_top_level_function_name(obj: Any) -> str:
+ """Return the fully-qualified name of a top-level function."""
+ assert is_top_level_function(obj)
+ module = obj.__module__
+ if module == '__main__':
+ module = os.path.splitext(os.path.basename(sys.modules[module].__file__))[0]
+ return module + "." + obj.__name__
+
+
+# File system helpers
+# ------------------------------------------------------------------------------------------
+
+def list_dir_recursively_with_ignore(dir_path: str, ignores: List[str] = None, add_base_to_relative: bool = False) -> List[Tuple[str, str]]:
+ """List all files recursively in a given directory while ignoring given file and directory names.
+ Returns list of tuples containing both absolute and relative paths."""
+ assert os.path.isdir(dir_path)
+ base_name = os.path.basename(os.path.normpath(dir_path))
+
+ if ignores is None:
+ ignores = []
+
+ result = []
+
+ for root, dirs, files in os.walk(dir_path, topdown=True):
+ for ignore_ in ignores:
+ dirs_to_remove = [d for d in dirs if fnmatch.fnmatch(d, ignore_)]
+
+ # dirs need to be edited in-place
+ for d in dirs_to_remove:
+ dirs.remove(d)
+
+ files = [f for f in files if not fnmatch.fnmatch(f, ignore_)]
+
+ absolute_paths = [os.path.join(root, f) for f in files]
+ relative_paths = [os.path.relpath(p, dir_path) for p in absolute_paths]
+
+ if add_base_to_relative:
+ relative_paths = [os.path.join(base_name, p) for p in relative_paths]
+
+ assert len(absolute_paths) == len(relative_paths)
+ result += zip(absolute_paths, relative_paths)
+
+ return result
+
+
+def copy_files_and_create_dirs(files: List[Tuple[str, str]]) -> None:
+ """Takes in a list of tuples of (src, dst) paths and copies files.
+ Will create all necessary directories."""
+ for file in files:
+ target_dir_name = os.path.dirname(file[1])
+
+ # will create all intermediate-level directories
+ if not os.path.exists(target_dir_name):
+ os.makedirs(target_dir_name)
+
+ shutil.copyfile(file[0], file[1])
+
+
+# URL helpers
+# ------------------------------------------------------------------------------------------
+
+def is_url(obj: Any, allow_file_urls: bool = False) -> bool:
+ """Determine whether the given object is a valid URL string."""
+ if not isinstance(obj, str) or not "://" in obj:
+ return False
+ if allow_file_urls and obj.startswith('file://'):
+ return True
+ try:
+ res = requests.compat.urlparse(obj)
+ if not res.scheme or not res.netloc or not "." in res.netloc:
+ return False
+ res = requests.compat.urlparse(requests.compat.urljoin(obj, "/"))
+ if not res.scheme or not res.netloc or not "." in res.netloc:
+ return False
+ except:
+ return False
+ return True
+
+
+def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False, cache: bool = True) -> Any:
+ """Download the given URL and return a binary-mode file object to access the data."""
+ assert num_attempts >= 1
+ assert not (return_filename and (not cache))
+
+ # Doesn't look like an URL scheme so interpret it as a local filename.
+ if not re.match('^[a-z]+://', url):
+ return url if return_filename else open(url, "rb")
+
+ # Handle file URLs. This code handles unusual file:// patterns that
+ # arise on Windows:
+ #
+ # file:///c:/foo.txt
+ #
+ # which would translate to a local '/c:/foo.txt' filename that's
+ # invalid. Drop the forward slash for such pathnames.
+ #
+ # If you touch this code path, you should test it on both Linux and
+ # Windows.
+ #
+ # Some internet resources suggest using urllib.request.url2pathname() but
+ # but that converts forward slashes to backslashes and this causes
+ # its own set of problems.
+ if url.startswith('file://'):
+ filename = urllib.parse.urlparse(url).path
+ if re.match(r'^/[a-zA-Z]:', filename):
+ filename = filename[1:]
+ return filename if return_filename else open(filename, "rb")
+
+ assert is_url(url)
+
+ # Lookup from cache.
+ if cache_dir is None:
+ cache_dir = make_cache_dir_path('downloads')
+
+ url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest()
+ if cache:
+ cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*"))
+ if len(cache_files) == 1:
+ filename = cache_files[0]
+ return filename if return_filename else open(filename, "rb")
+
+ # Download.
+ url_name = None
+ url_data = None
+ with requests.Session() as session:
+ if verbose:
+ print("Downloading %s ..." % url, end="", flush=True)
+ for attempts_left in reversed(range(num_attempts)):
+ try:
+ with session.get(url) as res:
+ res.raise_for_status()
+ if len(res.content) == 0:
+ raise IOError("No data received")
+
+ if len(res.content) < 8192:
+ content_str = res.content.decode("utf-8")
+ if "download_warning" in res.headers.get("Set-Cookie", ""):
+ links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link]
+ if len(links) == 1:
+ url = requests.compat.urljoin(url, links[0])
+ raise IOError("Google Drive virus checker nag")
+ if "Google Drive - Quota exceeded" in content_str:
+ raise IOError("Google Drive download quota exceeded -- please try again later")
+
+ match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", ""))
+ url_name = match[1] if match else url
+ url_data = res.content
+ if verbose:
+ print(" done")
+ break
+ except KeyboardInterrupt:
+ raise
+ except:
+ if not attempts_left:
+ if verbose:
+ print(" failed")
+ raise
+ if verbose:
+ print(".", end="", flush=True)
+
+ # Save to cache.
+ if cache:
+ safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name)
+ cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name)
+ temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name)
+ os.makedirs(cache_dir, exist_ok=True)
+ with open(temp_file, "wb") as f:
+ f.write(url_data)
+ os.replace(temp_file, cache_file) # atomic
+ if return_filename:
+ return cache_file
+
+ # Return data as file object.
+ assert not return_filename
+ return io.BytesIO(url_data)
+
+# ------------------------------------------------------------------------------------------
+# util function modified from https://github.com/nv-tlabs/LION/blob/0467d2199076e95a7e88bafd99dcd7d48a04b4a7/utils/model_helper.py
+def import_class(model_str):
+ from torch_utils.dist_utils import is_rank0
+ if is_rank0():
+ logger.info('import: {}', model_str)
+ p, m = model_str.rsplit('.', 1)
+ mod = importlib.import_module(p)
+ Model = getattr(mod, m)
+ return Model
+
+class ScopedTorchProfiler(ContextDecorator):
+ """
+ Marks ranges for both nvtx profiling (with nsys) and torch autograd profiler
+ """
+ __global_counts = {}
+ enabled=False
+
+ def __init__(self, unique_name: str):
+ """
+ Names must be unique!
+ """
+ ScopedTorchProfiler.__global_counts[unique_name] = 0
+ self._name = unique_name
+ self._autograd_scope = torch.profiler.record_function(unique_name)
+
+ def __enter__(self):
+ if ScopedTorchProfiler.enabled:
+ torch.cuda.nvtx.range_push(self._name)
+ self._autograd_scope.__enter__()
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ self._autograd_scope.__exit__(exc_type, exc_value, traceback)
+ if ScopedTorchProfiler.enabled:
+ torch.cuda.nvtx.range_pop()
+
+class TimingsMonitor():
+ CUDATimer = namedtuple('CUDATimer', ['start', 'end'])
+ def __init__(self, device, enabled=True, timing_names:List[str]=[], cuda_timing_names:List[str]=[]):
+ """
+ Usage:
+ tmonitor = TimingsMonitor(device)
+ for i in range(n_iter):
+ # Record arbitrary scopes
+ with tmonitor.timing_scope('regular_scope_name'):
+ ...
+ with tmonitor.cuda_timing_scope('nested_scope_name'):
+ ...
+ with tmonitor.cuda_timing_scope('cuda_scope_name'):
+ ...
+ tmonitor.record_timing('duration_name', end_time - start_time)
+
+ # Gather timings
+ tmonitor.record_all_cuda_timings()
+ tmonitor.update_all_averages()
+ averages = tmonitor.get_average_timings()
+ all_timings = tmonitor.get_timings()
+
+ Two types of timers, standard report timing and cuda timings.
+ Cuda timing supports scoped context manager cuda_event_scope.
+ Args:
+ device: device to time on (needed for cuda timers)
+ # enabled: HACK to only report timings from rank 0, set enabled=(global_rank==0)
+ timing_names: timings to report optional (will auto add new names)
+ cuda_timing_names: cuda periods to time optional (will auto add new names)
+ """
+ self.enabled=enabled
+ self.device = device
+
+ # Normal timing
+ # self.all_timings_dict = {k:None for k in timing_names + cuda_timing_names}
+ self.all_timings_dict = {}
+ self.avg_meter_dict = {}
+
+ # Cuda event timers to measure time spent on pushing data to gpu and on training step
+ self.cuda_event_timers = {}
+
+ for k in timing_names:
+ self.add_new_timing(k)
+
+ for k in cuda_timing_names:
+ self.add_new_cuda_timing(k)
+
+ # Running averages
+ # self.avg_meter_dict = {k:AverageMeter() for k in self.all_timings_dict}
+
+ def add_new_timing(self, name):
+ self.avg_meter_dict[name] = AverageMeter()
+ self.all_timings_dict[name] = None
+
+ def add_new_cuda_timing(self, name):
+ start_event = torch.cuda.Event(enable_timing=True)
+ end_event = torch.cuda.Event(enable_timing=True)
+ self.cuda_event_timers[name] = self.CUDATimer(start=start_event, end=end_event)
+ self.add_new_timing(name)
+
+ def clear_timings(self):
+ self.all_timings_dict = {k:None for k in self.all_timings_dict}
+
+ def get_timings(self):
+ return self.all_timings_dict
+
+ def get_average_timings(self):
+ return {k:v.avg for k,v in self.avg_meter_dict.items()}
+
+ def update_all_averages(self):
+ """
+ Once per iter, when timings have been finished recording, one should
+ call update_average_iter to keep running average of timings.
+ """
+ for k,v in self.all_timings_dict.items():
+ if v is None:
+ print("none_timing", k)
+ continue
+ self.avg_meter_dict[k].update(v)
+
+ def record_timing(self, name, value):
+ if name not in self.all_timings_dict: self.add_new_timing(name)
+ # assert name in self.all_timings_dict
+ self.all_timings_dict[name] = value
+
+ def _record_cuda_event_start(self, name):
+ if name in self.cuda_event_timers:
+ self.cuda_event_timers[name].start.record(
+ torch.cuda.current_stream(self.device))
+
+ def _record_cuda_event_end(self, name):
+ if name in self.cuda_event_timers:
+ self.cuda_event_timers[name].end.record(
+ torch.cuda.current_stream(self.device))
+
+ @contextmanager
+ def cuda_timing_scope(self, name, profile=True):
+ if name not in self.all_timings_dict: self.add_new_cuda_timing(name)
+ with ScopedTorchProfiler(name) if profile else nullcontext():
+ self._record_cuda_event_start(name)
+ try:
+ yield
+ finally:
+ self._record_cuda_event_end(name)
+
+ @contextmanager
+ def timing_scope(self, name, profile=True):
+ if name not in self.all_timings_dict: self.add_new_timing(name)
+ with ScopedTorchProfiler(name) if profile else nullcontext():
+ start_time = time.time()
+ try:
+ yield
+ finally:
+ self.record_timing(name, time.time()-start_time)
+
+ def record_all_cuda_timings(self):
+ """ After all the cuda events call this to synchronize and record down the cuda timings. """
+ for k, events in self.cuda_event_timers.items():
+ with torch.no_grad():
+ events.end.synchronize()
+ # Convert to seconds
+ time_elapsed = events.start.elapsed_time(events.end)/1000.
+ self.all_timings_dict[k] = time_elapsed
+
+def init_s3(config_file):
+ config = json.load(open(config_file, 'r'))
+ s3_client = boto3.client("s3", **config)
+ return s3_client
+
+def download_from_s3(file_path, target_path, cfg):
+ tic = time.time()
+ s3_client = init_s3(cfg.checkpoint.write_s3_config) # use to test the s3_client can be init
+ bucket_name = file_path.split('/')[2]
+ file_key = file_path.split(bucket_name+'/')[-1]
+ print(bucket_name, file_key)
+ s3_client.download_file(bucket_name, file_key, target_path)
+ logger.info(f'finish download from ! s3://{bucket_name}/{file_key} to {target_path} %.1f sec'%(
+ time.time() - tic))
+
+def upload_to_s3(buffer, bucket_name, key, config_dict):
+ logger.info(f'start upload_to_s3! bucket_name={bucket_name}, key={key}')
+ tic = time.time()
+ s3 = boto3.client('s3', **config_dict)
+ s3.put_object(Bucket=bucket_name, Key=key, Body=buffer.getvalue())
+ logger.info(f'finish upload_to_s3! s3://{bucket_name}/{key} %.1f sec'%(time.time() - tic))
+
+def write_ckpt_to_s3(cfg, all_model_dict, ckpt_name):
+ buffer = io.BytesIO()
+ tic = time.time()
+ torch.save(all_model_dict, buffer) # take ~0.25 sec
+ # logger.info('write ckpt to buffer: %.2f sec'%(time.time() - tic))
+ group, name = cfg.outdir.rstrip("/").split("/")[-2:]
+ key = f"checkpoints/{group}/{name}/ckpt/{ckpt_name}"
+ bucket_name = cfg.checkpoint.write_s3_bucket
+
+ s3_client = init_s3(cfg.checkpoint.write_s3_config) # use to test the s3_client can be init
+
+ config_dict = json.load(open(cfg.checkpoint.write_s3_config, 'r'))
+ upload_thread = threading.Thread(target=upload_to_s3, args=(buffer, bucket_name, key, config_dict))
+ upload_thread.start()
+ path = f"s3://{bucket_name}/{key}"
+ return path
+
+def upload_file_to_s3(cfg, file_path, key_name=None):
+ # file_path is the local file path, can be a yaml file
+ # this function is used to upload the ckecpoint only
+ tic = time.time()
+ group, name = cfg.outdir.rstrip("/").split("/")[-2:]
+ if key_name is None:
+ key = os.path.basename(file_path)
+ key = f"checkpoints/{group}/{name}/{key}"
+ bucket_name = cfg.checkpoint.write_s3_bucket
+ s3_client = init_s3(cfg.checkpoint.write_s3_config)
+ # Upload the file
+ with open(file_path, 'rb') as f:
+ s3_client.upload_fileobj(f, bucket_name, key)
+ full_s3_path = f"s3://{bucket_name}/{key}"
+ logger.info(f'upload_to_s3: {file_path} {full_s3_path} | use time: {time.time()-tic}')
+
+ return full_s3_path
+
+
+def load_from_s3(file_path, cfg, load_fn):
+ """
+ ckpt_path example:
+ s3://xzeng/checkpoints/2023_0413/vae_kl_5e-1/ckpt/snapshot_epo000163_iter164000.pt
+ """
+ s3_client = init_s3(cfg.checkpoint.write_s3_config) # use to test the s3_client can be init
+ bucket_name = file_path.split("s3://")[-1].split('/')[0]
+ key = file_path.split(f'{bucket_name}/')[-1]
+ # logger.info(f"-> try to load s3://{bucket_name}/{key} ")
+ tic = time.time()
+ for attemp in range(10):
+ try:
+ # Download the state dict from S3 into memory (as a binary stream)
+ with io.BytesIO() as buffer:
+ s3_client.download_fileobj(bucket_name, key, buffer)
+ buffer.seek(0)
+
+ # Load the state dict into a PyTorch model
+ # out = torch.load(buffer, map_location=torch.device("cpu"))
+ out = load_fn(buffer)
+ break
+ except:
+ logger.info(f"fail to load s3://{bucket_name}/{key} attemp: {attemp}")
+ from torch_utils.dist_utils import is_rank0
+ if is_rank0():
+ logger.info(f'loaded {file_path} | use time: {time.time()-tic:.1f} sec')
+ return out
+
+def load_torch_dict_from_s3(ckpt_path, cfg):
+ """
+ ckpt_path example:
+ s3://xzeng/checkpoints/2023_0413/vae_kl_5e-1/ckpt/snapshot_epo000163_iter164000.pt
+ """
+ s3_client = init_s3(cfg.checkpoint.write_s3_config) # use to test the s3_client can be init
+ bucket_name = ckpt_path.split("s3://")[-1].split('/')[0]
+ key = ckpt_path.split(f'{bucket_name}/')[-1]
+ for attemp in range(10):
+ try:
+ # Download the state dict from S3 into memory (as a binary stream)
+ with io.BytesIO() as buffer:
+ s3_client.download_fileobj(bucket_name, key, buffer)
+ buffer.seek(0)
+
+ # Load the state dict into a PyTorch model
+ out = torch.load(buffer, map_location=torch.device("cpu"))
+ break
+ except:
+ logger.info(f"fail to load s3://{bucket_name}/{key} attemp: {attemp}")
+ return out
+
+def count_parameters_in_M(model):
+ return np.sum(np.prod(v.size()) for name, v in model.named_parameters() if "auxiliary" not in name) / 1e6
+
+def printarr(*arrs, float_width=6, **kwargs):
+ """
+ Print a pretty table giving name, shape, dtype, type, and content information for input tensors or scalars.
+
+ Call like: printarr(my_arr, some_other_arr, maybe_a_scalar). Accepts a variable number of arguments.
+
+ Inputs can be:
+ - Numpy tensor arrays
+ - Pytorch tensor arrays
+ - Jax tensor arrays
+ - Python ints / floats
+ - None
+
+ It may also work with other array-like types, but they have not been tested.
+
+ Use the `float_width` option specify the precision to which floating point types are printed.
+
+ Author: Nicholas Sharp (nmwsharp.com)
+ Canonical source: https://gist.github.com/nmwsharp/54d04af87872a4988809f128e1a1d233
+ License: This snippet may be used under an MIT license, and it is also released into the public domain.
+ Please retain this docstring as a reference.
+ """
+
+ frame = inspect.currentframe().f_back
+ default_name = "[temporary]"
+
+ ## helpers to gather data about each array
+ def name_from_outer_scope(a):
+ if a is None:
+ return '[None]'
+ name = default_name
+ for k, v in frame.f_locals.items():
+ if v is a:
+ name = k
+ break
+ return name
+
+ def type_strip(type_str):
+ return type_str.lstrip('').replace('torch.', '').strip("'")
+
+ def dtype_str(a):
+ if a is None:
+ return 'None'
+ if isinstance(a, int):
+ return 'int'
+ if isinstance(a, float):
+ return 'float'
+ if isinstance(a, list) and len(a)>0:
+ return type_strip(str(type(a[0])))
+ if hasattr(a, 'dtype'):
+ return type_strip(str(a.dtype))
+ else:
+ return ''
+ def shape_str(a):
+ if a is None:
+ return 'N/A'
+ if isinstance(a, int):
+ return 'scalar'
+ if isinstance(a, float):
+ return 'scalar'
+ if isinstance(a, list):
+ return f"[{shape_str(a[0]) if len(a)>0 else '?'}]*{len(a)}"
+ if hasattr(a, 'shape'):
+ return str(tuple(a.shape))
+ else:
+ return ''
+ def type_str(a):
+ return type_strip(str(type(a))) # TODO this is is weird... what's the better way?
+ def device_str(a):
+ if hasattr(a, 'device'):
+ device_str = str(a.device)
+ if len(device_str) < 10:
+ # heuristic: jax returns some goofy long string we don't want, ignore it
+ return device_str
+ return ""
+ def format_float(x):
+ return f"{x:{float_width}g}"
+ def minmaxmean_str(a):
+ if a is None:
+ return ('N/A', 'N/A', 'N/A', 'N/A')
+ if isinstance(a, int) or isinstance(a, float):
+ return (format_float(a),)*4
+
+ # compute min/max/mean. if anything goes wrong, just print 'N/A'
+ min_str = "N/A"
+ try: min_str = format_float(a.min())
+ except: pass
+ max_str = "N/A"
+ try: max_str = format_float(a.max())
+ except: pass
+ mean_str = "N/A"
+ try: mean_str = format_float(a.mean())
+ except: pass
+ try: median_str = format_float(a.median())
+ except:
+ try: median_str = format_float(np.median(np.array(a)))
+ except: median_str = 'N/A'
+ return (min_str, max_str, mean_str, median_str)
+
+ def get_prop_dict(a,k=None):
+ minmaxmean = minmaxmean_str(a)
+ props = {
+ 'name' : name_from_outer_scope(a) if k is None else k,
+ # 'type' : str(type(a)).replace('torch.',''),
+ 'dtype' : dtype_str(a),
+ 'shape' : shape_str(a),
+ 'type' : type_str(a),
+ 'device' : device_str(a),
+ 'min' : minmaxmean[0],
+ 'max' : minmaxmean[1],
+ 'mean' : minmaxmean[2],
+ 'median': minmaxmean[3]
+ }
+ return props
+
+ try:
+
+ props = ['name', 'type', 'dtype', 'shape', 'device', 'min', 'max', 'mean', 'median']
+
+ # precompute all of the properties for each input
+ str_props = []
+ for a in arrs:
+ str_props.append(get_prop_dict(a))
+ for k,a in kwargs.items():
+ str_props.append(get_prop_dict(a, k=k))
+
+ # for each property, compute its length
+ maxlen = {}
+ for p in props: maxlen[p] = 0
+ for sp in str_props:
+ for p in props:
+ maxlen[p] = max(maxlen[p], len(sp[p]))
+
+ # if any property got all empty strings, don't bother printing it, remove if from the list
+ props = [p for p in props if maxlen[p] > 0]
+
+ # print a header
+ header_str = ""
+ for p in props:
+ prefix = "" if p == 'name' else " | "
+ fmt_key = ">" if p == 'name' else "<"
+ header_str += f"{prefix}{p:{fmt_key}{maxlen[p]}}"
+ print(header_str)
+ print("-"*len(header_str))
+
+ # now print the acual arrays
+ for strp in str_props:
+ for p in props:
+ prefix = "" if p == 'name' else " | "
+ fmt_key = ">" if p == 'name' else "<"
+ print(f"{prefix}{strp[p]:{fmt_key}{maxlen[p]}}", end='')
+ print("")
+
+ finally:
+ del frame
+
+def debug_print_all_tensor_sizes(min_tot_size = 0):
+ import gc
+ print("---------------------------------------"*3)
+ for obj in gc.get_objects():
+ try:
+ if torch.is_tensor(obj) or (hasattr(obj, 'data') and torch.is_tensor(obj.data)):
+ if np.prod(obj.size())>=min_tot_size:
+ print(type(obj), obj.size())
+ except:
+ pass
+def print_cpu_usage():
+
+ # Get current CPU usage as a percentage
+ cpu_usage = psutil.cpu_percent()
+
+ # Get current memory usage
+ memory_usage = psutil.virtual_memory().used
+
+ # Convert memory usage to a human-readable format
+ memory_usage_str = psutil._common.bytes2human(memory_usage)
+
+ # Print CPU and memory usage
+ msg = f"Current CPU usage: {cpu_usage}% | "
+ msg += f"Current memory usage: {memory_usage_str}"
+ return msg
+
+def calmsize(num_bytes):
+ if math.isnan(num_bytes):
+ return ''
+ for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
+ if abs(num_bytes) < 1024.0:
+ return "{:.1f}{}B".format(num_bytes, unit)
+ num_bytes /= 1024.0
+ return "{:.1f}{}B".format(num_bytes, 'Y')
+
+def readable_size(num_bytes: int) -> str:
+ return calmsize(num_bytes) ## '' if math.isnan(num_bytes) else '{:.1f}'.format(calmsize(num_bytes))
+
+def get_gpu_memory():
+ """
+ Get the current GPU memory usage for each device as a dictionary
+ """
+ output = subprocess.check_output(["nvidia-smi", "--query-gpu=memory.used", "--format=csv"])
+ output = output.decode("utf-8")
+ gpu_memory_values = output.split("\n")[1:-1]
+ gpu_memory_values = [int(x.strip().split()[0]) for x in gpu_memory_values]
+ gpu_memory = dict(zip(range(len(gpu_memory_values)), gpu_memory_values))
+ return gpu_memory
+
+def get_gpu_util():
+ """
+ Get the current GPU memory usage for each device as a dictionary
+ """
+ output = subprocess.check_output(["nvidia-smi", "--query-gpu=utilization.gpu", "--format=csv"])
+ output = output.decode("utf-8")
+ gpu_memory_values = output.split("\n")[1:-1]
+ gpu_memory_values = [int(x.strip().split()[0]) for x in gpu_memory_values]
+ gpu_util = dict(zip(range(len(gpu_memory_values)), gpu_memory_values))
+ return gpu_util
+
+
+def print_gpu_usage():
+ useage = get_gpu_memory()
+ msg = f" | GPU usage: "
+ for k, v in useage.items():
+ msg += f"{k}: {v} MB "
+ # utilization = get_gpu_util()
+ # msg + ' | util '
+ # for k, v in utilization.items():
+ # msg += f"{k}: {v} % "
+ return msg
+
+class AverageMeter(object):
+
+ def __init__(self):
+ self.reset()
+
+ def reset(self):
+ self.avg = 0
+ self.sum = 0
+ self.cnt = 0
+
+ def update(self, val, n=1):
+ self.sum += val * n
+ self.cnt += n
+ self.avg = self.sum / self.cnt
+
+
+def generate_random_string(length):
+ # This script will generate a string of 10 random ASCII letters (both lowercase and uppercase).
+ # You can adjust the length parameter to fit your needs.
+ letters = string.ascii_letters
+ return ''.join(random.choice(letters) for _ in range(length))
+
+
+class ForkedPdb(pdb.Pdb):
+ """
+ PDB Subclass for debugging multi-processed code
+ Suggested in: https://stackoverflow.com/questions/4716533/how-to-attach-debugger-to-a-python-subproccess
+ """
+ def interaction(self, *args, **kwargs):
+ _stdin = sys.stdin
+ try:
+ sys.stdin = open('/dev/stdin')
+ pdb.Pdb.interaction(self, *args, **kwargs)
+ finally:
+ sys.stdin = _stdin
+
+def check_exist_in_s3(file_path, s3_config):
+ s3 = init_s3(s3_config)
+ bucket_name, object_name = s3path_to_bucket_key(file_path)
+
+ try:
+ s3.head_object(Bucket=bucket_name, Key=object_name)
+ return 1
+ except:
+ logger.info(f'file not found: s3://{bucket_name}/{object_name}')
+ return 0
+
+def s3path_to_bucket_key(file_path):
+ bucket_name = file_path.split('/')[2]
+ object_name = file_path.split(bucket_name + '/')[-1]
+ return bucket_name, object_name
+
+def copy_file_to_s3(cfg, file_path_local, file_path_s3):
+ # work similar as upload_file_to_s3, but not trying to parse the file path
+ # file_path_s3: s3://{bucket}/{key}
+ bucket_name, key = s3path_to_bucket_key(file_path_s3)
+ tic = time.time()
+ s3_client = init_s3(cfg.checkpoint.write_s3_config)
+
+ # Upload the file
+ with open(file_path_local, 'rb') as f:
+ s3_client.upload_fileobj(f, bucket_name, key)
+ full_s3_path = f"s3://{bucket_name}/{key}"
+ logger.info(f'copy file: {file_path_local} {full_s3_path} | use time: {time.time()-tic}')
+ return full_s3_path
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/encoder_pc.py b/OmniPart/modules/PartField/partfield/model/PVCNN/encoder_pc.py
new file mode 100644
index 0000000..ace02f5
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/encoder_pc.py
@@ -0,0 +1,243 @@
+# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+
+from ast import Dict
+import math
+
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch_scatter import scatter_mean #, scatter_max
+
+from .unet_3daware import setup_unet #UNetTriplane3dAware
+from .conv_pointnet import ConvPointnet
+
+from .pc_encoder import PVCNNEncoder #PointNet
+
+import einops
+
+from .dnnlib_util import ScopedTorchProfiler, printarr
+
+def generate_plane_features(p, c, resolution, plane='xz'):
+ """
+ Args:
+ p: (B,3,n_p)
+ c: (B,C,n_p)
+ """
+ padding = 0.
+ c_dim = c.size(1)
+ # acquire indices of features in plane
+ xy = normalize_coordinate(p.clone(), plane=plane, padding=padding) # normalize to the range of (0, 1)
+ index = coordinate2index(xy, resolution)
+
+ # scatter plane features from points
+ fea_plane = c.new_zeros(p.size(0), c_dim, resolution**2)
+ fea_plane = scatter_mean(c, index, out=fea_plane) # B x 512 x reso^2
+ fea_plane = fea_plane.reshape(p.size(0), c_dim, resolution, resolution) # sparce matrix (B x 512 x reso x reso)
+ return fea_plane
+
+def normalize_coordinate(p, padding=0.1, plane='xz'):
+ ''' Normalize coordinate to [0, 1] for unit cube experiments
+
+ Args:
+ p (tensor): point
+ padding (float): conventional padding paramter of ONet for unit cube, so [-0.5, 0.5] -> [-0.55, 0.55]
+ plane (str): plane feature type, ['xz', 'xy', 'yz']
+ '''
+ if plane == 'xz':
+ xy = p[:, :, [0, 2]]
+ elif plane =='xy':
+ xy = p[:, :, [0, 1]]
+ else:
+ xy = p[:, :, [1, 2]]
+
+ xy_new = xy / (1 + padding + 10e-6) # (-0.5, 0.5)
+ xy_new = xy_new + 0.5 # range (0, 1)
+
+ # if there are outliers out of the range
+ if xy_new.max() >= 1:
+ xy_new[xy_new >= 1] = 1 - 10e-6
+ if xy_new.min() < 0:
+ xy_new[xy_new < 0] = 0.0
+ return xy_new
+
+
+def coordinate2index(x, resolution):
+ ''' Normalize coordinate to [0, 1] for unit cube experiments.
+ Corresponds to our 3D model
+
+ Args:
+ x (tensor): coordinate
+ reso (int): defined resolution
+ coord_type (str): coordinate type
+ '''
+ x = (x * resolution).long()
+ index = x[:, :, 0] + resolution * x[:, :, 1]
+ index = index[:, None, :]
+ return index
+
+def softclip(x, min, max, hardness=5):
+ # Soft clipping for the logsigma
+ x = min + F.softplus(hardness*(x - min))/hardness
+ x = max - F.softplus(-hardness*(x - max))/hardness
+ return x
+
+
+def sample_triplane_feat(feature_triplane, normalized_pos):
+ '''
+ normalized_pos [-1, 1]
+ '''
+ tri_plane = torch.unbind(feature_triplane, dim=1)
+
+ x_feat = F.grid_sample(
+ tri_plane[0],
+ torch.cat(
+ [normalized_pos[:, :, 0:1], normalized_pos[:, :, 1:2]],
+ dim=-1).unsqueeze(dim=1), padding_mode='border',
+ align_corners=True)
+ y_feat = F.grid_sample(
+ tri_plane[1],
+ torch.cat(
+ [normalized_pos[:, :, 1:2], normalized_pos[:, :, 2:3]],
+ dim=-1).unsqueeze(dim=1), padding_mode='border',
+ align_corners=True)
+
+ z_feat = F.grid_sample(
+ tri_plane[2],
+ torch.cat(
+ [normalized_pos[:, :, 0:1], normalized_pos[:, :, 2:3]],
+ dim=-1).unsqueeze(dim=1), padding_mode='border',
+ align_corners=True)
+ final_feat = (x_feat + y_feat + z_feat)
+ final_feat = final_feat.squeeze(dim=2).permute(0, 2, 1) # 32dimension
+ return final_feat
+
+
+# @persistence.persistent_class
+class TriPlanePC2Encoder(torch.nn.Module):
+ # Encoder that encode point cloud to triplane feature vector similar to ConvOccNet
+ def __init__(
+ self,
+ cfg,
+ device='cuda',
+ shape_min=-1.0,
+ shape_length=2.0,
+ use_2d_feat=False,
+ # point_encoder='pvcnn',
+ # use_point_scatter=False
+ ):
+ """
+ Outputs latent triplane from PC input
+ Configs:
+ max_logsigma: (float) Soft clip upper range for logsigm
+ min_logsigma: (float)
+ point_encoder_type: (str) one of ['pvcnn', 'pointnet']
+ pvcnn_flatten_voxels: (bool) for pvcnn whether to reduce voxel
+ features (instead of scattering point features)
+ unet_cfg: (dict)
+ z_triplane_channels: (int) output latent triplane
+ z_triplane_resolution: (int)
+ Args:
+
+ """
+ # assert img_resolution >= 4 and img_resolution & (img_resolution - 1) == 0
+ super().__init__()
+ self.device = device
+
+ self.cfg = cfg
+
+ self.shape_min = shape_min
+ self.shape_length = shape_length
+
+ self.z_triplane_resolution = cfg.z_triplane_resolution
+ z_triplane_channels = cfg.z_triplane_channels
+
+ point_encoder_out_dim = z_triplane_channels #* 2
+
+ in_channels = 6
+ # self.resample_filter=[1, 3, 3, 1]
+ if cfg.point_encoder_type == 'pvcnn':
+ self.pc_encoder = PVCNNEncoder(point_encoder_out_dim,
+ device=self.device, in_channels=in_channels, use_2d_feat=use_2d_feat) # Encode it to a volume vector.
+ elif cfg.point_encoder_type == 'pointnet':
+ # TODO the pointnet was buggy, investigate
+ self.pc_encoder = ConvPointnet(c_dim=point_encoder_out_dim,
+ dim=in_channels, hidden_dim=32,
+ plane_resolution=self.z_triplane_resolution,
+ padding=0)
+ else:
+ raise NotImplementedError(f"Point encoder {cfg.point_encoder_type} not implemented")
+
+ if cfg.unet_cfg.enabled:
+ self.unet_encoder = setup_unet(
+ output_channels=point_encoder_out_dim,
+ input_channels=point_encoder_out_dim,
+ unet_cfg=cfg.unet_cfg)
+ else:
+ self.unet_encoder = None
+
+ # @ScopedTorchProfiler('encode')
+ def encode(self, point_cloud_xyz, point_cloud_feature, mv_feat=None, pc2pc_idx=None) -> Dict:
+ # output = AttrDict()
+ point_cloud_xyz = (point_cloud_xyz - self.shape_min) / self.shape_length # [0, 1]
+ point_cloud_xyz = point_cloud_xyz - 0.5 # [-0.5, 0.5]
+ point_cloud = torch.cat([point_cloud_xyz, point_cloud_feature], dim=-1)
+
+ if self.cfg.point_encoder_type == 'pvcnn':
+ if mv_feat is not None:
+ pc_feat, points_feat = self.pc_encoder(point_cloud, mv_feat, pc2pc_idx)
+ else:
+ pc_feat, points_feat = self.pc_encoder(point_cloud) # 3D feature volume: BxDx32x32x32
+ if self.cfg.use_point_scatter:
+ # Scattering from PVCNN point features
+ points_feat_ = points_feat[0]
+ # shape: batch, latent size, resolution, resolution (e.g. 16, 256, 64, 64)
+ pc_feat_1 = generate_plane_features(point_cloud_xyz, points_feat_,
+ resolution=self.z_triplane_resolution, plane='xy')
+ pc_feat_2 = generate_plane_features(point_cloud_xyz, points_feat_,
+ resolution=self.z_triplane_resolution, plane='yz')
+ pc_feat_3 = generate_plane_features(point_cloud_xyz, points_feat_,
+ resolution=self.z_triplane_resolution, plane='xz')
+ pc_feat = pc_feat[0]
+
+ else:
+ pc_feat = pc_feat[0]
+ sf = self.z_triplane_resolution//32 # 32 is PVCNN's voxel dim
+
+ pc_feat_1 = torch.mean(pc_feat, dim=-1) #xy_plane, normalize in z plane
+ pc_feat_2 = torch.mean(pc_feat, dim=-3) #yz_plane, normalize in x plane
+ pc_feat_3 = torch.mean(pc_feat, dim=-2) #xz_plane, normalize in y plane
+
+ # nearest upsample
+ pc_feat_1 = einops.repeat(pc_feat_1, 'b c h w -> b c (h hm ) (w wm)', hm = sf, wm = sf)
+ pc_feat_2 = einops.repeat(pc_feat_2, 'b c h w -> b c (h hm) (w wm)', hm = sf, wm = sf)
+ pc_feat_3 = einops.repeat(pc_feat_3, 'b c h w -> b c (h hm) (w wm)', hm = sf, wm = sf)
+ elif self.cfg.point_encoder_type == 'pointnet':
+ assert self.cfg.use_point_scatter
+ # Run ConvPointnet
+ pc_feat = self.pc_encoder(point_cloud)
+ pc_feat_1 = pc_feat['xy'] #
+ pc_feat_2 = pc_feat['yz']
+ pc_feat_3 = pc_feat['xz']
+ else:
+ raise NotImplementedError()
+
+ if self.unet_encoder is not None:
+ # TODO eval adding a skip connection
+ # Unet expects B, 3, C, H, W
+ pc_feat_tri_plane_stack_pre = torch.stack([pc_feat_1, pc_feat_2, pc_feat_3], dim=1)
+ # dpc_feat_tri_plane_stack = self.unet_encoder(pc_feat_tri_plane_stack_pre)
+ # pc_feat_tri_plane_stack = pc_feat_tri_plane_stack_pre + dpc_feat_tri_plane_stack
+ pc_feat_tri_plane_stack = self.unet_encoder(pc_feat_tri_plane_stack_pre)
+ pc_feat_1, pc_feat_2, pc_feat_3 = torch.unbind(pc_feat_tri_plane_stack, dim=1)
+
+ return torch.stack([pc_feat_1, pc_feat_2, pc_feat_3], dim=1)
+
+ def forward(self, point_cloud_xyz, point_cloud_feature=None, mv_feat=None, pc2pc_idx=None):
+ return self.encode(point_cloud_xyz, point_cloud_feature=point_cloud_feature, mv_feat=mv_feat, pc2pc_idx=pc2pc_idx)
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pc_encoder.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pc_encoder.py
new file mode 100644
index 0000000..3f35aba
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pc_encoder.py
@@ -0,0 +1,90 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import functools
+
+from .pv_module import SharedMLP, PVConv
+
+def create_pointnet_components(
+ blocks, in_channels, with_se=False, normalize=True, eps=0,
+ width_multiplier=1, voxel_resolution_multiplier=1, scale_pvcnn=False, device='cuda'):
+ r, vr = width_multiplier, voxel_resolution_multiplier
+ layers, concat_channels = [], 0
+ for out_channels, num_blocks, voxel_resolution in blocks:
+ out_channels = int(r * out_channels)
+ if voxel_resolution is None:
+ block = functools.partial(SharedMLP, device=device)
+ else:
+ block = functools.partial(
+ PVConv, kernel_size=3, resolution=int(vr * voxel_resolution),
+ with_se=with_se, normalize=normalize, eps=eps, scale_pvcnn=scale_pvcnn, device=device)
+ for _ in range(num_blocks):
+ layers.append(block(in_channels, out_channels))
+ in_channels = out_channels
+ concat_channels += out_channels
+ return layers, in_channels, concat_channels
+
+class PCMerger(nn.Module):
+# merge surface sampled PC and rendering backprojected PC (w/ 2D features):
+ def __init__(self, in_channels=204, device="cuda"):
+ super(PCMerger, self).__init__()
+ self.mlp_normal = SharedMLP(3, [128, 128], device=device)
+ self.mlp_rgb = SharedMLP(3, [128, 128], device=device)
+ self.mlp_sam = SharedMLP(204 - 6, [128, 128], device=device)
+
+ def forward(self, feat, mv_feat, pc2pc_idx):
+ mv_feat_normal = self.mlp_normal(mv_feat[:, :3, :])
+ mv_feat_rgb = self.mlp_rgb(mv_feat[:, 3:6, :])
+ mv_feat_sam = self.mlp_sam(mv_feat[:, 6:, :])
+
+ mv_feat_normal = mv_feat_normal.permute(0, 2, 1)
+ mv_feat_rgb = mv_feat_rgb.permute(0, 2, 1)
+ mv_feat_sam = mv_feat_sam.permute(0, 2, 1)
+ feat = feat.permute(0, 2, 1)
+
+ for i in range(mv_feat.shape[0]):
+ mask = (pc2pc_idx[i] != -1).reshape(-1)
+ idx = pc2pc_idx[i][mask].reshape(-1)
+ feat[i][mask] += mv_feat_normal[i][idx] + mv_feat_rgb[i][idx] + mv_feat_sam[i][idx]
+
+ return feat.permute(0, 2, 1)
+
+
+class PVCNNEncoder(nn.Module):
+ def __init__(self, pvcnn_feat_dim, device='cuda', in_channels=3, use_2d_feat=False):
+ super(PVCNNEncoder, self).__init__()
+ self.device = device
+ self.blocks = ((pvcnn_feat_dim, 1, 32), (128, 2, 16), (256, 1, 8))
+ self.use_2d_feat=use_2d_feat
+ if in_channels == 6:
+ self.append_channel = 2
+ elif in_channels == 3:
+ self.append_channel = 1
+ else:
+ raise NotImplementedError
+ layers, channels_point, concat_channels_point = create_pointnet_components(
+ blocks=self.blocks, in_channels=in_channels + self.append_channel, with_se=False, normalize=False,
+ width_multiplier=1, voxel_resolution_multiplier=1, scale_pvcnn=True,
+ device=device
+ )
+ self.encoder = nn.ModuleList(layers)#.to(self.device)
+ if self.use_2d_feat:
+ self.merger = PCMerger()
+
+
+
+ def forward(self, input_pc, mv_feat=None, pc2pc_idx=None):
+ features = input_pc.permute(0, 2, 1) * 2 # make point cloud [-1, 1]
+ coords = features[:, :3, :]
+ out_features_list = []
+ voxel_feature_list = []
+ zero_padding = torch.zeros(features.shape[0], self.append_channel, features.shape[-1], device=features.device, dtype=features.dtype)
+ features = torch.cat([features, zero_padding], dim=1)##################
+
+ for i in range(len(self.encoder)):
+ features, _, voxel_feature = self.encoder[i]((features, coords))
+ if i == 0 and mv_feat is not None:
+ features = self.merger(features, mv_feat.permute(0, 2, 1), pc2pc_idx)
+ out_features_list.append(features)
+ voxel_feature_list.append(voxel_feature)
+ return voxel_feature_list, out_features_list
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/__init__.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/__init__.py
new file mode 100644
index 0000000..7fd32e5
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/__init__.py
@@ -0,0 +1,2 @@
+from .pvconv import PVConv
+from .shared_mlp import SharedMLP
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/ball_query.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/ball_query.py
new file mode 100644
index 0000000..ea2a820
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/ball_query.py
@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+
+from . import functional as F
+
+__all__ = ['BallQuery']
+
+
+class BallQuery(nn.Module):
+ def __init__(self, radius, num_neighbors, include_coordinates=True):
+ super().__init__()
+ self.radius = radius
+ self.num_neighbors = num_neighbors
+ self.include_coordinates = include_coordinates
+
+ def forward(self, points_coords, centers_coords, points_features=None):
+ points_coords = points_coords.contiguous()
+ centers_coords = centers_coords.contiguous()
+ neighbor_indices = F.ball_query(centers_coords, points_coords, self.radius, self.num_neighbors)
+ neighbor_coordinates = F.grouping(points_coords, neighbor_indices)
+ neighbor_coordinates = neighbor_coordinates - centers_coords.unsqueeze(-1)
+
+ if points_features is None:
+ assert self.include_coordinates, 'No Features For Grouping'
+ neighbor_features = neighbor_coordinates
+ else:
+ neighbor_features = F.grouping(points_features, neighbor_indices)
+ if self.include_coordinates:
+ neighbor_features = torch.cat([neighbor_coordinates, neighbor_features], dim=1)
+ return neighbor_features
+
+ def extra_repr(self):
+ return 'radius={}, num_neighbors={}{}'.format(
+ self.radius, self.num_neighbors, ', include coordinates' if self.include_coordinates else '')
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/frustum.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/frustum.py
new file mode 100644
index 0000000..fb30296
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/frustum.py
@@ -0,0 +1,141 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from . import functional as PF
+
+__all__ = ['FrustumPointNetLoss', 'get_box_corners_3d']
+
+
+class FrustumPointNetLoss(nn.Module):
+ def __init__(
+ self, num_heading_angle_bins, num_size_templates, size_templates, box_loss_weight=1.0,
+ corners_loss_weight=10.0, heading_residual_loss_weight=20.0, size_residual_loss_weight=20.0):
+ super().__init__()
+ self.box_loss_weight = box_loss_weight
+ self.corners_loss_weight = corners_loss_weight
+ self.heading_residual_loss_weight = heading_residual_loss_weight
+ self.size_residual_loss_weight = size_residual_loss_weight
+
+ self.num_heading_angle_bins = num_heading_angle_bins
+ self.num_size_templates = num_size_templates
+ self.register_buffer('size_templates', size_templates.view(self.num_size_templates, 3))
+ self.register_buffer(
+ 'heading_angle_bin_centers', torch.arange(0, 2 * np.pi, 2 * np.pi / self.num_heading_angle_bins)
+ )
+
+ def forward(self, inputs, targets):
+ mask_logits = inputs['mask_logits'] # (B, 2, N)
+ center_reg = inputs['center_reg'] # (B, 3)
+ center = inputs['center'] # (B, 3)
+ heading_scores = inputs['heading_scores'] # (B, NH)
+ heading_residuals_normalized = inputs['heading_residuals_normalized'] # (B, NH)
+ heading_residuals = inputs['heading_residuals'] # (B, NH)
+ size_scores = inputs['size_scores'] # (B, NS)
+ size_residuals_normalized = inputs['size_residuals_normalized'] # (B, NS, 3)
+ size_residuals = inputs['size_residuals'] # (B, NS, 3)
+
+ mask_logits_target = targets['mask_logits'] # (B, N)
+ center_target = targets['center'] # (B, 3)
+ heading_bin_id_target = targets['heading_bin_id'] # (B, )
+ heading_residual_target = targets['heading_residual'] # (B, )
+ size_template_id_target = targets['size_template_id'] # (B, )
+ size_residual_target = targets['size_residual'] # (B, 3)
+
+ batch_size = center.size(0)
+ batch_id = torch.arange(batch_size, device=center.device)
+
+ # Basic Classification and Regression losses
+ mask_loss = F.cross_entropy(mask_logits, mask_logits_target)
+ heading_loss = F.cross_entropy(heading_scores, heading_bin_id_target)
+ size_loss = F.cross_entropy(size_scores, size_template_id_target)
+ center_loss = PF.huber_loss(torch.norm(center_target - center, dim=-1), delta=2.0)
+ center_reg_loss = PF.huber_loss(torch.norm(center_target - center_reg, dim=-1), delta=1.0)
+
+ # Refinement losses for size/heading
+ heading_residuals_normalized = heading_residuals_normalized[batch_id, heading_bin_id_target] # (B, )
+ heading_residual_normalized_target = heading_residual_target / (np.pi / self.num_heading_angle_bins)
+ heading_residual_normalized_loss = PF.huber_loss(
+ heading_residuals_normalized - heading_residual_normalized_target, delta=1.0
+ )
+ size_residuals_normalized = size_residuals_normalized[batch_id, size_template_id_target] # (B, 3)
+ size_residual_normalized_target = size_residual_target / self.size_templates[size_template_id_target]
+ size_residual_normalized_loss = PF.huber_loss(
+ torch.norm(size_residual_normalized_target - size_residuals_normalized, dim=-1), delta=1.0
+ )
+
+ # Bounding box losses
+ heading = (heading_residuals[batch_id, heading_bin_id_target]
+ + self.heading_angle_bin_centers[heading_bin_id_target]) # (B, )
+ # Warning: in origin code, size_residuals are added twice (issue #43 and #49 in charlesq34/frustum-pointnets)
+ size = (size_residuals[batch_id, size_template_id_target]
+ + self.size_templates[size_template_id_target]) # (B, 3)
+ corners = get_box_corners_3d(centers=center, headings=heading, sizes=size, with_flip=False) # (B, 3, 8)
+ heading_target = self.heading_angle_bin_centers[heading_bin_id_target] + heading_residual_target # (B, )
+ size_target = self.size_templates[size_template_id_target] + size_residual_target # (B, 3)
+ corners_target, corners_target_flip = get_box_corners_3d(
+ centers=center_target, headings=heading_target,
+ sizes=size_target, with_flip=True) # (B, 3, 8)
+ corners_loss = PF.huber_loss(
+ torch.min(
+ torch.norm(corners - corners_target, dim=1), torch.norm(corners - corners_target_flip, dim=1)
+ ), delta=1.0)
+ # Summing up
+ loss = mask_loss + self.box_loss_weight * (
+ center_loss + center_reg_loss + heading_loss + size_loss
+ + self.heading_residual_loss_weight * heading_residual_normalized_loss
+ + self.size_residual_loss_weight * size_residual_normalized_loss
+ + self.corners_loss_weight * corners_loss
+ )
+
+ return loss
+
+
+def get_box_corners_3d(centers, headings, sizes, with_flip=False):
+ """
+ :param centers: coords of box centers, FloatTensor[N, 3]
+ :param headings: heading angles, FloatTensor[N, ]
+ :param sizes: box sizes, FloatTensor[N, 3]
+ :param with_flip: bool, whether to return flipped box (headings + np.pi)
+ :return:
+ coords of box corners, FloatTensor[N, 3, 8]
+ NOTE: corner points are in counter clockwise order, e.g.,
+ 2--1
+ 3--0 5
+ 7--4
+ """
+ l = sizes[:, 0] # (N,)
+ w = sizes[:, 1] # (N,)
+ h = sizes[:, 2] # (N,)
+ x_corners = torch.stack([l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2], dim=1) # (N, 8)
+ y_corners = torch.stack([h / 2, h / 2, h / 2, h / 2, -h / 2, -h / 2, -h / 2, -h / 2], dim=1) # (N, 8)
+ z_corners = torch.stack([w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2], dim=1) # (N, 8)
+
+ c = torch.cos(headings) # (N,)
+ s = torch.sin(headings) # (N,)
+ o = torch.ones_like(headings) # (N,)
+ z = torch.zeros_like(headings) # (N,)
+
+ centers = centers.unsqueeze(-1) # (B, 3, 1)
+ corners = torch.stack([x_corners, y_corners, z_corners], dim=1) # (N, 3, 8)
+ R = torch.stack([c, z, s, z, o, z, -s, z, c], dim=1).view(-1, 3, 3) # roty matrix: (N, 3, 3)
+ if with_flip:
+ R_flip = torch.stack([-c, z, -s, z, o, z, s, z, -c], dim=1).view(-1, 3, 3)
+ return torch.matmul(R, corners) + centers, torch.matmul(R_flip, corners) + centers
+ else:
+ return torch.matmul(R, corners) + centers
+
+ # centers = centers.unsqueeze(1) # (B, 1, 3)
+ # corners = torch.stack([x_corners, y_corners, z_corners], dim=-1) # (N, 8, 3)
+ # RT = torch.stack([c, z, -s, z, o, z, s, z, c], dim=1).view(-1, 3, 3) # (N, 3, 3)
+ # if with_flip:
+ # RT_flip = torch.stack([-c, z, s, z, o, z, -s, z, -c], dim=1).view(-1, 3, 3) # (N, 3, 3)
+ # return torch.matmul(corners, RT) + centers, torch.matmul(corners, RT_flip) + centers # (N, 8, 3)
+ # else:
+ # return torch.matmul(corners, RT) + centers # (N, 8, 3)
+
+ # corners = torch.stack([x_corners, y_corners, z_corners], dim=1) # (N, 3, 8)
+ # R = torch.stack([c, z, s, z, o, z, -s, z, c], dim=1).view(-1, 3, 3) # (N, 3, 3)
+ # corners = torch.matmul(R, corners) + centers.unsqueeze(2) # (N, 3, 8)
+ # corners = corners.transpose(1, 2) # (N, 8, 3)
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/__init__.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/__init__.py
new file mode 100644
index 0000000..993d1d1
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/__init__.py
@@ -0,0 +1 @@
+from .devoxelization import trilinear_devoxelize
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/devoxelization.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/devoxelization.py
new file mode 100644
index 0000000..c60dab1
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/functional/devoxelization.py
@@ -0,0 +1,12 @@
+from torch.autograd import Function
+import torch
+import torch.nn.functional as F
+
+__all__ = ['trilinear_devoxelize']
+
+def trilinear_devoxelize(c, coords, r, training=None):
+ coords = (coords * 2 + 1.0) / r - 1.0
+ coords = coords.permute(0, 2, 1).reshape(c.shape[0], 1, 1, -1, 3)
+ f = F.grid_sample(input=c, grid=coords, padding_mode='border', align_corners=False)
+ f = f.squeeze(dim=2).squeeze(dim=2)
+ return f
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/loss.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/loss.py
new file mode 100644
index 0000000..a35cdd8
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/loss.py
@@ -0,0 +1,10 @@
+import torch.nn as nn
+
+from . import functional as F
+
+__all__ = ['KLLoss']
+
+
+class KLLoss(nn.Module):
+ def forward(self, x, y):
+ return F.kl_loss(x, y)
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pointnet.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pointnet.py
new file mode 100644
index 0000000..e58e01c
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pointnet.py
@@ -0,0 +1,113 @@
+import torch
+import torch.nn as nn
+
+from . import functional as F
+from .ball_query import BallQuery
+from .shared_mlp import SharedMLP
+
+__all__ = ['PointNetAModule', 'PointNetSAModule', 'PointNetFPModule']
+
+
+class PointNetAModule(nn.Module):
+ def __init__(self, in_channels, out_channels, include_coordinates=True):
+ super().__init__()
+ if not isinstance(out_channels, (list, tuple)):
+ out_channels = [[out_channels]]
+ elif not isinstance(out_channels[0], (list, tuple)):
+ out_channels = [out_channels]
+
+ mlps = []
+ total_out_channels = 0
+ for _out_channels in out_channels:
+ mlps.append(
+ SharedMLP(
+ in_channels=in_channels + (3 if include_coordinates else 0),
+ out_channels=_out_channels, dim=1)
+ )
+ total_out_channels += _out_channels[-1]
+
+ self.include_coordinates = include_coordinates
+ self.out_channels = total_out_channels
+ self.mlps = nn.ModuleList(mlps)
+
+ def forward(self, inputs):
+ features, coords = inputs
+ if self.include_coordinates:
+ features = torch.cat([features, coords], dim=1)
+ coords = torch.zeros((coords.size(0), 3, 1), device=coords.device)
+ if len(self.mlps) > 1:
+ features_list = []
+ for mlp in self.mlps:
+ features_list.append(mlp(features).max(dim=-1, keepdim=True).values)
+ return torch.cat(features_list, dim=1), coords
+ else:
+ return self.mlps[0](features).max(dim=-1, keepdim=True).values, coords
+
+ def extra_repr(self):
+ return f'out_channels={self.out_channels}, include_coordinates={self.include_coordinates}'
+
+
+class PointNetSAModule(nn.Module):
+ def __init__(self, num_centers, radius, num_neighbors, in_channels, out_channels, include_coordinates=True):
+ super().__init__()
+ if not isinstance(radius, (list, tuple)):
+ radius = [radius]
+ if not isinstance(num_neighbors, (list, tuple)):
+ num_neighbors = [num_neighbors] * len(radius)
+ assert len(radius) == len(num_neighbors)
+ if not isinstance(out_channels, (list, tuple)):
+ out_channels = [[out_channels]] * len(radius)
+ elif not isinstance(out_channels[0], (list, tuple)):
+ out_channels = [out_channels] * len(radius)
+ assert len(radius) == len(out_channels)
+
+ groupers, mlps = [], []
+ total_out_channels = 0
+ for _radius, _out_channels, _num_neighbors in zip(radius, out_channels, num_neighbors):
+ groupers.append(
+ BallQuery(radius=_radius, num_neighbors=_num_neighbors, include_coordinates=include_coordinates)
+ )
+ mlps.append(
+ SharedMLP(
+ in_channels=in_channels + (3 if include_coordinates else 0),
+ out_channels=_out_channels, dim=2)
+ )
+ total_out_channels += _out_channels[-1]
+
+ self.num_centers = num_centers
+ self.out_channels = total_out_channels
+ self.groupers = nn.ModuleList(groupers)
+ self.mlps = nn.ModuleList(mlps)
+
+ def forward(self, inputs):
+ features, coords = inputs
+ centers_coords = F.furthest_point_sample(coords, self.num_centers)
+ features_list = []
+ for grouper, mlp in zip(self.groupers, self.mlps):
+ features_list.append(mlp(grouper(coords, centers_coords, features)).max(dim=-1).values)
+ if len(features_list) > 1:
+ return torch.cat(features_list, dim=1), centers_coords
+ else:
+ return features_list[0], centers_coords
+
+ def extra_repr(self):
+ return f'num_centers={self.num_centers}, out_channels={self.out_channels}'
+
+
+class PointNetFPModule(nn.Module):
+ def __init__(self, in_channels, out_channels):
+ super().__init__()
+ self.mlp = SharedMLP(in_channels=in_channels, out_channels=out_channels, dim=1)
+
+ def forward(self, inputs):
+ if len(inputs) == 3:
+ points_coords, centers_coords, centers_features = inputs
+ points_features = None
+ else:
+ points_coords, centers_coords, centers_features, points_features = inputs
+ interpolated_features = F.nearest_neighbor_interpolate(points_coords, centers_coords, centers_features)
+ if points_features is not None:
+ interpolated_features = torch.cat(
+ [interpolated_features, points_features], dim=1
+ )
+ return self.mlp(interpolated_features), points_coords
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pvconv.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pvconv.py
new file mode 100644
index 0000000..a64705d
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/pvconv.py
@@ -0,0 +1,38 @@
+import torch.nn as nn
+
+from . import functional as F
+from .voxelization import Voxelization
+from .shared_mlp import SharedMLP
+import torch
+
+__all__ = ['PVConv']
+
+
+class PVConv(nn.Module):
+ def __init__(
+ self, in_channels, out_channels, kernel_size, resolution, with_se=False, normalize=True, eps=0, scale_pvcnn=False,
+ device='cuda'):
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.kernel_size = kernel_size
+ self.resolution = resolution
+ self.voxelization = Voxelization(resolution, normalize=normalize, eps=eps, scale_pvcnn=scale_pvcnn)
+ voxel_layers = [
+ nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=kernel_size // 2, device=device),
+ nn.InstanceNorm3d(out_channels, eps=1e-4, device=device),
+ nn.LeakyReLU(0.1, True),
+ nn.Conv3d(out_channels, out_channels, kernel_size, stride=1, padding=kernel_size // 2, device=device),
+ nn.InstanceNorm3d(out_channels, eps=1e-4, device=device),
+ nn.LeakyReLU(0.1, True),
+ ]
+ self.voxel_layers = nn.Sequential(*voxel_layers)
+ self.point_features = SharedMLP(in_channels, out_channels, device=device)
+
+ def forward(self, inputs):
+ features, coords = inputs
+ voxel_features, voxel_coords = self.voxelization(features, coords)
+ voxel_features = self.voxel_layers(voxel_features)
+ devoxel_features = F.trilinear_devoxelize(voxel_features, voxel_coords, self.resolution, self.training)
+ fused_features = devoxel_features + self.point_features(features)
+ return fused_features, coords, voxel_features
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/shared_mlp.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/shared_mlp.py
new file mode 100644
index 0000000..e1d4ff8
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/shared_mlp.py
@@ -0,0 +1,35 @@
+import torch.nn as nn
+
+__all__ = ['SharedMLP']
+
+
+class SharedMLP(nn.Module):
+ def __init__(self, in_channels, out_channels, dim=1, device='cuda'):
+ super().__init__()
+ # print('==> SharedMLP device: ', device)
+ if dim == 1:
+ conv = nn.Conv1d
+ bn = nn.InstanceNorm1d
+ elif dim == 2:
+ conv = nn.Conv2d
+ bn = nn.InstanceNorm1d
+ else:
+ raise ValueError
+ if not isinstance(out_channels, (list, tuple)):
+ out_channels = [out_channels]
+ layers = []
+ for oc in out_channels:
+ layers.extend(
+ [
+ conv(in_channels, oc, 1, device=device),
+ bn(oc, device=device),
+ nn.ReLU(True),
+ ])
+ in_channels = oc
+ self.layers = nn.Sequential(*layers)
+
+ def forward(self, inputs):
+ if isinstance(inputs, (list, tuple)):
+ return (self.layers(inputs[0]), *inputs[1:])
+ else:
+ return self.layers(inputs)
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/voxelization.py b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/voxelization.py
new file mode 100644
index 0000000..7911113
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/pv_module/voxelization.py
@@ -0,0 +1,80 @@
+import torch
+import torch.nn as nn
+
+from . import functional as F
+
+__all__ = ['Voxelization']
+
+
+def my_voxelization(features, coords, resolution):
+ b, c, _ = features.shape
+ result = torch.zeros(b, c + 1, resolution * resolution * resolution, device=features.device, dtype=features.dtype)
+ r = resolution
+ r2 = resolution * resolution
+ coords = coords.long()
+ indices = coords[:, 0] * r2 + coords[:, 1] * r + coords[:, 2]
+
+ # print(r, r2, coords[:, 0].max(), coords[:, 1].max(), coords[:, 2].max())
+
+ # print(f"Resolution: {resolution}")
+ # print(f"Coords shape: {coords.shape}")
+ # print(f"Coords max per dim: x={coords[:, 0].max()}, y={coords[:, 1].max()}, z={coords[:, 2].max()}")
+ # print(f"Coords min per dim: x={coords[:, 0].min()}, y={coords[:, 1].min()}, z={coords[:, 2].min()}")
+ # print(f"Indices shape: {indices.shape}")
+ # print(f"Indices max: {indices.max()}, min: {indices.min()}")
+ # print(f"Expected max index: {resolution * resolution * resolution - 1}")
+
+ # # 检查是否有越界的索引
+ # max_valid_index = resolution * resolution * resolution - 1
+ # invalid_mask = (indices > max_valid_index) | (indices < 0)
+ # if invalid_mask.any():
+ # print(f"Found {invalid_mask.sum()} invalid indices!")
+ # print(f"Invalid indices: {indices[invalid_mask]}")
+ # # 找到对应的坐标
+ # invalid_coords = coords[:, :, invalid_mask.any(dim=0)]
+ # print(f"Invalid coords shape: {invalid_coords.shape}")
+ # if invalid_coords.numel() > 0:
+ # print(f"Sample invalid coords: {invalid_coords[:, :, :5]}") # 显示前5个无效坐标
+
+ indices = indices.unsqueeze(dim=1).expand(-1, result.shape[1], -1)
+ features = torch.cat([features, torch.ones(features.shape[0], 1, features.shape[2], device=features.device, dtype=features.dtype)], dim=1)
+ out_feature = result.scatter_(index=indices.long(), src=features, dim=2, reduce='add')
+ cnt = out_feature[:, -1:, :]
+ zero_mask = (cnt == 0).to(features.dtype)
+ cnt = cnt * (1 - zero_mask) + zero_mask * 1e-5
+ vox_feature = out_feature[:, :-1, :] / cnt
+ return vox_feature.view(b, c, resolution, resolution, resolution)
+
+class Voxelization(nn.Module):
+ def __init__(self, resolution, normalize=True, eps=0, scale_pvcnn=False):
+ super().__init__()
+ self.r = int(resolution)
+ self.normalize = normalize
+ self.eps = eps
+ self.scale_pvcnn = scale_pvcnn
+ assert not normalize
+
+ def forward(self, features, coords):
+ # import pdb; pdb.set_trace()
+ with torch.no_grad():
+ coords = coords.detach()
+
+ if self.normalize:
+ norm_coords = norm_coords / (norm_coords.norm(dim=1, keepdim=True).max(dim=2, keepdim=True).values * 2.0 + self.eps) + 0.5
+ else:
+ if self.scale_pvcnn:
+ norm_coords = (coords + 1) / 2.0 # [0, 1]
+ # print(norm_coords.shape, norm_coords.max(), norm_coords.min())
+ else:
+ # norm_coords = (norm_coords + 1) / 2.0
+ norm_coords = (coords + 1) / 2.0
+ norm_coords = torch.clamp(norm_coords * self.r, 0, self.r - 1)
+ # print(norm_coords.shape, norm_coords.max(), norm_coords.min())
+ vox_coords = torch.round(norm_coords)
+ # print(vox_coords.shape, vox_coords.max(), vox_coords.min())
+ # print(features.shape)
+ new_vox_feat = my_voxelization(features, vox_coords, self.r)
+ return new_vox_feat, norm_coords
+
+ def extra_repr(self):
+ return 'resolution={}{}'.format(self.r, ', normalized eps = {}'.format(self.eps) if self.normalize else '')
diff --git a/OmniPart/modules/PartField/partfield/model/PVCNN/unet_3daware.py b/OmniPart/modules/PartField/partfield/model/PVCNN/unet_3daware.py
new file mode 100644
index 0000000..b0084f0
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/PVCNN/unet_3daware.py
@@ -0,0 +1,427 @@
+import numpy as np
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import init
+
+import einops
+
+def conv3x3(in_channels, out_channels, stride=1,
+ padding=1, bias=True, groups=1):
+ return nn.Conv2d(
+ in_channels,
+ out_channels,
+ kernel_size=3,
+ stride=stride,
+ padding=padding,
+ bias=bias,
+ groups=groups)
+
+def upconv2x2(in_channels, out_channels, mode='transpose'):
+ if mode == 'transpose':
+ return nn.ConvTranspose2d(
+ in_channels,
+ out_channels,
+ kernel_size=2,
+ stride=2)
+ else:
+ # out_channels is always going to be the same
+ # as in_channels
+ return nn.Sequential(
+ nn.Upsample(mode='bilinear', scale_factor=2),
+ conv1x1(in_channels, out_channels))
+
+def conv1x1(in_channels, out_channels, groups=1):
+ return nn.Conv2d(
+ in_channels,
+ out_channels,
+ kernel_size=1,
+ groups=groups,
+ stride=1)
+
+class ConvTriplane3dAware(nn.Module):
+ """ 3D aware triplane conv (as described in RODIN) """
+ def __init__(self, internal_conv_f, in_channels, out_channels, order='xz'):
+ """
+ Args:
+ internal_conv_f: function that should return a 2D convolution Module
+ given in and out channels
+ order: if triplane input is in 'xz' order
+ """
+ super(ConvTriplane3dAware, self).__init__()
+ # Need 3 seperate convolutions
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ assert order in ['xz', 'zx']
+ self.order = order
+ # Going to stack from other planes
+ self.plane_convs = nn.ModuleList([
+ internal_conv_f(3*self.in_channels, self.out_channels) for _ in range(3)])
+
+ def forward(self, triplanes_list):
+ """
+ Args:
+ triplanes_list: [(B,Ci,H,W)]*3 in xy,yz,(zx or xz) depending on order
+ Returns:
+ out_triplanes_list: [(B,Co,H,W)]*3 in xy,yz,(zx or xz) depending on order
+ """
+ inps = list(triplanes_list)
+ xp = 1 #(yz)
+ yp = 2 #(zx)
+ zp = 0 #(xy)
+
+ if self.order == 'xz':
+ # get into zx order
+ inps[yp] = einops.rearrange(inps[yp], 'b c x z -> b c z x')
+
+
+ oplanes = [None]*3
+ # order shouldn't matter
+ for iplane in [zp, xp, yp]:
+ # i_plane -> (j,k)
+
+ # need to average out i and convert to (j,k)
+ # j_plane -> (k,i)
+ # k_plane -> (i,j)
+ jplane = (iplane+1)%3
+ kplane = (iplane+2)%3
+
+ ifeat = inps[iplane]
+ # need to average out nonshared dim
+ # Average pool across
+
+ # j_plane -> (k,i) -> (k,1) -> (1,k) -> (j,k)
+ # b c k i -> b c k 1
+ jpool = torch.mean(inps[jplane], dim=3 ,keepdim=True)
+ jpool = einops.rearrange(jpool, 'b c k 1 -> b c 1 k')
+ jpool = einops.repeat(jpool, 'b c 1 k -> b c j k', j=ifeat.size(2))
+
+ # k_plane -> (i,j) -> (1,j) -> (j,1) -> (j,k)
+ # b c i j -> b c 1 j
+ kpool = torch.mean(inps[kplane], dim=2 ,keepdim=True)
+ kpool = einops.rearrange(kpool, 'b c 1 j -> b c j 1')
+ kpool = einops.repeat(kpool, 'b c j 1 -> b c j k', k=ifeat.size(3))
+
+ # b c h w
+ # jpool = jpool.expand_as(ifeat)
+ # kpool = kpool.expand_as(ifeat)
+
+ # concat and conv on feature dim
+ catfeat = torch.cat([ifeat, jpool, kpool], dim=1)
+ oplane = self.plane_convs[iplane](catfeat)
+ oplanes[iplane] = oplane
+
+ if self.order == 'xz':
+ # get back into xz order
+ oplanes[yp] = einops.rearrange(oplanes[yp], 'b c z x -> b c x z')
+
+ return oplanes
+
+def roll_triplanes(triplanes_list):
+ # B, C, tri, h, w
+ tristack = torch.stack((triplanes_list),dim=2)
+ return einops.rearrange(tristack, 'b c tri h w -> b c (tri h) w', tri=3)
+
+def unroll_triplanes(rolled_triplane):
+ # B, C, tri*h, w
+ tristack = einops.rearrange(rolled_triplane, 'b c (tri h) w -> b c tri h w', tri=3)
+ return torch.unbind(tristack, dim=2)
+
+def conv1x1triplane3daware(in_channels, out_channels, order='xz', **kwargs):
+ return ConvTriplane3dAware(lambda inp, out: conv1x1(inp,out,**kwargs),
+ in_channels, out_channels,order=order)
+
+def Normalize(in_channels, num_groups=32):
+ num_groups = min(in_channels, num_groups) # avoid error if in_channels < 32
+ return torch.nn.GroupNorm(num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True)
+
+def nonlinearity(x):
+ # return F.relu(x)
+ # Swish
+ return x*torch.sigmoid(x)
+
+class Upsample(nn.Module):
+ def __init__(self, in_channels, with_conv):
+ super().__init__()
+ self.with_conv = with_conv
+ if self.with_conv:
+ self.conv = torch.nn.Conv2d(in_channels,
+ in_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1)
+
+ def forward(self, x):
+ x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
+ if self.with_conv:
+ x = self.conv(x)
+ return x
+
+class Downsample(nn.Module):
+ def __init__(self, in_channels, with_conv):
+ super().__init__()
+ self.with_conv = with_conv
+ if self.with_conv:
+ # no asymmetric padding in torch conv, must do it ourselves
+ self.conv = torch.nn.Conv2d(in_channels,
+ in_channels,
+ kernel_size=3,
+ stride=2,
+ padding=0)
+
+ def forward(self, x):
+ if self.with_conv:
+ pad = (0,1,0,1)
+ x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
+ x = self.conv(x)
+ else:
+ x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
+ return x
+
+class ResnetBlock3dAware(nn.Module):
+ def __init__(self, in_channels, out_channels=None):
+ #, conv_shortcut=False):
+ super().__init__()
+ self.in_channels = in_channels
+ out_channels = in_channels if out_channels is None else out_channels
+ self.out_channels = out_channels
+ # self.use_conv_shortcut = conv_shortcut
+
+ self.norm1 = Normalize(in_channels)
+ self.conv1 = conv3x3(self.in_channels, self.out_channels)
+
+ self.norm_mid = Normalize(out_channels)
+ self.conv_3daware = conv1x1triplane3daware(self.out_channels, self.out_channels)
+
+ self.norm2 = Normalize(out_channels)
+ self.conv2 = conv3x3(self.out_channels, self.out_channels)
+
+ if self.in_channels != self.out_channels:
+ self.nin_shortcut = torch.nn.Conv2d(in_channels,
+ out_channels,
+ kernel_size=1,
+ stride=1,
+ padding=0)
+
+ def forward(self, x):
+ # 3x3 plane comm
+ h = x
+ h = self.norm1(h)
+ h = nonlinearity(h)
+ h = self.conv1(h)
+
+ # 1x1 3d aware, crossplane comm
+ h = self.norm_mid(h)
+ h = nonlinearity(h)
+ h = unroll_triplanes(h)
+ h = self.conv_3daware(h)
+ h = roll_triplanes(h)
+
+ # 3x3 plane comm
+ h = self.norm2(h)
+ h = nonlinearity(h)
+ h = self.conv2(h)
+
+ if self.in_channels != self.out_channels:
+ x = self.nin_shortcut(x)
+
+ return x+h
+
+class DownConv3dAware(nn.Module):
+ """
+ A helper Module that performs 2 convolutions and 1 MaxPool.
+ A ReLU activation follows each convolution.
+ """
+ def __init__(self, in_channels, out_channels, downsample=True, with_conv=False):
+ super(DownConv3dAware, self).__init__()
+
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ self.block = ResnetBlock3dAware(in_channels=in_channels,
+ out_channels=out_channels)
+
+ self.do_downsample = downsample
+ self.downsample = Downsample(out_channels, with_conv=with_conv)
+
+ def forward(self, x):
+ """
+ rolled input, rolled output
+ Args:
+ x: rolled (b c (tri*h) w)
+ """
+ x = self.block(x)
+ before_pool = x
+ # if self.pooling:
+ # x = self.pool(x)
+ if self.do_downsample:
+ # unroll and cat channel-wise (to prevent pooling across triplane boundaries)
+ x = einops.rearrange(x, 'b c (tri h) w -> b (c tri) h w', tri=3)
+ x = self.downsample(x)
+ # undo
+ x = einops.rearrange(x, 'b (c tri) h w -> b c (tri h) w', tri=3)
+ return x, before_pool
+
+class UpConv3dAware(nn.Module):
+ """
+ A helper Module that performs 2 convolutions and 1 UpConvolution.
+ A ReLU activation follows each convolution.
+ """
+ def __init__(self, in_channels, out_channels,
+ merge_mode='concat', with_conv=False): #up_mode='transpose', ):
+ super(UpConv3dAware, self).__init__()
+
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.merge_mode = merge_mode
+
+ self.upsample = Upsample(in_channels, with_conv)
+
+ if self.merge_mode == 'concat':
+ self.norm1 = Normalize(in_channels+out_channels)
+ self.block = ResnetBlock3dAware(in_channels=in_channels+out_channels,
+ out_channels=out_channels)
+ else:
+ self.norm1 = Normalize(in_channels)
+ self.block = ResnetBlock3dAware(in_channels=in_channels,
+ out_channels=out_channels)
+
+
+ def forward(self, from_down, from_up):
+ """ Forward pass
+ rolled inputs, rolled output
+ rolled (b c (tri*h) w)
+ Arguments:
+ from_down: tensor from the encoder pathway
+ from_up: upconv'd tensor from the decoder pathway
+ """
+ # from_up = self.upconv(from_up)
+ from_up = self.upsample(from_up)
+ if self.merge_mode == 'concat':
+ x = torch.cat((from_up, from_down), 1)
+ else:
+ x = from_up + from_down
+
+ x = self.norm1(x)
+ x = self.block(x)
+ return x
+
+class UNetTriplane3dAware(nn.Module):
+ def __init__(self, out_channels, in_channels=3, depth=5,
+ start_filts=64,# up_mode='transpose',
+ use_initial_conv=False,
+ merge_mode='concat', **kwargs):
+ """
+ Arguments:
+ in_channels: int, number of channels in the input tensor.
+ Default is 3 for RGB images.
+ depth: int, number of MaxPools in the U-Net.
+ start_filts: int, number of convolutional filters for the
+ first conv.
+ """
+ super(UNetTriplane3dAware, self).__init__()
+
+
+ self.out_channels = out_channels
+ self.in_channels = in_channels
+ self.start_filts = start_filts
+ self.depth = depth
+
+ self.use_initial_conv = use_initial_conv
+ if use_initial_conv:
+ self.conv_initial = conv1x1(self.in_channels, self.start_filts)
+
+ self.down_convs = []
+ self.up_convs = []
+
+ # create the encoder pathway and add to a list
+ for i in range(depth):
+ if i == 0:
+ ins = self.start_filts if use_initial_conv else self.in_channels
+ else:
+ ins = outs
+ outs = self.start_filts*(2**i)
+ downsamp_it = True if i < depth-1 else False
+
+ down_conv = DownConv3dAware(ins, outs, downsample = downsamp_it)
+ self.down_convs.append(down_conv)
+
+ for i in range(depth-1):
+ ins = outs
+ outs = ins // 2
+ up_conv = UpConv3dAware(ins, outs,
+ merge_mode=merge_mode)
+ self.up_convs.append(up_conv)
+
+ # add the list of modules to current module
+ self.down_convs = nn.ModuleList(self.down_convs)
+ self.up_convs = nn.ModuleList(self.up_convs)
+
+ self.norm_out = Normalize(outs)
+ self.conv_final = conv1x1(outs, self.out_channels)
+
+ self.reset_params()
+
+ @staticmethod
+ def weight_init(m):
+ if isinstance(m, nn.Conv2d):
+ # init.xavier_normal_(m.weight, gain=0.1)
+ init.xavier_normal_(m.weight)
+ init.constant_(m.bias, 0)
+
+
+ def reset_params(self):
+ for i, m in enumerate(self.modules()):
+ self.weight_init(m)
+
+
+ def forward(self, x):
+ """
+ Args:
+ x: Stacked triplane expected to be in (B,3,C,H,W)
+ """
+ # Roll
+ x = einops.rearrange(x, 'b tri c h w -> b c (tri h) w', tri=3)
+
+ if self.use_initial_conv:
+ x = self.conv_initial(x)
+
+ encoder_outs = []
+ # encoder pathway, save outputs for merging
+ for i, module in enumerate(self.down_convs):
+ x, before_pool = module(x)
+ encoder_outs.append(before_pool)
+
+ # Spend a block in the middle
+ # x = self.block_mid(x)
+
+ for i, module in enumerate(self.up_convs):
+ before_pool = encoder_outs[-(i+2)]
+ x = module(before_pool, x)
+
+ x = self.norm_out(x)
+
+ # No softmax is used. This means you need to use
+ # nn.CrossEntropyLoss is your training script,
+ # as this module includes a softmax already.
+ x = self.conv_final(nonlinearity(x))
+
+ # Unroll
+ x = einops.rearrange(x, 'b c (tri h) w -> b tri c h w', tri=3)
+ return x
+
+
+def setup_unet(output_channels, input_channels, unet_cfg):
+ if unet_cfg['use_3d_aware']:
+ assert(unet_cfg['rolled'])
+ unet = UNetTriplane3dAware(
+ out_channels=output_channels,
+ in_channels=input_channels,
+ depth=unet_cfg['depth'],
+ use_initial_conv=unet_cfg['use_initial_conv'],
+ start_filts=unet_cfg['start_hidden_channels'],)
+ else:
+ raise NotImplementedError
+ return unet
+
diff --git a/OmniPart/modules/PartField/partfield/model/UNet/buildingblocks.py b/OmniPart/modules/PartField/partfield/model/UNet/buildingblocks.py
new file mode 100644
index 0000000..e97f501
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/UNet/buildingblocks.py
@@ -0,0 +1,546 @@
+#https://github.com/wolny/pytorch-3dunet/blob/master/pytorch3dunet/unet3d/buildingblocks.py
+# MIT License
+
+# Copyright (c) 2018 Adrian Wolny
+
+# 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.
+
+from functools import partial
+
+import torch
+from torch import nn as nn
+from torch.nn import functional as F
+
+# from pytorch3dunet.unet3d.se import ChannelSELayer3D, ChannelSpatialSELayer3D, SpatialSELayer3D
+
+
+def create_conv(in_channels, out_channels, kernel_size, order, num_groups, padding,
+ dropout_prob, is3d):
+ """
+ Create a list of modules with together constitute a single conv layer with non-linearity
+ and optional batchnorm/groupnorm.
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ kernel_size(int or tuple): size of the convolving kernel
+ order (string): order of things, e.g.
+ 'cr' -> conv + ReLU
+ 'gcr' -> groupnorm + conv + ReLU
+ 'cl' -> conv + LeakyReLU
+ 'ce' -> conv + ELU
+ 'bcr' -> batchnorm + conv + ReLU
+ 'cbrd' -> conv + batchnorm + ReLU + dropout
+ 'cbrD' -> conv + batchnorm + ReLU + dropout2d
+ num_groups (int): number of groups for the GroupNorm
+ padding (int or tuple): add zero-padding added to all three sides of the input
+ dropout_prob (float): dropout probability
+ is3d (bool): is3d (bool): if True use Conv3d, otherwise use Conv2d
+ Return:
+ list of tuple (name, module)
+ """
+ assert 'c' in order, "Conv layer MUST be present"
+ assert order[0] not in 'rle', 'Non-linearity cannot be the first operation in the layer'
+
+ modules = []
+ for i, char in enumerate(order):
+ if char == 'r':
+ modules.append(('ReLU', nn.ReLU(inplace=True)))
+ elif char == 'l':
+ modules.append(('LeakyReLU', nn.LeakyReLU(inplace=True)))
+ elif char == 'e':
+ modules.append(('ELU', nn.ELU(inplace=True)))
+ elif char == 'c':
+ # add learnable bias only in the absence of batchnorm/groupnorm
+ bias = not ('g' in order or 'b' in order)
+ if is3d:
+ conv = nn.Conv3d(in_channels, out_channels, kernel_size, padding=padding, bias=bias)
+ else:
+ conv = nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding, bias=bias)
+
+ modules.append(('conv', conv))
+ elif char == 'g':
+ is_before_conv = i < order.index('c')
+ if is_before_conv:
+ num_channels = in_channels
+ else:
+ num_channels = out_channels
+
+ # use only one group if the given number of groups is greater than the number of channels
+ if num_channels < num_groups:
+ num_groups = 1
+
+ assert num_channels % num_groups == 0, f'Expected number of channels in input to be divisible by num_groups. num_channels={num_channels}, num_groups={num_groups}'
+ modules.append(('groupnorm', nn.GroupNorm(num_groups=num_groups, num_channels=num_channels)))
+ elif char == 'b':
+ is_before_conv = i < order.index('c')
+ if is3d:
+ bn = nn.BatchNorm3d
+ else:
+ bn = nn.BatchNorm2d
+
+ if is_before_conv:
+ modules.append(('batchnorm', bn(in_channels)))
+ else:
+ modules.append(('batchnorm', bn(out_channels)))
+ elif char == 'd':
+ modules.append(('dropout', nn.Dropout(p=dropout_prob)))
+ elif char == 'D':
+ modules.append(('dropout2d', nn.Dropout2d(p=dropout_prob)))
+ else:
+ raise ValueError(f"Unsupported layer type '{char}'. MUST be one of ['b', 'g', 'r', 'l', 'e', 'c', 'd', 'D']")
+
+ return modules
+
+
+class SingleConv(nn.Sequential):
+ """
+ Basic convolutional module consisting of a Conv3d, non-linearity and optional batchnorm/groupnorm. The order
+ of operations can be specified via the `order` parameter
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ kernel_size (int or tuple): size of the convolving kernel
+ order (string): determines the order of layers, e.g.
+ 'cr' -> conv + ReLU
+ 'crg' -> conv + ReLU + groupnorm
+ 'cl' -> conv + LeakyReLU
+ 'ce' -> conv + ELU
+ num_groups (int): number of groups for the GroupNorm
+ padding (int or tuple): add zero-padding
+ dropout_prob (float): dropout probability, default 0.1
+ is3d (bool): if True use Conv3d, otherwise use Conv2d
+ """
+
+ def __init__(self, in_channels, out_channels, kernel_size=3, order='gcr', num_groups=8,
+ padding=1, dropout_prob=0.1, is3d=True):
+ super(SingleConv, self).__init__()
+
+ for name, module in create_conv(in_channels, out_channels, kernel_size, order,
+ num_groups, padding, dropout_prob, is3d):
+ self.add_module(name, module)
+
+
+class DoubleConv(nn.Sequential):
+ """
+ A module consisting of two consecutive convolution layers (e.g. BatchNorm3d+ReLU+Conv3d).
+ We use (Conv3d+ReLU+GroupNorm3d) by default.
+ This can be changed however by providing the 'order' argument, e.g. in order
+ to change to Conv3d+BatchNorm3d+ELU use order='cbe'.
+ Use padded convolutions to make sure that the output (H_out, W_out) is the same
+ as (H_in, W_in), so that you don't have to crop in the decoder path.
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ encoder (bool): if True we're in the encoder path, otherwise we're in the decoder
+ kernel_size (int or tuple): size of the convolving kernel
+ order (string): determines the order of layers, e.g.
+ 'cr' -> conv + ReLU
+ 'crg' -> conv + ReLU + groupnorm
+ 'cl' -> conv + LeakyReLU
+ 'ce' -> conv + ELU
+ num_groups (int): number of groups for the GroupNorm
+ padding (int or tuple): add zero-padding added to all three sides of the input
+ upscale (int): number of the convolution to upscale in encoder if DoubleConv, default: 2
+ dropout_prob (float or tuple): dropout probability for each convolution, default 0.1
+ is3d (bool): if True use Conv3d instead of Conv2d layers
+ """
+
+ def __init__(self, in_channels, out_channels, encoder, kernel_size=3, order='gcr',
+ num_groups=8, padding=1, upscale=2, dropout_prob=0.1, is3d=True):
+ super(DoubleConv, self).__init__()
+ if encoder:
+ # we're in the encoder path
+ conv1_in_channels = in_channels
+ if upscale == 1:
+ conv1_out_channels = out_channels
+ else:
+ conv1_out_channels = out_channels // 2
+ if conv1_out_channels < in_channels:
+ conv1_out_channels = in_channels
+ conv2_in_channels, conv2_out_channels = conv1_out_channels, out_channels
+ else:
+ # we're in the decoder path, decrease the number of channels in the 1st convolution
+ conv1_in_channels, conv1_out_channels = in_channels, out_channels
+ conv2_in_channels, conv2_out_channels = out_channels, out_channels
+
+ # check if dropout_prob is a tuple and if so
+ # split it for different dropout probabilities for each convolution.
+ if isinstance(dropout_prob, list) or isinstance(dropout_prob, tuple):
+ dropout_prob1 = dropout_prob[0]
+ dropout_prob2 = dropout_prob[1]
+ else:
+ dropout_prob1 = dropout_prob2 = dropout_prob
+
+ # conv1
+ self.add_module('SingleConv1',
+ SingleConv(conv1_in_channels, conv1_out_channels, kernel_size, order, num_groups,
+ padding=padding, dropout_prob=dropout_prob1, is3d=is3d))
+ # conv2
+ self.add_module('SingleConv2',
+ SingleConv(conv2_in_channels, conv2_out_channels, kernel_size, order, num_groups,
+ padding=padding, dropout_prob=dropout_prob2, is3d=is3d))
+
+
+class ResNetBlock(nn.Module):
+ """
+ Residual block that can be used instead of standard DoubleConv in the Encoder module.
+ Motivated by: https://arxiv.org/pdf/1706.00120.pdf
+
+ Notice we use ELU instead of ReLU (order='cge') and put non-linearity after the groupnorm.
+ """
+
+ def __init__(self, in_channels, out_channels, kernel_size=3, order='cge', num_groups=8, is3d=True, **kwargs):
+ super(ResNetBlock, self).__init__()
+
+ if in_channels != out_channels:
+ # conv1x1 for increasing the number of channels
+ if is3d:
+ self.conv1 = nn.Conv3d(in_channels, out_channels, 1)
+ else:
+ self.conv1 = nn.Conv2d(in_channels, out_channels, 1)
+ else:
+ self.conv1 = nn.Identity()
+
+ self.conv2 = SingleConv(in_channels, out_channels, kernel_size=kernel_size, order=order, num_groups=num_groups,
+ is3d=is3d)
+ # remove non-linearity from the 3rd convolution since it's going to be applied after adding the residual
+ n_order = order
+ for c in 'rel':
+ n_order = n_order.replace(c, '')
+ self.conv3 = SingleConv(out_channels, out_channels, kernel_size=kernel_size, order=n_order,
+ num_groups=num_groups, is3d=is3d)
+
+ # create non-linearity separately
+ if 'l' in order:
+ self.non_linearity = nn.LeakyReLU(negative_slope=0.1, inplace=True)
+ elif 'e' in order:
+ self.non_linearity = nn.ELU(inplace=True)
+ else:
+ self.non_linearity = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ # apply first convolution to bring the number of channels to out_channels
+ residual = self.conv1(x)
+
+ out = self.conv2(x)
+ out = self.conv3(out)
+
+ out += residual
+ out = self.non_linearity(out)
+
+ return out
+
+class Encoder(nn.Module):
+ """
+ A single module from the encoder path consisting of the optional max
+ pooling layer (one may specify the MaxPool kernel_size to be different
+ from the standard (2,2,2), e.g. if the volumetric data is anisotropic
+ (make sure to use complementary scale_factor in the decoder path) followed by
+ a basic module (DoubleConv or ResNetBlock).
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ conv_kernel_size (int or tuple): size of the convolving kernel
+ apply_pooling (bool): if True use MaxPool3d before DoubleConv
+ pool_kernel_size (int or tuple): the size of the window
+ pool_type (str): pooling layer: 'max' or 'avg'
+ basic_module(nn.Module): either ResNetBlock or DoubleConv
+ conv_layer_order (string): determines the order of layers
+ in `DoubleConv` module. See `DoubleConv` for more info.
+ num_groups (int): number of groups for the GroupNorm
+ padding (int or tuple): add zero-padding added to all three sides of the input
+ upscale (int): number of the convolution to upscale in encoder if DoubleConv, default: 2
+ dropout_prob (float or tuple): dropout probability, default 0.1
+ is3d (bool): use 3d or 2d convolutions/pooling operation
+ """
+
+ def __init__(self, in_channels, out_channels, conv_kernel_size=3, apply_pooling=True,
+ pool_kernel_size=2, pool_type='max', basic_module=DoubleConv, conv_layer_order='gcr',
+ num_groups=8, padding=1, upscale=2, dropout_prob=0.1, is3d=True):
+ super(Encoder, self).__init__()
+ assert pool_type in ['max', 'avg']
+ if apply_pooling:
+ if pool_type == 'max':
+ if is3d:
+ self.pooling = nn.MaxPool3d(kernel_size=pool_kernel_size)
+ else:
+ self.pooling = nn.MaxPool2d(kernel_size=pool_kernel_size)
+ else:
+ if is3d:
+ self.pooling = nn.AvgPool3d(kernel_size=pool_kernel_size)
+ else:
+ self.pooling = nn.AvgPool2d(kernel_size=pool_kernel_size)
+ else:
+ self.pooling = None
+
+ self.basic_module = basic_module(in_channels, out_channels,
+ encoder=True,
+ kernel_size=conv_kernel_size,
+ order=conv_layer_order,
+ num_groups=num_groups,
+ padding=padding,
+ upscale=upscale,
+ dropout_prob=dropout_prob,
+ is3d=is3d)
+
+ def forward(self, x):
+ if self.pooling is not None:
+ x = self.pooling(x)
+ x = self.basic_module(x)
+ return x
+
+
+class Decoder(nn.Module):
+ """
+ A single module for decoder path consisting of the upsampling layer
+ (either learned ConvTranspose3d or nearest neighbor interpolation)
+ followed by a basic module (DoubleConv or ResNetBlock).
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output channels
+ conv_kernel_size (int or tuple): size of the convolving kernel
+ scale_factor (int or tuple): used as the multiplier for the image H/W/D in
+ case of nn.Upsample or as stride in case of ConvTranspose3d, must reverse the MaxPool3d operation
+ from the corresponding encoder
+ basic_module(nn.Module): either ResNetBlock or DoubleConv
+ conv_layer_order (string): determines the order of layers
+ in `DoubleConv` module. See `DoubleConv` for more info.
+ num_groups (int): number of groups for the GroupNorm
+ padding (int or tuple): add zero-padding added to all three sides of the input
+ upsample (str): algorithm used for upsampling:
+ InterpolateUpsampling: 'nearest' | 'linear' | 'bilinear' | 'trilinear' | 'area'
+ TransposeConvUpsampling: 'deconv'
+ No upsampling: None
+ Default: 'default' (chooses automatically)
+ dropout_prob (float or tuple): dropout probability, default 0.1
+ """
+
+ def __init__(self, in_channels, out_channels, conv_kernel_size=3, scale_factor=2, basic_module=DoubleConv,
+ conv_layer_order='gcr', num_groups=8, padding=1, upsample='default',
+ dropout_prob=0.1, is3d=True):
+ super(Decoder, self).__init__()
+
+ # perform concat joining per default
+ concat = True
+
+ # don't adapt channels after join operation
+ adapt_channels = False
+
+ if upsample is not None and upsample != 'none':
+ if upsample == 'default':
+ if basic_module == DoubleConv:
+ upsample = 'nearest' # use nearest neighbor interpolation for upsampling
+ concat = True # use concat joining
+ adapt_channels = False # don't adapt channels
+ elif basic_module == ResNetBlock: #or basic_module == ResNetBlockSE:
+ upsample = 'deconv' # use deconvolution upsampling
+ concat = False # use summation joining
+ adapt_channels = True # adapt channels after joining
+
+ # perform deconvolution upsampling if mode is deconv
+ if upsample == 'deconv':
+ self.upsampling = TransposeConvUpsampling(in_channels=in_channels, out_channels=out_channels,
+ kernel_size=conv_kernel_size, scale_factor=scale_factor,
+ is3d=is3d)
+ else:
+ self.upsampling = InterpolateUpsampling(mode=upsample)
+ else:
+ # no upsampling
+ self.upsampling = NoUpsampling()
+ # concat joining
+ self.joining = partial(self._joining, concat=True)
+
+ # perform joining operation
+ self.joining = partial(self._joining, concat=concat)
+
+ # adapt the number of in_channels for the ResNetBlock
+ if adapt_channels is True:
+ in_channels = out_channels
+
+ self.basic_module = basic_module(in_channels, out_channels,
+ encoder=False,
+ kernel_size=conv_kernel_size,
+ order=conv_layer_order,
+ num_groups=num_groups,
+ padding=padding,
+ dropout_prob=dropout_prob,
+ is3d=is3d)
+
+ def forward(self, encoder_features, x):
+ x = self.upsampling(encoder_features=encoder_features, x=x)
+ x = self.joining(encoder_features, x)
+ x = self.basic_module(x)
+ return x
+
+ @staticmethod
+ def _joining(encoder_features, x, concat):
+ if concat:
+ return torch.cat((encoder_features, x), dim=1)
+ else:
+ return encoder_features + x
+
+
+def create_encoders(in_channels, f_maps, basic_module, conv_kernel_size, conv_padding,
+ conv_upscale, dropout_prob,
+ layer_order, num_groups, pool_kernel_size, is3d):
+ # create encoder path consisting of Encoder modules. Depth of the encoder is equal to `len(f_maps)`
+ encoders = []
+ for i, out_feature_num in enumerate(f_maps):
+ if i == 0:
+ # apply conv_coord only in the first encoder if any
+ encoder = Encoder(in_channels, out_feature_num,
+ apply_pooling=False, # skip pooling in the firs encoder
+ basic_module=basic_module,
+ conv_layer_order=layer_order,
+ conv_kernel_size=conv_kernel_size,
+ num_groups=num_groups,
+ padding=conv_padding,
+ upscale=conv_upscale,
+ dropout_prob=dropout_prob,
+ is3d=is3d)
+ else:
+ encoder = Encoder(f_maps[i - 1], out_feature_num,
+ basic_module=basic_module,
+ conv_layer_order=layer_order,
+ conv_kernel_size=conv_kernel_size,
+ num_groups=num_groups,
+ pool_kernel_size=pool_kernel_size,
+ padding=conv_padding,
+ upscale=conv_upscale,
+ dropout_prob=dropout_prob,
+ is3d=is3d)
+
+ encoders.append(encoder)
+
+ return nn.ModuleList(encoders)
+
+
+def create_decoders(f_maps, basic_module, conv_kernel_size, conv_padding, layer_order,
+ num_groups, upsample, dropout_prob, is3d):
+ # create decoder path consisting of the Decoder modules. The length of the decoder list is equal to `len(f_maps) - 1`
+ decoders = []
+ reversed_f_maps = list(reversed(f_maps[1:]))
+ for i in range(len(reversed_f_maps) - 1):
+ if basic_module == DoubleConv and upsample != 'deconv':
+ in_feature_num = reversed_f_maps[i] + reversed_f_maps[i + 1]
+ else:
+ in_feature_num = reversed_f_maps[i]
+
+ out_feature_num = reversed_f_maps[i + 1]
+
+ decoder = Decoder(in_feature_num, out_feature_num,
+ basic_module=basic_module,
+ conv_layer_order=layer_order,
+ conv_kernel_size=conv_kernel_size,
+ num_groups=num_groups,
+ padding=conv_padding,
+ upsample=upsample,
+ dropout_prob=dropout_prob,
+ is3d=is3d)
+ decoders.append(decoder)
+ return nn.ModuleList(decoders)
+
+
+class AbstractUpsampling(nn.Module):
+ """
+ Abstract class for upsampling. A given implementation should upsample a given 5D input tensor using either
+ interpolation or learned transposed convolution.
+ """
+
+ def __init__(self, upsample):
+ super(AbstractUpsampling, self).__init__()
+ self.upsample = upsample
+
+ def forward(self, encoder_features, x):
+ # get the spatial dimensions of the output given the encoder_features
+ output_size = encoder_features.size()[2:]
+ # upsample the input and return
+ return self.upsample(x, output_size)
+
+
+class InterpolateUpsampling(AbstractUpsampling):
+ """
+ Args:
+ mode (str): algorithm used for upsampling:
+ 'nearest' | 'linear' | 'bilinear' | 'trilinear' | 'area'. Default: 'nearest'
+ used only if transposed_conv is False
+ """
+
+ def __init__(self, mode='nearest'):
+ upsample = partial(self._interpolate, mode=mode)
+ super().__init__(upsample)
+
+ @staticmethod
+ def _interpolate(x, size, mode):
+ return F.interpolate(x, size=size, mode=mode)
+
+
+class TransposeConvUpsampling(AbstractUpsampling):
+ """
+ Args:
+ in_channels (int): number of input channels for transposed conv
+ used only if transposed_conv is True
+ out_channels (int): number of output channels for transpose conv
+ used only if transposed_conv is True
+ kernel_size (int or tuple): size of the convolving kernel
+ used only if transposed_conv is True
+ scale_factor (int or tuple): stride of the convolution
+ used only if transposed_conv is True
+ is3d (bool): if True use ConvTranspose3d, otherwise use ConvTranspose2d
+ """
+
+ class Upsample(nn.Module):
+ """
+ Workaround the 'ValueError: requested an output size...' in the `_output_padding` method in
+ transposed convolution. It performs transposed conv followed by the interpolation to the correct size if necessary.
+ """
+
+ def __init__(self, conv_transposed, is3d):
+ super().__init__()
+ self.conv_transposed = conv_transposed
+ self.is3d = is3d
+
+ def forward(self, x, size):
+ x = self.conv_transposed(x)
+ return F.interpolate(x, size=size)
+
+ def __init__(self, in_channels, out_channels, kernel_size=3, scale_factor=2, is3d=True):
+ # make sure that the output size reverses the MaxPool3d from the corresponding encoder
+ if is3d is True:
+ conv_transposed = nn.ConvTranspose3d(in_channels, out_channels, kernel_size=kernel_size,
+ stride=scale_factor, padding=1, bias=False)
+ else:
+ conv_transposed = nn.ConvTranspose2d(in_channels, out_channels, kernel_size=kernel_size,
+ stride=scale_factor, padding=1, bias=False)
+ upsample = self.Upsample(conv_transposed, is3d)
+ super().__init__(upsample)
+
+
+class NoUpsampling(AbstractUpsampling):
+ def __init__(self):
+ super().__init__(self._no_upsampling)
+
+ @staticmethod
+ def _no_upsampling(x, size):
+ return x
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/UNet/model.py b/OmniPart/modules/PartField/partfield/model/UNet/model.py
new file mode 100644
index 0000000..db20b2f
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/UNet/model.py
@@ -0,0 +1,170 @@
+# https://github.com/wolny/pytorch-3dunet/blob/master/pytorch3dunet/unet3d/buildingblocks.py
+# MIT License
+
+# Copyright (c) 2018 Adrian Wolny
+
+# 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.
+
+import torch.nn as nn
+
+from partfield.model.UNet.buildingblocks import DoubleConv, ResNetBlock, \
+ create_decoders, create_encoders
+
+def number_of_features_per_level(init_channel_number, num_levels):
+ return [init_channel_number * 2 ** k for k in range(num_levels)]
+
+class AbstractUNet(nn.Module):
+ """
+ Base class for standard and residual UNet.
+
+ Args:
+ in_channels (int): number of input channels
+ out_channels (int): number of output segmentation masks;
+ Note that the of out_channels might correspond to either
+ different semantic classes or to different binary segmentation mask.
+ It's up to the user of the class to interpret the out_channels and
+ use the proper loss criterion during training (i.e. CrossEntropyLoss (multi-class)
+ or BCEWithLogitsLoss (two-class) respectively)
+ f_maps (int, tuple): number of feature maps at each level of the encoder; if it's an integer the number
+ of feature maps is given by the geometric progression: f_maps ^ k, k=1,2,3,4
+ final_sigmoid (bool): if True apply element-wise nn.Sigmoid after the final 1x1 convolution,
+ otherwise apply nn.Softmax. In effect only if `self.training == False`, i.e. during validation/testing
+ basic_module: basic model for the encoder/decoder (DoubleConv, ResNetBlock, ....)
+ layer_order (string): determines the order of layers in `SingleConv` module.
+ E.g. 'crg' stands for GroupNorm3d+Conv3d+ReLU. See `SingleConv` for more info
+ num_groups (int): number of groups for the GroupNorm
+ num_levels (int): number of levels in the encoder/decoder path (applied only if f_maps is an int)
+ default: 4
+ is_segmentation (bool): if True and the model is in eval mode, Sigmoid/Softmax normalization is applied
+ after the final convolution; if False (regression problem) the normalization layer is skipped
+ conv_kernel_size (int or tuple): size of the convolving kernel in the basic_module
+ pool_kernel_size (int or tuple): the size of the window
+ conv_padding (int or tuple): add zero-padding added to all three sides of the input
+ conv_upscale (int): number of the convolution to upscale in encoder if DoubleConv, default: 2
+ upsample (str): algorithm used for decoder upsampling:
+ InterpolateUpsampling: 'nearest' | 'linear' | 'bilinear' | 'trilinear' | 'area'
+ TransposeConvUpsampling: 'deconv'
+ No upsampling: None
+ Default: 'default' (chooses automatically)
+ dropout_prob (float or tuple): dropout probability, default: 0.1
+ is3d (bool): if True the model is 3D, otherwise 2D, default: True
+ """
+
+ def __init__(self, in_channels, out_channels, final_sigmoid, basic_module, f_maps=64, layer_order='gcr',
+ num_groups=8, num_levels=4, is_segmentation=False, conv_kernel_size=3, pool_kernel_size=2,
+ conv_padding=1, conv_upscale=2, upsample='default', dropout_prob=0.1, is3d=True, encoder_only=False):
+ super(AbstractUNet, self).__init__()
+
+ if isinstance(f_maps, int):
+ f_maps = number_of_features_per_level(f_maps, num_levels=num_levels)
+
+ assert isinstance(f_maps, list) or isinstance(f_maps, tuple)
+ assert len(f_maps) > 1, "Required at least 2 levels in the U-Net"
+ if 'g' in layer_order:
+ assert num_groups is not None, "num_groups must be specified if GroupNorm is used"
+
+ # create encoder path
+ self.encoders = create_encoders(in_channels, f_maps, basic_module, conv_kernel_size,
+ conv_padding, conv_upscale, dropout_prob,
+ layer_order, num_groups, pool_kernel_size, is3d)
+
+ self.encoder_only = encoder_only
+
+ if encoder_only == False:
+ # create decoder path
+ self.decoders = create_decoders(f_maps, basic_module, conv_kernel_size, conv_padding,
+ layer_order, num_groups, upsample, dropout_prob,
+ is3d)
+
+ # in the last layer a 1×1 convolution reduces the number of output channels to the number of labels
+ if is3d:
+ self.final_conv = nn.Conv3d(f_maps[1], out_channels, 1)
+ else:
+ self.final_conv = nn.Conv2d(f_maps[1], out_channels, 1)
+
+ if is_segmentation:
+ # semantic segmentation problem
+ if final_sigmoid:
+ self.final_activation = nn.Sigmoid()
+ else:
+ self.final_activation = nn.Softmax(dim=1)
+ else:
+ # regression problem
+ self.final_activation = None
+
+ def forward(self, x, return_bottleneck_feat=False):
+ # encoder part
+ encoders_features = []
+ for encoder in self.encoders:
+ x = encoder(x)
+ # reverse the encoder outputs to be aligned with the decoder
+ encoders_features.insert(0, x)
+
+ # remove the last encoder's output from the list
+ # !!remember: it's the 1st in the list
+ bottleneck_feat = encoders_features[0]
+ if self.encoder_only:
+ return bottleneck_feat
+ else:
+ encoders_features = encoders_features[1:]
+
+ # decoder part
+ for decoder, encoder_features in zip(self.decoders, encoders_features):
+ # pass the output from the corresponding encoder and the output
+ # of the previous decoder
+ x = decoder(encoder_features, x)
+
+ x = self.final_conv(x)
+ # During training the network outputs logits
+ if self.final_activation is not None:
+ x = self.final_activation(x)
+
+ if return_bottleneck_feat:
+ return x, bottleneck_feat
+ else:
+ return x
+
+class ResidualUNet3D(AbstractUNet):
+ """
+ Residual 3DUnet model implementation based on https://arxiv.org/pdf/1706.00120.pdf.
+ Uses ResNetBlock as a basic building block, summation joining instead
+ of concatenation joining and transposed convolutions for upsampling (watch out for block artifacts).
+ Since the model effectively becomes a residual net, in theory it allows for deeper UNet.
+ """
+
+ def __init__(self, in_channels, out_channels, final_sigmoid=True, f_maps=(8, 16, 64, 256, 1024), layer_order='gcr',
+ num_groups=8, num_levels=5, is_segmentation=True, conv_padding=1,
+ conv_upscale=2, upsample='default', dropout_prob=0.1, encoder_only=False, **kwargs):
+ super(ResidualUNet3D, self).__init__(in_channels=in_channels,
+ out_channels=out_channels,
+ final_sigmoid=final_sigmoid,
+ basic_module=ResNetBlock,
+ f_maps=f_maps,
+ layer_order=layer_order,
+ num_groups=num_groups,
+ num_levels=num_levels,
+ is_segmentation=is_segmentation,
+ conv_padding=conv_padding,
+ conv_upscale=conv_upscale,
+ upsample=upsample,
+ dropout_prob=dropout_prob,
+ encoder_only=encoder_only,
+ is3d=True)
+
+
diff --git a/OmniPart/modules/PartField/partfield/model/model_utils.py b/OmniPart/modules/PartField/partfield/model/model_utils.py
new file mode 100644
index 0000000..c1cc16b
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/model_utils.py
@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+
+class VanillaMLP(nn.Module):
+ def __init__(self, input_dim, output_dim, out_activation, n_hidden_layers=4, n_neurons=64, activation="ReLU"):
+ super().__init__()
+ self.n_neurons = n_neurons
+ self.n_hidden_layers = n_hidden_layers
+ self.activation = activation
+ self.out_activation = out_activation
+ layers = [
+ self.make_linear(input_dim, self.n_neurons, is_first=True, is_last=False),
+ self.make_activation(),
+ ]
+ for i in range(self.n_hidden_layers - 1):
+ layers += [
+ self.make_linear(
+ self.n_neurons, self.n_neurons, is_first=False, is_last=False
+ ),
+ self.make_activation(),
+ ]
+ layers += [
+ self.make_linear(self.n_neurons, output_dim, is_first=False, is_last=True)
+ ]
+ if self.out_activation == "sigmoid":
+ layers += [nn.Sigmoid()]
+ elif self.out_activation == "tanh":
+ layers += [nn.Tanh()]
+ elif self.out_activation == "hardtanh":
+ layers += [nn.Hardtanh()]
+ elif self.out_activation == "GELU":
+ layers += [nn.GELU()]
+ elif self.out_activation == "RELU":
+ layers += [nn.ReLU()]
+ else:
+ raise NotImplementedError
+ self.layers = nn.Sequential(*layers)
+
+ def forward(self, x, split_size=100000):
+ with torch.cuda.amp.autocast(enabled=False):
+ out = self.layers(x)
+ return out
+
+ def make_linear(self, dim_in, dim_out, is_first, is_last):
+ layer = nn.Linear(dim_in, dim_out, bias=False)
+ return layer
+
+ def make_activation(self):
+ if self.activation == "ReLU":
+ return nn.ReLU(inplace=True)
+ elif self.activation == "GELU":
+ return nn.GELU()
+ else:
+ raise NotImplementedError
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/model/triplane.py b/OmniPart/modules/PartField/partfield/model/triplane.py
new file mode 100644
index 0000000..6274a83
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model/triplane.py
@@ -0,0 +1,331 @@
+#https://github.com/3DTopia/OpenLRM/blob/main/openlrm/models/modeling_lrm.py
+# Copyright (c) 2023-2024, Zexin He
+#
+# 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
+#
+# https://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.
+
+import torch
+import torch.nn as nn
+from functools import partial
+
+def project_onto_planes(planes, coordinates):
+ """
+ Does a projection of a 3D point onto a batch of 2D planes,
+ returning 2D plane coordinates.
+
+ Takes plane axes of shape n_planes, 3, 3
+ # Takes coordinates of shape N, M, 3
+ # returns projections of shape N*n_planes, M, 2
+ """
+ N, M, C = coordinates.shape
+ n_planes, _, _ = planes.shape
+ coordinates = coordinates.unsqueeze(1).expand(-1, n_planes, -1, -1).reshape(N*n_planes, M, 3)
+ inv_planes = torch.linalg.inv(planes).unsqueeze(0).expand(N, -1, -1, -1).reshape(N*n_planes, 3, 3)
+ projections = torch.bmm(coordinates, inv_planes)
+ return projections[..., :2]
+
+def sample_from_planes(plane_features, coordinates, mode='bilinear', padding_mode='zeros', box_warp=None):
+ plane_axes = torch.tensor([[[1, 0, 0],
+ [0, 1, 0],
+ [0, 0, 1]],
+ [[1, 0, 0],
+ [0, 0, 1],
+ [0, 1, 0]],
+ [[0, 0, 1],
+ [0, 1, 0],
+ [1, 0, 0]]], dtype=torch.float32).cuda()
+
+ assert padding_mode == 'zeros'
+ N, n_planes, C, H, W = plane_features.shape
+ _, M, _ = coordinates.shape
+ plane_features = plane_features.view(N*n_planes, C, H, W)
+
+ projected_coordinates = project_onto_planes(plane_axes, coordinates).unsqueeze(1)
+ output_features = torch.nn.functional.grid_sample(plane_features, projected_coordinates.float(), mode=mode, padding_mode=padding_mode, align_corners=False).permute(0, 3, 2, 1).reshape(N, n_planes, M, C)
+ return output_features
+
+def get_grid_coord(grid_size = 256, align_corners=False):
+ if align_corners == False:
+ coords = torch.linspace(-1 + 1/(grid_size), 1 - 1/(grid_size), steps=grid_size)
+ else:
+ coords = torch.linspace(-1, 1, steps=grid_size)
+ i, j, k = torch.meshgrid(coords, coords, coords, indexing='ij')
+ coordinates = torch.stack((i, j, k), dim=-1).reshape(-1, 3)
+ return coordinates
+
+class BasicBlock(nn.Module):
+ """
+ Transformer block that is in its simplest form.
+ Designed for PF-LRM architecture.
+ """
+ # Block contains a self-attention layer and an MLP
+ def __init__(self, inner_dim: int, num_heads: int, eps: float,
+ attn_drop: float = 0., attn_bias: bool = False,
+ mlp_ratio: float = 4., mlp_drop: float = 0.):
+ super().__init__()
+ self.norm1 = nn.LayerNorm(inner_dim, eps=eps)
+ self.self_attn = nn.MultiheadAttention(
+ embed_dim=inner_dim, num_heads=num_heads,
+ dropout=attn_drop, bias=attn_bias, batch_first=True)
+ self.norm2 = nn.LayerNorm(inner_dim, eps=eps)
+ self.mlp = nn.Sequential(
+ nn.Linear(inner_dim, int(inner_dim * mlp_ratio)),
+ nn.GELU(),
+ nn.Dropout(mlp_drop),
+ nn.Linear(int(inner_dim * mlp_ratio), inner_dim),
+ nn.Dropout(mlp_drop),
+ )
+
+ def forward(self, x):
+ # x: [N, L, D]
+ before_sa = self.norm1(x)
+ x = x + self.self_attn(before_sa, before_sa, before_sa, need_weights=False)[0]
+ x = x + self.mlp(self.norm2(x))
+ return x
+
+class ConditionBlock(nn.Module):
+ """
+ Transformer block that takes in a cross-attention condition.
+ Designed for SparseLRM architecture.
+ """
+ # Block contains a cross-attention layer, a self-attention layer, and an MLP
+ def __init__(self, inner_dim: int, cond_dim: int, num_heads: int, eps: float,
+ attn_drop: float = 0., attn_bias: bool = False,
+ mlp_ratio: float = 4., mlp_drop: float = 0.):
+ super().__init__()
+ self.norm1 = nn.LayerNorm(inner_dim, eps=eps)
+ self.cross_attn = nn.MultiheadAttention(
+ embed_dim=inner_dim, num_heads=num_heads, kdim=cond_dim, vdim=cond_dim,
+ dropout=attn_drop, bias=attn_bias, batch_first=True)
+ self.norm2 = nn.LayerNorm(inner_dim, eps=eps)
+ self.self_attn = nn.MultiheadAttention(
+ embed_dim=inner_dim, num_heads=num_heads,
+ dropout=attn_drop, bias=attn_bias, batch_first=True)
+ self.norm3 = nn.LayerNorm(inner_dim, eps=eps)
+ self.mlp = nn.Sequential(
+ nn.Linear(inner_dim, int(inner_dim * mlp_ratio)),
+ nn.GELU(),
+ nn.Dropout(mlp_drop),
+ nn.Linear(int(inner_dim * mlp_ratio), inner_dim),
+ nn.Dropout(mlp_drop),
+ )
+
+ def forward(self, x, cond):
+ # x: [N, L, D]
+ # cond: [N, L_cond, D_cond]
+ x = x + self.cross_attn(self.norm1(x), cond, cond, need_weights=False)[0]
+ before_sa = self.norm2(x)
+ x = x + self.self_attn(before_sa, before_sa, before_sa, need_weights=False)[0]
+ x = x + self.mlp(self.norm3(x))
+ return x
+
+class TransformerDecoder(nn.Module):
+ def __init__(self, block_type: str,
+ num_layers: int, num_heads: int,
+ inner_dim: int, cond_dim: int = None,
+ eps: float = 1e-6):
+ super().__init__()
+ self.block_type = block_type
+ self.layers = nn.ModuleList([
+ self._block_fn(inner_dim, cond_dim)(
+ num_heads=num_heads,
+ eps=eps,
+ )
+ for _ in range(num_layers)
+ ])
+ self.norm = nn.LayerNorm(inner_dim, eps=eps)
+
+ @property
+ def block_type(self):
+ return self._block_type
+
+ @block_type.setter
+ def block_type(self, block_type):
+ assert block_type in ['cond', 'basic'], \
+ f"Unsupported block type: {block_type}"
+ self._block_type = block_type
+
+ def _block_fn(self, inner_dim, cond_dim):
+ assert inner_dim is not None, f"inner_dim must always be specified"
+ if self.block_type == 'basic':
+ return partial(BasicBlock, inner_dim=inner_dim)
+ elif self.block_type == 'cond':
+ assert cond_dim is not None, f"Condition dimension must be specified for ConditionBlock"
+ return partial(ConditionBlock, inner_dim=inner_dim, cond_dim=cond_dim)
+ else:
+ raise ValueError(f"Unsupported block type during runtime: {self.block_type}")
+
+
+ def forward_layer(self, layer: nn.Module, x: torch.Tensor, cond: torch.Tensor,):
+ if self.block_type == 'basic':
+ return layer(x)
+ elif self.block_type == 'cond':
+ return layer(x, cond)
+ else:
+ raise NotImplementedError
+
+ def forward(self, x: torch.Tensor, cond: torch.Tensor = None):
+ # x: [N, L, D]
+ # cond: [N, L_cond, D_cond] or None
+ for layer in self.layers:
+ x = self.forward_layer(layer, x, cond)
+ x = self.norm(x)
+ return x
+
+class Voxel2Triplane(nn.Module):
+ """
+ Full model of the basic single-view large reconstruction model.
+ """
+ def __init__(self, transformer_dim: int, transformer_layers: int, transformer_heads: int,
+ triplane_low_res: int, triplane_high_res: int, triplane_dim: int, voxel_feat_dim: int, normalize_vox_feat=False, voxel_dim=16):
+ super().__init__()
+
+ # attributes
+ self.triplane_low_res = triplane_low_res
+ self.triplane_high_res = triplane_high_res
+ self.triplane_dim = triplane_dim
+ self.voxel_feat_dim = voxel_feat_dim
+
+ # initialize pos_embed with 1/sqrt(dim) * N(0, 1)
+ self.pos_embed = nn.Parameter(torch.randn(1, 3*triplane_low_res**2, transformer_dim) * (1. / transformer_dim) ** 0.5)
+ self.transformer = TransformerDecoder(
+ block_type='cond',
+ num_layers=transformer_layers, num_heads=transformer_heads,
+ inner_dim=transformer_dim, cond_dim=voxel_feat_dim
+ )
+ self.upsampler = nn.ConvTranspose2d(transformer_dim, triplane_dim, kernel_size=8, stride=8, padding=0)
+
+ self.normalize_vox_feat = normalize_vox_feat
+ if normalize_vox_feat:
+ self.vox_norm = nn.LayerNorm(voxel_feat_dim, eps=1e-6)
+ self.vox_pos_embed = nn.Parameter(torch.randn(1, voxel_dim * voxel_dim * voxel_dim, voxel_feat_dim) * (1. / voxel_feat_dim) ** 0.5)
+
+ def forward_transformer(self, voxel_feats):
+ N = voxel_feats.shape[0]
+ x = self.pos_embed.repeat(N, 1, 1) # [N, L, D]
+ if self.normalize_vox_feat:
+ vox_pos_embed = self.vox_pos_embed.repeat(N, 1, 1) # [N, L, D]
+ voxel_feats = self.vox_norm(voxel_feats + vox_pos_embed)
+ x = self.transformer(
+ x,
+ cond=voxel_feats
+ )
+ return x
+
+ def reshape_upsample(self, tokens):
+ N = tokens.shape[0]
+ H = W = self.triplane_low_res
+ x = tokens.view(N, 3, H, W, -1)
+ x = torch.einsum('nihwd->indhw', x) # [3, N, D, H, W]
+ x = x.contiguous().view(3*N, -1, H, W) # [3*N, D, H, W]
+ x = self.upsampler(x) # [3*N, D', H', W']
+ x = x.view(3, N, *x.shape[-3:]) # [3, N, D', H', W']
+ x = torch.einsum('indhw->nidhw', x) # [N, 3, D', H', W']
+ x = x.contiguous()
+ return x
+
+ def forward(self, voxel_feats):
+ N = voxel_feats.shape[0]
+
+ # encode image
+ assert voxel_feats.shape[-1] == self.voxel_feat_dim, \
+ f"Feature dimension mismatch: {voxel_feats.shape[-1]} vs {self.voxel_feat_dim}"
+
+ # transformer generating planes
+ tokens = self.forward_transformer(voxel_feats)
+ planes = self.reshape_upsample(tokens)
+ assert planes.shape[0] == N, "Batch size mismatch for planes"
+ assert planes.shape[1] == 3, "Planes should have 3 channels"
+
+ return planes
+
+
+class TriplaneTransformer(nn.Module):
+ """
+ Full model of the basic single-view large reconstruction model.
+ """
+ def __init__(self, input_dim: int, transformer_dim: int, transformer_layers: int, transformer_heads: int,
+ triplane_low_res: int, triplane_high_res: int, triplane_dim: int):
+ super().__init__()
+
+ # attributes
+ self.triplane_low_res = triplane_low_res
+ self.triplane_high_res = triplane_high_res
+ self.triplane_dim = triplane_dim
+
+ # initialize pos_embed with 1/sqrt(dim) * N(0, 1)
+ self.pos_embed = nn.Parameter(torch.randn(1, 3*triplane_low_res**2, transformer_dim) * (1. / transformer_dim) ** 0.5)
+ self.transformer = TransformerDecoder(
+ block_type='basic',
+ num_layers=transformer_layers, num_heads=transformer_heads,
+ inner_dim=transformer_dim,
+ )
+
+ self.downsampler = nn.Sequential(
+ nn.Conv2d(input_dim, transformer_dim, kernel_size=3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.MaxPool2d(kernel_size=2, stride=2), # Reduces size from 128x128 to 64x64
+
+ nn.Conv2d(transformer_dim, transformer_dim, kernel_size=3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.MaxPool2d(kernel_size=2, stride=2), # Reduces size from 64x64 to 32x32
+ )
+
+ self.upsampler = nn.ConvTranspose2d(transformer_dim, triplane_dim, kernel_size=4, stride=4, padding=0)
+
+ self.mlp = nn.Sequential(
+ nn.Linear(input_dim, triplane_dim),
+ nn.ReLU(),
+ nn.Linear(triplane_dim, triplane_dim)
+ )
+
+ def forward_transformer(self, triplanes):
+ N = triplanes.shape[0]
+ tokens = torch.einsum('nidhw->nihwd', triplanes).reshape(N, self.pos_embed.shape[1], -1) # [N, L, D]
+ x = self.pos_embed.repeat(N, 1, 1) + tokens # [N, L, D]
+ x = self.transformer(x)
+ return x
+
+ def reshape_downsample(self, triplanes):
+ N = triplanes.shape[0]
+ H = W = self.triplane_high_res
+ x = triplanes.view(N, 3, -1, H, W)
+ x = torch.einsum('nidhw->indhw', x) # [3, N, D, H, W]
+ x = x.contiguous().view(3*N, -1, H, W) # [3*N, D, H, W]
+ x = self.downsampler(x) # [3*N, D', H', W']
+ x = x.view(3, N, *x.shape[-3:]) # [3, N, D', H', W']
+ x = torch.einsum('indhw->nidhw', x) # [N, 3, D', H', W']
+ x = x.contiguous()
+ return x
+
+ def reshape_upsample(self, tokens):
+ N = tokens.shape[0]
+ H = W = self.triplane_low_res
+ x = tokens.view(N, 3, H, W, -1)
+ x = torch.einsum('nihwd->indhw', x) # [3, N, D, H, W]
+ x = x.contiguous().view(3*N, -1, H, W) # [3*N, D, H, W]
+ x = self.upsampler(x) # [3*N, D', H', W']
+ x = x.view(3, N, *x.shape[-3:]) # [3, N, D', H', W']
+ x = torch.einsum('indhw->nidhw', x) # [N, 3, D', H', W']
+ x = x.contiguous()
+ return x
+
+ def forward(self, triplanes):
+ downsampled_triplanes = self.reshape_downsample(triplanes)
+ tokens = self.forward_transformer(downsampled_triplanes)
+ residual = self.reshape_upsample(tokens)
+
+ triplanes = triplanes.permute(0, 1, 3, 4, 2).contiguous()
+ triplanes = self.mlp(triplanes)
+ triplanes = triplanes.permute(0, 1, 4, 2, 3).contiguous()
+ planes = triplanes + residual
+ return planes
diff --git a/OmniPart/modules/PartField/partfield/model_trainer_pvcnn_only_demo.py b/OmniPart/modules/PartField/partfield/model_trainer_pvcnn_only_demo.py
new file mode 100644
index 0000000..d0e371b
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/model_trainer_pvcnn_only_demo.py
@@ -0,0 +1,283 @@
+import torch
+import lightning.pytorch as pl
+from .dataloader import Demo_Dataset, Demo_Remesh_Dataset, Correspondence_Demo_Dataset
+from torch.utils.data import DataLoader
+from partfield.model.UNet.model import ResidualUNet3D
+from partfield.model.triplane import TriplaneTransformer, get_grid_coord #, sample_from_planes, Voxel2Triplane
+from partfield.model.model_utils import VanillaMLP
+import torch.nn.functional as F
+import torch.nn as nn
+import os
+import trimesh
+import skimage
+import numpy as np
+import h5py
+import torch.distributed as dist
+from partfield.model.PVCNN.encoder_pc import TriPlanePC2Encoder, sample_triplane_feat
+import json
+import gc
+import time
+from plyfile import PlyData, PlyElement
+
+
+class Model(pl.LightningModule):
+ def __init__(self, cfg):
+ super().__init__()
+
+ self.save_hyperparameters()
+ self.cfg = cfg
+ self.automatic_optimization = False
+ self.triplane_resolution = cfg.triplane_resolution
+ self.triplane_channels_low = cfg.triplane_channels_low
+ self.triplane_transformer = TriplaneTransformer(
+ input_dim=cfg.triplane_channels_low * 2,
+ transformer_dim=1024,
+ transformer_layers=6,
+ transformer_heads=8,
+ triplane_low_res=32,
+ triplane_high_res=128,
+ triplane_dim=cfg.triplane_channels_high,
+ )
+ self.sdf_decoder = VanillaMLP(input_dim=64,
+ output_dim=1,
+ out_activation="tanh",
+ n_neurons=64, #64
+ n_hidden_layers=6) #6
+ self.use_pvcnn = cfg.use_pvcnnonly
+ self.use_2d_feat = cfg.use_2d_feat
+ if self.use_pvcnn:
+ self.pvcnn = TriPlanePC2Encoder(
+ cfg.pvcnn,
+ device="cuda",
+ shape_min=-1,
+ shape_length=2,
+ use_2d_feat=self.use_2d_feat) #.cuda()
+ self.logit_scale = nn.Parameter(torch.tensor([1.0], requires_grad=True))
+ self.grid_coord = get_grid_coord(256)
+ self.mse_loss = torch.nn.MSELoss()
+ self.l1_loss = torch.nn.L1Loss(reduction='none')
+
+ if cfg.regress_2d_feat:
+ self.feat_decoder = VanillaMLP(input_dim=64,
+ output_dim=192,
+ out_activation="GELU",
+ n_neurons=64, #64
+ n_hidden_layers=6) #6
+
+ def predict_dataloader(self):
+ if self.cfg.remesh_demo:
+ dataset = Demo_Remesh_Dataset(self.cfg)
+ elif self.cfg.correspondence_demo:
+ dataset = Correspondence_Demo_Dataset(self.cfg)
+ else:
+ dataset = Demo_Dataset(self.cfg)
+
+ dataloader = DataLoader(dataset,
+ num_workers=self.cfg.dataset.val_num_workers,
+ batch_size=self.cfg.dataset.val_batch_size,
+ shuffle=False,
+ pin_memory=True,
+ drop_last=False)
+
+ return dataloader
+
+
+ @torch.no_grad()
+ def predict_step(self, batch, batch_idx):
+ save_dir = f"{self.cfg.result_name}"
+ os.makedirs(save_dir, exist_ok=True)
+
+ uid = batch['uid'][0]
+ view_id = 0
+ starttime = time.time()
+
+ if uid == "car" or uid == "complex_car":
+ # if uid == "complex_car":
+ print("Skipping this for now.")
+ print(uid)
+ return
+
+ ### Skip if model already processed
+ if os.path.exists(f'{save_dir}/part_feat_{uid}_{view_id}.npy') or os.path.exists(f'{save_dir}/part_feat_{uid}_{view_id}_batch.npy'):
+ print("Already processed "+uid)
+ return
+
+ N = batch['pc'].shape[0]
+ assert N == 1
+
+ if self.use_2d_feat:
+ print("ERROR. Dataloader not implemented with input 2d feat.")
+ exit()
+ else:
+ pc_feat = self.pvcnn(batch['pc'], batch['pc'])
+
+ planes = pc_feat
+ planes = self.triplane_transformer(planes)
+ sdf_planes, part_planes = torch.split(planes, [64, planes.shape[2] - 64], dim=2)
+
+ if self.cfg.is_pc:
+ tensor_vertices = batch['pc'].reshape(1, -1, 3).cuda().to(torch.float16)
+ point_feat = sample_triplane_feat(part_planes, tensor_vertices) # N, M, C
+ point_feat = point_feat.cpu().detach().numpy().reshape(-1, 448)
+
+ np.save(f'{save_dir}/part_feat_{uid}_{view_id}.npy', point_feat)
+ print(f"Exported part_feat_{uid}_{view_id}.npy")
+
+ ###########
+ from sklearn.decomposition import PCA
+ data_scaled = point_feat / np.linalg.norm(point_feat, axis=-1, keepdims=True)
+
+ pca = PCA(n_components=3)
+
+ data_reduced = pca.fit_transform(data_scaled)
+ data_reduced = (data_reduced - data_reduced.min()) / (data_reduced.max() - data_reduced.min())
+ colors_255 = (data_reduced * 255).astype(np.uint8)
+
+ points = batch['pc'].squeeze().detach().cpu().numpy()
+
+ if colors_255 is None:
+ colors_255 = np.full_like(points, 255) # Default to white color (255,255,255)
+ else:
+ assert colors_255.shape == points.shape, "Colors must have the same shape as points"
+
+ # Convert to structured array for PLY format
+ vertex_data = np.array(
+ [(*point, *color) for point, color in zip(points, colors_255)],
+ dtype=[("x", "f4"), ("y", "f4"), ("z", "f4"), ("red", "u1"), ("green", "u1"), ("blue", "u1")]
+ )
+
+ # Create PLY element
+ el = PlyElement.describe(vertex_data, "vertex")
+ # Write to file
+ filename = f'{save_dir}/feat_pca_{uid}_{view_id}.ply'
+ PlyData([el], text=True).write(filename)
+ print(f"Saved PLY file: {filename}")
+ ############
+
+ else:
+ use_cuda_version = True
+ if use_cuda_version:
+
+ def sample_points(vertices, faces, n_point_per_face):
+ # Generate random barycentric coordinates
+ # borrowed from Kaolin https://github.com/NVIDIAGameWorks/kaolin/blob/master/kaolin/ops/mesh/trianglemesh.py#L43
+ n_f = faces.shape[0]
+ u = torch.sqrt(torch.rand((n_f, n_point_per_face, 1),
+ device=vertices.device,
+ dtype=vertices.dtype))
+ v = torch.rand((n_f, n_point_per_face, 1),
+ device=vertices.device,
+ dtype=vertices.dtype)
+ w0 = 1 - u
+ w1 = u * (1 - v)
+ w2 = u * v
+
+ face_v_0 = torch.index_select(vertices, 0, faces[:, 0].reshape(-1))
+ face_v_1 = torch.index_select(vertices, 0, faces[:, 1].reshape(-1))
+ face_v_2 = torch.index_select(vertices, 0, faces[:, 2].reshape(-1))
+ points = w0 * face_v_0.unsqueeze(dim=1) + w1 * face_v_1.unsqueeze(dim=1) + w2 * face_v_2.unsqueeze(dim=1)
+ return points
+
+ def sample_and_mean_memory_save_version(part_planes, tensor_vertices, n_point_per_face):
+ n_sample_each = self.cfg.n_sample_each # we iterate over this to avoid OOM
+ n_v = tensor_vertices.shape[1]
+ n_sample = n_v // n_sample_each + 1
+ all_sample = []
+ for i_sample in range(n_sample):
+ sampled_feature = sample_triplane_feat(part_planes, tensor_vertices[:, i_sample * n_sample_each: i_sample * n_sample_each + n_sample_each,])
+ assert sampled_feature.shape[1] % n_point_per_face == 0
+ sampled_feature = sampled_feature.reshape(1, -1, n_point_per_face, sampled_feature.shape[-1])
+ sampled_feature = torch.mean(sampled_feature, axis=-2)
+ all_sample.append(sampled_feature)
+ return torch.cat(all_sample, dim=1)
+
+ if self.cfg.vertex_feature:
+ tensor_vertices = batch['vertices'][0].reshape(1, -1, 3).to(torch.float32)
+ point_feat = sample_and_mean_memory_save_version(part_planes, tensor_vertices, 1)
+ else:
+ n_point_per_face = self.cfg.n_point_per_face
+ tensor_vertices = sample_points(batch['vertices'][0], batch['faces'][0], n_point_per_face)
+ tensor_vertices = tensor_vertices.reshape(1, -1, 3).to(torch.float32)
+ point_feat = sample_and_mean_memory_save_version(part_planes, tensor_vertices, n_point_per_face) # N, M, C
+
+ #### Take mean feature in the triangle
+ print("Time elapsed for feature prediction: " + str(time.time() - starttime))
+ point_feat = point_feat.reshape(-1, 448).cpu().numpy()
+ np.save(f'{save_dir}/part_feat_{uid}_{view_id}_batch.npy', point_feat)
+ print(f"Exported part_feat_{uid}_{view_id}.npy")
+
+ ###########
+ from sklearn.decomposition import PCA
+ data_scaled = point_feat / np.linalg.norm(point_feat, axis=-1, keepdims=True)
+
+ pca = PCA(n_components=3)
+
+ data_reduced = pca.fit_transform(data_scaled)
+ data_reduced = (data_reduced - data_reduced.min()) / (data_reduced.max() - data_reduced.min())
+ colors_255 = (data_reduced * 255).astype(np.uint8)
+ V = batch['vertices'][0].cpu().numpy()
+ F = batch['faces'][0].cpu().numpy()
+ if self.cfg.vertex_feature:
+ colored_mesh = trimesh.Trimesh(vertices=V, faces=F, vertex_colors=colors_255, process=False)
+ else:
+ colored_mesh = trimesh.Trimesh(vertices=V, faces=F, face_colors=colors_255, process=False)
+ colored_mesh.export(f'{save_dir}/feat_pca_{uid}_{view_id}.ply')
+ ############
+ torch.cuda.empty_cache()
+
+ else:
+ ### Mesh input (obj file)
+ V = batch['vertices'][0].cpu().numpy()
+ F = batch['faces'][0].cpu().numpy()
+
+ ##### Loop through faces #####
+ num_samples_per_face = self.cfg.n_point_per_face
+
+ all_point_feats = []
+ for face in F:
+ # Get the vertices of the current face
+ v0, v1, v2 = V[face]
+
+ # Generate random barycentric coordinates
+ u = np.random.rand(num_samples_per_face, 1)
+ v = np.random.rand(num_samples_per_face, 1)
+ is_prob = (u+v) >1
+ u[is_prob] = 1 - u[is_prob]
+ v[is_prob] = 1 - v[is_prob]
+ w = 1 - u - v
+
+ # Calculate points in Cartesian coordinates
+ points = u * v0 + v * v1 + w * v2
+
+ tensor_vertices = torch.from_numpy(points.copy()).reshape(1, -1, 3).cuda().to(torch.float32)
+ point_feat = sample_triplane_feat(part_planes, tensor_vertices) # N, M, C
+
+ #### Take mean feature in the triangle
+ point_feat = torch.mean(point_feat, axis=1).cpu().detach().numpy()
+ all_point_feats.append(point_feat)
+ ##############################
+
+ all_point_feats = np.array(all_point_feats).reshape(-1, 448)
+
+ point_feat = all_point_feats
+
+ np.save(f'{save_dir}/part_feat_{uid}_{view_id}.npy', point_feat)
+ print(f"Exported part_feat_{uid}_{view_id}.npy")
+
+ ###########
+ from sklearn.decomposition import PCA
+ data_scaled = point_feat / np.linalg.norm(point_feat, axis=-1, keepdims=True)
+
+ pca = PCA(n_components=3)
+
+ data_reduced = pca.fit_transform(data_scaled)
+ data_reduced = (data_reduced - data_reduced.min()) / (data_reduced.max() - data_reduced.min())
+ colors_255 = (data_reduced * 255).astype(np.uint8)
+
+ colored_mesh = trimesh.Trimesh(vertices=V, faces=F, face_colors=colors_255, process=False)
+ colored_mesh.export(f'{save_dir}/feat_pca_{uid}_{view_id}.ply')
+ ############
+
+ print("Time elapsed: " + str(time.time()-starttime))
+
+ return
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/partfield_encoder.py b/OmniPart/modules/PartField/partfield/partfield_encoder.py
new file mode 100644
index 0000000..a70994b
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/partfield_encoder.py
@@ -0,0 +1,103 @@
+import torch
+import lightning.pytorch as pl
+# from .dataloader import Demo_Dataset, Demo_Remesh_Dataset, Correspondence_Demo_Dataset
+from torch.utils.data import DataLoader
+from .model.UNet.model import ResidualUNet3D
+from .model.triplane import TriplaneTransformer, get_grid_coord #, sample_from_planes, Voxel2Triplane
+from .model.model_utils import VanillaMLP
+import torch.nn.functional as F
+import torch.nn as nn
+import os
+import trimesh
+import skimage
+import numpy as np
+import h5py
+import torch.distributed as dist
+from .model.PVCNN.encoder_pc import TriPlanePC2Encoder, sample_triplane_feat
+import json
+import gc
+import time
+from plyfile import PlyData, PlyElement
+
+
+class Model(pl.LightningModule):
+ def __init__(self, cfg):
+ super().__init__()
+
+ self.save_hyperparameters()
+ self.cfg = cfg
+ self.automatic_optimization = False
+ self.triplane_resolution = cfg.triplane_resolution
+ self.triplane_channels_low = cfg.triplane_channels_low
+ self.triplane_transformer = TriplaneTransformer(
+ input_dim=cfg.triplane_channels_low * 2,
+ transformer_dim=1024,
+ transformer_layers=6,
+ transformer_heads=8,
+ triplane_low_res=32,
+ triplane_high_res=128,
+ triplane_dim=cfg.triplane_channels_high,
+ )
+ self.sdf_decoder = VanillaMLP(input_dim=64,
+ output_dim=1,
+ out_activation="tanh",
+ n_neurons=64, #64
+ n_hidden_layers=6) #6
+ self.use_pvcnn = cfg.use_pvcnnonly
+ self.use_2d_feat = cfg.use_2d_feat
+ if self.use_pvcnn:
+ self.pvcnn = TriPlanePC2Encoder(
+ cfg.pvcnn,
+ device="cuda",
+ shape_min=-1,
+ shape_length=2,
+ use_2d_feat=self.use_2d_feat) #.cuda()
+ self.logit_scale = nn.Parameter(torch.tensor([1.0], requires_grad=True))
+ self.grid_coord = get_grid_coord(256)
+ self.mse_loss = torch.nn.MSELoss()
+ self.l1_loss = torch.nn.L1Loss(reduction='none')
+
+ if cfg.regress_2d_feat:
+ self.feat_decoder = VanillaMLP(input_dim=64,
+ output_dim=192,
+ out_activation="GELU",
+ n_neurons=64, #64
+ n_hidden_layers=6) #6
+
+ # def predict_dataloader(self):
+ # if self.cfg.remesh_demo:
+ # dataset = Demo_Remesh_Dataset(self.cfg)
+ # elif self.cfg.correspondence_demo:
+ # dataset = Correspondence_Demo_Dataset(self.cfg)
+ # else:
+ # dataset = Demo_Dataset(self.cfg)
+
+ # dataloader = DataLoader(dataset,
+ # num_workers=self.cfg.dataset.val_num_workers,
+ # batch_size=self.cfg.dataset.val_batch_size,
+ # shuffle=False,
+ # pin_memory=True,
+ # drop_last=False)
+
+ # return dataloader
+
+
+ @torch.no_grad()
+ def encode(self, points):
+
+ N = points.shape[0]
+ # assert N == 1
+ pcd = points[..., :3]
+
+ pc_feat = self.pvcnn(pcd, pcd)
+
+ planes = pc_feat
+ planes = self.triplane_transformer(planes)
+ sdf_planes, part_planes = torch.split(planes, [64, planes.shape[2] - 64], dim=2)
+
+ tensor_vertices = pcd.reshape(N, -1, 3).cuda().to(pcd.dtype)
+ point_feat = sample_triplane_feat(part_planes, tensor_vertices) # N, M, C
+ # point_feat = point_feat.cpu().detach().numpy().reshape(-1, 448)
+ point_feat = point_feat.reshape(N, -1, 448)
+
+ return point_feat
\ No newline at end of file
diff --git a/OmniPart/modules/PartField/partfield/utils.py b/OmniPart/modules/PartField/partfield/utils.py
new file mode 100644
index 0000000..8dc1764
--- /dev/null
+++ b/OmniPart/modules/PartField/partfield/utils.py
@@ -0,0 +1,5 @@
+import trimesh
+
+def load_mesh_util(input_fname):
+ mesh = trimesh.load(input_fname, force='mesh', process=False)
+ return mesh
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/config.py b/OmniPart/modules/bbox_gen/config.py
new file mode 100644
index 0000000..46e7ff1
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/config.py
@@ -0,0 +1,57 @@
+import os
+from omegaconf import OmegaConf, DictConfig
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+from datetime import datetime
+
+@dataclass
+class ExperimentConfig:
+ name: str = "default"
+ tag: str = ""
+ use_timestamp: bool = False
+ timestamp: Optional[str] = None
+ exp_root_dir: str = "outputs"
+
+ ### these shouldn't be set manually
+ exp_dir: str = "outputs/default"
+ trial_name: str = "exp"
+ trial_dir: str = "outputs/default/exp"
+ ###
+
+ resume: Optional[str] = None
+ ckpt_path: Optional[str] = None
+
+ data: dict = field(default_factory=dict)
+ model_pl: dict = field(default_factory=dict)
+
+ trainer: dict = field(default_factory=dict)
+ checkpoint: dict = field(default_factory=dict)
+ checkpoint_epoch: Optional[dict] = None
+ wandb: dict = field(default_factory=dict)
+
+
+def load_config(*yamls: str, cli_args: list = [], from_string=False, **kwargs) -> Any:
+ if from_string:
+ yaml_confs = [OmegaConf.create(s) for s in yamls]
+ else:
+ yaml_confs = [OmegaConf.load(f) for f in yamls]
+ cli_conf = OmegaConf.from_cli(cli_args)
+ cfg = OmegaConf.merge(*yaml_confs, cli_conf, kwargs)
+ OmegaConf.resolve(cfg)
+ assert isinstance(cfg, DictConfig)
+ scfg = parse_structured(ExperimentConfig, cfg)
+ return scfg
+
+
+def config_to_primitive(config, resolve: bool = True) -> Any:
+ return OmegaConf.to_container(config, resolve=resolve)
+
+
+def dump_config(path: str, config) -> None:
+ with open(path, "w") as fp:
+ OmegaConf.save(config=config, f=fp)
+
+
+def parse_structured(fields: Any, cfg: Optional[Union[dict, DictConfig]] = None) -> Any:
+ scfg = OmegaConf.structured(fields(**cfg))
+ return scfg
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/models/autogressive_bbox_gen.py b/OmniPart/modules/bbox_gen/models/autogressive_bbox_gen.py
new file mode 100644
index 0000000..1082e7b
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/models/autogressive_bbox_gen.py
@@ -0,0 +1,305 @@
+from dataclasses import dataclass
+import os
+import sys
+import torch
+import trimesh
+from torch import nn
+from transformers import AutoModelForCausalLM
+from transformers.generation.logits_process import LogitsProcessorList
+from einops import rearrange
+
+from .image_encoder import DINOv2ImageEncoder
+from ..config import parse_structured
+from .bboxopt import BBoxOPT, BBoxOPTConfig
+from ..utils.bbox_tokenizer import BoundsTokenizerDiag
+from .bbox_gen_models import GroupEmbedding, MultiModalProjector, MeshDecodeLogitsProcessor, SparseStructureEncoder
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+modules_dir = os.path.dirname(os.path.dirname(current_dir))
+partfield_dir = os.path.join(modules_dir, 'PartField')
+if partfield_dir not in sys.path:
+ sys.path.insert(0, partfield_dir)
+import importlib.util
+from ...PartField.partfield.config import default_argument_parser, setup
+
+
+class BboxGen(nn.Module):
+
+ @dataclass
+ class Config:
+ # encoder config
+ encoder_dim_feat: int = 3
+ encoder_dim: int = 64
+ encoder_heads: int = 4
+ encoder_token_num: int = 256
+ encoder_qkv_bias: bool = False
+ encoder_use_ln_post: bool = True
+ encoder_use_checkpoint: bool = False
+ encoder_num_embed_freqs: int = 8
+ encoder_embed_include_pi: bool = False
+ encoder_init_scale: float = 0.25
+ encoder_random_fps: bool = True
+ encoder_learnable_query: bool = False
+ encoder_layers: int = 4
+ group_embedding_dim: int = 64
+
+ # decoder config
+ vocab_size: int = 518
+ decoder_hidden_size: int = 1536
+ decoder_num_hidden_layers: int = 24
+ decoder_ffn_dim: int = 6144
+ decoder_heads: int = 16
+ decoder_use_flash_attention: bool = True
+ decoder_gradient_checkpointing: bool = True
+
+ # data config
+ bins: int = 64
+ BOS_id: int = 64
+ EOS_id: int = 65
+ PAD_id: int = 66
+ max_length: int = 2187 # bos + 50x2x3 + 1374 + 512
+ voxel_token_length: int = 1886
+ voxel_token_placeholder: int = -1
+
+ # tokenizer config
+ max_group_size: int = 50
+
+ # voxel encoder
+ partfield_encoder_path: str = ""
+
+ cfg: Config
+
+ def __init__(self, cfg,model_name="facebook/dinov2-with-registers-large",ckpt=""):
+ super().__init__()
+ self.cfg = parse_structured(self.Config, cfg)
+
+ self.image_encoder = DINOv2ImageEncoder(
+ model_name=model_name,ckpt=ckpt
+ )
+
+ self.image_projector = MultiModalProjector(
+ in_features=(1024 + self.cfg.group_embedding_dim),
+ out_features=self.cfg.decoder_hidden_size,
+ )
+
+ self.group_embedding = GroupEmbedding(
+ max_group_size=self.cfg.max_group_size,
+ hidden_size=self.cfg.group_embedding_dim,
+ )
+
+ self.decoder_config = BBoxOPTConfig(
+ vocab_size=self.cfg.vocab_size,
+ hidden_size=self.cfg.decoder_hidden_size,
+ num_hidden_layers=self.cfg.decoder_num_hidden_layers,
+ ffn_dim=self.cfg.decoder_ffn_dim,
+ max_position_embeddings=self.cfg.max_length,
+ num_attention_heads=self.cfg.decoder_heads,
+ pad_token_id=self.cfg.PAD_id,
+ bos_token_id=self.cfg.BOS_id,
+ eos_token_id=self.cfg.EOS_id,
+ use_cache=True,
+ init_std=0.02,
+ )
+
+ if self.cfg.decoder_use_flash_attention:
+ self.decoder: BBoxOPT = AutoModelForCausalLM.from_config(
+ self.decoder_config,
+ torch_dtype=torch.bfloat16,
+ attn_implementation="flash_attention_2"
+ )
+ else:
+ self.decoder: BBoxOPT = AutoModelForCausalLM.from_config(
+ self.decoder_config,
+ )
+ if self.cfg.decoder_gradient_checkpointing:
+ self.decoder.gradient_checkpointing_enable()
+
+ self.logits_processor = LogitsProcessorList()
+
+ self.logits_processor.append(MeshDecodeLogitsProcessor(
+ bins=self.cfg.bins,
+ BOS_id=self.cfg.BOS_id,
+ EOS_id=self.cfg.EOS_id,
+ PAD_id=self.cfg.PAD_id,
+ vertices_num=2,
+ ))
+ self.tokenizer = BoundsTokenizerDiag(
+ bins=self.cfg.bins,
+ BOS_id=self.cfg.BOS_id,
+ EOS_id=self.cfg.EOS_id,
+ PAD_id=self.cfg.PAD_id,
+ )
+
+ self._load_partfield_encoder()
+
+ self.partfield_voxel_encoder = SparseStructureEncoder(
+ in_channels=451,
+ channels=[448, 448, 448, 1024],
+ latent_channels=448,
+ num_res_blocks=1,
+ num_res_blocks_middle=1,
+ norm_type="layer",
+ )
+
+
+ def _load_partfield_encoder(self):
+ # Load PartField encoder
+ model_spec = importlib.util.spec_from_file_location(
+ "partfield.partfield_encoder",
+ os.path.join(partfield_dir, "partfield", "partfield_encoder.py")
+ )
+ model_module = importlib.util.module_from_spec(model_spec)
+ model_spec.loader.exec_module(model_module)
+ Model = model_module.Model
+ parser = default_argument_parser()
+ args = []
+ args.extend(["-c", os.path.join(partfield_dir, "configs/final/demo.yaml")])
+ args.append("--opts")
+ args.extend(["continue_ckpt", self.cfg.partfield_encoder_path])
+ parsed_args = parser.parse_args(args)
+ cfg = setup(parsed_args, freeze=False)
+ self.partfield_encoder = Model(cfg)
+ self.partfield_encoder.eval()
+ weights = torch.load(self.cfg.partfield_encoder_path,weights_only=False)["state_dict"]
+ self.partfield_encoder.load_state_dict(weights)
+ for param in self.partfield_encoder.parameters():
+ param.requires_grad = False
+ print("PartField encoder loaded")
+
+ def _prepare_lm_inputs(self, voxel_token, input_ids):
+ inputs_embeds = torch.zeros(input_ids.shape[0], input_ids.shape[1], self.cfg.decoder_hidden_size, device=input_ids.device, dtype=voxel_token.dtype)
+ voxel_token_mask = (input_ids == self.cfg.voxel_token_placeholder)
+ inputs_embeds[voxel_token_mask] = voxel_token.view(-1, self.cfg.decoder_hidden_size)
+
+ inputs_embeds[~voxel_token_mask] = self.decoder.get_input_embeddings()(input_ids[~voxel_token_mask]).to(dtype=inputs_embeds.dtype)
+
+ attention_mask = (input_ids != self.cfg.PAD_id)
+ return inputs_embeds, attention_mask.long()
+
+ def forward(self, batch):
+
+ image_latents = self.image_encoder(batch['images'])
+ masks = batch['masks']
+ masks_emb = self.group_embedding(masks)
+ masks_emb = rearrange(masks_emb, 'b c h w -> b (h w) c') # B x Q x C
+ group_emb = torch.zeros((image_latents.shape[0], image_latents.shape[1], masks_emb.shape[2]), device=image_latents.device, dtype=image_latents.dtype)
+ group_emb[:, :masks_emb.shape[1], :] = masks_emb
+ image_latents = torch.cat([image_latents, group_emb], dim=-1)
+ image_latents = self.image_projector(image_latents)
+
+ points = batch['points'][..., :3]
+ rot_matrix = torch.tensor([[1, 0, 0], [0, 0, -1], [0, 1, 0]], device=points.device, dtype=points.dtype)
+ rot_points = torch.matmul(points, rot_matrix)
+ rot_points = rot_points * (2 * 0.9) # from (-0.5, 0.5) to (-1, 1)
+
+ partfield_feat = self.partfield_encoder.encode(rot_points)
+ feat_volume = torch.zeros((points.shape[0], 448, 64, 64, 64), device=partfield_feat.device, dtype=partfield_feat.dtype)
+ whole_voxel_index = batch['whole_voxel_index'] # (b, m, 3)
+
+ batch_size, num_points = whole_voxel_index.shape[0], whole_voxel_index.shape[1]
+ batch_indices = torch.arange(batch_size, device=whole_voxel_index.device).unsqueeze(1).expand(-1, num_points) # (b, m)
+ batch_flat = batch_indices.flatten() # (b*m,)
+ x_flat = whole_voxel_index[..., 0].flatten() # (b*m,)
+ y_flat = whole_voxel_index[..., 1].flatten() # (b*m,)
+ z_flat = whole_voxel_index[..., 2].flatten() # (b*m,)
+ partfield_feat_flat = partfield_feat.reshape(-1, 448) # (b*m, 448)
+ feat_volume[batch_flat, :, x_flat, y_flat, z_flat] = partfield_feat_flat
+
+ xyz_volume = torch.zeros((points.shape[0], 3, 64, 64, 64), device=points.device, dtype=points.dtype)
+ xyz_volume[batch_flat, :, x_flat, y_flat, z_flat] = points.reshape(-1, 3)
+ feat_volume = torch.cat([feat_volume, xyz_volume], dim=1)
+
+ feat_volume = self.partfield_voxel_encoder(feat_volume)
+ feat_volume = rearrange(feat_volume, 'b c x y z -> b (x y z) c')
+
+ voxel_token = torch.cat([image_latents, feat_volume], dim=1) # B x N x D
+
+ input_ids = batch['input_ids']
+ inputs_embeds, attention_mask = self._prepare_lm_inputs(voxel_token, input_ids)
+ output = self.decoder(
+ attention_mask=attention_mask,
+ inputs_embeds=inputs_embeds,
+ return_dict=True,
+ )
+ return {
+ "logits": output.logits,
+ }
+
+ def gen_mesh_from_bounds(self, bounds, random_color):
+ bboxes = []
+ for j in range(bounds.shape[0]):
+ bbox = trimesh.primitives.Box(bounds=bounds[j])
+ color = random_color[j]
+ bbox.visual.vertex_colors = color
+ bboxes.append(bbox)
+ mesh = trimesh.Scene(bboxes)
+ return mesh
+
+ def generate(self, batch):
+
+ image_latents = self.image_encoder(batch['images'])
+ masks = batch['masks']
+ masks_emb = self.group_embedding(masks)
+ masks_emb = rearrange(masks_emb, 'b c h w -> b (h w) c') # B x Q x C
+ group_emb = torch.zeros((image_latents.shape[0], image_latents.shape[1], masks_emb.shape[2]), device=image_latents.device, dtype=image_latents.dtype)
+ group_emb[:, :masks_emb.shape[1], :] = masks_emb
+ image_latents = torch.cat([image_latents, group_emb], dim=-1)
+ image_latents = self.image_projector(image_latents)
+
+ points = batch['points'][..., :3]
+ rot_matrix = torch.tensor([[1, 0, 0], [0, 0, -1], [0, 1, 0]], device=points.device, dtype=points.dtype)
+ rot_points = torch.matmul(points, rot_matrix)
+ rot_points = rot_points * (2 * 0.9) # from (-0.5, 0.5) to (-1, 1)
+
+ partfield_feat = self.partfield_encoder.encode(rot_points)
+ feat_volume = torch.zeros((points.shape[0], 448, 64, 64, 64), device=partfield_feat.device, dtype=partfield_feat.dtype)
+ whole_voxel_index = batch['whole_voxel_index'] # (b, m, 3)
+
+ batch_size, num_points = whole_voxel_index.shape[0], whole_voxel_index.shape[1]
+ batch_indices = torch.arange(batch_size, device=whole_voxel_index.device).unsqueeze(1).expand(-1, num_points) # (b, m)
+ batch_flat = batch_indices.flatten() # (b*m,)
+ x_flat = whole_voxel_index[..., 0].flatten() # (b*m,)
+ y_flat = whole_voxel_index[..., 1].flatten() # (b*m,)
+ z_flat = whole_voxel_index[..., 2].flatten() # (b*m,)
+ partfield_feat_flat = partfield_feat.reshape(-1, 448) # (b*m, 448)
+ feat_volume[batch_flat, :, x_flat, y_flat, z_flat] = partfield_feat_flat
+
+ xyz_volume = torch.zeros((points.shape[0], 3, 64, 64, 64), device=points.device, dtype=points.dtype)
+ xyz_volume[batch_flat, :, x_flat, y_flat, z_flat] = points.reshape(-1, 3)
+ feat_volume = torch.cat([feat_volume, xyz_volume], dim=1)
+
+ feat_volume = self.partfield_voxel_encoder(feat_volume)
+ feat_volume = rearrange(feat_volume, 'b c x y z -> b (x y z) c')
+
+ voxel_token = torch.cat([image_latents, feat_volume], dim=1) # B x N x D
+
+ meshes = []
+ mesh_names = []
+ bboxes = []
+
+ output = self.decoder.generate(
+ inputs_embeds=voxel_token,
+ max_new_tokens=self.cfg.max_length - voxel_token.shape[1],
+ logits_processor=self.logits_processor,
+ do_sample=True,
+ top_k=5,
+ top_p=0.95,
+ temperature=0.5,
+ use_cache=True,
+ )
+
+ for i in range(output.shape[0]):
+ bounds = self.tokenizer.decode(output[i].detach().cpu().numpy(), coord_rg=(-0.5, 0.5))
+ # mesh = self.gen_mesh_from_bounds(bounds, batch['random_color'][i])
+ # meshes.append(mesh)
+ mesh_names.append("topk=5")
+ bboxes.append(bounds)
+
+ return {
+ # 'meshes': meshes,
+ 'mesh_names': mesh_names,
+ 'bboxes': bboxes,
+ }
+
+
+
diff --git a/OmniPart/modules/bbox_gen/models/bbox_gen_models.py b/OmniPart/modules/bbox_gen/models/bbox_gen_models.py
new file mode 100644
index 0000000..2fd7652
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/models/bbox_gen_models.py
@@ -0,0 +1,215 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+from diffusers.models.normalization import FP32LayerNorm
+from diffusers.models.attention import FeedForward
+from transformers.generation.logits_process import LogitsProcessor
+from typing import List, Literal, Optional
+
+from ..modules.norm import GroupNorm32, ChannelLayerNorm32
+
+
+class GroupEmbedding(nn.Module):
+ def __init__(self, max_group_size, hidden_size=64):
+ super().__init__()
+
+ self.group_embedding = nn.Embedding(max_group_size + 1, hidden_size) # +1 for background
+ self.group_embedding.weight.data.normal_(mean=0.0, std=0.02)
+
+ def forward(self, masks):
+ batch_size, height, width = masks.shape
+ masks_flat = masks.reshape(batch_size, -1)
+ embeddings = self.group_embedding(masks_flat)
+ embeddings = embeddings.reshape(batch_size, height, width, -1)
+ embeddings = embeddings.permute(0, 3, 1, 2)
+ return embeddings
+
+
+class MultiModalProjector(torch.nn.Module):
+ def __init__(self, in_features: int, out_features: int, pos_embed_seq_len=None):
+ super().__init__()
+
+ self.norm1 = FP32LayerNorm(in_features)
+ self.ff = FeedForward(in_features, out_features, mult=1, activation_fn="gelu")
+ self.norm2 = FP32LayerNorm(out_features)
+ if pos_embed_seq_len is not None:
+ self.pos_embed = nn.Parameter(torch.zeros(1, pos_embed_seq_len, in_features))
+ else:
+ self.pos_embed = None
+
+ def forward(self, encoder_hidden_states_image: torch.Tensor) -> torch.Tensor:
+ if self.pos_embed is not None:
+ batch_size, seq_len, embed_dim = encoder_hidden_states_image.shape
+ encoder_hidden_states_image = encoder_hidden_states_image.view(-1, 2 * seq_len, embed_dim)
+ encoder_hidden_states_image = encoder_hidden_states_image + self.pos_embed
+
+ hidden_states = self.norm1(encoder_hidden_states_image)
+ hidden_states = self.ff(hidden_states)
+ hidden_states = self.norm2(hidden_states)
+ return hidden_states
+
+
+class MeshDecodeLogitsProcessor(LogitsProcessor):
+ def __init__(self, bins, BOS_id, EOS_id, PAD_id, vertices_num=8):
+ super().__init__()
+ self.bins = bins
+ self.BOS_id = BOS_id
+ self.EOS_id = EOS_id
+ self.PAD_id = PAD_id
+ self.filter_value = -float('inf')
+ self.vertices_num = vertices_num
+
+ def force_token(self, scores, token_id):
+ mask = torch.ones_like(scores, dtype=torch.bool)
+ mask[:, token_id] = False
+ scores[mask] = self.filter_value
+
+ def __call__(self, input_ids, scores):
+ # # all rules:
+ # # 1. first token: BOS
+ current_len = input_ids.shape[-1]
+ if current_len == 0:
+ # force bos
+ self.force_token(scores, self.BOS_id)
+ elif current_len <= self.vertices_num * 3 + 1:
+ scores[:, self.bins:] = self.filter_value
+ else:
+ scores[:, self.BOS_id] = self.filter_value
+ scores[:, self.PAD_id] = self.filter_value
+
+ effective_tokens = current_len - 1
+ complete_boxes = effective_tokens % (self.vertices_num * 3) == 0
+ # print(effective_tokens, complete_boxes)
+ if not complete_boxes:
+ scores[:, self.EOS_id] = self.filter_value
+
+ return scores
+
+
+def norm_layer(norm_type: str, *args, **kwargs) -> nn.Module:
+ """
+ Return a normalization layer.
+ """
+ if norm_type == "group":
+ return GroupNorm32(32, *args, **kwargs)
+ elif norm_type == "layer":
+ return ChannelLayerNorm32(*args, **kwargs)
+ else:
+ raise ValueError(f"Invalid norm type {norm_type}")
+
+
+class ResBlock3d(nn.Module):
+ def __init__(
+ self,
+ channels: int,
+ out_channels: Optional[int] = None,
+ norm_type: Literal["group", "layer"] = "layer",
+ ):
+ super().__init__()
+ self.channels = channels
+ self.out_channels = out_channels or channels
+
+ self.norm1 = norm_layer(norm_type, channels)
+ self.norm2 = norm_layer(norm_type, self.out_channels)
+ self.conv1 = nn.Conv3d(channels, self.out_channels, 3, padding=1)
+ self.conv2 = zero_module(nn.Conv3d(self.out_channels, self.out_channels, 3, padding=1))
+ self.skip_connection = nn.Conv3d(channels, self.out_channels, 1) if channels != self.out_channels else nn.Identity()
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ h = self.norm1(x)
+ h = F.silu(h)
+ h = self.conv1(h)
+ h = self.norm2(h)
+ h = F.silu(h)
+ h = self.conv2(h)
+ h = h + self.skip_connection(x)
+ return h
+
+
+class DownsampleBlock3d(nn.Module):
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ mode: Literal["conv", "avgpool"] = "conv",
+ ):
+ assert mode in ["conv", "avgpool"], f"Invalid mode {mode}"
+
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ if mode == "conv":
+ self.conv = nn.Conv3d(in_channels, out_channels, 2, stride=2)
+ elif mode == "avgpool":
+ assert in_channels == out_channels, "Pooling mode requires in_channels to be equal to out_channels"
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if hasattr(self, "conv"):
+ return self.conv(x)
+ else:
+ return F.avg_pool3d(x, 2)
+
+
+def zero_module(module):
+ """
+ Zero out the parameters of a module and return it.
+ """
+ for p in module.parameters():
+ p.detach().zero_()
+ return module
+
+
+class SparseStructureEncoder(nn.Module):
+ def __init__(
+ self,
+ in_channels: int,
+ latent_channels: int,
+ num_res_blocks: int,
+ channels: List[int],
+ num_res_blocks_middle: int = 2,
+ norm_type: Literal["group", "layer"] = "layer",
+ ):
+ super().__init__()
+ self.in_channels = in_channels
+ self.latent_channels = latent_channels
+ self.num_res_blocks = num_res_blocks
+ self.channels = channels
+ self.num_res_blocks_middle = num_res_blocks_middle
+ self.norm_type = norm_type
+ self.dtype = torch.float16
+ self.input_layer = nn.Conv3d(in_channels, channels[0], 3, padding=1)
+
+ self.blocks = nn.ModuleList([])
+ for i, ch in enumerate(channels):
+ self.blocks.extend([
+ ResBlock3d(ch, ch)
+ for _ in range(num_res_blocks)
+ ])
+ if i < len(channels) - 1:
+ self.blocks.append(
+ DownsampleBlock3d(ch, channels[i+1])
+ )
+
+ self.middle_block = nn.Sequential(*[
+ ResBlock3d(channels[-1], channels[-1])
+ for _ in range(num_res_blocks_middle)
+ ])
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def forward(self, x: torch.Tensor):
+ h = self.input_layer(x)
+ h = h.type(self.dtype)
+
+ for block in self.blocks:
+ h = block(h)
+ h = self.middle_block(h)
+
+ h = h.type(x.dtype)
+ return h
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/models/bboxopt.py b/OmniPart/modules/bbox_gen/models/bboxopt.py
new file mode 100644
index 0000000..83d652b
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/models/bboxopt.py
@@ -0,0 +1,223 @@
+import torch
+import torch.utils.checkpoint
+from torch import nn
+
+from transformers import AutoModelForCausalLM, AutoConfig
+from transformers.models.opt.modeling_opt import OPTForCausalLM, OPTModel, OPTDecoder, OPTConfig
+
+from transformers.utils import logging
+from typing import Optional, Union
+from transformers import __version__ as transformers_version
+from transformers.generation.logits_process import LogitsProcessorList
+from transformers.generation.utils import GenerateNonBeamOutput, GenerateEncoderDecoderOutput, GenerateDecoderOnlyOutput
+from transformers.generation.stopping_criteria import StoppingCriteriaList
+from transformers.generation.configuration_utils import GenerationConfig
+from transformers.generation.streamers import BaseStreamer
+
+logger = logging.get_logger(__name__)
+
+class BBoxOPTConfig(OPTConfig):
+ model_type = "mesh_opt"
+
+class BBoxOPTDecoder(OPTDecoder):
+ config_class = BBoxOPTConfig
+
+class BBoxOPTModel(OPTModel):
+ config_class = BBoxOPTConfig
+ def __init__(self, config: BBoxOPTConfig):
+ super(OPTModel, self).__init__(config)
+ self.decoder = BBoxOPTDecoder(config)
+ # Initialize weights and apply final processing
+ self.post_init()
+
+class BBoxOPT(OPTForCausalLM):
+ config_class = BBoxOPTConfig
+
+ def __init__(self, config: BBoxOPTConfig):
+ super(OPTForCausalLM, self).__init__(config)
+ self.model = BBoxOPTModel(config)
+
+ # the lm_head weight is automatically tied to the embed tokens weight
+ self.lm_head = nn.Linear(config.word_embed_proj_dim, config.vocab_size, bias=False)
+
+ # Initialize weights and apply final processing
+ self.post_init()
+
+ def _sample(
+ self,
+ input_ids: torch.LongTensor,
+ logits_processor: LogitsProcessorList,
+ stopping_criteria: StoppingCriteriaList,
+ generation_config: GenerationConfig,
+ synced_gpus: bool,
+ streamer: Optional["BaseStreamer"],
+ **model_kwargs,
+ ) -> Union[GenerateNonBeamOutput, torch.LongTensor]:
+ r"""
+ Generates sequences of token ids for models with a language modeling head using **multinomial sampling** and
+ can be used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.
+
+ Parameters:
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+ The sequence used as a prompt for the generation.
+ logits_processor (`LogitsProcessorList`):
+ An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]
+ used to modify the prediction scores of the language modeling head applied at each generation step.
+ stopping_criteria (`StoppingCriteriaList`):
+ An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]
+ used to tell if the generation loop should stop.
+ generation_config ([`~generation.GenerationConfig`]):
+ The generation configuration to be used as parametrization of the decoding method.
+ synced_gpus (`bool`):
+ Whether to continue running the while loop until max_length (needed for ZeRO stage 3)
+ streamer (`BaseStreamer`, *optional*):
+ Streamer object that will be used to stream the generated sequences. Generated tokens are passed
+ through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
+ model_kwargs:
+ Additional model specific kwargs will be forwarded to the `forward` function of the model. If model is
+ an encoder-decoder model the kwargs should include `encoder_outputs`.
+
+ Return:
+ [`~generation.GenerateDecoderOnlyOutput`], [`~generation.GenerateEncoderDecoderOutput`] or `torch.LongTensor`:
+ A `torch.LongTensor` containing the generated tokens (default behaviour) or a
+ [`~generation.GenerateDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and
+ `return_dict_in_generate=True` or a [`~generation.GenerateEncoderDecoderOutput`] if
+ `model.config.is_encoder_decoder=True`.
+ """
+ # init values
+ pad_token_id = generation_config._pad_token_tensor
+ output_attentions = generation_config.output_attentions
+ output_hidden_states = generation_config.output_hidden_states
+ output_scores = generation_config.output_scores
+ output_logits = generation_config.output_logits
+ return_dict_in_generate = generation_config.return_dict_in_generate
+ max_length = generation_config.max_length
+ has_eos_stopping_criteria = any(hasattr(criteria, "eos_token_id") for criteria in stopping_criteria)
+ do_sample = generation_config.do_sample
+
+ # init attention / hidden states / scores tuples
+ scores = () if (return_dict_in_generate and output_scores) else None
+ raw_logits = () if (return_dict_in_generate and output_logits) else None
+ decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
+ cross_attentions = () if (return_dict_in_generate and output_attentions) else None
+ decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None
+
+ # if model is an encoder-decoder, retrieve encoder attention weights and hidden states
+ if return_dict_in_generate and self.config.is_encoder_decoder:
+ encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
+ encoder_hidden_states = (
+ model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
+ )
+
+ # keep track of which sequences are already finished
+ batch_size, cur_len = input_ids.shape[:2]
+ this_peer_finished = False
+ unfinished_sequences = torch.ones(batch_size, dtype=torch.long, device=input_ids.device)
+ if transformers_version=="4.50.3":
+ model_kwargs = self._get_initial_cache_position(input_ids, model_kwargs)
+ else:
+ model_kwargs = self._get_initial_cache_position(cur_len,input_ids.device, model_kwargs)
+ while self._has_unfinished_sequences(
+ this_peer_finished, synced_gpus, device=input_ids.device
+ ) and cur_len < max_length:
+ # prepare model inputs
+ model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
+
+ # prepare variable output controls (note: some models won't accept all output controls)
+ model_inputs.update({"output_attentions": output_attentions} if output_attentions else {})
+ model_inputs.update({"output_hidden_states": output_hidden_states} if output_hidden_states else {})
+
+ # forward pass to get next token
+ outputs = self(**model_inputs, return_dict=True)
+
+ if synced_gpus and this_peer_finished:
+ continue # don't waste resources running the code we don't need
+
+ # Clone is needed to avoid keeping a hanging ref to outputs.logits which may be very large for first iteration
+ # (the clone itself is always small)
+ next_token_logits = outputs.logits.clone()[:, -1, :].float()
+
+ # pre-process distribution
+ next_token_scores = logits_processor(input_ids, next_token_logits)
+
+ # Store scores, attentions and hidden_states when required
+ if return_dict_in_generate:
+ if output_scores:
+ scores += (next_token_scores,)
+ if output_logits:
+ raw_logits += (next_token_logits,)
+ if output_attentions:
+ decoder_attentions += (
+ (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
+ )
+ if self.config.is_encoder_decoder:
+ cross_attentions += (outputs.cross_attentions,)
+
+ if output_hidden_states:
+ decoder_hidden_states += (
+ (outputs.decoder_hidden_states,)
+ if self.config.is_encoder_decoder
+ else (outputs.hidden_states,)
+ )
+
+ # token selection
+ if do_sample:
+ probs = nn.functional.softmax(next_token_scores, dim=-1)
+ # TODO (joao): this OP throws "skipping cudagraphs due to ['incompatible ops']", find solution
+ next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
+ else:
+ next_tokens = torch.argmax(next_token_scores, dim=-1)
+
+ # finished sentences should have their next token be a padding token
+ if has_eos_stopping_criteria:
+ next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
+
+ # update generated ids, model inputs, and length for next step
+ input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
+ if streamer is not None:
+ streamer.put(next_tokens.cpu())
+ model_kwargs = self._update_model_kwargs_for_generation(
+ outputs,
+ model_kwargs,
+ is_encoder_decoder=self.config.is_encoder_decoder,
+ )
+
+ unfinished_sequences = unfinished_sequences & ~stopping_criteria(input_ids, scores)
+ this_peer_finished = unfinished_sequences.max() == 0
+ cur_len += 1
+
+ # This is needed to properly delete outputs.logits which may be very large for first iteration
+ # Otherwise a reference to outputs is kept which keeps the logits alive in the next iteration
+ del outputs
+
+ if streamer is not None:
+ streamer.end()
+
+ if return_dict_in_generate:
+ if self.config.is_encoder_decoder:
+ return GenerateEncoderDecoderOutput(
+ sequences=input_ids,
+ scores=scores,
+ logits=raw_logits,
+ encoder_attentions=encoder_attentions,
+ encoder_hidden_states=encoder_hidden_states,
+ decoder_attentions=decoder_attentions,
+ cross_attentions=cross_attentions,
+ decoder_hidden_states=decoder_hidden_states,
+ past_key_values=model_kwargs.get("past_key_values"),
+ )
+ else:
+ return GenerateDecoderOnlyOutput(
+ sequences=input_ids,
+ scores=scores,
+ logits=raw_logits,
+ attentions=decoder_attentions,
+ hidden_states=decoder_hidden_states,
+ past_key_values=model_kwargs.get("past_key_values"),
+ )
+ else:
+ return input_ids
+
+
+AutoConfig.register("mesh_opt", BBoxOPTConfig)
+AutoModelForCausalLM.register(BBoxOPTConfig, BBoxOPT)
diff --git a/OmniPart/modules/bbox_gen/models/image_encoder.py b/OmniPart/modules/bbox_gen/models/image_encoder.py
new file mode 100644
index 0000000..59ebe39
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/models/image_encoder.py
@@ -0,0 +1,44 @@
+from typing import Literal
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+from safetensors.torch import load_file
+from transformers import AutoModel,AutoConfig
+
+
+class DINOv2ImageEncoder(nn.Module):
+ def __init__(self, model_name: Literal[
+ "facebook/dinov2-with-registers-large",
+ "facebook/dinov2-large"
+ ],ckpt=""):
+ super().__init__()
+ config = AutoConfig.from_pretrained(model_name)
+ self.model=AutoModel.from_config(config).to(dtype=torch.float16)
+ self.model.load_state_dict(torch.load(ckpt,map_location="cpu",weights_only=False) if not ckpt.endswith('.safetensors') else load_file(ckpt,device="cpu"))
+ #self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16)
+ self.model.requires_grad_(False)
+ self.model.eval()
+
+ DINOv2_INPUT_MEAN = torch.as_tensor([0.485, 0.456, 0.406], dtype=torch.float32)[
+ None, :, None, None
+ ]
+ DINOv2_INPUT_STD = torch.as_tensor([0.229, 0.224, 0.225], dtype=torch.float32)[
+ None, :, None, None
+ ]
+ self.register_buffer("DINOv2_INPUT_MEAN", DINOv2_INPUT_MEAN, persistent=False)
+ self.register_buffer("DINOv2_INPUT_STD", DINOv2_INPUT_STD, persistent=False)
+ self.max_size = 518
+ self.hidden_size = self.model.config.hidden_size
+
+ def preprocess(self, image: torch.Tensor):
+ B, C, H, W = image.shape
+ assert C == 3 and H <= self.max_size and W <= self.max_size
+ image = (image - self.DINOv2_INPUT_MEAN.to(image)) / self.DINOv2_INPUT_STD.to(image)
+ return image
+
+ def forward(self, image: torch.Tensor):
+ image = self.preprocess(image)
+ features = self.model(image).last_hidden_state
+ return features
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/modules/norm.py b/OmniPart/modules/bbox_gen/modules/norm.py
new file mode 100644
index 0000000..9400025
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/modules/norm.py
@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class LayerNorm32(nn.LayerNorm):
+ def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+ origin_dtype = inputs.dtype
+ return F.layer_norm(
+ inputs.float(),
+ self.normalized_shape,
+ self.weight.float() if self.weight is not None else None,
+ self.bias.float() if self.bias is not None else None,
+ self.eps,
+ ).to(origin_dtype)
+
+
+class GroupNorm32(nn.GroupNorm):
+ """
+ A GroupNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return super().forward(x.float()).type(x.dtype)
+
+
+class ChannelLayerNorm32(LayerNorm32):
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ # print(x.dtype)
+ DIM = x.dim()
+ x = x.permute(0, *range(2, DIM), 1).contiguous()
+ x = super().forward(x)
+ x = x.permute(0, DIM-1, *range(1, DIM-1)).contiguous()
+ return x
+
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/utils/bbox_tokenizer.py b/OmniPart/modules/bbox_gen/utils/bbox_tokenizer.py
new file mode 100644
index 0000000..9c344fc
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/utils/bbox_tokenizer.py
@@ -0,0 +1,64 @@
+
+import numpy as np
+from .mesh import change_pcd_range
+
+
+class BoundsTokenizerDiag:
+ def __init__(self, bins, BOS_id, EOS_id, PAD_id):
+ self.bins = bins
+ self.BOS_id = BOS_id
+ self.EOS_id = EOS_id
+ self.PAD_id = PAD_id
+
+ def encode(self, data_dict, coord_rg=(-1,1)):
+ """
+ Encode bounding boxes to token sequence
+
+ Args:
+ data_dict: dictionary containing bounding boxes
+ coord_rg: range of coordinate values
+ Returns:
+ token sequence
+ """
+ bounds = data_dict["bounds"] # (s, 2, 3)
+
+ all_vertices = bounds.reshape(-1, 6)
+
+ all_vertices = change_pcd_range(all_vertices, from_rg=coord_rg, to_rg=(0.5/self.bins, 1-0.5/self.bins))
+ quantized_vertices = (all_vertices * self.bins).astype(np.int32)
+
+ tokens = []
+ tokens.append(self.BOS_id)
+ tokens.extend(quantized_vertices.flatten().tolist())
+ tokens.append(self.EOS_id)
+ tokens = np.array(tokens)
+
+ return tokens
+
+ def decode(self, tokens, coord_rg=(-1,1)):
+ """
+ Decode token sequence back to bounding boxes
+
+ Args:
+ tokens: token sequence
+ Returns:
+ bounding box array [N, 2, 3]
+ """
+ # Remove special tokens
+ valid_tokens = []
+ for t in tokens:
+ if t != self.BOS_id and t != self.EOS_id and t != self.PAD_id:
+ valid_tokens.append(t)
+
+ # Ensure correct number of tokens (2 vertices per box, 3 coordinates per vertex)
+ if len(valid_tokens) % (2 * 3) != 0:
+ raise ValueError(f"Invalid token count: {len(valid_tokens)}")
+
+ # Reshape to vertex coordinates
+ points = np.array(valid_tokens).reshape(-1, 2, 3)
+
+ # Convert quantized coordinates back to continuous values
+ points = points / self.bins
+ points = change_pcd_range(points, from_rg=(0.5/self.bins, 1-0.5/self.bins), to_rg=coord_rg)
+
+ return points
\ No newline at end of file
diff --git a/OmniPart/modules/bbox_gen/utils/mesh.py b/OmniPart/modules/bbox_gen/utils/mesh.py
new file mode 100644
index 0000000..f81eb85
--- /dev/null
+++ b/OmniPart/modules/bbox_gen/utils/mesh.py
@@ -0,0 +1,42 @@
+import numpy as np
+import trimesh
+import torch
+
+
+def normalize_scene(scene, rg=(-0.5, 0.5)):
+ # put to [-0.5, 0.5]
+ whole_center = scene.bounding_box.centroid
+ scene.apply_translation(-whole_center)
+ whole_scale = max(scene.bounding_box.extents)
+ scene.apply_scale((rg[1]-rg[0]) / whole_scale)
+ return scene
+
+def normalize_mesh(mesh, rg=(-1,1)):
+ # put to [-1, 1]
+ vmin = mesh.vertices.min(axis=0)
+ vmax = mesh.vertices.max(axis=0)
+ center = (vmin + vmax) / 2
+ scale = (vmax - vmin).max()
+ mesh.vertices = (mesh.vertices - center) / scale * (rg[1] - rg[0]) + (rg[0] + rg[1]) / 2
+
+def change_mesh_range(mesh, from_rg=(-1,1), to_rg=(-1,1)):
+ mesh.vertices = (mesh.vertices - (from_rg[0] + from_rg[1]) / 2) / (from_rg[1] - from_rg[0]) * (to_rg[1] - to_rg[0]) + (to_rg[0] + to_rg[1]) / 2
+ return mesh
+
+def change_pcd_range(pcd, from_rg=(-1,1), to_rg=(-1,1)):
+ pcd = (pcd - (from_rg[0] + from_rg[1]) / 2) / (from_rg[1] - from_rg[0]) * (to_rg[1] - to_rg[0]) + (to_rg[0] + to_rg[1]) / 2
+ return pcd
+
+def quantize_vertices(v, bins):
+ return (v * bins).astype(np.int32)
+
+def sample_points(mesh, n):
+ points, face_index = trimesh.sample.sample_surface(mesh, n)
+ normals = mesh.face_normals[face_index]
+ return points, normals
+
+def clear_mesh(mesh):
+ mesh.update_faces(mesh.nondegenerate_faces(height=1.e-8))
+ mesh.remove_unreferenced_vertices()
+ mesh.merge_vertices(digits_vertex=0)
+ return mesh
\ No newline at end of file
diff --git a/OmniPart/modules/inference_utils.py b/OmniPart/modules/inference_utils.py
new file mode 100644
index 0000000..680aeee
--- /dev/null
+++ b/OmniPart/modules/inference_utils.py
@@ -0,0 +1,408 @@
+import os
+os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
+import numpy as np
+from typing import Optional
+from PIL import Image, ImageDraw
+import torchvision.transforms.functional as TF
+import cv2
+import torch
+import trimesh
+import glob
+from tqdm import tqdm
+
+
+def tensor_to_mask_array(mask_tensor):
+ if isinstance(mask_tensor, torch.Tensor):
+ mask_array = mask_tensor.cpu().numpy()
+
+ if mask_array.max() <= 1.0:
+ mask_array = (mask_array * 255).astype(np.uint8)
+ else:
+ mask_array = mask_array.astype(np.uint8)
+
+ return mask_array
+
+def load_img_mask(img_path, mask_path, size=(518, 518)): #()
+ image = Image.open(img_path)
+ alpha = np.array(image.getchannel(3))
+ bbox = np.array(alpha).nonzero()
+ bbox = [bbox[1].min(), bbox[0].min(), bbox[1].max(), bbox[0].max()]
+ center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
+ hsize = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) / 2
+ aug_size_ratio = 1.2
+ aug_hsize = hsize * aug_size_ratio
+ aug_center_offset = [0, 0]
+ aug_center = [center[0] + aug_center_offset[0], center[1] + aug_center_offset[1]]
+ aug_bbox = [int(aug_center[0] - aug_hsize), int(aug_center[1] - aug_hsize), int(aug_center[0] + aug_hsize), int(aug_center[1] + aug_hsize)]
+ img_height, img_width = alpha.shape
+
+ if mask_path.endswith('.npy'):
+ mask = np.load(mask_path)
+
+ elif mask_path.endswith('.exr'):
+ mask = cv2.imread(mask_path, cv2.IMREAD_UNCHANGED)
+ else:
+ mask = cv2.imread(mask_path, cv2.IMREAD_UNCHANGED)
+ if mask.dtype == np.uint8 or mask.dtype == np.uint16:
+ mask = mask.astype(np.float32)
+
+ #mask = cv2.imread(mask_path, cv2.IMREAD_UNCHANGED)
+
+
+ pad_left = max(0, -aug_bbox[0])
+ pad_top = max(0, -aug_bbox[1])
+ pad_right = max(0, aug_bbox[2] - img_width)
+ pad_bottom = max(0, aug_bbox[3] - img_height)
+
+ if pad_left > 0 or pad_top > 0 or pad_right > 0 or pad_bottom > 0:
+ img_array = np.array(image)
+ padded_img_array = np.pad(
+ img_array,
+ ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)),
+ mode='constant',
+ constant_values=0
+ )
+ padded_mask_array = np.pad(mask, ((pad_top, pad_bottom), (pad_left, pad_right), (0, 0)), mode='constant', constant_values=0)
+ image = Image.fromarray(padded_img_array.astype('uint8'))
+ aug_bbox[0] += pad_left
+ aug_bbox[1] += pad_top
+ aug_bbox[2] += pad_left
+ aug_bbox[3] += pad_top
+ mask = padded_mask_array
+
+ image = image.crop(aug_bbox)
+ mask = mask[aug_bbox[1]:aug_bbox[3], aug_bbox[0]:aug_bbox[2]]
+ ordered_mask_input, mask_vis = load_bottom_up_mask(mask)
+
+ image_white_bg = np.array(image)
+ image_black_bg = np.array(image)
+ if image_white_bg.shape[-1] == 4:
+ mask_img = image_white_bg[..., 3] == 0
+ image_white_bg[mask_img] = [255, 255, 255, 255]
+ image_black_bg[mask_img] = [0, 0, 0, 255]
+ image_white_bg = image_white_bg[..., :3]
+ image_black_bg = image_black_bg[..., :3]
+ img_white_bg = Image.fromarray(image_white_bg.astype('uint8'))
+ img_black_bg = Image.fromarray(image_black_bg.astype('uint8'))
+
+ img_white_bg = img_white_bg.resize(size, resample=Image.Resampling.LANCZOS)
+ img_black_bg = img_black_bg.resize(size, resample=Image.Resampling.LANCZOS)
+ img_mask_vis = vis_mask_on_img(img_white_bg, mask_vis)
+ img_white_bg = TF.to_tensor(img_white_bg)
+ img_black_bg = TF.to_tensor(img_black_bg)
+
+ return img_white_bg, img_black_bg, ordered_mask_input, img_mask_vis
+
+
+def load_bottom_up_mask(mask, size=(518, 518)):
+ mask_input = smart_downsample_mask(mask, (37, 37))
+ mask_vis = cv2.resize(mask_input, (518, 518), interpolation=cv2.INTER_NEAREST)
+ mask_input = np.array(mask_input, dtype=np.int32)
+ unique_indices = np.unique(mask_input)
+ unique_indices = unique_indices[unique_indices > 0]
+
+ part_positions = {}
+ for idx in unique_indices:
+ y_coords, _ = np.where(mask_input == idx)
+ if len(y_coords) > 0:
+ part_positions[idx] = np.max(y_coords)
+
+ sorted_parts = sorted(part_positions.items(), key=lambda x: -x[1]) # Sort by y-coordinate in descending order
+ # Create mapping from old indices to new indices (ordered by position)
+ index_map = {}
+ for new_idx, (old_idx, _) in enumerate(sorted_parts, 1): # Start from 1 (0 is background)
+ index_map[old_idx] = new_idx
+ # Apply the mapping to create position-ordered mask
+ ordered_mask_input = np.zeros_like(mask_input)
+ for old_idx, new_idx in index_map.items():
+ ordered_mask_input[mask_input == old_idx] = new_idx
+ mask_vis = np.array(mask_vis, dtype=np.int32)
+ ordered_mask_input = torch.from_numpy(ordered_mask_input).long()
+
+ return ordered_mask_input, mask_vis
+
+
+def smart_downsample_mask(mask, target_size):
+ h, w = mask.shape[:2]
+ target_h, target_w = target_size
+ h_ratio = h / target_h
+ w_ratio = w / target_w
+
+ downsampled = np.zeros((target_h, target_w), dtype=mask.dtype)
+ for i in range(target_h):
+ for j in range(target_w):
+ y_start = int(i * h_ratio)
+ y_end = min(int((i + 1) * h_ratio), h)
+ x_start = int(j * w_ratio)
+ x_end = min(int((j + 1) * w_ratio), w)
+ region = mask[y_start:y_end, x_start:x_end]
+ if region.size == 0:
+ continue
+ unique_values, counts = np.unique(region.flatten(), return_counts=True)
+ non_zero_mask = unique_values > 0
+ if np.any(non_zero_mask):
+ non_zero_values = unique_values[non_zero_mask]
+ non_zero_counts = counts[non_zero_mask]
+ max_idx = np.argmax(non_zero_counts)
+ downsampled[i, j] = non_zero_values[max_idx]
+ else:
+ max_idx = np.argmax(counts)
+ downsampled[i, j] = unique_values[max_idx]
+
+ return downsampled
+
+
+def vis_mask_on_img(img, mask):
+ H, W = mask.shape
+ mask_vis = np.zeros((H, W, 3), dtype=np.uint8) + 255
+ for part_id in range(1, int(mask.max()) + 1):
+ part_mask = (mask == part_id)
+ if part_mask.sum() > 0:
+ color = get_random_color((part_id - 1), use_float=False)[:3]
+ mask_vis[part_mask, 0:3] = color
+ mask_img = Image.fromarray(mask_vis)
+ combined_width = W * 2
+ combined_height = H
+ combined_img = Image.new('RGB', (combined_width, combined_height), (255, 255, 255))
+ combined_img.paste(img, (0, 0))
+ combined_img.paste(mask_img, (W, 0))
+ draw = ImageDraw.Draw(combined_img)
+ draw.line([(W, 0), (W, H)], fill=(0, 0, 0), width=2)
+
+ return combined_img
+
+
+def get_random_color(index: Optional[int] = None, use_float: bool = False):
+ # some pleasing colors
+ # matplotlib.colormaps['Set3'].colors + matplotlib.colormaps['Set2'].colors + matplotlib.colormaps['Set1'].colors
+ palette = np.array(
+ [
+ [141, 211, 199, 255],
+ [255, 255, 179, 255],
+ [190, 186, 218, 255],
+ [251, 128, 114, 255],
+ [128, 177, 211, 255],
+ [253, 180, 98, 255],
+ [179, 222, 105, 255],
+ [252, 205, 229, 255],
+ [217, 217, 217, 255],
+ [188, 128, 189, 255],
+ [204, 235, 197, 255],
+ [255, 237, 111, 255],
+ [102, 194, 165, 255],
+ [252, 141, 98, 255],
+ [141, 160, 203, 255],
+ [231, 138, 195, 255],
+ [166, 216, 84, 255],
+ [255, 217, 47, 255],
+ [229, 196, 148, 255],
+ [179, 179, 179, 255],
+ [228, 26, 28, 255],
+ [55, 126, 184, 255],
+ [77, 175, 74, 255],
+ [152, 78, 163, 255],
+ [255, 127, 0, 255],
+ [255, 255, 51, 255],
+ [166, 86, 40, 255],
+ [247, 129, 191, 255],
+ [153, 153, 153, 255],
+ ],
+ dtype=np.uint8,
+ )
+
+ if index is None:
+ index = np.random.randint(0, len(palette))
+
+ if index >= len(palette):
+ index = index % len(palette)
+
+ if use_float:
+ return palette[index].astype(np.float32) / 255
+ else:
+ return palette[index]
+
+
+def change_pcd_range(pcd, from_rg=(-1,1), to_rg=(-1,1)):
+ pcd = (pcd - (from_rg[0] + from_rg[1]) / 2) / (from_rg[1] - from_rg[0]) * (to_rg[1] - to_rg[0]) + (to_rg[0] + to_rg[1]) / 2
+ return pcd
+
+
+def prepare_bbox_gen_input(voxel_coords_path, img_white_bg, ordered_mask_input, bins=64, device="cuda"):
+ whole_voxel = np.load(voxel_coords_path)
+ whole_voxel = whole_voxel[:, 1:]
+ whole_voxel = (whole_voxel + 0.5) / bins - 0.5
+ whole_voxel_index = change_pcd_range(whole_voxel, from_rg=(-0.5, 0.5), to_rg=(0.5/bins, 1-0.5/bins))
+ whole_voxel_index = (whole_voxel_index * bins).astype(np.int32)
+
+ points = torch.from_numpy(whole_voxel).to(torch.float16).unsqueeze(0).to(device)
+ whole_voxel_index = torch.from_numpy(whole_voxel_index).long().unsqueeze(0).to(device)
+ images = img_white_bg.unsqueeze(0).to(device)
+ masks = ordered_mask_input.unsqueeze(0).to(device)
+
+ return {
+ "points": points,
+ "whole_voxel_index": whole_voxel_index,
+ "images": images,
+ "masks": masks,
+ }
+
+
+def vis_voxel_coords(voxel_coords, bins=64):
+ voxel_coords = voxel_coords[:, 1:]
+ voxel_coords = (voxel_coords + 0.5) / bins - 0.5
+ voxel_coords_ply = trimesh.PointCloud(voxel_coords)
+ rot_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]])
+ voxel_coords_ply.apply_transform(rot_matrix)
+ return voxel_coords_ply
+
+
+
+def gen_mesh_from_bounds(bounds):
+ bboxes = []
+ rot_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]])
+ for j in range(bounds.shape[0]):
+ bbox = trimesh.primitives.Box(bounds=bounds[j])
+ color = get_random_color(j, use_float=True)
+ bbox.visual.vertex_colors = color
+ bboxes.append(bbox)
+ mesh = trimesh.Scene(bboxes)
+ mesh.apply_transform(rot_matrix)
+ return mesh
+
+
+def prepare_part_synthesis_input(voxel_coords_path, bbox_depth_path, ordered_mask_input, padding_size=2, bins=64, device="cuda"):
+ overall_coords = np.load(voxel_coords_path)
+ overall_coords = overall_coords[:, 1:] # Remove first column
+
+ bbox_scene = np.load(bbox_depth_path)
+
+ all_coords_wnoise = []
+ part_layouts = []
+ start_idx = 0
+
+ part_layouts.append(slice(start_idx, start_idx + overall_coords.shape[0]))
+ start_idx += overall_coords.shape[0]
+ assigned_points = np.zeros(overall_coords.shape[0], dtype=bool)
+
+ bbox_coords_list = []
+ bbox_masks = []
+
+ for bbox in bbox_scene:
+ points = change_pcd_range(bbox, from_rg=(-0.5, 0.5), to_rg=(0.5/bins, 1-0.5/bins))
+ bbox_min = np.floor(points[0] * bins).astype(np.int32)
+ bbox_max = np.ceil(points[1] * bins).astype(np.int32)
+ bbox_min = np.clip(bbox_min - padding_size, 0, bins - 1)
+ bbox_max = np.clip(bbox_max + padding_size, 0, bins - 1)
+
+ bbox_mask = np.all((overall_coords >= bbox_min) & (overall_coords <= bbox_max), axis=1)
+ bbox_masks.append(bbox_mask)
+
+ if np.sum(bbox_mask) == 0:
+ continue
+
+ assigned_points = assigned_points | bbox_mask
+ bbox_coords = overall_coords[bbox_mask]
+ bbox_coords_list.append(bbox_coords)
+ part_layouts.append(slice(start_idx, start_idx + bbox_coords.shape[0]))
+ start_idx += bbox_coords.shape[0]
+ bbox_coords = torch.from_numpy(bbox_coords)
+ all_coords_wnoise.append(bbox_coords)
+
+ unassigned_mask = ~assigned_points
+ unassigned_coords = overall_coords[unassigned_mask]
+
+ if np.sum(unassigned_mask) > 0 and len(bbox_scene) > 0:
+ print(f"Assigning {np.sum(unassigned_mask)} unassigned points to nearest bboxes")
+
+ nearest_bbox_indices = []
+
+ for point_idx, point in enumerate(unassigned_coords):
+ min_dist = float('inf')
+ nearest_idx = -1
+
+ for bbox_idx, bbox in enumerate(bbox_scene):
+ points = change_pcd_range(bbox, from_rg=(-0.5, 0.5), to_rg=(0.5/bins, 1-0.5/bins))
+ bbox_min = np.floor(points[0] * bins).astype(np.int32)
+ bbox_max = np.ceil(points[1] * bins).astype(np.int32)
+
+ dx = min(abs(point[0] - bbox_min[0]), abs(point[0] - bbox_max[0]))
+ dy = min(abs(point[1] - bbox_min[1]), abs(point[1] - bbox_max[1]))
+ dz = min(abs(point[2] - bbox_min[2]), abs(point[2] - bbox_max[2]))
+ # dist = dx + dy + dz
+ dist = min(dx, dy, dz)
+
+ if dist < min_dist:
+ min_dist = dist;
+ nearest_idx = bbox_idx
+
+ nearest_bbox_indices.append(nearest_idx)
+
+ for bbox_idx in range(len(bbox_scene)):
+ points_for_this_bbox = np.array([i for i, idx in enumerate(nearest_bbox_indices) if idx == bbox_idx])
+
+ if len(points_for_this_bbox) > 0:
+ additional_coords = unassigned_coords[points_for_this_bbox]
+
+ if bbox_idx < len(bbox_coords_list):
+ combined_coords = np.vstack([bbox_coords_list[bbox_idx], additional_coords])
+
+ old_slice = part_layouts[bbox_idx + 1] # +1 because first slice is whole model
+ new_slice = slice(old_slice.start, old_slice.start + combined_coords.shape[0])
+ part_layouts[bbox_idx + 1] = new_slice
+
+ additional_points = additional_coords.shape[0]
+ for i in range(bbox_idx + 2, len(part_layouts)):
+ old_slice = part_layouts[i]
+ new_slice = slice(old_slice.start + additional_points, old_slice.stop + additional_points)
+ part_layouts[i] = new_slice
+
+ all_coords_wnoise[bbox_idx] = torch.from_numpy(combined_coords)
+
+ start_idx += additional_points
+ else:
+ part_layouts.append(slice(start_idx, start_idx + additional_coords.shape[0]))
+ start_idx += additional_coords.shape[0]
+ all_coords_wnoise.append(torch.from_numpy(additional_coords))
+
+ overall_coords = torch.from_numpy(overall_coords)
+ all_coords_wnoise.insert(0, overall_coords)
+ combined_coords = torch.cat(all_coords_wnoise, dim=0).int()
+ coords = torch.cat(
+ [torch.full((combined_coords.shape[0], 1), 0, dtype=torch.int32), combined_coords],
+ dim=-1
+ ).to(device)
+
+ masks = ordered_mask_input.unsqueeze(0).to(device)
+
+ return {
+ 'coords': coords,
+ 'part_layouts': part_layouts,
+ 'masks': masks,
+ }
+
+
+def merge_parts(save_dir,prefix):
+ scene_list = []
+ scene_list_texture = []
+ part_list = glob.glob(os.path.join(save_dir, "*.glb"))
+ part_list = [p for p in part_list if "part" in p and "parts" not in p and "part0" not in p] # part 0 is the overall model
+ part_list.sort()
+ for i, part_path in enumerate(tqdm(part_list, desc="Merging parts")):
+ part_mesh = trimesh.load(part_path, force='mesh')
+ scene_list_texture.append(part_mesh)
+
+ random_color = get_random_color(i, use_float=True)
+ part_mesh_color = part_mesh.copy()
+ part_mesh_color.visual = trimesh.visual.ColorVisuals(
+ mesh=part_mesh_color,
+ vertex_colors=random_color
+ )
+ scene_list.append(part_mesh_color)
+ os.remove(part_path)
+ scene_texture = trimesh.Scene(scene_list_texture)
+ mesh_texture_path=os.path.join(save_dir, f"{prefix}_mesh_textured.glb")
+ scene_texture.export(mesh_texture_path)
+ scene = trimesh.Scene(scene_list)
+ mesh_segment_path=os.path.join(save_dir, f"{prefix}_mesh_segment.glb")
+ scene.export(mesh_segment_path)
+ return mesh_texture_path,mesh_segment_path
\ No newline at end of file
diff --git a/OmniPart/modules/label_2d_mask/label_parts.py b/OmniPart/modules/label_2d_mask/label_parts.py
new file mode 100644
index 0000000..d95f608
--- /dev/null
+++ b/OmniPart/modules/label_2d_mask/label_parts.py
@@ -0,0 +1,575 @@
+"""
+Image Part Segmentation and Labeling Tool
+
+This script segments images into meaningful parts using the Segment Anything Model (SAM)
+and optionally removes backgrounds using BriaRMBG. It identifies, visualizes, and merges
+different parts of objects in images.
+
+Key features:
+- Background removal with alpha channel preservation
+- Automatic part segmentation with SAM
+- Intelligent part merging for logical grouping
+- Detection of parts that SAM might miss
+- Splitting of disconnected parts into separate components
+- Edge cleaning and smoothing of segmentations
+- Visualization of segmented parts with clear labeling
+"""
+
+import os
+import argparse
+import numpy as np
+import cv2
+import torch
+from PIL import Image
+
+from torchvision.transforms import functional as F
+from torchvision import transforms
+import torch.nn.functional as F_nn
+from segment_anything import SamAutomaticMaskGenerator, build_sam
+from .visualizer import Visualizer
+
+# Minimum size threshold for considering a segment (in pixels)
+size_th = 2000
+
+def get_mask(group_ids, image, ids=None, img_name=None, save_dir=None):
+ """
+ Creates and saves a colored visualization of mask segments.
+
+ Args:
+ group_ids: Array of segment IDs for each pixel
+ image: Input image
+ ids: Identifier to append to output filename
+ img_name: Base name of the image for saving
+
+ Returns:
+ Array of segment IDs (unchanged, just for convenience)
+ """
+ colored_mask = np.zeros((image.shape[0], image.shape[1], 3), dtype=np.uint8)
+
+ colored_mask[group_ids == -1] = [255, 255, 255]
+
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0]
+
+ for i, unique_id in enumerate(unique_ids):
+ color_r = (i * 50 + 80) % 256
+ color_g = (i * 120 + 40) % 256
+ color_b = (i * 180 + 20) % 256
+
+ mask = (group_ids == unique_id)
+ colored_mask[mask] = [color_r, color_g, color_b]
+
+ mask_path = os.path.join(save_dir, f"{img_name}_mask_segments_{ids}.png")
+ cv2.imwrite(mask_path, cv2.cvtColor(colored_mask, cv2.COLOR_RGB2BGR))
+ print(f"Saved mask segments visualization to {mask_path}")
+
+ return group_ids
+
+
+def clean_segment_edges(group_ids):
+ """
+ Clean up segment edges by applying morphological operations to each segment.
+
+ Args:
+ group_ids: Array of segment IDs for each pixel
+
+ Returns:
+ Cleaned array of segment IDs with smoother boundaries
+ """
+ # Get unique segment IDs (excluding background -1)
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0]
+
+ # Create a clean group_ids array
+ cleaned_group_ids = np.full_like(group_ids, -1) # Start with all background
+
+ # Define kernel for morphological operations
+ kernel = np.ones((3, 3), np.uint8)
+
+ # Process each segment individually
+ for segment_id in unique_ids:
+ # Extract the mask for this segment
+ segment_mask = (group_ids == segment_id).astype(np.uint8)
+
+ # Apply morphological closing to smooth edges
+ smoothed_mask = cv2.morphologyEx(segment_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+
+ # Apply morphological opening to remove small isolated pixels
+ smoothed_mask = cv2.morphologyEx(smoothed_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+
+ # Add this segment back to the cleaned result
+ cleaned_group_ids[smoothed_mask > 0] = segment_id
+
+ print(f"Cleaned edges for {len(unique_ids)} segments")
+ return cleaned_group_ids
+
+
+def prepare_image(image, bg_color=None, rmbg_net=None):
+ image_size = (1024, 1024)
+ transform_image = transforms.Compose([
+ transforms.Resize(image_size),
+ transforms.ToTensor(),
+ transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+ ])
+ input_images = transform_image(image).unsqueeze(0).to('cuda')
+
+ # Prediction
+ with torch.no_grad():
+ preds = rmbg_net(input_images)[-1].sigmoid().cpu()
+ pred = preds[0].squeeze()
+ pred_pil = transforms.ToPILImage()(pred)
+ mask = pred_pil.resize(image.size)
+ image.putalpha(mask)
+
+ return image
+
+
+def resize_and_pad_to_square(image, target_size=518):
+ """
+ Resize image to have longest side equal to target_size and pad shorter side
+ to create a square image.
+
+ Args:
+ image: PIL image or numpy array
+ target_size: Target square size, defaults to 518
+
+ Returns:
+ PIL Image resized and padded to square (target_size x target_size)
+ """
+ # Ensure image is a PIL Image object
+ if isinstance(image, np.ndarray):
+ image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if len(image.shape) == 3 and image.shape[2] == 3 else image)
+
+ # Get original dimensions
+ width, height = image.size
+
+ # Determine which dimension is longer
+ if width > height:
+ # Width is longer
+ new_width = target_size
+ new_height = int(height * (target_size / width))
+ else:
+ # Height is longer
+ new_height = target_size
+ new_width = int(width * (target_size / height))
+
+ # Resize image while maintaining aspect ratio
+ resized_image = image.resize((new_width, new_height), Image.LANCZOS)
+
+ # Create new square image with proper mode (with or without alpha channel)
+ mode = "RGBA" if image.mode == "RGBA" else "RGB"
+ background_color = (255, 255, 255, 0) if mode == "RGBA" else (255, 255, 255)
+ square_image = Image.new(mode, (target_size, target_size), background_color)
+
+ # Calculate position to paste resized image (centered)
+ paste_x = (target_size - new_width) // 2
+ paste_y = (target_size - new_height) // 2
+
+ # Paste resized image onto square background
+ if mode == "RGBA":
+ square_image.paste(resized_image, (paste_x, paste_y), resized_image)
+ else:
+ square_image.paste(resized_image, (paste_x, paste_y))
+
+ return square_image
+
+
+def split_disconnected_parts(group_ids, size_threshold=None):
+ """
+ Split each part into separate parts if they contain disconnected regions.
+
+ Args:
+ group_ids: Array of segment IDs for each pixel
+ size_threshold: Minimum size threshold for considering a segment (in pixels).
+ If None, uses the global size_th variable.
+
+ Returns:
+ Updated array with each connected component having a unique ID
+ """
+ # Use provided threshold or fall back to global variable
+ if size_threshold is None:
+ size_threshold = size_th
+ # Create a copy to hold the result
+ new_group_ids = np.full_like(group_ids, -1) # Start with all background
+
+ # Get unique part IDs (excluding background -1)
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0]
+
+ # Track the next available ID
+ next_id = 0
+ total_split_regions = 0
+
+ # For each existing part ID
+ for part_id in unique_ids:
+ # Extract the mask for this part
+ part_mask = (group_ids == part_id).astype(np.uint8)
+
+ # Find connected components within this part
+ num_labels, labels = cv2.connectedComponents(part_mask, connectivity=8)
+
+ if num_labels == 1: # Just background (0), no regions found
+ continue
+
+ if num_labels == 2: # One connected component (background + 1 region)
+ # Assign the original part's area to the next available ID
+ new_group_ids[labels == 1] = next_id
+ next_id += 1
+ else: # Multiple disconnected components
+ split_count = 0
+ print(f"Part {part_id} has {num_labels-1} disconnected regions, splitting...")
+
+ # For each connected component (skipping background label 0)
+ for label in range(1, num_labels):
+ region_mask = labels == label
+ region_size = np.sum(region_mask)
+
+ # Only include regions that are large enough
+ if region_size >= size_threshold / 5: # Using size threshold to avoid tiny fragments
+ new_group_ids[region_mask] = next_id
+ split_count += 1
+ next_id += 1
+ else:
+ print(f" Skipping small disconnected region ({region_size} pixels)")
+
+ total_split_regions += split_count
+
+ if total_split_regions > 0:
+ print(f"Split disconnected parts: original {len(unique_ids)} parts -> {next_id} connected parts")
+ else:
+ print("No parts needed splitting - all parts are already connected")
+
+ return new_group_ids
+
+# -------------------------------------------------------
+# MAIN SEGMENTATION FUNCTION
+# -------------------------------------------------------
+
+def get_sam_mask(image, mask_generator, visual, merge_groups=None, existing_group_ids=None,
+ check_undetected=True, rgba_image=None, img_name=None, skip_split=False, save_dir=None, size_threshold=None):
+ """
+ Generate and process SAM masks for the image, with optional merging and undetected region detection.
+
+ Args:
+ size_threshold: Minimum size threshold for considering a segment (in pixels).
+ If None, uses the global size_th variable.
+ """
+ # Use provided threshold or fall back to global variable
+ if size_threshold is None:
+ size_threshold = size_th
+ label_mode = '1'
+ anno_mode = ['Mask', 'Mark']
+
+ exist_group = False
+
+ # Use existing group IDs if provided, otherwise generate new ones with SAM
+ if existing_group_ids is not None:
+ group_ids = existing_group_ids.copy()
+ group_counter = np.max(group_ids) + 1
+ exist_group = True
+ else:
+ # Generate masks using SAM
+ masks = mask_generator.generate(image)
+ group_ids = np.full((image.shape[0], image.shape[1]), -1, dtype=int)
+ num_masks = len(masks)
+ group_counter = 0
+
+ # Sort masks by area (largest first)
+ area_sorted_masks = sorted(masks, key=lambda x: x["area"], reverse=True)
+
+ # Create background mask if we have RGBA image
+ background_mask = None
+ if rgba_image is not None:
+ rgba_array = np.array(rgba_image)
+ if rgba_array.shape[2] == 4:
+ # Use alpha channel to create foreground/background mask
+ background_mask = rgba_array[:, :, 3] <= 10 # Areas with very low alpha are background
+
+ # First pass: assign original group IDs
+ for i in range(0, num_masks):
+ if area_sorted_masks[i]["area"] < size_threshold:
+ print(f"Skipping mask {i}, area too small: {area_sorted_masks[i]['area']} < {size_threshold}")
+ continue
+
+ mask = area_sorted_masks[i]["segmentation"]
+
+ # Check proportion of background pixels in this mask
+ if background_mask is not None:
+ # Calculate how many pixels in this mask are background
+ background_pixels_in_mask = np.sum(mask & background_mask)
+ mask_area = np.sum(mask)
+ background_ratio = background_pixels_in_mask / mask_area
+
+ # Skip mask if background proportion is too high (>10%)
+ if background_ratio > 0.1:
+ print(f" Skipping mask {i}, background ratio: {background_ratio:.2f}")
+ continue
+
+ # Assign group ID to this mask's pixels
+ group_ids[mask] = group_counter
+ print(f"Assigned mask {i} with area {area_sorted_masks[i]['area']} to group {group_counter}")
+ group_counter += 1
+
+ # Split disconnected parts immediately after SAM segmentation
+ print("Splitting disconnected parts in initial segmentation...")
+ group_ids = split_disconnected_parts(group_ids, size_threshold)
+
+ # Update group counter after splitting
+ if np.max(group_ids) >= 0:
+ group_counter = np.max(group_ids) + 1
+ print(f"After early splitting, now have {len(np.unique(group_ids))-1} regions (excluding background)")
+
+ # Check for undetected parts using RGBA information
+ if check_undetected and rgba_image is not None:
+ print("Checking for undetected parts using RGBA image...")
+ # Create a foreground mask from the alpha channel
+ rgba_array = np.array(rgba_image)
+
+ # Check if the image has an alpha channel
+ if rgba_array.shape[2] == 4:
+ print(f"Image has alpha channel, checking for undetected parts...")
+ # Use alpha channel to identify non-transparent pixels (foreground)
+ alpha_mask = rgba_array[:, :, 3] > 0
+
+ # Create existing parts mask and dilate it
+ existing_parts_mask = (group_ids != -1)
+ kernel = np.ones((4, 4), np.uint8)
+
+ # Use larger kernel for faster dilation
+ large_kernel = np.ones((4, 4), np.uint8)
+ dilated_parts = cv2.dilate(existing_parts_mask.astype(np.uint8), large_kernel)
+
+ # Find undetected areas (foreground but not detected by SAM)
+ undetected_mask = alpha_mask & (~dilated_parts.astype(bool))
+
+ # Process only if there are enough undetected pixels
+ if np.sum(undetected_mask) > size_threshold:
+ print(f"Found undetected parts with {np.sum(undetected_mask)} pixels")
+
+ # Find connected components in undetected regions
+ num_labels, labels = cv2.connectedComponents(
+ undetected_mask.astype(np.uint8),
+ connectivity=8
+ )
+
+ print(f" Found {num_labels-1} initial regions")
+
+ # Use Union-Find data structure for efficient region merging
+ parent = list(range(num_labels))
+
+ # Find with path compression
+ def find(x):
+ """Find with path compression for Union-Find"""
+ if parent[x] != x:
+ parent[x] = find(parent[x])
+ return parent[x]
+
+ # Union by rank/size
+ def union(x, y):
+ """Union operation for Union-Find"""
+ root_x = find(x)
+ root_y = find(y)
+ if root_x != root_y:
+ # Use smaller ID as parent
+ if root_x < root_y:
+ parent[root_y] = root_x
+ else:
+ parent[root_x] = root_y
+
+ # Calculate areas for all regions at once
+ areas = np.bincount(labels.flatten())[1:] if num_labels > 1 else []
+
+ # Filter regions by minimum size
+ valid_regions = np.where(areas >= size_threshold/5)[0] + 1
+
+ # Barrier mask for connectivity checks
+ barrier_mask = existing_parts_mask
+
+ # Pre-compute dilated regions for all valid regions
+ dilated_regions = {}
+ for i in valid_regions:
+ region_mask = (labels == i).astype(np.uint8)
+ dilated_regions[i] = cv2.dilate(region_mask, kernel, iterations=2)
+
+ # Check for region merges based on proximity and overlap
+ for idx, i in enumerate(valid_regions[:-1]):
+ for j in valid_regions[idx+1:]:
+ # Check overlap between dilated regions
+ overlap = dilated_regions[i] & dilated_regions[j]
+ overlap_size = np.sum(overlap)
+
+ # Merge if significant overlap and not separated by existing parts
+ if overlap_size > 40 and not np.any(overlap & barrier_mask):
+ # Calculate overlap ratios
+ overlap_ratio_i = overlap_size / areas[i-1]
+ overlap_ratio_j = overlap_size / areas[j-1]
+
+ if max(overlap_ratio_i, overlap_ratio_j) > 0.03:
+ union(i, j)
+ print(f" Merging regions {i} and {j} (overlap: {overlap_size} px)")
+
+ # Apply the merging results to create merged labels
+ merged_labels = np.zeros_like(labels)
+ for label in range(1, num_labels):
+ merged_labels[labels == label] = find(label)
+
+ # Get unique merged regions
+ unique_merged_regions = np.unique(merged_labels[merged_labels > 0])
+ print(f" After merging: {len(unique_merged_regions)} connected regions")
+
+ # Add regions to group_ids if they're large enough
+ group_counter_start = group_counter
+ for label in unique_merged_regions:
+ region_mask = merged_labels == label
+ region_size = np.sum(region_mask)
+
+ if region_size > size_threshold:
+ print(f" Adding region with ID {label} ({region_size} pixels) as group {group_counter}")
+ group_ids[region_mask] = group_counter
+ group_counter += 1
+ else:
+ print(f" Skipping small region with ID {label} ({region_size} pixels < {size_threshold})")
+
+ print(f" Added {group_counter - group_counter_start} regions that weren't detected by SAM")
+
+ # Process edges for all new parts at once
+ if group_counter > group_counter_start:
+ print("Processing edges for newly detected parts...")
+
+ # Create combined mask for all new parts
+ new_parts_mask = np.zeros_like(group_ids, dtype=bool)
+ for part_id in range(group_counter_start, group_counter):
+ new_parts_mask |= (group_ids == part_id)
+
+ # Compute edges for all new parts at once
+ all_new_dilated = cv2.dilate(new_parts_mask.astype(np.uint8), kernel, iterations=1)
+ all_new_eroded = cv2.erode(new_parts_mask.astype(np.uint8), kernel, iterations=1)
+ all_new_edges = all_new_dilated.astype(bool) & (~all_new_eroded.astype(bool))
+
+ print(f"Edge processing completed for {group_counter - group_counter_start} new parts")
+
+ # Save debug visualization of initial segmentation
+ if not exist_group:
+ get_mask(group_ids, image, ids=2, img_name=img_name, save_dir=save_dir)
+
+ # Merge groups if specified
+ if merge_groups is not None:
+ # Start with current group_ids
+ merged_group_ids = group_ids
+
+ # Preserve background regions
+ merged_group_ids[group_ids == -1] = -1
+
+ # For each merge group, assign all pixels to the first ID in that group
+ for new_id, group in enumerate(merge_groups):
+ # Create a mask to include all original IDs in this group
+ group_mask = np.zeros_like(group_ids, dtype=bool)
+
+ orig_ids_first = group[0]
+ # Process each original ID
+ for orig_id in group:
+ # Get mask for this original ID
+ mask = (group_ids == orig_id)
+ pixels = np.sum(mask)
+ if pixels > 0:
+ print(f" Including original ID {orig_id} ({pixels} pixels)")
+ group_mask = group_mask | mask
+ else:
+ print(f" Warning: Original ID {orig_id} does not exist")
+
+ # Set all pixels in this group to the first ID in the group
+ if np.any(group_mask):
+ print(f" Merging {np.sum(group_mask)} pixels to ID {orig_ids_first}")
+ merged_group_ids[group_mask] = orig_ids_first
+
+ # Reassign IDs to be continuous from 0
+ unique_ids = np.unique(merged_group_ids)
+ unique_ids = unique_ids[unique_ids != -1] # Exclude background
+ id_reassignment = {old_id: new_id for new_id, old_id in enumerate(unique_ids)}
+
+ # Create new array with reassigned IDs
+ new_group_ids = np.full_like(merged_group_ids, -1) # Start with all background
+ for old_id, new_id in id_reassignment.items():
+ new_group_ids[merged_group_ids == old_id] = new_id
+
+ # Update merged_group_ids with continuous IDs
+ merged_group_ids = new_group_ids
+
+ print(f"ID reassignment complete: {len(id_reassignment)} groups now have sequential IDs from 0 to {len(id_reassignment)-1}")
+
+ # Replace original group IDs with merged result
+ group_ids = merged_group_ids
+ print(f"Merging complete, now have {len(np.unique(group_ids))-1} regions (excluding background)")
+
+ # Skip splitting disconnected parts if requested
+ if not skip_split:
+ # Split disconnected parts into separate parts
+ group_ids = split_disconnected_parts(group_ids, size_threshold)
+ print(f"After splitting disconnected parts, now have {len(np.unique(group_ids))-1} regions (excluding background)")
+ else:
+ # Always split disconnected parts for initial segmentation
+ group_ids = split_disconnected_parts(group_ids, size_threshold)
+ print(f"After splitting disconnected parts, now have {len(np.unique(group_ids))-1} regions (excluding background)")
+
+ # Create visualization with clear labeling
+ vis_mask = visual
+ # First draw background areas (ID -1)
+ background_mask = (group_ids == -1)
+ if np.any(background_mask):
+ vis_mask = visual.draw_binary_mask(background_mask, color=[1.0, 1.0, 1.0], alpha=0.0)
+
+ # Then draw each segment with unique colors and labels
+ for unique_id in np.unique(group_ids):
+ if unique_id == -1: # Skip background
+ continue
+ mask = (group_ids == unique_id)
+
+ # Calculate center point and area of this region
+ y_indices, x_indices = np.where(mask)
+ if len(y_indices) > 0 and len(x_indices) > 0:
+ area = len(y_indices) # Calculate region area
+
+ print(f"Labeling region {unique_id}, area: {area} pixels")
+ if area < 30: # Skip very small regions
+ continue
+
+ # Use different colors for different IDs to enhance visual distinction
+ color_r = (unique_id * 50 + 80) % 200 / 255.0 + 0.2
+ color_g = (unique_id * 120 + 40) % 200 / 255.0 + 0.2
+ color_b = (unique_id * 180 + 20) % 200 / 255.0 + 0.2
+ color = [color_r, color_g, color_b]
+
+ # Adjust transparency based on area size
+ adaptive_alpha = min(0.3, max(0.1, 0.1 + area / 100000))
+
+ # Extract edges of this region
+ kernel = np.ones((3, 3), np.uint8)
+ dilated = cv2.dilate(mask.astype(np.uint8), kernel, iterations=1)
+ eroded = cv2.erode(mask.astype(np.uint8), kernel, iterations=1)
+ edge = dilated.astype(bool) & (~eroded.astype(bool))
+
+ # Build label text
+ label = f"{unique_id}"
+
+ # First draw the main body of the region
+ vis_mask = visual.draw_binary_mask_with_number(
+ mask,
+ text=label,
+ label_mode=label_mode,
+ alpha=adaptive_alpha,
+ anno_mode=anno_mode,
+ color=color,
+ font_size=20
+ )
+
+ # Enhance edges (add border effect for all parts)
+ edge_color = [min(c*1.3, 1.0) for c in color] # Slightly brighter edge color
+ vis_mask = visual.draw_binary_mask(
+ edge,
+ alpha=0.8, # Lower transparency for edges to make them more visible
+ color=edge_color
+ )
+
+ im = vis_mask.get_image()
+
+ return group_ids, im
\ No newline at end of file
diff --git a/OmniPart/modules/label_2d_mask/visualizer.py b/OmniPart/modules/label_2d_mask/visualizer.py
new file mode 100644
index 0000000..160f3d9
--- /dev/null
+++ b/OmniPart/modules/label_2d_mask/visualizer.py
@@ -0,0 +1,1406 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+import colorsys
+import logging
+import math
+import numpy as np
+from enum import Enum, unique
+import cv2
+import matplotlib as mpl
+import matplotlib.colors as mplc
+import matplotlib.figure as mplfigure
+import pycocotools.mask as mask_util
+import torch
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+from PIL import Image
+
+from detectron2.structures import BitMasks, Boxes, BoxMode, Keypoints, PolygonMasks, RotatedBoxes
+from detectron2.utils.file_io import PathManager
+
+from detectron2.utils.colormap import random_color
+import random
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["ColorMode", "VisImage", "Visualizer"]
+
+
+_SMALL_OBJECT_AREA_THRESH = 1000
+_LARGE_MASK_AREA_THRESH = 120000
+_OFF_WHITE = (1.0, 1.0, 240.0 / 255)
+_BLACK = (0, 0, 0)
+_RED = (1.0, 0, 0)
+
+_KEYPOINT_THRESHOLD = 0.05
+
+
+@unique
+class ColorMode(Enum):
+ """
+ Enum of different color modes to use for instance visualizations.
+ """
+
+ IMAGE = 0
+ """
+ Picks a random color for every instance and overlay segmentations with low opacity.
+ """
+ SEGMENTATION = 1
+ """
+ Let instances of the same category have similar colors
+ (from metadata.thing_colors), and overlay them with
+ high opacity. This provides more attention on the quality of segmentation.
+ """
+ IMAGE_BW = 2
+ """
+ Same as IMAGE, but convert all areas without masks to gray-scale.
+ Only available for drawing per-instance mask predictions.
+ """
+
+
+class GenericMask:
+ """
+ Attribute:
+ polygons (list[ndarray]): list[ndarray]: polygons for this mask.
+ Each ndarray has format [x, y, x, y, ...]
+ mask (ndarray): a binary mask
+ """
+
+ def __init__(self, mask_or_polygons, height, width):
+ self._mask = self._polygons = self._has_holes = None
+ self.height = height
+ self.width = width
+
+ m = mask_or_polygons
+ if isinstance(m, dict):
+ # RLEs
+ assert "counts" in m and "size" in m
+ if isinstance(m["counts"], list): # uncompressed RLEs
+ h, w = m["size"]
+ assert h == height and w == width
+ m = mask_util.frPyObjects(m, h, w)
+ self._mask = mask_util.decode(m)[:, :]
+ return
+
+ if isinstance(m, list): # list[ndarray]
+ self._polygons = [np.asarray(x).reshape(-1) for x in m]
+ return
+
+ if isinstance(m, np.ndarray): # assumed to be a binary mask
+ assert m.shape[1] != 2, m.shape
+ assert m.shape == (
+ height,
+ width,
+ ), f"mask shape: {m.shape}, target dims: {height}, {width}"
+ self._mask = m.astype("uint8")
+ return
+
+ raise ValueError("GenericMask cannot handle object {} of type '{}'".format(m, type(m)))
+
+ @property
+ def mask(self):
+ if self._mask is None:
+ self._mask = self.polygons_to_mask(self._polygons)
+ return self._mask
+
+ @property
+ def polygons(self):
+ if self._polygons is None:
+ self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
+ return self._polygons
+
+ @property
+ def has_holes(self):
+ if self._has_holes is None:
+ if self._mask is not None:
+ self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
+ else:
+ self._has_holes = False # if original format is polygon, does not have holes
+ return self._has_holes
+
+ def mask_to_polygons(self, mask):
+ # cv2.RETR_CCOMP flag retrieves all the contours and arranges them to a 2-level
+ # hierarchy. External contours (boundary) of the object are placed in hierarchy-1.
+ # Internal contours (holes) are placed in hierarchy-2.
+ # cv2.CHAIN_APPROX_NONE flag gets vertices of polygons from contours.
+ mask = np.ascontiguousarray(mask) # some versions of cv2 does not support incontiguous arr
+ res = cv2.findContours(mask.astype("uint8"), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
+ hierarchy = res[-1]
+ if hierarchy is None: # empty mask
+ return [], False
+ has_holes = (hierarchy.reshape(-1, 4)[:, 3] >= 0).sum() > 0
+ res = res[-2]
+ res = [x.flatten() for x in res]
+ # These coordinates from OpenCV are integers in range [0, W-1 or H-1].
+ # We add 0.5 to turn them into real-value coordinate space. A better solution
+ # would be to first +0.5 and then dilate the returned polygon by 0.5.
+ res = [x + 0.5 for x in res if len(x) >= 6]
+ return res, has_holes
+
+ def polygons_to_mask(self, polygons):
+ rle = mask_util.frPyObjects(polygons, self.height, self.width)
+ rle = mask_util.merge(rle)
+ return mask_util.decode(rle)[:, :]
+
+ def area(self):
+ return self.mask.sum()
+
+ def bbox(self):
+ p = mask_util.frPyObjects(self.polygons, self.height, self.width)
+ p = mask_util.merge(p)
+ bbox = mask_util.toBbox(p)
+ bbox[2] += bbox[0]
+ bbox[3] += bbox[1]
+ return bbox
+
+
+class _PanopticPrediction:
+ """
+ Unify different panoptic annotation/prediction formats
+ """
+
+ def __init__(self, panoptic_seg, segments_info, metadata=None):
+ if segments_info is None:
+ assert metadata is not None
+ # If "segments_info" is None, we assume "panoptic_img" is a
+ # H*W int32 image storing the panoptic_id in the format of
+ # category_id * label_divisor + instance_id. We reserve -1 for
+ # VOID label.
+ label_divisor = metadata.label_divisor
+ segments_info = []
+ for panoptic_label in np.unique(panoptic_seg.numpy()):
+ if panoptic_label == -1:
+ # VOID region.
+ continue
+ pred_class = panoptic_label // label_divisor
+ isthing = pred_class in metadata.thing_dataset_id_to_contiguous_id.values()
+ segments_info.append(
+ {
+ "id": int(panoptic_label),
+ "category_id": int(pred_class),
+ "isthing": bool(isthing),
+ }
+ )
+ del metadata
+
+ self._seg = panoptic_seg
+
+ self._sinfo = {s["id"]: s for s in segments_info} # seg id -> seg info
+ segment_ids, areas = torch.unique(panoptic_seg, sorted=True, return_counts=True)
+ areas = areas.numpy()
+ sorted_idxs = np.argsort(-areas)
+ self._seg_ids, self._seg_areas = segment_ids[sorted_idxs], areas[sorted_idxs]
+ self._seg_ids = self._seg_ids.tolist()
+ for sid, area in zip(self._seg_ids, self._seg_areas):
+ if sid in self._sinfo:
+ self._sinfo[sid]["area"] = float(area)
+
+ def non_empty_mask(self):
+ """
+ Returns:
+ (H, W) array, a mask for all pixels that have a prediction
+ """
+ empty_ids = []
+ for id in self._seg_ids:
+ if id not in self._sinfo:
+ empty_ids.append(id)
+ if len(empty_ids) == 0:
+ return np.zeros(self._seg.shape, dtype=np.uint8)
+ assert (
+ len(empty_ids) == 1
+ ), ">1 ids corresponds to no labels. This is currently not supported"
+ return (self._seg != empty_ids[0]).numpy().astype(np.bool)
+
+ def semantic_masks(self):
+ for sid in self._seg_ids:
+ sinfo = self._sinfo.get(sid)
+ if sinfo is None or sinfo["isthing"]:
+ # Some pixels (e.g. id 0 in PanopticFPN) have no instance or semantic predictions.
+ continue
+ yield (self._seg == sid).numpy().astype(np.bool), sinfo
+
+ def instance_masks(self):
+ for sid in self._seg_ids:
+ sinfo = self._sinfo.get(sid)
+ if sinfo is None or not sinfo["isthing"]:
+ continue
+ mask = (self._seg == sid).numpy().astype(np.bool)
+ if mask.sum() > 0:
+ yield mask, sinfo
+
+
+def _create_text_labels(classes, scores, class_names, is_crowd=None):
+ """
+ Args:
+ classes (list[int] or None):
+ scores (list[float] or None):
+ class_names (list[str] or None):
+ is_crowd (list[bool] or None):
+
+ Returns:
+ list[str] or None
+ """
+ labels = None
+ if classes is not None:
+ if class_names is not None and len(class_names) > 0:
+ labels = [class_names[i] for i in classes]
+ else:
+ labels = [str(i) for i in classes]
+ if scores is not None:
+ if labels is None:
+ labels = ["{:.0f}%".format(s * 100) for s in scores]
+ else:
+ labels = ["{} {:.0f}%".format(l, s * 100) for l, s in zip(labels, scores)]
+ if labels is not None and is_crowd is not None:
+ labels = [l + ("|crowd" if crowd else "") for l, crowd in zip(labels, is_crowd)]
+ return labels
+
+
+class VisImage:
+ def __init__(self, img, scale=1.0):
+ """
+ Args:
+ img (ndarray): an RGB image of shape (H, W, 3) in range [0, 255].
+ scale (float): scale the input image
+ """
+ self.img = img
+ self.scale = scale
+ self.width, self.height = img.shape[1], img.shape[0]
+ self._setup_figure(img)
+
+ def _setup_figure(self, img):
+ """
+ Args:
+ Same as in :meth:`__init__()`.
+
+ Returns:
+ fig (matplotlib.pyplot.figure): top level container for all the image plot elements.
+ ax (matplotlib.pyplot.Axes): contains figure elements and sets the coordinate system.
+ """
+ fig = mplfigure.Figure(frameon=False)
+ self.dpi = fig.get_dpi()
+ # add a small 1e-2 to avoid precision lost due to matplotlib's truncation
+ # (https://github.com/matplotlib/matplotlib/issues/15363)
+ fig.set_size_inches(
+ (self.width * self.scale + 1e-2) / self.dpi,
+ (self.height * self.scale + 1e-2) / self.dpi,
+ )
+ self.canvas = FigureCanvasAgg(fig)
+ # self.canvas = mpl.backends.backend_cairo.FigureCanvasCairo(fig)
+ ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
+ ax.axis("off")
+ self.fig = fig
+ self.ax = ax
+ self.reset_image(img)
+
+ def reset_image(self, img):
+ """
+ Args:
+ img: same as in __init__
+ """
+ img = img.astype("uint8")
+ self.ax.imshow(img, extent=(0, self.width, self.height, 0), interpolation="nearest")
+
+ def save(self, filepath):
+ """
+ Args:
+ filepath (str): a string that contains the absolute path, including the file name, where
+ the visualized image will be saved.
+ """
+ self.fig.savefig(filepath)
+
+ def get_image(self):
+ """
+ Returns:
+ ndarray:
+ the visualized image of shape (H, W, 3) (RGB) in uint8 type.
+ The shape is scaled w.r.t the input image using the given `scale` argument.
+ """
+ canvas = self.canvas
+ s, (width, height) = canvas.print_to_buffer()
+ # buf = io.BytesIO() # works for cairo backend
+ # canvas.print_rgba(buf)
+ # width, height = self.width, self.height
+ # s = buf.getvalue()
+
+ buffer = np.frombuffer(s, dtype="uint8")
+
+ img_rgba = buffer.reshape(height, width, 4)
+ rgb, alpha = np.split(img_rgba, [3], axis=2)
+ return rgb.astype("uint8")
+
+
+class Visualizer:
+ """
+ Visualizer that draws data about detection/segmentation on images.
+
+ It contains methods like `draw_{text,box,circle,line,binary_mask,polygon}`
+ that draw primitive objects to images, as well as high-level wrappers like
+ `draw_{instance_predictions,sem_seg,panoptic_seg_predictions,dataset_dict}`
+ that draw composite data in some pre-defined style.
+
+ Note that the exact visualization style for the high-level wrappers are subject to change.
+ Style such as color, opacity, label contents, visibility of labels, or even the visibility
+ of objects themselves (e.g. when the object is too small) may change according
+ to different heuristics, as long as the results still look visually reasonable.
+
+ To obtain a consistent style, you can implement custom drawing functions with the
+ abovementioned primitive methods instead. If you need more customized visualization
+ styles, you can process the data yourself following their format documented in
+ tutorials (:doc:`/tutorials/models`, :doc:`/tutorials/datasets`). This class does not
+ intend to satisfy everyone's preference on drawing styles.
+
+ This visualizer focuses on high rendering quality rather than performance. It is not
+ designed to be used for real-time applications.
+ """
+
+ # TODO implement a fast, rasterized version using OpenCV
+
+ def __init__(self, img_rgb, metadata=None, scale=1.0, instance_mode=ColorMode.IMAGE):
+ """
+ Args:
+ img_rgb: a numpy array of shape (H, W, C), where H and W correspond to
+ the height and width of the image respectively. C is the number of
+ color channels. The image is required to be in RGB format since that
+ is a requirement of the Matplotlib library. The image is also expected
+ to be in the range [0, 255].
+ metadata (Metadata): dataset metadata (e.g. class names and colors)
+ instance_mode (ColorMode): defines one of the pre-defined style for drawing
+ instances on an image.
+ """
+ self.img = np.asarray(img_rgb).clip(0, 255).astype(np.uint8)
+ # if metadata is None:
+ # metadata = MetadataCatalog.get("__nonexist__")
+ # self.metadata = metadata
+ self.output = VisImage(self.img, scale=scale)
+ self.cpu_device = torch.device("cpu")
+
+ # too small texts are useless, therefore clamp to 9
+ self._default_font_size = max(
+ np.sqrt(self.output.height * self.output.width) // 90, 10 // scale
+ )
+ self._default_font_size = 18
+ self._instance_mode = instance_mode
+ self.keypoint_threshold = _KEYPOINT_THRESHOLD
+
+ import matplotlib.colors as mcolors
+ css4_colors = mcolors.CSS4_COLORS
+ self.color_proposals = [list(mcolors.hex2color(color)) for color in css4_colors.values()]
+
+ def draw_instance_predictions(self, predictions):
+ """
+ Draw instance-level prediction results on an image.
+
+ Args:
+ predictions (Instances): the output of an instance detection/segmentation
+ model. Following fields will be used to draw:
+ "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ boxes = predictions.pred_boxes if predictions.has("pred_boxes") else None
+ scores = predictions.scores if predictions.has("scores") else None
+ classes = predictions.pred_classes.tolist() if predictions.has("pred_classes") else None
+ labels = _create_text_labels(classes, scores, self.metadata.get("thing_classes", None))
+ keypoints = predictions.pred_keypoints if predictions.has("pred_keypoints") else None
+
+ keep = (scores > 0.5).cpu()
+ boxes = boxes[keep]
+ scores = scores[keep]
+ classes = np.array(classes)
+ classes = classes[np.array(keep)]
+ labels = np.array(labels)
+ labels = labels[np.array(keep)]
+
+ if predictions.has("pred_masks"):
+ masks = np.asarray(predictions.pred_masks)
+ masks = masks[np.array(keep)]
+ masks = [GenericMask(x, self.output.height, self.output.width) for x in masks]
+ else:
+ masks = None
+
+ if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("thing_colors"):
+ # if self.metadata.get("thing_colors"):
+ colors = [
+ self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in classes
+ ]
+ alpha = 0.4
+ else:
+ colors = None
+ alpha = 0.4
+
+ if self._instance_mode == ColorMode.IMAGE_BW:
+ self.output.reset_image(
+ self._create_grayscale_image(
+ (predictions.pred_masks.any(dim=0) > 0).numpy()
+ if predictions.has("pred_masks")
+ else None
+ )
+ )
+ alpha = 0.3
+
+ self.overlay_instances(
+ masks=masks,
+ boxes=boxes,
+ labels=labels,
+ keypoints=keypoints,
+ assigned_colors=colors,
+ alpha=alpha,
+ )
+ return self.output
+
+ def draw_sem_seg(self, sem_seg, area_threshold=None, alpha=0.7):
+ """
+ Draw semantic segmentation predictions/labels.
+
+ Args:
+ sem_seg (Tensor or ndarray): the segmentation of shape (H, W).
+ Each value is the integer label of the pixel.
+ area_threshold (int): segments with less than `area_threshold` are not drawn.
+ alpha (float): the larger it is, the more opaque the segmentations are.
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ if isinstance(sem_seg, torch.Tensor):
+ sem_seg = sem_seg.numpy()
+ labels, areas = np.unique(sem_seg, return_counts=True)
+ sorted_idxs = np.argsort(-areas).tolist()
+ labels = labels[sorted_idxs]
+ for label in filter(lambda l: l < len(self.metadata.stuff_classes), labels):
+ try:
+ mask_color = [x / 255 for x in self.metadata.stuff_colors[label]]
+ except (AttributeError, IndexError):
+ mask_color = None
+
+ binary_mask = (sem_seg == label).astype(np.uint8)
+ text = self.metadata.stuff_classes[label]
+ self.draw_binary_mask(
+ binary_mask,
+ color=mask_color,
+ edge_color=_OFF_WHITE,
+ text=text,
+ alpha=alpha,
+ area_threshold=area_threshold,
+ )
+ return self.output
+
+ def draw_panoptic_seg(self, panoptic_seg, segments_info, area_threshold=None, alpha=0.7):
+ """
+ Draw panoptic prediction annotations or results.
+
+ Args:
+ panoptic_seg (Tensor): of shape (height, width) where the values are ids for each
+ segment.
+ segments_info (list[dict] or None): Describe each segment in `panoptic_seg`.
+ If it is a ``list[dict]``, each dict contains keys "id", "category_id".
+ If None, category id of each pixel is computed by
+ ``pixel // metadata.label_divisor``.
+ area_threshold (int): stuff segments with less than `area_threshold` are not drawn.
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ pred = _PanopticPrediction(panoptic_seg, segments_info, self.metadata)
+
+ if self._instance_mode == ColorMode.IMAGE_BW:
+ self.output.reset_image(self._create_grayscale_image(pred.non_empty_mask()))
+
+ # draw mask for all semantic segments first i.e. "stuff"
+ for mask, sinfo in pred.semantic_masks():
+ category_idx = sinfo["category_id"]
+ try:
+ mask_color = [x / 255 for x in self.metadata.stuff_colors[category_idx]]
+ except AttributeError:
+ mask_color = None
+
+ text = self.metadata.stuff_classes[category_idx].replace('-other','').replace('-merged','')
+ self.draw_binary_mask(
+ mask,
+ color=mask_color,
+ edge_color=_OFF_WHITE,
+ text=text,
+ alpha=alpha,
+ area_threshold=area_threshold,
+ )
+
+ # draw mask for all instances second
+ all_instances = list(pred.instance_masks())
+ if len(all_instances) == 0:
+ return self.output
+ masks, sinfo = list(zip(*all_instances))
+ category_ids = [x["category_id"] for x in sinfo]
+
+ try:
+ scores = [x["score"] for x in sinfo]
+ except KeyError:
+ scores = None
+ class_names = [name.replace('-other','').replace('-merged','') for name in self.metadata.thing_classes]
+ labels = _create_text_labels(
+ category_ids, scores, class_names, [x.get("iscrowd", 0) for x in sinfo]
+ )
+
+ try:
+ colors = [
+ self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in category_ids
+ ]
+ except AttributeError:
+ colors = None
+ self.overlay_instances(masks=masks, labels=labels, assigned_colors=colors, alpha=alpha)
+
+ return self.output
+
+ draw_panoptic_seg_predictions = draw_panoptic_seg # backward compatibility
+
+ def draw_dataset_dict(self, dic):
+ """
+ Draw annotations/segmentaions in Detectron2 Dataset format.
+
+ Args:
+ dic (dict): annotation/segmentation data of one image, in Detectron2 Dataset format.
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ annos = dic.get("annotations", None)
+ if annos:
+ if "segmentation" in annos[0]:
+ masks = [x["segmentation"] for x in annos]
+ else:
+ masks = None
+ if "keypoints" in annos[0]:
+ keypts = [x["keypoints"] for x in annos]
+ keypts = np.array(keypts).reshape(len(annos), -1, 3)
+ else:
+ keypts = None
+
+ boxes = [
+ BoxMode.convert(x["bbox"], x["bbox_mode"], BoxMode.XYXY_ABS)
+ if len(x["bbox"]) == 4
+ else x["bbox"]
+ for x in annos
+ ]
+
+ colors = None
+ category_ids = [x["category_id"] for x in annos]
+ if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("thing_colors"):
+ colors = [
+ self._jitter([x / 255 for x in self.metadata.thing_colors[c]])
+ for c in category_ids
+ ]
+ names = self.metadata.get("thing_classes", None)
+ labels = _create_text_labels(
+ category_ids,
+ scores=None,
+ class_names=names,
+ is_crowd=[x.get("iscrowd", 0) for x in annos],
+ )
+ self.overlay_instances(
+ labels=labels, boxes=boxes, masks=masks, keypoints=keypts, assigned_colors=colors
+ )
+
+ sem_seg = dic.get("sem_seg", None)
+ if sem_seg is None and "sem_seg_file_name" in dic:
+ with PathManager.open(dic["sem_seg_file_name"], "rb") as f:
+ sem_seg = Image.open(f)
+ sem_seg = np.asarray(sem_seg, dtype="uint8")
+ if sem_seg is not None:
+ self.draw_sem_seg(sem_seg, area_threshold=0, alpha=0.4)
+
+ pan_seg = dic.get("pan_seg", None)
+ if pan_seg is None and "pan_seg_file_name" in dic:
+ with PathManager.open(dic["pan_seg_file_name"], "rb") as f:
+ pan_seg = Image.open(f)
+ pan_seg = np.asarray(pan_seg)
+ from panopticapi.utils import rgb2id
+
+ pan_seg = rgb2id(pan_seg)
+ if pan_seg is not None:
+ segments_info = dic["segments_info"]
+ pan_seg = torch.tensor(pan_seg)
+ self.draw_panoptic_seg(pan_seg, segments_info, area_threshold=0, alpha=0.7)
+ return self.output
+
+ def overlay_instances(
+ self,
+ *,
+ boxes=None,
+ labels=None,
+ masks=None,
+ keypoints=None,
+ assigned_colors=None,
+ alpha=0.5,
+ ):
+ """
+ Args:
+ boxes (Boxes, RotatedBoxes or ndarray): either a :class:`Boxes`,
+ or an Nx4 numpy array of XYXY_ABS format for the N objects in a single image,
+ or a :class:`RotatedBoxes`,
+ or an Nx5 numpy array of (x_center, y_center, width, height, angle_degrees) format
+ for the N objects in a single image,
+ labels (list[str]): the text to be displayed for each instance.
+ masks (masks-like object): Supported types are:
+
+ * :class:`detectron2.structures.PolygonMasks`,
+ :class:`detectron2.structures.BitMasks`.
+ * list[list[ndarray]]: contains the segmentation masks for all objects in one image.
+ The first level of the list corresponds to individual instances. The second
+ level to all the polygon that compose the instance, and the third level
+ to the polygon coordinates. The third level should have the format of
+ [x0, y0, x1, y1, ..., xn, yn] (n >= 3).
+ * list[ndarray]: each ndarray is a binary mask of shape (H, W).
+ * list[dict]: each dict is a COCO-style RLE.
+ keypoints (Keypoint or array like): an array-like object of shape (N, K, 3),
+ where the N is the number of instances and K is the number of keypoints.
+ The last dimension corresponds to (x, y, visibility or score).
+ assigned_colors (list[matplotlib.colors]): a list of colors, where each color
+ corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
+ for full list of formats that the colors are accepted in.
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ num_instances = 0
+ if boxes is not None:
+ boxes = self._convert_boxes(boxes)
+ num_instances = len(boxes)
+ if masks is not None:
+ masks = self._convert_masks(masks)
+ if num_instances:
+ assert len(masks) == num_instances
+ else:
+ num_instances = len(masks)
+ if keypoints is not None:
+ if num_instances:
+ assert len(keypoints) == num_instances
+ else:
+ num_instances = len(keypoints)
+ keypoints = self._convert_keypoints(keypoints)
+ if labels is not None:
+ assert len(labels) == num_instances
+ if assigned_colors is None:
+ assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
+ if num_instances == 0:
+ return self.output
+ if boxes is not None and boxes.shape[1] == 5:
+ return self.overlay_rotated_instances(
+ boxes=boxes, labels=labels, assigned_colors=assigned_colors
+ )
+
+ # Display in largest to smallest order to reduce occlusion.
+ areas = None
+ if boxes is not None:
+ areas = np.prod(boxes[:, 2:] - boxes[:, :2], axis=1)
+ elif masks is not None:
+ areas = np.asarray([x.area() for x in masks])
+
+ if areas is not None:
+ sorted_idxs = np.argsort(-areas).tolist()
+ # Re-order overlapped instances in descending order.
+ boxes = boxes[sorted_idxs] if boxes is not None else None
+ labels = [labels[k] for k in sorted_idxs] if labels is not None else None
+ masks = [masks[idx] for idx in sorted_idxs] if masks is not None else None
+ assigned_colors = [assigned_colors[idx] for idx in sorted_idxs]
+ keypoints = keypoints[sorted_idxs] if keypoints is not None else None
+
+ for i in range(num_instances):
+ color = assigned_colors[i]
+ if boxes is not None:
+ self.draw_box(boxes[i], edge_color=color)
+
+ if masks is not None:
+ for segment in masks[i].polygons:
+ self.draw_polygon(segment.reshape(-1, 2), color, alpha=alpha)
+
+ if labels is not None:
+ # first get a box
+ if boxes is not None:
+ x0, y0, x1, y1 = boxes[i]
+ text_pos = (x0, y0) # if drawing boxes, put text on the box corner.
+ horiz_align = "left"
+ elif masks is not None:
+ # skip small mask without polygon
+ if len(masks[i].polygons) == 0:
+ continue
+
+ x0, y0, x1, y1 = masks[i].bbox()
+
+ # draw text in the center (defined by median) when box is not drawn
+ # median is less sensitive to outliers.
+ text_pos = np.median(masks[i].mask.nonzero(), axis=1)[::-1]
+ horiz_align = "center"
+ else:
+ continue # drawing the box confidence for keypoints isn't very useful.
+ # for small objects, draw text at the side to avoid occlusion
+ instance_area = (y1 - y0) * (x1 - x0)
+ if (
+ instance_area < _SMALL_OBJECT_AREA_THRESH * self.output.scale
+ or y1 - y0 < 40 * self.output.scale
+ ):
+ if y1 >= self.output.height - 5:
+ text_pos = (x1, y0)
+ else:
+ text_pos = (x0, y1)
+
+ height_ratio = (y1 - y0) / np.sqrt(self.output.height * self.output.width)
+ lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
+ font_size = (
+ np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2)
+ * 0.5
+ * self._default_font_size
+ )
+ self.draw_text(
+ labels[i],
+ text_pos,
+ color=lighter_color,
+ horizontal_alignment=horiz_align,
+ font_size=font_size,
+ )
+
+ # draw keypoints
+ if keypoints is not None:
+ for keypoints_per_instance in keypoints:
+ self.draw_and_connect_keypoints(keypoints_per_instance)
+
+ return self.output
+
+ def overlay_rotated_instances(self, boxes=None, labels=None, assigned_colors=None):
+ """
+ Args:
+ boxes (ndarray): an Nx5 numpy array of
+ (x_center, y_center, width, height, angle_degrees) format
+ for the N objects in a single image.
+ labels (list[str]): the text to be displayed for each instance.
+ assigned_colors (list[matplotlib.colors]): a list of colors, where each color
+ corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
+ for full list of formats that the colors are accepted in.
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ num_instances = len(boxes)
+
+ if assigned_colors is None:
+ assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
+ if num_instances == 0:
+ return self.output
+
+ # Display in largest to smallest order to reduce occlusion.
+ if boxes is not None:
+ areas = boxes[:, 2] * boxes[:, 3]
+
+ sorted_idxs = np.argsort(-areas).tolist()
+ # Re-order overlapped instances in descending order.
+ boxes = boxes[sorted_idxs]
+ labels = [labels[k] for k in sorted_idxs] if labels is not None else None
+ colors = [assigned_colors[idx] for idx in sorted_idxs]
+
+ for i in range(num_instances):
+ self.draw_rotated_box_with_label(
+ boxes[i], edge_color=colors[i], label=labels[i] if labels is not None else None
+ )
+
+ return self.output
+
+ def draw_and_connect_keypoints(self, keypoints):
+ """
+ Draws keypoints of an instance and follows the rules for keypoint connections
+ to draw lines between appropriate keypoints. This follows color heuristics for
+ line color.
+
+ Args:
+ keypoints (Tensor): a tensor of shape (K, 3), where K is the number of keypoints
+ and the last dimension corresponds to (x, y, probability).
+
+ Returns:
+ output (VisImage): image object with visualizations.
+ """
+ visible = {}
+ keypoint_names = self.metadata.get("keypoint_names")
+ for idx, keypoint in enumerate(keypoints):
+
+ # draw keypoint
+ x, y, prob = keypoint
+ if prob > self.keypoint_threshold:
+ self.draw_circle((x, y), color=_RED)
+ if keypoint_names:
+ keypoint_name = keypoint_names[idx]
+ visible[keypoint_name] = (x, y)
+
+ if self.metadata.get("keypoint_connection_rules"):
+ for kp0, kp1, color in self.metadata.keypoint_connection_rules:
+ if kp0 in visible and kp1 in visible:
+ x0, y0 = visible[kp0]
+ x1, y1 = visible[kp1]
+ color = tuple(x / 255.0 for x in color)
+ self.draw_line([x0, x1], [y0, y1], color=color)
+
+ # draw lines from nose to mid-shoulder and mid-shoulder to mid-hip
+ # Note that this strategy is specific to person keypoints.
+ # For other keypoints, it should just do nothing
+ try:
+ ls_x, ls_y = visible["left_shoulder"]
+ rs_x, rs_y = visible["right_shoulder"]
+ mid_shoulder_x, mid_shoulder_y = (ls_x + rs_x) / 2, (ls_y + rs_y) / 2
+ except KeyError:
+ pass
+ else:
+ # draw line from nose to mid-shoulder
+ nose_x, nose_y = visible.get("nose", (None, None))
+ if nose_x is not None:
+ self.draw_line([nose_x, mid_shoulder_x], [nose_y, mid_shoulder_y], color=_RED)
+
+ try:
+ # draw line from mid-shoulder to mid-hip
+ lh_x, lh_y = visible["left_hip"]
+ rh_x, rh_y = visible["right_hip"]
+ except KeyError:
+ pass
+ else:
+ mid_hip_x, mid_hip_y = (lh_x + rh_x) / 2, (lh_y + rh_y) / 2
+ self.draw_line([mid_hip_x, mid_shoulder_x], [mid_hip_y, mid_shoulder_y], color=_RED)
+ return self.output
+
+ """
+ Primitive drawing functions:
+ """
+
+ def draw_text(
+ self,
+ text,
+ position,
+ *,
+ font_size=None,
+ color="g",
+ horizontal_alignment="center",
+ rotation=0,
+ ):
+ """
+ Args:
+ text (str): class label
+ position (tuple): a tuple of the x and y coordinates to place text on image.
+ font_size (int, optional): font of the text. If not provided, a font size
+ proportional to the image width is calculated and used.
+ color: color of the text. Refer to `matplotlib.colors` for full list
+ of formats that are accepted.
+ horizontal_alignment (str): see `matplotlib.text.Text`
+ rotation: rotation angle in degrees CCW
+
+ Returns:
+ output (VisImage): image object with text drawn.
+ """
+ if not font_size:
+ font_size = self._default_font_size
+
+ # since the text background is dark, we don't want the text to be dark
+ color = np.maximum(list(mplc.to_rgb(color)), 0.15)
+ color[np.argmax(color)] = max(0.8, np.max(color))
+
+ def contrasting_color(rgb):
+ """Returns 'white' or 'black' depending on which color contrasts more with the given RGB value."""
+
+ # Decompose the RGB tuple
+ R, G, B = rgb
+
+ # Calculate the Y value
+ Y = 0.299 * R + 0.587 * G + 0.114 * B
+
+ # If Y value is greater than 128, it's closer to white so return black. Otherwise, return white.
+ return 'black' if Y > 128 else 'white'
+
+ bbox_background = contrasting_color(color*255)
+
+ x, y = position
+ self.output.ax.text(
+ x,
+ y,
+ text,
+ size=font_size * self.output.scale,
+ family="sans-serif",
+ bbox={"facecolor": bbox_background, "alpha": 0.8, "pad": 0.7, "edgecolor": "none"},
+ verticalalignment="top",
+ horizontalalignment=horizontal_alignment,
+ color=color,
+ zorder=10,
+ rotation=rotation,
+ )
+ return self.output
+
+ def draw_box(self, box_coord, alpha=0.5, edge_color="g", line_style="-"):
+ """
+ Args:
+ box_coord (tuple): a tuple containing x0, y0, x1, y1 coordinates, where x0 and y0
+ are the coordinates of the image's top left corner. x1 and y1 are the
+ coordinates of the image's bottom right corner.
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+ edge_color: color of the outline of the box. Refer to `matplotlib.colors`
+ for full list of formats that are accepted.
+ line_style (string): the string to use to create the outline of the boxes.
+
+ Returns:
+ output (VisImage): image object with box drawn.
+ """
+ x0, y0, x1, y1 = box_coord
+ width = x1 - x0
+ height = y1 - y0
+
+ linewidth = max(self._default_font_size / 12, 1)
+
+ self.output.ax.add_patch(
+ mpl.patches.Rectangle(
+ (x0, y0),
+ width,
+ height,
+ fill=False,
+ edgecolor=edge_color,
+ linewidth=linewidth * self.output.scale,
+ alpha=alpha,
+ linestyle=line_style,
+ )
+ )
+ return self.output
+
+ def draw_rotated_box_with_label(
+ self, rotated_box, alpha=0.5, edge_color="g", line_style="-", label=None
+ ):
+ """
+ Draw a rotated box with label on its top-left corner.
+
+ Args:
+ rotated_box (tuple): a tuple containing (cnt_x, cnt_y, w, h, angle),
+ where cnt_x and cnt_y are the center coordinates of the box.
+ w and h are the width and height of the box. angle represents how
+ many degrees the box is rotated CCW with regard to the 0-degree box.
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+ edge_color: color of the outline of the box. Refer to `matplotlib.colors`
+ for full list of formats that are accepted.
+ line_style (string): the string to use to create the outline of the boxes.
+ label (string): label for rotated box. It will not be rendered when set to None.
+
+ Returns:
+ output (VisImage): image object with box drawn.
+ """
+ cnt_x, cnt_y, w, h, angle = rotated_box
+ area = w * h
+ # use thinner lines when the box is small
+ linewidth = self._default_font_size / (
+ 6 if area < _SMALL_OBJECT_AREA_THRESH * self.output.scale else 3
+ )
+
+ theta = angle * math.pi / 180.0
+ c = math.cos(theta)
+ s = math.sin(theta)
+ rect = [(-w / 2, h / 2), (-w / 2, -h / 2), (w / 2, -h / 2), (w / 2, h / 2)]
+ # x: left->right ; y: top->down
+ rotated_rect = [(s * yy + c * xx + cnt_x, c * yy - s * xx + cnt_y) for (xx, yy) in rect]
+ for k in range(4):
+ j = (k + 1) % 4
+ self.draw_line(
+ [rotated_rect[k][0], rotated_rect[j][0]],
+ [rotated_rect[k][1], rotated_rect[j][1]],
+ color=edge_color,
+ linestyle="--" if k == 1 else line_style,
+ linewidth=linewidth,
+ )
+
+ if label is not None:
+ text_pos = rotated_rect[1] # topleft corner
+
+ height_ratio = h / np.sqrt(self.output.height * self.output.width)
+ label_color = self._change_color_brightness(edge_color, brightness_factor=0.7)
+ font_size = (
+ np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2) * 0.5 * self._default_font_size
+ )
+ self.draw_text(label, text_pos, color=label_color, font_size=font_size, rotation=angle)
+
+ return self.output
+
+ def draw_circle(self, circle_coord, color, radius=3):
+ """
+ Args:
+ circle_coord (list(int) or tuple(int)): contains the x and y coordinates
+ of the center of the circle.
+ color: color of the polygon. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted.
+ radius (int): radius of the circle.
+
+ Returns:
+ output (VisImage): image object with box drawn.
+ """
+ x, y = circle_coord
+ self.output.ax.add_patch(
+ mpl.patches.Circle(circle_coord, radius=radius, fill=True, color=color)
+ )
+ return self.output
+
+ def draw_line(self, x_data, y_data, color, linestyle="-", linewidth=None):
+ """
+ Args:
+ x_data (list[int]): a list containing x values of all the points being drawn.
+ Length of list should match the length of y_data.
+ y_data (list[int]): a list containing y values of all the points being drawn.
+ Length of list should match the length of x_data.
+ color: color of the line. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted.
+ linestyle: style of the line. Refer to `matplotlib.lines.Line2D`
+ for a full list of formats that are accepted.
+ linewidth (float or None): width of the line. When it's None,
+ a default value will be computed and used.
+
+ Returns:
+ output (VisImage): image object with line drawn.
+ """
+ if linewidth is None:
+ linewidth = self._default_font_size / 3
+ linewidth = max(linewidth, 1)
+ self.output.ax.add_line(
+ mpl.lines.Line2D(
+ x_data,
+ y_data,
+ linewidth=linewidth * self.output.scale,
+ color=color,
+ linestyle=linestyle,
+ )
+ )
+ return self.output
+
+ def draw_binary_mask(
+ self, binary_mask, color=None, *, edge_color=None, text=None, alpha=0.7, area_threshold=10
+ ):
+ """
+ Args:
+ binary_mask (ndarray): numpy array of shape (H, W), where H is the image height and
+ W is the image width. Each value in the array is either a 0 or 1 value of uint8
+ type.
+ color: color of the mask. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted. If None, will pick a random color.
+ edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
+ full list of formats that are accepted.
+ text (str): if None, will be drawn on the object
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+ area_threshold (float): a connected component smaller than this area will not be shown.
+
+ Returns:
+ output (VisImage): image object with mask drawn.
+ """
+ if color is None:
+ color = random_color(rgb=True, maximum=1)
+ color = mplc.to_rgb(color)
+
+ has_valid_segment = False
+ binary_mask = binary_mask.astype("uint8") # opencv needs uint8
+ mask = GenericMask(binary_mask, self.output.height, self.output.width)
+ shape2d = (binary_mask.shape[0], binary_mask.shape[1])
+
+ if not mask.has_holes:
+ # draw polygons for regular masks
+ for segment in mask.polygons:
+ area = mask_util.area(mask_util.frPyObjects([segment], shape2d[0], shape2d[1]))
+ if area < (area_threshold or 0):
+ continue
+ has_valid_segment = True
+ segment = segment.reshape(-1, 2)
+ self.draw_polygon(segment, color=color, edge_color=edge_color, alpha=alpha)
+ else:
+ # TODO: Use Path/PathPatch to draw vector graphics:
+ # https://stackoverflow.com/questions/8919719/how-to-plot-a-complex-polygon
+ rgba = np.zeros(shape2d + (4,), dtype="float32")
+ rgba[:, :, :3] = color
+ rgba[:, :, 3] = (mask.mask == 1).astype("float32") * alpha
+ has_valid_segment = True
+ self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
+
+ if text is not None and has_valid_segment:
+ lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
+ self._draw_text_in_mask(binary_mask, text, lighter_color)
+ return self.output
+
+ def draw_binary_mask_with_number(
+ self, binary_mask, color=None, *, edge_color=None, text=None, label_mode='1',
+ alpha=0.1, anno_mode=['Mask'], area_threshold=10, font_size=None
+ ):
+ """
+ Args:
+ binary_mask (ndarray): numpy array of shape (H, W), where H is the image height and
+ W is the image width. Each value in the array is either a 0 or 1 value of uint8
+ type.
+ color: color of the mask. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted. If None, will pick a random color.
+ edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
+ full list of formats that are accepted.
+ text (str): if None, will be drawn on the object
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+ area_threshold (float): a connected component smaller than this area will not be shown.
+
+ Returns:
+ output (VisImage): image object with mask drawn.
+ """
+ if color is None:
+ randint = random.randint(0, len(self.color_proposals)-1)
+ color = self.color_proposals[randint]
+ color = mplc.to_rgb(color)
+
+ has_valid_segment = True
+ binary_mask = binary_mask.astype("uint8") # opencv needs uint8
+ mask = GenericMask(binary_mask, self.output.height, self.output.width)
+ shape2d = (binary_mask.shape[0], binary_mask.shape[1])
+ bbox = mask.bbox()
+
+ if 'Mask' in anno_mode:
+ if not mask.has_holes:
+ # draw polygons for regular masks
+ for segment in mask.polygons:
+ area = mask_util.area(mask_util.frPyObjects([segment], shape2d[0], shape2d[1]))
+ if area < (area_threshold or 0):
+ continue
+ has_valid_segment = True
+ segment = segment.reshape(-1, 2)
+ self.draw_polygon(segment, color=color, edge_color=edge_color, alpha=alpha)
+ else:
+ # TODO: Use Path/PathPatch to draw vector graphics:
+ # https://stackoverflow.com/questions/8919719/how-to-plot-a-complex-polygon
+ rgba = np.zeros(shape2d + (4,), dtype="float32")
+ rgba[:, :, :3] = color
+ rgba[:, :, 3] = (mask.mask == 1).astype("float32") * alpha
+ has_valid_segment = True
+ self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
+
+ if 'Box' in anno_mode:
+ self.draw_box(bbox, edge_color=color, alpha=0.75)
+
+ if 'Mark' in anno_mode:
+ has_valid_segment = True
+ else:
+ has_valid_segment = False
+
+ if text is not None and has_valid_segment:
+ lighter_color = [1,1,1]
+ self._draw_number_in_mask(binary_mask, text, lighter_color, label_mode, font_size)
+ return self.output
+
+ def draw_soft_mask(self, soft_mask, color=None, *, text=None, alpha=0.5):
+ """
+ Args:
+ soft_mask (ndarray): float array of shape (H, W), each value in [0, 1].
+ color: color of the mask. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted. If None, will pick a random color.
+ text (str): if None, will be drawn on the object
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+
+ Returns:
+ output (VisImage): image object with mask drawn.
+ """
+ if color is None:
+ color = random_color(rgb=True, maximum=1)
+ color = mplc.to_rgb(color)
+
+ shape2d = (soft_mask.shape[0], soft_mask.shape[1])
+ rgba = np.zeros(shape2d + (4,), dtype="float32")
+ rgba[:, :, :3] = color
+ rgba[:, :, 3] = soft_mask * alpha
+ self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
+
+ if text is not None:
+ lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
+ binary_mask = (soft_mask > 0.5).astype("uint8")
+ self._draw_text_in_mask(binary_mask, text, lighter_color)
+ return self.output
+
+ def draw_polygon(self, segment, color, edge_color=None, alpha=0.5):
+ """
+ Args:
+ segment: numpy array of shape Nx2, containing all the points in the polygon.
+ color: color of the polygon. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted.
+ edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
+ full list of formats that are accepted. If not provided, a darker shade
+ of the polygon color will be used instead.
+ alpha (float): blending efficient. Smaller values lead to more transparent masks.
+
+ Returns:
+ output (VisImage): image object with polygon drawn.
+ """
+ if edge_color is None:
+ # make edge color darker than the polygon color
+ if alpha > 0.8:
+ edge_color = self._change_color_brightness(color, brightness_factor=-0.7)
+ else:
+ edge_color = color
+ edge_color = mplc.to_rgb(edge_color) + (1,)
+
+ polygon = mpl.patches.Polygon(
+ segment,
+ fill=True,
+ facecolor=mplc.to_rgb(color) + (alpha,),
+ edgecolor=edge_color,
+ linewidth=max(self._default_font_size // 15 * self.output.scale, 1),
+ )
+ self.output.ax.add_patch(polygon)
+ return self.output
+
+ """
+ Internal methods:
+ """
+
+ def _jitter(self, color):
+ """
+ Randomly modifies given color to produce a slightly different color than the color given.
+
+ Args:
+ color (tuple[double]): a tuple of 3 elements, containing the RGB values of the color
+ picked. The values in the list are in the [0.0, 1.0] range.
+
+ Returns:
+ jittered_color (tuple[double]): a tuple of 3 elements, containing the RGB values of the
+ color after being jittered. The values in the list are in the [0.0, 1.0] range.
+ """
+ color = mplc.to_rgb(color)
+ # np.random.seed(0)
+ vec = np.random.rand(3)
+ # better to do it in another color space
+ vec = vec / np.linalg.norm(vec) * 0.5
+ res = np.clip(vec + color, 0, 1)
+ return tuple(res)
+
+ def _create_grayscale_image(self, mask=None):
+ """
+ Create a grayscale version of the original image.
+ The colors in masked area, if given, will be kept.
+ """
+ img_bw = self.img.astype("f4").mean(axis=2)
+ img_bw = np.stack([img_bw] * 3, axis=2)
+ if mask is not None:
+ img_bw[mask] = self.img[mask]
+ return img_bw
+
+ def _change_color_brightness(self, color, brightness_factor):
+ """
+ Depending on the brightness_factor, gives a lighter or darker color i.e. a color with
+ less or more saturation than the original color.
+
+ Args:
+ color: color of the polygon. Refer to `matplotlib.colors` for a full list of
+ formats that are accepted.
+ brightness_factor (float): a value in [-1.0, 1.0] range. A lightness factor of
+ 0 will correspond to no change, a factor in [-1.0, 0) range will result in
+ a darker color and a factor in (0, 1.0] range will result in a lighter color.
+
+ Returns:
+ modified_color (tuple[double]): a tuple containing the RGB values of the
+ modified color. Each value in the tuple is in the [0.0, 1.0] range.
+ """
+ assert brightness_factor >= -1.0 and brightness_factor <= 1.0
+ color = mplc.to_rgb(color)
+ polygon_color = colorsys.rgb_to_hls(*mplc.to_rgb(color))
+ modified_lightness = polygon_color[1] + (brightness_factor * polygon_color[1])
+ modified_lightness = 0.0 if modified_lightness < 0.0 else modified_lightness
+ modified_lightness = 1.0 if modified_lightness > 1.0 else modified_lightness
+ modified_color = colorsys.hls_to_rgb(polygon_color[0], modified_lightness, polygon_color[2])
+ return modified_color
+
+ def _convert_boxes(self, boxes):
+ """
+ Convert different format of boxes to an NxB array, where B = 4 or 5 is the box dimension.
+ """
+ if isinstance(boxes, Boxes) or isinstance(boxes, RotatedBoxes):
+ return boxes.tensor.detach().numpy()
+ else:
+ return np.asarray(boxes)
+
+ def _convert_masks(self, masks_or_polygons):
+ """
+ Convert different format of masks or polygons to a tuple of masks and polygons.
+
+ Returns:
+ list[GenericMask]:
+ """
+
+ m = masks_or_polygons
+ if isinstance(m, PolygonMasks):
+ m = m.polygons
+ if isinstance(m, BitMasks):
+ m = m.tensor.numpy()
+ if isinstance(m, torch.Tensor):
+ m = m.numpy()
+ ret = []
+ for x in m:
+ if isinstance(x, GenericMask):
+ ret.append(x)
+ else:
+ ret.append(GenericMask(x, self.output.height, self.output.width))
+ return ret
+
+ def _draw_number_in_mask(self, binary_mask, text, color, label_mode='1', font_size=None):
+ """
+ Find proper places to draw text given a binary mask.
+ """
+
+ def number_to_string(n):
+ chars = []
+ while n:
+ n, remainder = divmod(n-1, 26)
+ chars.append(chr(97 + remainder))
+ return ''.join(reversed(chars))
+
+ binary_mask = np.pad(binary_mask, ((1, 1), (1, 1)), 'constant')
+ mask_dt = cv2.distanceTransform(binary_mask, cv2.DIST_L2, 0)
+ mask_dt = mask_dt[1:-1, 1:-1]
+ max_dist = np.max(mask_dt)
+ coords_y, coords_x = np.where(mask_dt == max_dist) # coords is [y, x]
+
+ if label_mode == 'a':
+ text = number_to_string(int(text))
+ else:
+ text = text
+
+ # self.draw_text(text, (coords_x[len(coords_x)//2] + 2, coords_y[len(coords_y)//2] - 6), color=color)
+ self.draw_text(text, (coords_x[len(coords_x)//2] + 2, coords_y[len(coords_y)//2] - 6),
+ color=color, font_size=font_size)
+
+ # TODO sometimes drawn on wrong objects. the heuristics here can improve.
+ # _num_cc, cc_labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask, 8)
+ # if stats[1:, -1].size == 0:
+ # return
+ # largest_component_id = np.argmax(stats[1:, -1]) + 1
+
+ # # draw text on the largest component, as well as other very large components.
+ # for cid in range(1, _num_cc):
+ # if cid == largest_component_id or stats[cid, -1] > _LARGE_MASK_AREA_THRESH:
+ # # median is more stable than centroid
+ # # center = centroids[largest_component_id]
+ # center = np.median((cc_labels == cid).nonzero(), axis=1)[::-1]
+ # # bottom=np.max((cc_labels == cid).nonzero(), axis=1)[::-1]
+ # # center[1]=bottom[1]+2
+ # self.draw_text(text, center, color=color)
+
+ def _draw_text_in_mask(self, binary_mask, text, color):
+ """
+ Find proper places to draw text given a binary mask.
+ """
+ # TODO sometimes drawn on wrong objects. the heuristics here can improve.
+ _num_cc, cc_labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask, 8)
+ if stats[1:, -1].size == 0:
+ return
+ largest_component_id = np.argmax(stats[1:, -1]) + 1
+
+ # draw text on the largest component, as well as other very large components.
+ for cid in range(1, _num_cc):
+ if cid == largest_component_id or stats[cid, -1] > _LARGE_MASK_AREA_THRESH:
+ # median is more stable than centroid
+ # center = centroids[largest_component_id]
+ center = np.median((cc_labels == cid).nonzero(), axis=1)[::-1]
+ bottom=np.max((cc_labels == cid).nonzero(), axis=1)[::-1]
+ center[1]=bottom[1]+2
+ self.draw_text(text, center, color=color)
+
+ def _convert_keypoints(self, keypoints):
+ if isinstance(keypoints, Keypoints):
+ keypoints = keypoints.tensor
+ keypoints = np.asarray(keypoints)
+ return keypoints
+
+ def get_output(self):
+ """
+ Returns:
+ output (VisImage): the image output containing the visualizations added
+ to the image.
+ """
+ return self.output
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/__init__.py b/OmniPart/modules/part_synthesis/__init__.py
new file mode 100644
index 0000000..20d240a
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/__init__.py
@@ -0,0 +1,6 @@
+from . import models
+from . import modules
+from . import pipelines
+from . import renderers
+from . import representations
+from . import utils
diff --git a/OmniPart/modules/part_synthesis/models/__init__.py b/OmniPart/modules/part_synthesis/models/__init__.py
new file mode 100644
index 0000000..efbcce6
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/__init__.py
@@ -0,0 +1,135 @@
+import importlib
+
+__attributes = {
+ 'SparseStructureEncoder': 'sparse_structure_vae',
+ 'SparseStructureDecoder': 'sparse_structure_vae',
+
+ 'SparseStructureFlowModel': 'sparse_structure_flow',
+
+ 'SLatEncoder': 'structured_latent_vae',
+ 'SLatGaussianDecoder': 'structured_latent_vae',
+ 'SLatRadianceFieldDecoder': 'structured_latent_vae',
+ 'SLatMeshDecoder': 'structured_latent_vae',
+ 'ElasticSLatEncoder': 'structured_latent_vae',
+ 'ElasticSLatGaussianDecoder': 'structured_latent_vae',
+ 'ElasticSLatRadianceFieldDecoder': 'structured_latent_vae',
+ 'ElasticSLatMeshDecoder': 'structured_latent_vae',
+
+ 'SLatFlowModel': 'structured_latent_flow',
+ 'ElasticSLatFlowModel': 'structured_latent_flow',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+def from_pretrained(path: str, **kwargs):
+ """
+ Load a model from a pretrained checkpoint.
+
+ Args:
+ path: The path to the checkpoint. Can be either local path or a Hugging Face model name.
+ NOTE: config file and model file should take the name f'{path}.json' and f'{path}.safetensors' respectively.
+ **kwargs: Additional arguments for the model constructor.
+ """
+ import os
+ import json
+ from safetensors.torch import load_file
+ is_local = os.path.exists(f"{path}.json") and os.path.exists(f"{path}.safetensors")
+ # print(f"is local: {is_local}, path: {path} because {os.path.exists(f'{path}.json')} and {os.path.exists(f'{path}.safetensors')}")
+
+ if is_local:
+ config_file = f"{path}.json"
+ model_file = f"{path}.safetensors"
+ else:
+ from huggingface_hub import hf_hub_download
+ path_parts = path.split('/')
+ repo_id = f'{path_parts[0]}/{path_parts[1]}'
+ model_name = '/'.join(path_parts[2:])
+ config_file = hf_hub_download(repo_id, f"{model_name}.json")
+ model_file = hf_hub_download(repo_id, f"{model_name}.safetensors")
+
+ with open(config_file, 'r') as f:
+ config = json.load(f)
+
+ # print(f"Config loaded successfully: {config.get('name', 'Name not found in config')}")
+
+ if 'name' not in config:
+ raise ValueError(f"Config file missing required 'name' field")
+
+ model_class = config['name']
+ if model_class.lower() in [k.lower() for k in __attributes.keys()]:
+ # Try to find case-insensitive match
+ for k in __attributes.keys():
+ if k.lower() == model_class.lower():
+ model_class = k
+ break
+ # print(f"Using model class: {model_class}")
+
+ try:
+ model_constructor = __getattr__(model_class)
+ except AttributeError as e:
+ print(f"Model lookup failed: {e}")
+ raise ValueError(f"Model class '{model_class}' not found in available models: {list(__attributes.keys())}")
+
+ # print(f"Initializing model with args: {config.get('args', {})}")
+ model = model_constructor(**config.get('args', {}), **kwargs)
+
+ # Load state dict
+ state_dict = load_file(model_file)
+
+ # print(f"State dict loaded successfully from {model_file}")
+
+ # Check key compatibility
+ model_keys = set(model.state_dict().keys())
+ loaded_keys = set(state_dict.keys())
+ missing_keys = model_keys - loaded_keys
+ unexpected_keys = loaded_keys - model_keys
+ if missing_keys:
+ print(f"Missing keys in state dict: {missing_keys}")
+ if unexpected_keys:
+ print(f"Unexpected keys in state dict: {unexpected_keys}")
+
+ # Load state dict with strict=False to allow missing keys
+ model.load_state_dict(state_dict, strict=False)
+
+ return model
+
+# For Pylance
+if __name__ == '__main__':
+ from .sparse_structure_vae import (
+ SparseStructureEncoder,
+ SparseStructureDecoder,
+ )
+
+ from .sparse_structure_flow import SparseStructureFlowModel
+
+ from .structured_latent_vae import (
+ SLatEncoder,
+ SLatGaussianDecoder,
+ SLatRadianceFieldDecoder,
+ SLatMeshDecoder,
+ ElasticSLatEncoder,
+ ElasticSLatGaussianDecoder,
+ ElasticSLatRadianceFieldDecoder,
+ ElasticSLatMeshDecoder,
+ )
+
+ from .structured_latent_flow import (
+ SLatFlowModel,
+ ElasticSLatFlowModel,
+ )
diff --git a/OmniPart/modules/part_synthesis/models/sparse_elastic_mixin.py b/OmniPart/modules/part_synthesis/models/sparse_elastic_mixin.py
new file mode 100644
index 0000000..186b3b0
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/sparse_elastic_mixin.py
@@ -0,0 +1,67 @@
+"""
+This file defines a mixin class for sparse transformers that enables elastic memory management.
+It provides functionality to dynamically adjust memory usage by controlling gradient checkpointing
+across transformer blocks, allowing for trading computation for memory efficiency.
+"""
+
+from contextlib import contextmanager
+from typing import *
+import math
+from ..modules import sparse as sp
+from ..utils.elastic_utils import ElasticModuleMixin
+
+
+class SparseTransformerElasticMixin(ElasticModuleMixin):
+ """
+ A mixin class for sparse transformers that provides elastic memory management capabilities.
+ Extends the base ElasticModuleMixin with sparse tensor-specific functionality.
+ """
+
+ def _get_input_size(self, x: sp.SparseTensor, *args, **kwargs):
+ """
+ Determines the input size from a sparse tensor.
+
+ Args:
+ x: A SparseTensor input
+ *args, **kwargs: Additional arguments (unused)
+
+ Returns:
+ The size of the feature dimension of the sparse tensor
+ """
+ return x.feats.shape[0]
+
+ @contextmanager
+ def with_mem_ratio(self, mem_ratio=1.0):
+ """
+ Context manager that temporarily adjusts memory usage by enabling gradient checkpointing
+ for a portion of the transformer blocks based on the specified memory ratio.
+
+ Args:
+ mem_ratio: A value between 0 and 1 indicating the desired memory ratio.
+ 1.0 means use all available memory (no checkpointing).
+ Lower values enable more checkpointing to reduce memory usage.
+
+ Yields:
+ The exact memory ratio that could be achieved with the block granularity.
+ """
+ if mem_ratio == 1.0:
+ # No memory optimization needed if ratio is 1.0
+ yield 1.0
+ return
+
+ # Calculate how many blocks should use checkpointing
+ num_blocks = len(self.blocks)
+ num_checkpoint_blocks = min(math.ceil((1 - mem_ratio) * num_blocks) + 1, num_blocks)
+
+ # Calculate the actual memory ratio based on the number of checkpointed blocks
+ exact_mem_ratio = 1 - (num_checkpoint_blocks - 1) / num_blocks
+
+ # Enable checkpointing for the calculated number of blocks
+ for i in range(num_blocks):
+ self.blocks[i].use_checkpoint = i < num_checkpoint_blocks
+
+ yield exact_mem_ratio
+
+ # Restore all blocks to not use checkpointing after context exit
+ for i in range(num_blocks):
+ self.blocks[i].use_checkpoint = False
diff --git a/OmniPart/modules/part_synthesis/models/sparse_structure_flow.py b/OmniPart/modules/part_synthesis/models/sparse_structure_flow.py
new file mode 100644
index 0000000..717ad53
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/sparse_structure_flow.py
@@ -0,0 +1,299 @@
+"""
+This file implements a Sparse Structure Flow model for 3D data generation or transformation.
+It contains a transformer-based architecture that processes 3D volumes by:
+1. Embedding timesteps for diffusion/flow-based modeling
+2. Patchifying 3D inputs for efficient processing
+3. Using cross-attention mechanisms to condition the generation on external features
+4. Supporting various positional encoding schemes for 3D data
+
+The model is designed for high-dimensional structure generation with conditional inputs
+and follows a transformer-based architecture similar to DiT (Diffusion Transformers).
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..modules.utils import convert_module_to_f16, convert_module_to_f32
+from ..modules.transformer import AbsolutePositionEmbedder, ModulatedTransformerCrossBlock
+from ..modules.spatial import patchify, unpatchify
+
+
+class TimestepEmbedder(nn.Module):
+ """
+ Embeds scalar timesteps into vector representations.
+ This is crucial for diffusion models where the model needs to know
+ which noise level (timestep) it's currently operating at.
+ """
+ def __init__(self, hidden_size, frequency_embedding_size=256):
+ """
+ Initialize the timestep embedder.
+
+ Args:
+ hidden_size: Dimension of the output embeddings
+ frequency_embedding_size: Dimension of the intermediate frequency embeddings
+ """
+ super().__init__()
+ self.mlp = nn.Sequential(
+ nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+ nn.SiLU(),
+ nn.Linear(hidden_size, hidden_size, bias=True),
+ )
+ self.frequency_embedding_size = frequency_embedding_size
+
+ @staticmethod
+ def timestep_embedding(t, dim, max_period=10000):
+ """
+ Create sinusoidal timestep embeddings similar to positional encodings in transformers.
+
+ Args:
+ t: a 1-D Tensor of N indices, one per batch element.
+ These may be fractional.
+ dim: the dimension of the output.
+ max_period: controls the minimum frequency of the embeddings.
+
+ Returns:
+ an (N, D) Tensor of positional embeddings.
+ """
+ # Implementation based on OpenAI's GLIDE repository
+ half = dim // 2
+ freqs = torch.exp(
+ -np.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+ ).to(device=t.device)
+ args = t[:, None].float() * freqs[None]
+ embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+ if dim % 2:
+ embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+ return embedding
+
+ def forward(self, t):
+ """
+ Embed timesteps into vectors.
+
+ Args:
+ t: Timesteps to embed [batch_size]
+
+ Returns:
+ Embedded timesteps [batch_size, hidden_size]
+ """
+ t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+ t_emb = self.mlp(t_freq)
+ return t_emb
+
+
+class SparseStructureFlowModel(nn.Module):
+ """
+ A transformer-based model for processing 3D data with conditional inputs.
+ The model patchifies 3D volumes, processes them with transformer blocks,
+ and then reconstructs the 3D volume at the output.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ cond_channels: int,
+ out_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ patch_size: int = 2,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ share_mod: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ ):
+ """
+ Initialize the Sparse Structure Flow model.
+
+ Args:
+ resolution: Input resolution (assumes cubic inputs of shape [resolution, resolution, resolution])
+ in_channels: Number of input channels
+ model_channels: Number of model's internal channels
+ cond_channels: Number of channels in conditional input
+ out_channels: Number of output channels
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (defaults to model_channels // num_head_channels)
+ num_head_channels: Number of channels per attention head
+ mlp_ratio: Ratio for MLP hidden dimension relative to model_channels
+ patch_size: Size of patches for patchifying the input
+ pe_mode: Type of positional encoding ("ape" for absolute, "rope" for rotary)
+ use_fp16: Whether to use FP16 precision for most operations
+ use_checkpoint: Whether to use gradient checkpointing to save memory
+ share_mod: Whether to share modulation layers across blocks
+ qk_rms_norm: Whether to use RMS normalization for query and key in self-attention
+ qk_rms_norm_cross: Whether to use RMS normalization for query and key in cross-attention
+ """
+ super().__init__()
+ self.resolution = resolution
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.cond_channels = cond_channels
+ self.out_channels = out_channels
+ self.num_blocks = num_blocks
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.patch_size = patch_size
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.qk_rms_norm = qk_rms_norm
+ self.qk_rms_norm_cross = qk_rms_norm_cross
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Timestep embedding network
+ self.t_embedder = TimestepEmbedder(model_channels)
+
+ # Optional shared modulation for all blocks
+ if share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(model_channels, 6 * model_channels, bias=True)
+ )
+
+ # Set up positional encoding
+ if pe_mode == "ape":
+ pos_embedder = AbsolutePositionEmbedder(model_channels, 3)
+ # Create a grid of 3D coordinates for each patch position
+ coords = torch.meshgrid(*[torch.arange(res, device=self.device) for res in [resolution // patch_size] * 3], indexing='ij')
+ coords = torch.stack(coords, dim=-1).reshape(-1, 3)
+ pos_emb = pos_embedder(coords)
+ self.register_buffer("pos_emb", pos_emb)
+
+ # Input projection layer
+ self.input_layer = nn.Linear(in_channels * patch_size**3, model_channels)
+
+ # Transformer blocks with cross-attention for conditioning
+ self.blocks = nn.ModuleList([
+ ModulatedTransformerCrossBlock(
+ model_channels,
+ cond_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode='full',
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ share_mod=share_mod,
+ qk_rms_norm=self.qk_rms_norm,
+ qk_rms_norm_cross=self.qk_rms_norm_cross,
+ )
+ for _ in range(num_blocks)
+ ])
+
+ # Output projection layer
+ self.out_layer = nn.Linear(model_channels, out_channels * patch_size**3)
+
+ # Initialize model weights
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the transformer blocks of the model to float16 for improved efficiency.
+ """
+ self.blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the transformer blocks of the model back to float32 (e.g., for inference).
+ """
+ self.blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model using carefully chosen initialization schemes.
+ """
+ # Initialize transformer layers with Xavier uniform initialization
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ # Initialize timestep embedding MLP with normal distribution
+ nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+ nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+ # Zero-out adaLN modulation layers to ensure stable training initially
+ if self.share_mod:
+ nn.init.constant_(self.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(self.adaLN_modulation[-1].bias, 0)
+ else:
+ for block in self.blocks:
+ nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+ # Zero-out output layers to ensure initial predictions are near zero
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def forward(self, x: torch.Tensor, t: torch.Tensor, cond: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass of the model.
+
+ Args:
+ x: Input tensor of shape [batch_size, in_channels, resolution, resolution, resolution]
+ t: Timestep tensor of shape [batch_size]
+ cond: Conditional input tensor
+
+ Returns:
+ Output tensor of shape [batch_size, out_channels, resolution, resolution, resolution]
+ """
+ # Validate input shape
+ assert [*x.shape] == [x.shape[0], self.in_channels, *[self.resolution] * 3], \
+ f"Input shape mismatch, got {x.shape}, expected {[x.shape[0], self.in_channels, *[self.resolution] * 3]}"
+
+ # Patchify the input volume and reshape for transformer processing
+ h = patchify(x, self.patch_size)
+ h = h.view(*h.shape[:2], -1).permute(0, 2, 1).contiguous() # [B, num_patches, patch_dim]
+
+ # Project to model dimension
+ h = self.input_layer(h)
+
+ # Add positional embeddings
+ h = h + self.pos_emb[None]
+
+ # Get timestep embeddings
+ t_emb = self.t_embedder(t)
+ if self.share_mod:
+ t_emb = self.adaLN_modulation(t_emb)
+
+ # Convert to appropriate dtype for computation
+ t_emb = t_emb.type(self.dtype)
+ h = h.type(self.dtype)
+ cond = cond.type(self.dtype)
+ # print("transfer cond")
+ # print("*" * 20)
+ # print(cond.shape) # torch.Size([4, 4122, 1024])
+ # Process through transformer blocks
+ for block in self.blocks:
+ h = block(h, t_emb, cond)
+
+ # print("transferred ")
+
+ # Convert back to original dtype
+ h = h.type(x.dtype)
+
+ # Final normalization and projection
+ h = F.layer_norm(h, h.shape[-1:])
+ h = self.out_layer(h)
+
+ # Reshape and unpatchify to get final 3D output
+ h = h.permute(0, 2, 1).view(h.shape[0], h.shape[2], *[self.resolution // self.patch_size] * 3)
+ h = unpatchify(h, self.patch_size).contiguous()
+
+ return h
diff --git a/OmniPart/modules/part_synthesis/models/sparse_structure_vae.py b/OmniPart/modules/part_synthesis/models/sparse_structure_vae.py
new file mode 100644
index 0000000..593e328
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/sparse_structure_vae.py
@@ -0,0 +1,450 @@
+"""
+sparse_structure_vae.py
+
+This file implements a Variational Autoencoder (VAE) for 3D sparse structural representations.
+It's part of the TRELLIS framework and contains components for encoding volumetric data
+into a latent space and decoding it back to volumetric representation.
+
+The implementation includes:
+- 3D normalization layers
+- 3D residual blocks for feature extraction
+- 3D downsampling and upsampling blocks for resolution changes
+- Encoder (SparseStructureEncoder) that maps input volumes to a latent distribution
+- Decoder (SparseStructureDecoder) that reconstructs volumes from latent codes
+
+This VAE architecture is specifically designed for capturing structural information
+in a compressed latent representation that can be sampled probabilistically.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ..modules.norm import GroupNorm32, ChannelLayerNorm32
+from ..modules.spatial import pixel_shuffle_3d
+from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+
+
+def norm_layer(norm_type: str, *args, **kwargs) -> nn.Module:
+ """
+ Return a normalization layer based on the specified type.
+
+ Args:
+ norm_type: Either "group" for GroupNorm or "layer" for LayerNorm
+ *args, **kwargs: Arguments passed to the normalization layer
+
+ Returns:
+ An instance of the requested normalization layer
+ """
+ if norm_type == "group":
+ return GroupNorm32(32, *args, **kwargs)
+ elif norm_type == "layer":
+ return ChannelLayerNorm32(*args, **kwargs)
+ else:
+ raise ValueError(f"Invalid norm type {norm_type}")
+
+
+class ResBlock3d(nn.Module):
+ """
+ 3D Residual Block with two convolutions and a skip connection.
+
+ The block applies normalization, activation, and convolution twice,
+ with a skip connection from the input to the output.
+ """
+ def __init__(
+ self,
+ channels: int,
+ out_channels: Optional[int] = None,
+ norm_type: Literal["group", "layer"] = "layer",
+ ):
+ """
+ Initialize a 3D ResBlock.
+
+ Args:
+ channels: Number of input channels
+ out_channels: Number of output channels (defaults to input channels)
+ norm_type: Type of normalization to use
+ """
+ super().__init__()
+ self.channels = channels
+ self.out_channels = out_channels or channels
+
+ # First normalization and convolution
+ self.norm1 = norm_layer(norm_type, channels)
+ self.norm2 = norm_layer(norm_type, self.out_channels)
+ self.conv1 = nn.Conv3d(channels, self.out_channels, 3, padding=1)
+ # Second convolution is initialized with zeros for stable training
+ self.conv2 = zero_module(nn.Conv3d(self.out_channels, self.out_channels, 3, padding=1))
+ # Skip connection: identity if channels match, otherwise 1x1 conv
+ self.skip_connection = nn.Conv3d(channels, self.out_channels, 1) if channels != self.out_channels else nn.Identity()
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the ResBlock.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Output tensor after residual computation
+ """
+ h = self.norm1(x)
+ h = F.silu(h)
+ h = self.conv1(h)
+ h = self.norm2(h)
+ h = F.silu(h)
+ h = self.conv2(h)
+ h = h + self.skip_connection(x) # Residual connection
+ return h
+
+
+class DownsampleBlock3d(nn.Module):
+ """
+ 3D downsampling block to reduce spatial dimensions by a factor of 2.
+
+ Supports downsampling via strided convolution or average pooling.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ mode: Literal["conv", "avgpool"] = "conv",
+ ):
+ """
+ Initialize a 3D downsampling block.
+
+ Args:
+ in_channels: Number of input channels
+ out_channels: Number of output channels
+ mode: Downsampling method ("conv" or "avgpool")
+ """
+ assert mode in ["conv", "avgpool"], f"Invalid mode {mode}"
+
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ if mode == "conv":
+ self.conv = nn.Conv3d(in_channels, out_channels, 2, stride=2)
+ elif mode == "avgpool":
+ assert in_channels == out_channels, "Pooling mode requires in_channels to be equal to out_channels"
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the downsampling block.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Downsampled tensor
+ """
+ if hasattr(self, "conv"):
+ return self.conv(x)
+ else:
+ return F.avg_pool3d(x, 2)
+
+
+class UpsampleBlock3d(nn.Module):
+ """
+ 3D upsampling block to increase spatial dimensions by a factor of 2.
+
+ Supports upsampling via transposed convolution or nearest-neighbor interpolation.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ mode: Literal["conv", "nearest"] = "conv",
+ ):
+ """
+ Initialize a 3D upsampling block.
+
+ Args:
+ in_channels: Number of input channels
+ out_channels: Number of output channels
+ mode: Upsampling method ("conv" or "nearest")
+ """
+ assert mode in ["conv", "nearest"], f"Invalid mode {mode}"
+
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ if mode == "conv":
+ # For pixel shuffle upsampling, we need 8x channels (2³ = 8)
+ self.conv = nn.Conv3d(in_channels, out_channels*8, 3, padding=1)
+ elif mode == "nearest":
+ assert in_channels == out_channels, "Nearest mode requires in_channels to be equal to out_channels"
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the upsampling block.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Upsampled tensor
+ """
+ if hasattr(self, "conv"):
+ x = self.conv(x)
+ return pixel_shuffle_3d(x, 2) # 3D pixel shuffle for upsampling
+ else:
+ return F.interpolate(x, scale_factor=2, mode="nearest")
+
+
+class SparseStructureEncoder(nn.Module):
+ """
+ Encoder for Sparse Structure (\mathcal{E}_S in the paper Sec. 3.3).
+
+ Takes a 3D volume as input and encodes it into a latent distribution (mean and logvar).
+ Can sample from this distribution to get a latent representation.
+
+ Args:
+ in_channels (int): Channels of the input.
+ latent_channels (int): Channels of the latent representation.
+ num_res_blocks (int): Number of residual blocks at each resolution.
+ channels (List[int]): Channels of the encoder blocks.
+ num_res_blocks_middle (int): Number of residual blocks in the middle.
+ norm_type (Literal["group", "layer"]): Type of normalization layer.
+ use_fp16 (bool): Whether to use FP16.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ latent_channels: int,
+ num_res_blocks: int,
+ channels: List[int],
+ num_res_blocks_middle: int = 2,
+ norm_type: Literal["group", "layer"] = "layer",
+ use_fp16: bool = False,
+ ):
+ """
+ Initialize the encoder for sparse structure.
+ """
+ super().__init__()
+ self.in_channels = in_channels
+ self.latent_channels = latent_channels
+ self.num_res_blocks = num_res_blocks
+ self.channels = channels
+ self.num_res_blocks_middle = num_res_blocks_middle
+ self.norm_type = norm_type
+ self.use_fp16 = use_fp16
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Initial projection from input to feature space
+ self.input_layer = nn.Conv3d(in_channels, channels[0], 3, padding=1)
+
+ # Encoder blocks with progressive downsampling
+ self.blocks = nn.ModuleList([])
+ for i, ch in enumerate(channels):
+ # Add residual blocks at the current resolution
+ self.blocks.extend([
+ ResBlock3d(ch, ch)
+ for _ in range(num_res_blocks)
+ ])
+ # Add downsampling block if not at the final resolution
+ if i < len(channels) - 1:
+ self.blocks.append(
+ DownsampleBlock3d(ch, channels[i+1])
+ )
+
+ # Middle blocks at the lowest resolution
+ self.middle_block = nn.Sequential(*[
+ ResBlock3d(channels[-1], channels[-1])
+ for _ in range(num_res_blocks_middle)
+ ])
+
+ # Output layer produces both mean and logvar for the latent distribution
+ self.out_layer = nn.Sequential(
+ norm_layer(norm_type, channels[-1]),
+ nn.SiLU(),
+ nn.Conv3d(channels[-1], latent_channels*2, 3, padding=1)
+ )
+
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16.
+ """
+ self.use_fp16 = True
+ self.dtype = torch.float16
+ self.blocks.apply(convert_module_to_f16)
+ self.middle_block.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model to float32.
+ """
+ self.use_fp16 = False
+ self.dtype = torch.float32
+ self.blocks.apply(convert_module_to_f32)
+ self.middle_block.apply(convert_module_to_f32)
+
+ def forward(self, x: torch.Tensor, sample_posterior: bool = False, return_raw: bool = False) -> torch.Tensor:
+ """
+ Forward pass through the encoder.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+ sample_posterior: Whether to sample from the posterior distribution or just return mean
+ return_raw: Whether to return the raw outputs (z, mean, logvar) instead of just z
+
+ Returns:
+ Either the latent representation or a tuple of (z, mean, logvar) if return_raw=True
+ """
+ h = self.input_layer(x)
+ h = h.type(self.dtype) # Convert to FP16 if needed
+
+ # Process through encoder blocks
+ for block in self.blocks:
+ h = block(h)
+ h = self.middle_block(h)
+
+ h = h.type(x.dtype) # Convert back to input dtype
+ h = self.out_layer(h)
+
+ # Split output into mean and log variance
+ mean, logvar = h.chunk(2, dim=1)
+
+ # Sample from the posterior if requested
+ if sample_posterior:
+ std = torch.exp(0.5 * logvar)
+ z = mean + std * torch.randn_like(std) # Reparameterization trick
+ else:
+ z = mean
+
+ if return_raw:
+ return z, mean, logvar
+ return z
+
+
+class SparseStructureDecoder(nn.Module):
+ """
+ Decoder for Sparse Structure (\mathcal{D}_S in the paper Sec. 3.3).
+
+ Takes a latent representation and decodes it back to a 3D volume.
+ Uses a symmetric architecture to the encoder with upsampling instead of downsampling.
+
+ Args:
+ out_channels (int): Channels of the output.
+ latent_channels (int): Channels of the latent representation.
+ num_res_blocks (int): Number of residual blocks at each resolution.
+ channels (List[int]): Channels of the decoder blocks.
+ num_res_blocks_middle (int): Number of residual blocks in the middle.
+ norm_type (Literal["group", "layer"]): Type of normalization layer.
+ use_fp16 (bool): Whether to use FP16.
+ """
+ def __init__(
+ self,
+ out_channels: int,
+ latent_channels: int,
+ num_res_blocks: int,
+ channels: List[int],
+ num_res_blocks_middle: int = 2,
+ norm_type: Literal["group", "layer"] = "layer",
+ use_fp16: bool = False,
+ ):
+ """
+ Initialize the decoder for sparse structure.
+ """
+ super().__init__()
+ self.out_channels = out_channels
+ self.latent_channels = latent_channels
+ self.num_res_blocks = num_res_blocks
+ self.channels = channels
+ self.num_res_blocks_middle = num_res_blocks_middle
+ self.norm_type = norm_type
+ self.use_fp16 = use_fp16
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Initial projection from latent space to feature space
+ self.input_layer = nn.Conv3d(latent_channels, channels[0], 3, padding=1)
+
+ # Middle blocks at the lowest resolution
+ self.middle_block = nn.Sequential(*[
+ ResBlock3d(channels[0], channels[0])
+ for _ in range(num_res_blocks_middle)
+ ])
+
+ # Decoder blocks with progressive upsampling
+ self.blocks = nn.ModuleList([])
+ for i, ch in enumerate(channels):
+ # Add residual blocks at the current resolution
+ self.blocks.extend([
+ ResBlock3d(ch, ch)
+ for _ in range(num_res_blocks)
+ ])
+ # Add upsampling block if not at the final resolution
+ if i < len(channels) - 1:
+ self.blocks.append(
+ UpsampleBlock3d(ch, channels[i+1])
+ )
+
+ # Final output layer to generate the desired output channels
+ self.out_layer = nn.Sequential(
+ norm_layer(norm_type, channels[-1]),
+ nn.SiLU(),
+ nn.Conv3d(channels[-1], out_channels, 3, padding=1)
+ )
+
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16.
+ """
+ self.use_fp16 = True
+ self.dtype = torch.float16
+ self.blocks.apply(convert_module_to_f16)
+ self.middle_block.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model to float32.
+ """
+ self.use_fp16 = False
+ self.dtype = torch.float32
+ self.blocks.apply(convert_module_to_f32)
+ self.middle_block.apply(convert_module_to_f32)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Latent representation tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Reconstructed output tensor
+ """
+ h = self.input_layer(x)
+
+ h = h.type(self.dtype) # Convert to FP16 if needed
+
+ h = self.middle_block(h)
+ # Process through decoder blocks
+ for block in self.blocks:
+ h = block(h)
+
+ h = h.type(x.dtype) # Convert back to input dtype
+ h = self.out_layer(h)
+ return h
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_flow.py b/OmniPart/modules/part_synthesis/models/structured_latent_flow.py
new file mode 100644
index 0000000..59d9ffe
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_flow.py
@@ -0,0 +1,470 @@
+from typing import *
+from einops import rearrange
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+from ..modules.transformer import AbsolutePositionEmbedder
+from ..modules.norm import LayerNorm32
+from ..modules import sparse as sp
+from ..modules.sparse.transformer import ModulatedSparseTransformerCrossBlock
+from .sparse_structure_flow import TimestepEmbedder
+from .sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SparseResBlock3d(nn.Module):
+ """
+ 3D Sparse Residual Block with time embedding conditioning.
+
+ This block performs normalization, convolution operations on sparse tensors,
+ and incorporates time embeddings via adaptive layer normalization.
+ Supports optional up/downsampling.
+ """
+ def __init__(
+ self,
+ channels: int,
+ emb_channels: int,
+ out_channels: Optional[int] = None,
+ downsample: bool = False,
+ upsample: bool = False,
+ ):
+ super().__init__()
+ self.channels = channels
+ self.emb_channels = emb_channels
+ self.out_channels = out_channels or channels
+ self.downsample = downsample
+ self.upsample = upsample
+
+ assert not (downsample and upsample), "Cannot downsample and upsample at the same time"
+
+ # First normalization and convolution
+ self.norm1 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6)
+ self.norm2 = LayerNorm32(self.out_channels, elementwise_affine=False, eps=1e-6)
+ self.conv1 = sp.SparseConv3d(channels, self.out_channels, 3)
+
+ # Second convolution initialized to zero for stable training
+ self.conv2 = zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3))
+
+ # Time embedding projection for adaptive layer norm
+ self.emb_layers = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(emb_channels, 2 * self.out_channels, bias=True),
+ )
+
+ # Skip connection with linear projection if channel dimensions change
+ self.skip_connection = sp.SparseLinear(channels, self.out_channels) if channels != self.out_channels else nn.Identity()
+
+ # Optional up/downsampling
+ self.updown = None
+ if self.downsample:
+ self.updown = sp.SparseDownsample(2)
+ elif self.upsample:
+ self.updown = sp.SparseUpsample(2)
+
+ def _updown(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """Apply up/downsampling if configured"""
+ if self.updown is not None:
+ x = self.updown(x)
+ return x
+
+ def forward(self, x: sp.SparseTensor, emb: torch.Tensor) -> sp.SparseTensor:
+ """
+ Forward pass of the residual block.
+
+ Args:
+ x: Input sparse tensor
+ emb: Time embedding tensor
+
+ Returns:
+ Processed sparse tensor
+ """
+ # print(f"number of points in the input: {x.coords.shape[0]}")
+ # Project embedding to scale and shift factors
+ emb_out = self.emb_layers(emb).type(x.dtype)
+ scale, shift = torch.chunk(emb_out, 2, dim=1)
+
+ # Apply up/downsampling if needed
+ x = self._updown(x)
+
+ # Main processing path
+ h = x.replace(self.norm1(x.feats))
+ h = h.replace(F.silu(h.feats))
+ h = self.conv1(h)
+ # Apply adaptive layer norm using scale and shift from time embedding
+ h = h.replace(self.norm2(h.feats)) * (1 + scale) + shift
+ h = h.replace(F.silu(h.feats))
+ h = self.conv2(h)
+
+ # Residual connection
+ h = h + self.skip_connection(x)
+
+ return h
+
+
+class SLatFlowModel(nn.Module):
+ """
+ Structured Latent Flow Model for 3D generative modeling.
+
+ This model combines sparse convolutions with transformer blocks and
+ supports conditional generation. It uses a U-Net-like architecture with
+ skip connections and has optional mixed precision support.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ cond_channels: int,
+ out_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ patch_size: int = 2,
+ num_io_res_blocks: int = 2,
+ io_block_channels: List[int] = None,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ use_skip_connection: bool = True,
+ share_mod: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ ):
+ super().__init__()
+ self.resolution = resolution
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.cond_channels = cond_channels
+ self.out_channels = out_channels
+ self.num_blocks = num_blocks
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.patch_size = patch_size
+ self.num_io_res_blocks = num_io_res_blocks
+ self.io_block_channels = io_block_channels
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.use_skip_connection = use_skip_connection
+ self.share_mod = share_mod
+ self.qk_rms_norm = qk_rms_norm
+ self.qk_rms_norm_cross = qk_rms_norm_cross
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Validate configurations
+ if self.io_block_channels is not None:
+ assert int(np.log2(patch_size)) == np.log2(patch_size), "Patch size must be a power of 2"
+ assert np.log2(patch_size) == len(io_block_channels), "Number of IO ResBlocks must match the number of stages"
+
+ # Time step embedder
+ self.t_embedder = TimestepEmbedder(model_channels)
+
+ # Shared modulation for all transformer blocks if enabled
+ if share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(model_channels, 6 * model_channels, bias=True)
+ )
+
+ self.part_max_size = 50
+
+ # Positional embedding for transformer blocks
+ if pe_mode == "ape":
+ self.pos_embedder = AbsolutePositionEmbedder(model_channels)
+ self.part_pe = nn.Embedding(self.part_max_size + 1, model_channels) # +1 for overall object
+
+ self.part_pe_proj = nn.Linear(model_channels, model_channels)
+
+ # Mask embedding
+ self.dinov2_hidden_size = 1024
+ self.mask_group_emb_dim = 128
+
+ self.mask_group_emb = nn.Embedding(self.part_max_size + 1, self.mask_group_emb_dim) # +1 for background
+ self.mask_group_emb_proj = nn.Linear(self.mask_group_emb_dim, self.dinov2_hidden_size)
+
+ # Input projection layer
+ self.input_layer = sp.SparseLinear(in_channels, model_channels if io_block_channels is None else io_block_channels[0])
+
+ # Input processing blocks (downsampling path)
+ self.input_blocks = nn.ModuleList([])
+ # print(f"io_block_channels: {io_block_channels}") # io_block_channels: [128]
+ # print(f"model_channels: {model_channels}") # model_channels: 1024
+
+ if io_block_channels is not None:
+ for chs, next_chs in zip(io_block_channels, io_block_channels[1:] + [model_channels]):
+ # Add regular residual blocks at current resolution
+ self.input_blocks.extend([
+ SparseResBlock3d(
+ chs,
+ model_channels,
+ out_channels=chs,
+ )
+ for _ in range(num_io_res_blocks-1)
+ ])
+ # Add downsampling block at the end of each resolution level
+ self.input_blocks.append(
+ SparseResBlock3d(
+ chs,
+ model_channels,
+ out_channels=next_chs,
+ downsample=True,
+ )
+ )
+
+ # Core transformer blocks
+ self.blocks = nn.ModuleList([
+ ModulatedSparseTransformerCrossBlock(
+ model_channels,
+ cond_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode='full',
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ share_mod=self.share_mod,
+ qk_rms_norm=self.qk_rms_norm,
+ qk_rms_norm_cross=self.qk_rms_norm_cross,
+ )
+ for _ in range(num_blocks)
+ ])
+
+ # Output processing blocks (upsampling path)
+ self.out_blocks = nn.ModuleList([])
+ if io_block_channels is not None:
+ for chs, prev_chs in zip(reversed(io_block_channels), [model_channels] + list(reversed(io_block_channels[1:]))):
+ # Add upsampling block at the beginning of each resolution level
+ self.out_blocks.append(
+ SparseResBlock3d(
+ prev_chs * 2 if self.use_skip_connection else prev_chs,
+ model_channels,
+ out_channels=chs,
+ upsample=True,
+ )
+ )
+ # Add regular residual blocks at current resolution
+ self.out_blocks.extend([
+ SparseResBlock3d(
+ chs * 2 if self.use_skip_connection else chs,
+ model_channels,
+ out_channels=chs,
+ )
+ for _ in range(num_io_res_blocks-1)
+ ])
+
+ # Final output projection
+ self.out_layer = sp.SparseLinear(model_channels if io_block_channels is None else io_block_channels[0], out_channels)
+
+ # Initialize model weights
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+ # else:
+ # self.convert_to_fp32()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 for mixed precision training.
+ """
+ self.input_blocks.apply(convert_module_to_f16)
+ self.blocks.apply(convert_module_to_f16)
+ self.out_blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32.
+ """
+ self.input_blocks.apply(convert_module_to_f32)
+ self.blocks.apply(convert_module_to_f32)
+ self.out_blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights with specialized initialization for different components.
+ """
+ # Initialize transformer layers with Xavier uniform initialization
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ # Initialize timestep embedding MLP with normal distribution
+ nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+ nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+ # Zero-out adaLN modulation layers for stable training
+ if self.share_mod:
+ nn.init.constant_(self.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(self.adaLN_modulation[-1].bias, 0)
+ else:
+ for block in self.blocks:
+ nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+ # Zero-out output layers for stable training
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ # part embedding initialization
+ nn.init.zeros_(self.part_pe_proj.weight)
+ nn.init.zeros_(self.part_pe_proj.bias)
+
+ # Initialize layer positional embeddings
+ self.part_pe.weight.data.normal_(mean=0.0,std=0.02)
+
+ # Initialize group embedding
+ nn.init.zeros_(self.mask_group_emb_proj.weight)
+ nn.init.zeros_(self.mask_group_emb_proj.bias)
+
+ self.mask_group_emb.weight.data.normal_(mean=0.0, std=0.02)
+
+ def forward(self, x: sp.SparseTensor, t: torch.Tensor, cond: torch.Tensor, **kwargs) -> sp.SparseTensor:
+ """
+ Forward pass of the Structured Latent Flow model.
+
+ Args:
+ x: Input sparse tensor
+ t: Timestep embedding inputs
+ cond: Conditional input for cross-attention
+ **kwargs: Additional arguments, including part_layouts if available
+
+ Returns:
+ Output sparse tensor
+ """
+
+ # x = x.type(self.dtype)
+ # t = t.type(self.dtype)
+ # cond = cond.type(self.dtype)
+ input_dtype = x.dtype
+
+ masks = kwargs['masks'] # [b, h, w]
+
+ # Ensure masks are always long type regardless of source
+ masks = masks.long() # Explicitly convert to long type for embedding
+ masks = rearrange(masks, 'b h w -> b (h w)') # [b, h*w]
+ masks_emb = self.mask_group_emb(masks) # [b, h*w, 128]
+ masks_emb = self.mask_group_emb_proj(masks_emb) # [b, h*w, 1024]
+ group_emb = torch.zeros((cond.shape[0], cond.shape[1], masks_emb.shape[2]), device=cond.device, dtype=cond.dtype)
+ group_emb[:, :masks_emb.shape[1], :] = masks_emb
+ cond = cond + group_emb
+ cond = cond.type(self.dtype)
+
+ # Store original batch IDs for later restoration
+ original_batch_ids = x.coords[:, 0].clone()
+
+ # Create new batch IDs to represent individual parts (instead of batches)
+ new_batch_ids = torch.zeros_like(original_batch_ids)
+
+ # Assign unique IDs to each part across all batches
+ part_layouts = kwargs['part_layouts']
+ part_id = 0
+ len_before = 0
+ batch_last_partid = []
+ for batch_idx, part_layout in enumerate(part_layouts):
+ for layout_idx, layout in enumerate(part_layout):
+ adjusted_layout = slice(layout.start + len_before, layout.stop + len_before, layout.step)
+ new_batch_ids[adjusted_layout] = part_id
+ part_id += 1
+
+ batch_last_partid.append(part_id)
+ len_before += part_layout[-1].stop
+
+ # Project input to model dimensions and convert to target dtype
+ x = self.input_layer(x).type(self.dtype)
+
+ x = sp.SparseTensor(
+ feats = x.feats,
+ coords = torch.cat([new_batch_ids.view(-1, 1), x.coords[:, 1:]], dim=1),)
+
+ # Process timestep embedding and condition input
+ t_emb = self.t_embedder(t)
+ if self.share_mod:
+ t_emb = self.adaLN_modulation(t_emb)
+ t_emb = t_emb.type(self.dtype)
+ t_emb_updown = []
+ for batch_idx, part_layout in enumerate(part_layouts):
+ t_emb_updown_batch = t_emb[batch_idx:batch_idx+1].repeat(len(part_layout), 1)
+ t_emb_updown.append(t_emb_updown_batch)
+ t_emb_updown = torch.cat(t_emb_updown, dim=0).type(self.dtype)
+
+ # Store features for skip connections
+ skips = []
+
+ # Downsampling path through input blocks
+ for block in self.input_blocks:
+ x = block(x, t_emb_updown)
+ skips.append(x.feats)
+
+ # Store part-wise batch IDs before transformer processing
+ part_wise_batch_ids = x.coords[:, 0].clone()
+
+ # Convert to batch-wise IDs for transformer blocks
+ new_transformer_batch_ids = torch.zeros_like(part_wise_batch_ids)
+ part_ids_in_each_object = torch.zeros_like(part_wise_batch_ids)
+ start_reform = 0
+ last_part_id = 0
+ for part_id in batch_last_partid:
+ mask = (part_wise_batch_ids >= last_part_id) & (part_wise_batch_ids < part_id)
+ new_transformer_batch_ids[mask] = start_reform
+ part_ids_in_each_object[mask] = part_wise_batch_ids[mask] - last_part_id
+ last_part_id = part_id
+ start_reform += 1
+
+ # Update coordinates with batch-wise IDs for transformer processing
+ h = sp.SparseTensor(
+ feats = x.feats,
+ coords = torch.cat([new_transformer_batch_ids.view(-1, 1), x.coords[:, 1:]], dim=1))
+
+ # Add positional embeddings for transformer blocks
+ if self.pe_mode == "ape":
+ # Add absolute positional embeddings to spatial coordinates
+ h = h + self.pos_embedder(h.coords[:, 1:]).type(self.dtype)
+ # Part-with PE; overall is 0
+ part_pe = self.part_pe(part_ids_in_each_object)
+ part_pe = self.part_pe_proj(part_pe)
+ h = h + part_pe.type(self.dtype)
+
+ else:
+ raise NotImplementedError
+
+ # Process with transformer blocks
+ for block in self.blocks:
+ h = block(h, t_emb, cond)
+
+ h = x.replace(feats=h.feats, coords=torch.cat([part_wise_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+
+ # Upsampling path with output blocks and skip connections
+ for block, skip in zip(self.out_blocks, reversed(skips)):
+ if self.use_skip_connection:
+ h = block(h.replace(torch.cat([h.feats, skip], dim=1)), t_emb_updown)
+ else:
+ h = block(h, t_emb_updown)
+
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ h = self.out_layer(h.type(input_dtype))
+ h = sp.SparseTensor(
+ feats = h.feats,
+ coords = torch.cat([original_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+
+ return h
+
+
+class ElasticSLatFlowModel(SparseTransformerElasticMixin, SLatFlowModel):
+ """
+ Structured Latent Flow Model with elastic memory management.
+
+ This class extends SLatFlowModel with memory-efficient operations,
+ allowing training with limited VRAM by dynamically managing memory
+ allocation for sparse tensors.
+ """
+ pass
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/__init__.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/__init__.py
new file mode 100644
index 0000000..4e2ac35
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/__init__.py
@@ -0,0 +1,4 @@
+from .encoder import SLatEncoder, ElasticSLatEncoder
+from .decoder_gs import SLatGaussianDecoder, ElasticSLatGaussianDecoder
+from .decoder_rf import SLatRadianceFieldDecoder, ElasticSLatRadianceFieldDecoder
+from .decoder_mesh import SLatMeshDecoder, ElasticSLatMeshDecoder
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/base.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/base.py
new file mode 100644
index 0000000..9f7bad2
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/base.py
@@ -0,0 +1,185 @@
+"""
+Base Sparse Transformer Implementation for TRELLIS Framework
+
+This file implements the base architecture for sparse transformers used in structured latent variable models.
+It provides a configurable foundation with multiple attention mechanisms (full, windowed, shifted window)
+and supports different positional encoding strategies. The sparse implementation allows for efficient
+processing of data with varying density patterns.
+
+The main class SparseTransformerBase serves as the foundation for encoder and decoder implementations
+in the structured latent VAE models.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+from ...modules.utils import convert_module_to_f16, convert_module_to_f32
+from ...modules import sparse as sp
+from ...modules.transformer import AbsolutePositionEmbedder
+from ...modules.sparse.transformer import SparseTransformerBlock
+
+
+def block_attn_config(self):
+ """
+ Return the attention configuration for each transformer block.
+
+ Generates configurations for each block based on the specified attention mode:
+ - shift_window: Uses serialized attention with shifting window patterns
+ - shift_sequence: Uses serialized attention with sequence shifts
+ - shift_order: Uses serialized attention with different serialization orders
+ - full: Uses standard full attention (non-sparse)
+ - swin: Uses Swin Transformer-style windowed attention
+
+ Yields:
+ Tuple containing attention mode and its parameters
+ """
+ for i in range(self.num_blocks):
+ if self.attn_mode == "shift_window":
+ yield "serialized", self.window_size, 0, (16 * (i % 2),) * 3, sp.SerializeMode.Z_ORDER
+ elif self.attn_mode == "shift_sequence":
+ yield "serialized", self.window_size, self.window_size // 2 * (i % 2), (0, 0, 0), sp.SerializeMode.Z_ORDER
+ elif self.attn_mode == "shift_order":
+ yield "serialized", self.window_size, 0, (0, 0, 0), sp.SerializeModes[i % 4]
+ elif self.attn_mode == "full":
+ yield "full", None, None, None, None
+ elif self.attn_mode == "swin":
+ yield "windowed", self.window_size, None, self.window_size // 2 * (i % 2), None
+
+
+class SparseTransformerBase(nn.Module):
+ """
+ Sparse Transformer without output layers.
+ Serve as the base class for encoder and decoder.
+
+ Implements a transformer architecture that can work with sparse data structures,
+ supporting various attention mechanisms and positional encodings.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ model_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ """
+ Initialize the sparse transformer base model.
+
+ Args:
+ in_channels: Number of input channels
+ model_channels: Hidden dimension size
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (calculated from head_channels if None)
+ num_head_channels: Number of channels per attention head
+ mlp_ratio: Ratio for MLP hidden dimension
+ attn_mode: Attention mechanism type
+ window_size: Size of attention window for windowed modes
+ pe_mode: Positional encoding mode (absolute or rotary)
+ use_fp16: Whether to use half precision
+ use_checkpoint: Whether to use gradient checkpointing
+ qk_rms_norm: Whether to use RMS normalization for query and key
+ """
+ super().__init__()
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.num_blocks = num_blocks
+ self.window_size = window_size
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.attn_mode = attn_mode
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.qk_rms_norm = qk_rms_norm
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Create positional embedder if using absolute positional encoding
+ if pe_mode == "ape":
+ self.pos_embedder = AbsolutePositionEmbedder(model_channels)
+
+ # Input projection layer
+ self.input_layer = sp.SparseLinear(in_channels, model_channels)
+
+ # Build transformer blocks with configurations from block_attn_config
+ self.blocks = nn.ModuleList([
+ SparseTransformerBlock(
+ model_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ qk_rms_norm=self.qk_rms_norm,
+ )
+ for attn_mode, window_size, shift_sequence, shift_window, serialize_mode in block_attn_config(self)
+ ])
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 precision.
+ Used for mixed precision training.
+ """
+ self.blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32 precision.
+ Used after mixed precision training or inference.
+ """
+ self.blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model using Xavier uniform initialization.
+ This helps with training stability and convergence.
+ """
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ def forward(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """
+ Forward pass through the sparse transformer.
+
+ Args:
+ x: Input sparse tensor
+
+ Returns:
+ Processed sparse tensor after passing through all transformer blocks
+ """
+ # Project input to model dimension
+ h = self.input_layer(x)
+
+ # Add positional embeddings if using absolute positional encoding
+ if self.pe_mode == "ape":
+ h = h + self.pos_embedder(x.coords[:, 1:])
+
+ # Convert to target precision
+ h = h.type(self.dtype)
+
+ # Pass through transformer blocks sequentially
+ for block in self.blocks:
+ h = block(h)
+
+ return h
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_gs.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_gs.py
new file mode 100644
index 0000000..ff72cfe
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_gs.py
@@ -0,0 +1,180 @@
+"""
+decoder_gs.py: Structured Latent Gaussian Decoder for 3D Representation Learning
+
+This file contains decoder implementations that transform latent codes into 3D Gaussian
+representations. The decoders use sparse transformer architectures for efficient processing
+and flexible attention mechanisms. The main components are:
+- SLatGaussianDecoder: Core decoder that maps latent codes to 3D Gaussians
+- ElasticSLatGaussianDecoder: Memory-efficient variant with elastic memory management
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ...modules import sparse as sp
+from ...utils.random_utils import hammersley_sequence
+from .base import SparseTransformerBase
+from ...representations import Gaussian
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatGaussianDecoder(SparseTransformerBase):
+ """
+ Sparse Transformer-based decoder that converts latent codes to 3D Gaussian representations.
+
+ This decoder processes sparse tensors and outputs parameters for Gaussian primitives
+ that can be rendered in 3D space, including positions, features, scaling, rotation,
+ and opacity.
+ """
+ def __init__(
+ self,
+ resolution: int, # The resolution of the 3D grid
+ model_channels: int, # Number of channels in the transformer layers
+ latent_channels: int, # Number of channels in the input latent code
+ num_blocks: int, # Number of transformer blocks
+ num_heads: Optional[int] = None, # Number of attention heads
+ num_head_channels: Optional[int] = 64, # Channels per attention head
+ mlp_ratio: float = 4, # Ratio for MLP size in transformer blocks
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", # Attention mechanism
+ window_size: int = 8, # Size of attention windows for windowed attention
+ pe_mode: Literal["ape", "rope"] = "ape", # Positional encoding mode
+ use_fp16: bool = False, # Whether to use half-precision
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for attention
+ representation_config: dict = None, # Configuration for the Gaussian representation
+ ):
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+ self._calc_layout() # Calculate output tensor layout
+ self.out_layer = sp.SparseLinear(model_channels, self.out_channels) # Final projection layer
+ self._build_perturbation() # Build position perturbation for better initialization
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights, with special handling for output layers.
+ Zero-initializes the output layer for stability.
+ """
+ super().initialize_weights()
+ # Zero-out output layers:
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def _build_perturbation(self) -> None:
+ """
+ Build position perturbation for Gaussian means.
+ Uses Hammersley sequence for quasi-random uniform distribution of points,
+ then transforms to match the desired Gaussian spatial distribution.
+ """
+ perturbation = [hammersley_sequence(3, i, self.rep_config['num_gaussians']) for i in range(self.rep_config['num_gaussians'])]
+ perturbation = torch.tensor(perturbation).float() * 2 - 1 # Scale to [-1, 1]
+ perturbation = perturbation / self.rep_config['voxel_size'] # Scale by voxel size
+ perturbation = torch.atanh(perturbation).to(self.device) # Apply inverse tanh for better gradient flow
+ self.register_buffer('offset_perturbation', perturbation) # Register as buffer (not a parameter)
+
+ def _calc_layout(self) -> None:
+ """
+ Calculate the layout of the output tensor.
+ Defines the shape and size of each Gaussian parameter group (position, features, scaling, rotation, opacity)
+ and their positions in the output tensor.
+ """
+ self.layout = {
+ '_xyz' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_features_dc' : {'shape': (self.rep_config['num_gaussians'], 1, 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_scaling' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_rotation' : {'shape': (self.rep_config['num_gaussians'], 4), 'size': self.rep_config['num_gaussians'] * 4},
+ '_opacity' : {'shape': (self.rep_config['num_gaussians'], 1), 'size': self.rep_config['num_gaussians']},
+ }
+ # Calculate ranges for each parameter group in the flattened output tensor
+ start = 0
+ for k, v in self.layout.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.out_channels = start # Total number of output channels
+
+ def to_representation(self, x: sp.SparseTensor) -> List[Gaussian]:
+ """
+ Convert a batch of network outputs to 3D Gaussian representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of Gaussian representations, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ # Create a new Gaussian representation object with proper configuration
+ representation = Gaussian(
+ sh_degree=0, # No spherical harmonics, just using DC term
+ aabb=[-0.5, -0.5, -0.5, 1.0, 1.0, 1.0], # Axis-aligned bounding box
+ mininum_kernel_size = self.rep_config['3d_filter_kernel_size'],
+ scaling_bias = self.rep_config['scaling_bias'],
+ opacity_bias = self.rep_config['opacity_bias'],
+ scaling_activation = self.rep_config['scaling_activation']
+ )
+ # Get base positions from sparse tensor coordinates
+ xyz = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution
+
+ # Process each parameter group
+ for k, v in self.layout.items():
+ if k == '_xyz':
+ # Handle positions with special perturbation logic
+ offset = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape'])
+ offset = offset * self.rep_config['lr'][k] # Apply learning rate scale
+ if self.rep_config['perturb_offset']:
+ offset = offset + self.offset_perturbation # Add perturbation
+ # Transform offsets through tanh and scale appropriately
+ offset = torch.tanh(offset) / self.resolution * 0.5 * self.rep_config['voxel_size']
+ _xyz = xyz.unsqueeze(1) + offset
+ setattr(representation, k, _xyz.flatten(0, 1))
+ else:
+ # Handle other parameters (features, scaling, rotation, opacity)
+ feats = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']).flatten(0, 1)
+ feats = feats * self.rep_config['lr'][k] # Apply parameter-specific learning rate
+ setattr(representation, k, feats)
+ ret.append(representation)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[Gaussian]:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Input sparse tensor containing latent codes
+
+ Returns:
+ List of Gaussian representations ready for rendering
+ """
+ h = super().forward(x) # Process through transformer blocks
+ h = h.type(x.dtype) # Ensure consistent dtype
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) # Apply layer normalization
+ h = self.out_layer(h) # Project to final output dimensions
+ return self.to_representation(h) # Convert to Gaussian representations
+
+
+class ElasticSLatGaussianDecoder(SparseTransformerElasticMixin, SparseTransformerBase):
+ """
+ Slat VAE Gaussian decoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocations
+ and using efficient sparse operations.
+ """
+ pass
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_mesh.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_mesh.py
new file mode 100644
index 0000000..76b2247
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_mesh.py
@@ -0,0 +1,222 @@
+"""
+Mesh Decoder Module for Structured Latent VAE
+
+This file implements a mesh-based decoder for the structured latent variational autoencoder (SLAT VAE).
+It contains specialized sparse neural network components that transform latent representations into
+3D mesh structures through a series of sparse convolutions and subdivisions.
+
+The module implements:
+1. SparseSubdivideBlock3d - A block that subdivides sparse tensors to increase resolution
+2. SLatMeshDecoder - Main decoder that transforms latent codes into 3D meshes
+3. ElasticSLatMeshDecoder - Memory-efficient version for low VRAM environments
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ...modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ...representations import MeshExtractResult
+from ...representations.mesh import SparseFeatures2Mesh
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SparseSubdivideBlock3d(nn.Module):
+ """
+ A 3D subdivide block that can subdivide the sparse tensor.
+
+ This block increases the resolution of sparse tensors by a factor of 2,
+ and optionally changes the number of channels.
+
+ Args:
+ channels: channels in the inputs and outputs.
+ resolution: the current resolution of the sparse tensor.
+ out_channels: if specified, the number of output channels.
+ num_groups: the number of groups for the group norm.
+ """
+ def __init__(
+ self,
+ channels: int,
+ resolution: int,
+ out_channels: Optional[int] = None,
+ num_groups: int = 32
+ ):
+ super().__init__()
+ self.channels = channels
+ self.resolution = resolution
+ self.out_resolution = resolution * 2
+ self.out_channels = out_channels or channels
+
+ # Normalization and activation before subdivision
+ self.act_layers = nn.Sequential(
+ sp.SparseGroupNorm32(num_groups, channels),
+ sp.SparseSiLU()
+ )
+
+ # Subdivision operator that doubles the resolution
+ self.sub = sp.SparseSubdivide()
+
+ # Post-subdivision processing with residual connection
+ self.out_layers = nn.Sequential(
+ sp.SparseConv3d(channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}"),
+ sp.SparseGroupNorm32(num_groups, self.out_channels),
+ sp.SparseSiLU(),
+ zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}")),
+ )
+
+ # Skip connection that handles potential channel dimension changes
+ if self.out_channels == channels:
+ self.skip_connection = nn.Identity()
+ else:
+ self.skip_connection = sp.SparseConv3d(channels, self.out_channels, 1, indice_key=f"res_{self.out_resolution}")
+
+ def forward(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """
+ Apply the block to a Tensor, conditioned on a timestep embedding.
+
+ Args:
+ x: an [N x C x ...] Tensor of features.
+ Returns:
+ an [N x C x ...] Tensor of outputs with doubled resolution.
+ """
+ h = self.act_layers(x)
+ h = self.sub(h) # Double the resolution
+ x = self.sub(x) # Also subdivide the input for skip connection
+ h = self.out_layers(h)
+ h = h + self.skip_connection(x) # Add skip connection
+ return h
+
+
+class SLatMeshDecoder(SparseTransformerBase):
+ """
+ Structured Latent Mesh Decoder that transforms latent codes into 3D meshes.
+
+ Uses sparse transformers followed by upsampling blocks to generate high-resolution
+ features that are then converted to meshes.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ model_channels: int,
+ latent_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin",
+ window_size: int = 8,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ representation_config: dict = None,
+ ):
+ # Initialize the transformer backbone
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+
+ # Mesh extractor to convert features to mesh representation
+ self.mesh_extractor = SparseFeatures2Mesh(res=self.resolution*4, use_color=self.rep_config.get('use_color', False))
+ self.out_channels = self.mesh_extractor.feats_channels
+
+ # Upsampling blocks that progressively increase resolution
+ self.upsample = nn.ModuleList([
+ SparseSubdivideBlock3d(
+ channels=model_channels,
+ resolution=resolution,
+ out_channels=model_channels // 4
+ ),
+ SparseSubdivideBlock3d(
+ channels=model_channels // 4,
+ resolution=resolution * 2,
+ out_channels=model_channels // 8
+ )
+ ])
+
+ # Final layer to map features to mesh attributes
+ self.out_layer = sp.SparseLinear(model_channels // 8, self.out_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """Initialize model weights, with special handling for output layers."""
+ super().initialize_weights()
+ # Zero-out output layers for stable training
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 for memory efficiency.
+ """
+ super().convert_to_fp16()
+ self.upsample.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32 for precision.
+ """
+ super().convert_to_fp32()
+ self.upsample.apply(convert_module_to_f32)
+
+ def to_representation(self, x: sp.SparseTensor) -> List[MeshExtractResult]:
+ """
+ Convert a batch of network outputs to 3D mesh representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of mesh representation results, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ mesh = self.mesh_extractor(x[i], training=self.training)
+ ret.append(mesh)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[MeshExtractResult]:
+ """
+ Process latent codes through the decoder and extract meshes.
+
+ Args:
+ x: Input sparse tensor of latent codes
+
+ Returns:
+ List of extracted mesh representations
+ """
+ h = super().forward(x) # Process through transformer blocks
+ for block in self.upsample:
+ h = block(h) # Progressively increase resolution
+ h = h.type(x.dtype)
+ h = self.out_layer(h) # Final projection to mesh features
+ return self.to_representation(h) # Convert features to meshes
+
+
+class ElasticSLatMeshDecoder(SparseTransformerElasticMixin, SLatMeshDecoder):
+ """
+ Structured Latent Mesh Decoder with elastic memory management.
+
+ This variant uses elastic sparse tensor operations to reduce memory usage
+ during training, making it suitable for environments with limited VRAM.
+ """
+ pass
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_rf.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_rf.py
new file mode 100644
index 0000000..fc6d395
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/decoder_rf.py
@@ -0,0 +1,156 @@
+"""
+This file implements radiance field decoders for Structured Latent VAE models.
+The main class SLatRadianceFieldDecoder is a sparse transformer-based decoder that
+transforms latent codes into sparse representations of 3D scenes (Strivec representation).
+It also includes an elastic memory version (ElasticSLatRadianceFieldDecoder) for low VRAM training.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ...representations import Strivec
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatRadianceFieldDecoder(SparseTransformerBase):
+ """
+ A sparse transformer-based decoder for converting latent codes to radiance field representations.
+ This decoder processes sparse tensors through transformer blocks and outputs parameters for Strivec representation.
+ """
+ def __init__(
+ self,
+ resolution: int, # Resolution of the output 3D grid
+ model_channels: int, # Number of channels in the model's hidden layers
+ latent_channels: int, # Number of channels in the latent code
+ num_blocks: int, # Number of transformer blocks
+ num_heads: Optional[int] = None, # Number of attention heads
+ num_head_channels: Optional[int] = 64, # Channels per attention head
+ mlp_ratio: float = 4, # Ratio for MLP hidden dimension
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", # Attention mode
+ window_size: int = 8, # Size of local attention window
+ pe_mode: Literal["ape", "rope"] = "ape", # Positional encoding mode
+ use_fp16: bool = False, # Whether to use half precision
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing
+ qk_rms_norm: bool = False, # Whether to normalize query and key
+ representation_config: dict = None, # Configuration for output representation
+ ):
+ # Initialize the base sparse transformer
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+ self._calc_layout() # Calculate the output layout
+ # Final layer to project features to the output representation
+ self.out_layer = sp.SparseLinear(model_channels, self.out_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model.
+ Zero-initializes the output layer for better training stability.
+ """
+ super().initialize_weights()
+ # Zero-out output layers for better training stability
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def _calc_layout(self) -> None:
+ """
+ Calculate the output tensor layout for the Strivec representation.
+ Defines the shapes and sizes of different components and their positions in the output tensor.
+ """
+ self.layout = {
+ 'trivec': {'shape': (self.rep_config['rank'], 3, self.rep_config['dim']), 'size': self.rep_config['rank'] * 3 * self.rep_config['dim']},
+ 'density': {'shape': (self.rep_config['rank'],), 'size': self.rep_config['rank']},
+ 'features_dc': {'shape': (self.rep_config['rank'], 1, 3), 'size': self.rep_config['rank'] * 3},
+ }
+ # Calculate the range (start, end) indices for each component in the output tensor
+ start = 0
+ for k, v in self.layout.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.out_channels = start
+
+ def to_representation(self, x: sp.SparseTensor) -> List[Strivec]:
+ """
+ Convert a batch of network outputs to 3D representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of Strivec representations, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ # Create a new Strivec representation
+ representation = Strivec(
+ sh_degree=0,
+ resolution=self.resolution,
+ aabb=[-0.5, -0.5, -0.5, 1, 1, 1], # Axis-aligned bounding box
+ rank=self.rep_config['rank'],
+ dim=self.rep_config['dim'],
+ device='cuda',
+ )
+ representation.density_shift = 0.0
+ # Set position from sparse coordinates (normalized to [0,1])
+ representation.position = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution
+ # Set depth (octree level) based on resolution
+ representation.depth = torch.full((representation.position.shape[0], 1), int(np.log2(self.resolution)), dtype=torch.uint8, device='cuda')
+
+ # Extract each component from the output features according to the layout
+ for k, v in self.layout.items():
+ setattr(representation, k, x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']))
+
+ # Add 1 to trivec for stability (prevent zero vectors)
+ representation.trivec = representation.trivec + 1
+ ret.append(representation)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[Strivec]:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Input sparse tensor containing latent codes
+
+ Returns:
+ List of Strivec representations
+ """
+ # Pass through transformer backbone
+ h = super().forward(x)
+ h = h.type(x.dtype)
+ # Layer normalization on feature dimension
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ # Final projection to output features
+ h = self.out_layer(h)
+ # Convert network output to Strivec representations
+ return self.to_representation(h)
+
+
+class ElasticSLatRadianceFieldDecoder(SparseTransformerElasticMixin, SLatRadianceFieldDecoder):
+ """
+ Slat VAE Radiance Field Decoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocation
+ and performing operations in chunks when needed.
+ """
+ pass
diff --git a/OmniPart/modules/part_synthesis/models/structured_latent_vae/encoder.py b/OmniPart/modules/part_synthesis/models/structured_latent_vae/encoder.py
new file mode 100644
index 0000000..7716652
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/models/structured_latent_vae/encoder.py
@@ -0,0 +1,138 @@
+"""
+Structured Latent Variable Encoder Module
+----------------------------------------
+This file defines encoder classes for the Structured Latent Variable Autoencoder (SLatVAE).
+It contains implementations for the sparse transformer-based encoder that maps input
+features to a latent distribution, as well as a memory-efficient elastic version.
+The encoder follows a variational approach, outputting means and log variances for
+the latent space representation.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatEncoder(SparseTransformerBase):
+ """
+ Sparse Latent Variable Encoder that uses transformer architecture to encode
+ sparse data into a latent distribution.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ latent_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin",
+ window_size: int = 8,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ """
+ Initialize the Sparse Latent Encoder.
+
+ Args:
+ resolution: Input data resolution
+ in_channels: Number of input feature channels
+ model_channels: Number of internal model feature channels
+ latent_channels: Dimension of the latent space
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (optional)
+ num_head_channels: Channels per attention head if num_heads is None
+ mlp_ratio: Expansion ratio for MLP in transformer blocks
+ attn_mode: Type of attention mechanism to use
+ window_size: Size of attention windows if using windowed attention
+ pe_mode: Positional encoding mode (absolute or relative)
+ use_fp16: Whether to use half-precision floating point
+ use_checkpoint: Whether to use gradient checkpointing
+ qk_rms_norm: Whether to apply RMS normalization to query and key
+ """
+ super().__init__(
+ in_channels=in_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ # Output layer projects to twice the latent dimension (for mean and logvar)
+ self.out_layer = sp.SparseLinear(model_channels, 2 * latent_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights with special handling for output layer.
+ The output layer weights are initialized to zero to stabilize training.
+ """
+ super().initialize_weights()
+ # Zero-out output layers for better training stability
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def forward(self, x: sp.SparseTensor, sample_posterior=True, return_raw=False):
+ """
+ Forward pass through the encoder.
+
+ Args:
+ x: Input sparse tensor
+ sample_posterior: Whether to sample from posterior or return mean
+ return_raw: Whether to return mean and logvar in addition to samples
+
+ Returns:
+ If return_raw is True:
+ - sampled latent variables, mean, and logvar
+ Otherwise:
+ - sampled latent variables only
+ """
+ # Process through transformer blocks
+ h = super().forward(x)
+ h = h.type(x.dtype)
+ # Apply layer normalization to features
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ h = self.out_layer(h)
+
+ # Split output into mean and logvar components
+ mean, logvar = h.feats.chunk(2, dim=-1)
+ if sample_posterior:
+ # Reparameterization trick: z = mean + std * epsilon
+ std = torch.exp(0.5 * logvar)
+ z = mean + std * torch.randn_like(std)
+ else:
+ # Use mean directly without sampling
+ z = mean
+ z = h.replace(z)
+
+ if return_raw:
+ return z, mean, logvar
+ else:
+ return z
+
+
+class ElasticSLatEncoder(SparseTransformerElasticMixin, SLatEncoder):
+ """
+ SLat VAE encoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocation
+ and performing operations with reduced memory footprint.
+ """
+ pass
diff --git a/OmniPart/modules/part_synthesis/modules/attention/__init__.py b/OmniPart/modules/part_synthesis/modules/attention/__init__.py
new file mode 100644
index 0000000..f452320
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/attention/__init__.py
@@ -0,0 +1,36 @@
+from typing import *
+
+BACKEND = 'flash_attn'
+DEBUG = False
+
+def __from_env():
+ import os
+
+ global BACKEND
+ global DEBUG
+
+ env_attn_backend = os.environ.get('ATTN_BACKEND')
+ env_sttn_debug = os.environ.get('ATTN_DEBUG')
+
+ if env_attn_backend is not None and env_attn_backend in ['xformers', 'flash_attn', 'sdpa', 'naive']:
+ BACKEND = env_attn_backend
+ if env_sttn_debug is not None:
+ DEBUG = env_sttn_debug == '1'
+
+ print(f"[ATTENTION] Using backend: {BACKEND}")
+
+
+__from_env()
+
+
+def set_backend(backend: Literal['xformers', 'flash_attn']):
+ global BACKEND
+ BACKEND = backend
+
+def set_debug(debug: bool):
+ global DEBUG
+ DEBUG = debug
+
+
+from .full_attn import *
+from .modules import *
diff --git a/OmniPart/modules/part_synthesis/modules/attention/full_attn.py b/OmniPart/modules/part_synthesis/modules/attention/full_attn.py
new file mode 100644
index 0000000..e671db8
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/attention/full_attn.py
@@ -0,0 +1,199 @@
+"""
+Full Attention Module
+
+This file implements different versions of the Scaled Dot-Product Attention mechanism used in transformer models.
+It provides a unified interface that supports multiple backend implementations (xformers, flash_attn,
+PyTorch's native SDPA, or a naive implementation) while maintaining consistent input/output formats.
+The module allows for flexible calling patterns with different tensor arrangements for queries, keys, and values.
+"""
+
+from typing import *
+import torch
+import math
+from . import DEBUG, BACKEND # Import configuration variables
+
+# Select the appropriate attention backend based on configuration
+if BACKEND == 'xformers':
+ import xformers.ops as xops
+elif BACKEND == 'flash_attn':
+ import flash_attn
+elif BACKEND == 'sdpa':
+ from torch.nn.functional import scaled_dot_product_attention as sdpa
+elif BACKEND == 'naive':
+ pass # Will use the naive implementation defined below
+else:
+ raise ValueError(f"Unknown attention backend: {BACKEND}")
+
+
+__all__ = [
+ 'scaled_dot_product_attention', # Only expose this main function
+]
+
+
+def _naive_sdpa(q, k, v):
+ """
+ Naive implementation of scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): Query tensor
+ k (torch.Tensor): Key tensor
+ v (torch.Tensor): Value tensor
+
+ Returns:
+ torch.Tensor: Output attention tensor
+
+ Note:
+ This implementation follows the standard attention formula:
+ Attention(Q,K,V) = softmax(QK^T/sqrt(d_k))V
+ """
+ q = q.permute(0, 2, 1, 3) # [N, H, L, C] - Reshape for batched matrix multiplication
+ k = k.permute(0, 2, 1, 3) # [N, H, L, C]
+ v = v.permute(0, 2, 1, 3) # [N, H, L, C]
+ scale_factor = 1 / math.sqrt(q.size(-1)) # Scale factor to prevent softmax saturation
+ attn_weight = q @ k.transpose(-2, -1) * scale_factor # Compute scaled dot product
+ attn_weight = torch.softmax(attn_weight, dim=-1) # Apply softmax to get attention weights
+ out = attn_weight @ v # Apply attention weights to values
+ out = out.permute(0, 2, 1, 3) # [N, L, H, C] - Restore original dimension order
+ return out
+
+
+@overload
+def scaled_dot_product_attention(qkv: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ qkv (torch.Tensor): A [N, L, 3, H, C] tensor containing Qs, Ks, and Vs.
+ """
+ ...
+
+@overload
+def scaled_dot_product_attention(q: torch.Tensor, kv: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, C] tensor containing Qs.
+ kv (torch.Tensor): A [N, L, 2, H, C] tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def scaled_dot_product_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, Ci] tensor containing Qs.
+ k (torch.Tensor): A [N, L, H, Ci] tensor containing Ks.
+ v (torch.Tensor): A [N, L, H, Co] tensor containing Vs.
+
+ Note:
+ k and v are assumed to have the same coordinate map.
+ """
+ ...
+
+def scaled_dot_product_attention(*args, **kwargs):
+ """
+ Unified interface for scaled dot product attention with multiple calling patterns.
+
+ Supports three calling patterns:
+ 1. Single combined QKV tensor: scaled_dot_product_attention(qkv)
+ 2. Separate Q and combined KV: scaled_dot_product_attention(q, kv)
+ 3. Separate Q, K, V tensors: scaled_dot_product_attention(q, k, v)
+
+ The function automatically selects the appropriate backend implementation
+ based on the BACKEND configuration.
+ """
+ # Define expected argument names for each calling pattern
+ arg_names_dict = {
+ 1: ['qkv'],
+ 2: ['q', 'kv'],
+ 3: ['q', 'k', 'v']
+ }
+ num_all_args = len(args) + len(kwargs)
+ assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3"
+ for key in arg_names_dict[num_all_args][len(args):]:
+ assert key in kwargs, f"Missing argument {key}"
+
+ # Handle case 1: Single combined QKV tensor
+ if num_all_args == 1:
+ qkv = args[0] if len(args) > 0 else kwargs['qkv']
+ assert len(qkv.shape) == 5 and qkv.shape[2] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, L, 3, H, C]"
+ device = qkv.device
+
+ # Handle case 2: Separate Q and combined KV tensors
+ elif num_all_args == 2:
+ # print("handle case 2")
+ q = args[0] if len(args) > 0 else kwargs['q']
+ kv = args[1] if len(args) > 1 else kwargs['kv']
+ assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}"
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]"
+ assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]"
+ device = q.device
+
+ # Handle case 3: Separate Q, K, V tensors
+ elif num_all_args == 3:
+ # print("handle case 3")
+ q = args[0] if len(args) > 0 else kwargs['q']
+ k = args[1] if len(args) > 1 else kwargs['k']
+ v = args[2] if len(args) > 2 else kwargs['v']
+ assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}"
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]"
+ assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]"
+ assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]"
+ device = q.device
+
+ # print("no problem")
+ # Use xformers backend
+ if BACKEND == 'xformers':
+ if num_all_args == 1:
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor into separate Q, K, V
+ elif num_all_args == 2:
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ out = xops.memory_efficient_attention(q, k, v)
+
+ # Use Flash Attention backend
+ elif BACKEND == 'flash_attn':
+ # print("flash_attn")
+ if num_all_args == 1:
+ # print("case 1")
+ out = flash_attn.flash_attn_qkvpacked_func(qkv) # Use packed QKV format
+ elif num_all_args == 2:
+ # print("case 2")
+ out = flash_attn.flash_attn_kvpacked_func(q, kv) # Use packed KV format with separate Q
+ elif num_all_args == 3:
+ # print("case 3")
+ out = flash_attn.flash_attn_func(q, k, v) # Use fully separate Q, K, V
+
+ # Use PyTorch's native scaled dot product attention
+ elif BACKEND == 'sdpa':
+ # print("sdpa")
+ if num_all_args == 1:
+ # print("case 1")
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor
+ elif num_all_args == 2:
+ # print("case 2")
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ # PyTorch's SDPA expects tensors in format [N, H, L, C]
+ q = q.permute(0, 2, 1, 3) # [N, H, L, C]
+ k = k.permute(0, 2, 1, 3) # [N, H, L, C]
+ v = v.permute(0, 2, 1, 3) # [N, H, L, C]
+ out = sdpa(q, k, v) # [N, H, L, C]
+ out = out.permute(0, 2, 1, 3) # Convert back to [N, L, H, C]
+
+ # Use naive implementation
+ elif BACKEND == 'naive':
+ # print("naive")
+ if num_all_args == 1:
+ # print("case 1")
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor
+ elif num_all_args == 2:
+ # print("case 2")
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ out = _naive_sdpa(q, k, v) # Call the naive implementation
+
+ else:
+ raise ValueError(f"Unknown attention module: {BACKEND}")
+ # print("no problem")
+ return out
diff --git a/OmniPart/modules/part_synthesis/modules/attention/modules.py b/OmniPart/modules/part_synthesis/modules/attention/modules.py
new file mode 100644
index 0000000..3eb46c1
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/attention/modules.py
@@ -0,0 +1,256 @@
+"""
+This file contains attention mechanism implementations for the TRELLIS framework.
+It provides various components needed for building transformer-based architectures,
+including custom normalization, rotary position embeddings, and attention modules
+with different configurations and optimizations.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .full_attn import scaled_dot_product_attention
+
+
+class MultiHeadRMSNorm(nn.Module):
+ """
+ Multi-head RMS normalization layer that applies per-head normalization.
+ This helps stabilize attention computations by normalizing query and key vectors.
+
+ Args:
+ dim (int): The dimensionality of each head
+ heads (int): Number of attention heads
+ """
+ def __init__(self, dim: int, heads: int):
+ super().__init__()
+ self.scale = dim ** 0.5
+ self.gamma = nn.Parameter(torch.ones(heads, dim))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Apply RMS normalization along the last dimension.
+
+ Args:
+ x (torch.Tensor): Input tensor of shape [..., dim]
+
+ Returns:
+ torch.Tensor: Normalized tensor with the same shape
+ """
+ return (F.normalize(x.float(), dim = -1) * self.gamma * self.scale).to(x.dtype)
+
+
+class RotaryPositionEmbedder(nn.Module):
+ """
+ Implements Rotary Position Embedding (RoPE), which encodes position information
+ into the query and key tensors through a rotation-based approach.
+
+ Args:
+ hidden_size (int): Size of the hidden dimension
+ in_channels (int): Number of input channels, defaults to 3
+ """
+ def __init__(self, hidden_size: int, in_channels: int = 3):
+ super().__init__()
+ assert hidden_size % 2 == 0, "Hidden size must be divisible by 2"
+ self.hidden_size = hidden_size
+ self.in_channels = in_channels
+ self.freq_dim = hidden_size // in_channels // 2
+ # Calculate frequency bands on a log scale
+ self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim
+ self.freqs = 1.0 / (10000 ** self.freqs)
+
+ def _get_phases(self, indices: torch.Tensor) -> torch.Tensor:
+ """
+ Compute phase shifts based on position indices.
+
+ Args:
+ indices (torch.Tensor): Position indices
+
+ Returns:
+ torch.Tensor: Complex tensor containing phase information
+ """
+ self.freqs = self.freqs.to(indices.device)
+ phases = torch.outer(indices, self.freqs)
+ phases = torch.polar(torch.ones_like(phases), phases)
+ return phases
+
+ def _rotary_embedding(self, x: torch.Tensor, phases: torch.Tensor) -> torch.Tensor:
+ """
+ Apply rotary embeddings to the input tensor.
+
+ Args:
+ x (torch.Tensor): Input tensor
+ phases (torch.Tensor): Phase tensor from _get_phases
+
+ Returns:
+ torch.Tensor: Tensor with rotary embeddings applied
+ """
+ x_complex = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2))
+ x_rotated = x_complex * phases
+ x_embed = torch.view_as_real(x_rotated).reshape(*x_rotated.shape[:-1], -1).to(x.dtype)
+ return x_embed
+
+ def forward(self, q: torch.Tensor, k: torch.Tensor, indices: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Apply rotary position embeddings to query and key tensors.
+
+ Args:
+ q (torch.Tensor): [..., N, D] tensor of queries
+ k (torch.Tensor): [..., N, D] tensor of keys
+ indices (torch.Tensor): [..., N, C] tensor of spatial positions. If None,
+ sequential indices will be used.
+
+ Returns:
+ Tuple[torch.Tensor, torch.Tensor]: Position-encoded query and key tensors
+ """
+ if indices is None:
+ indices = torch.arange(q.shape[-2], device=q.device)
+ if len(q.shape) > 2:
+ indices = indices.unsqueeze(0).expand(q.shape[:-2] + (-1,))
+
+ phases = self._get_phases(indices.reshape(-1)).reshape(*indices.shape[:-1], -1)
+ if phases.shape[1] < self.hidden_size // 2:
+ phases = torch.cat([phases, torch.polar(
+ torch.ones(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device),
+ torch.zeros(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device)
+ )], dim=-1)
+ q_embed = self._rotary_embedding(q, phases)
+ k_embed = self._rotary_embedding(k, phases)
+ return q_embed, k_embed
+
+
+class MultiHeadAttention(nn.Module):
+ """
+ Flexible multi-head attention implementation supporting both self-attention
+ and cross-attention with various optimizations.
+
+ Args:
+ channels (int): Number of input/output channels
+ num_heads (int): Number of attention heads
+ ctx_channels (Optional[int]): Number of context channels for cross-attention
+ type (str): Type of attention, either "self" or "cross"
+ attn_mode (str): Attention computation mode, either "full" or "windowed"
+ window_size (Optional[int]): Size of attention window if windowed mode is used
+ shift_window (Optional[Tuple[int, int, int]]): Shift amount for windowed attention
+ qkv_bias (bool): Whether to include bias in QKV projections
+ use_rope (bool): Whether to use rotary position embeddings
+ qk_rms_norm (bool): Whether to apply RMS normalization to Q and K
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ ctx_channels: Optional[int]=None,
+ type: Literal["self", "cross"] = "self",
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ qkv_bias: bool = True,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ super().__init__()
+ assert channels % num_heads == 0
+ assert type in ["self", "cross"], f"Invalid attention type: {type}"
+ assert attn_mode in ["full", "windowed"], f"Invalid attention mode: {attn_mode}"
+ assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention"
+
+ if attn_mode == "windowed":
+ raise NotImplementedError("Windowed attention is not yet implemented")
+
+ self.channels = channels
+ self.head_dim = channels // num_heads
+ self.ctx_channels = ctx_channels if ctx_channels is not None else channels
+ self.num_heads = num_heads
+ self._type = type
+ self.attn_mode = attn_mode
+ self.window_size = window_size
+ self.shift_window = shift_window
+ self.use_rope = use_rope
+ self.qk_rms_norm = qk_rms_norm
+
+ # Initialize projection layers based on attention type
+ if self._type == "self":
+ # For self-attention, create a single QKV projection
+ self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias)
+ else:
+ # For cross-attention, create separate projections for query and key-value
+ self.to_q = nn.Linear(channels, channels, bias=qkv_bias)
+ self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias)
+
+ # Optional RMS normalization for stabilizing attention
+ if self.qk_rms_norm:
+ self.q_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads)
+ self.k_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads)
+
+ # Output projection
+ self.to_out = nn.Linear(channels, channels)
+
+ # Optional rotary position embeddings
+ if use_rope:
+ self.rope = RotaryPositionEmbedder(channels)
+
+ def forward(self, x: torch.Tensor, context: Optional[torch.Tensor] = None, indices: Optional[torch.Tensor] = None) -> torch.Tensor:
+ """
+ Apply multi-head attention to the input tensor.
+
+ Args:
+ x (torch.Tensor): Input tensor of shape [B, L, C]
+ context (Optional[torch.Tensor]): Context tensor for cross-attention
+ indices (Optional[torch.Tensor]): Position indices for rotary embeddings
+
+ Returns:
+ torch.Tensor: Output tensor of shape [B, L, C]
+ """
+ B, L, C = x.shape
+ if self._type == "self":
+ # Self-attention path
+ qkv = self.to_qkv(x)
+ qkv = qkv.reshape(B, L, 3, self.num_heads, -1)
+ if self.use_rope:
+ # Apply rotary position embeddings if enabled
+ q, k, v = qkv.unbind(dim=2)
+ q, k = self.rope(q, k, indices)
+ qkv = torch.stack([q, k, v], dim=2)
+ if self.attn_mode == "full":
+ if self.qk_rms_norm:
+ # Apply RMS normalization to queries and keys if enabled
+ q, k, v = qkv.unbind(dim=2)
+ q = self.q_rms_norm(q)
+ k = self.k_rms_norm(k)
+ h = scaled_dot_product_attention(q, k, v)
+ else:
+ # Standard attention with combined QKV tensor
+ h = scaled_dot_product_attention(qkv)
+ elif self.attn_mode == "windowed":
+ raise NotImplementedError("Windowed attention is not yet implemented")
+ else:
+
+ # Cross-attention path
+ Lkv = context.shape[1]
+ q = self.to_q(x)
+ # print(f"context shape: {context.shape}")
+ kv = self.to_kv(context)
+ # print("reshape kv")
+ q = q.reshape(B, L, self.num_heads, -1)
+ kv = kv.reshape(B, Lkv, 2, self.num_heads, -1)
+ # print("unbind kv")
+ if self.qk_rms_norm:
+ # print("qk_rms_norm")
+ # Apply RMS normalization to queries and keys if enabled
+ q = self.q_rms_norm(q)
+ k, v = kv.unbind(dim=2)
+ # print("unbind kv2")
+ k = self.k_rms_norm(k)
+ # print("unbind kv3")
+ h = scaled_dot_product_attention(q, k, v)
+ # print("unbind kv4")
+ else:
+ # Standard cross-attention
+ # print("unbind kv2")
+ # print(kv.shape)
+ h = scaled_dot_product_attention(q, kv)
+ # print("unbind kv3")
+ # Reshape and project back to the original dimension
+ h = h.reshape(B, L, -1)
+ h = self.to_out(h)
+ return h
diff --git a/OmniPart/modules/part_synthesis/modules/norm.py b/OmniPart/modules/part_synthesis/modules/norm.py
new file mode 100644
index 0000000..0903572
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/norm.py
@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+
+
+class LayerNorm32(nn.LayerNorm):
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return super().forward(x.float()).type(x.dtype)
+
+
+class GroupNorm32(nn.GroupNorm):
+ """
+ A GroupNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return super().forward(x.float()).type(x.dtype)
+
+
+class ChannelLayerNorm32(LayerNorm32):
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ DIM = x.dim()
+ x = x.permute(0, *range(2, DIM), 1).contiguous()
+ x = super().forward(x)
+ x = x.permute(0, DIM-1, *range(1, DIM-1)).contiguous()
+ return x
+
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/__init__.py b/OmniPart/modules/part_synthesis/modules/sparse/__init__.py
new file mode 100644
index 0000000..726756c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/__init__.py
@@ -0,0 +1,102 @@
+from typing import *
+
+BACKEND = 'spconv'
+DEBUG = False
+ATTN = 'flash_attn'
+
+def __from_env():
+ import os
+
+ global BACKEND
+ global DEBUG
+ global ATTN
+
+ env_sparse_backend = os.environ.get('SPARSE_BACKEND')
+ env_sparse_debug = os.environ.get('SPARSE_DEBUG')
+ env_sparse_attn = os.environ.get('SPARSE_ATTN_BACKEND')
+ if env_sparse_attn is None:
+ env_sparse_attn = os.environ.get('ATTN_BACKEND')
+
+ if env_sparse_backend is not None and env_sparse_backend in ['spconv', 'torchsparse']:
+ BACKEND = env_sparse_backend
+ if env_sparse_debug is not None:
+ DEBUG = env_sparse_debug == '1'
+ if env_sparse_attn is not None and env_sparse_attn in ['xformers', 'flash_attn']:
+ ATTN = env_sparse_attn
+
+ print(f"[SPARSE] Backend: {BACKEND}, Attention: {ATTN}")
+
+
+__from_env()
+
+
+def set_backend(backend: Literal['spconv', 'torchsparse']):
+ global BACKEND
+ BACKEND = backend
+
+def set_debug(debug: bool):
+ global DEBUG
+ DEBUG = debug
+
+def set_attn(attn: Literal['xformers', 'flash_attn']):
+ global ATTN
+ ATTN = attn
+
+
+import importlib
+
+__attributes = {
+ 'SparseTensor': 'basic',
+ 'sparse_batch_broadcast': 'basic',
+ 'sparse_batch_op': 'basic',
+ 'sparse_cat': 'basic',
+ 'sparse_unbind': 'basic',
+ 'SparseGroupNorm': 'norm',
+ 'SparseLayerNorm': 'norm',
+ 'SparseGroupNorm32': 'norm',
+ 'SparseLayerNorm32': 'norm',
+ 'SparseReLU': 'nonlinearity',
+ 'SparseSiLU': 'nonlinearity',
+ 'SparseGELU': 'nonlinearity',
+ 'SparseActivation': 'nonlinearity',
+ 'SparseLinear': 'linear',
+ 'sparse_scaled_dot_product_attention': 'attention',
+ 'SerializeMode': 'attention',
+ 'sparse_serialized_scaled_dot_product_self_attention': 'attention',
+ 'sparse_windowed_scaled_dot_product_self_attention': 'attention',
+ 'SparseMultiHeadAttention': 'attention',
+ 'SparseConv3d': 'conv',
+ 'SparseInverseConv3d': 'conv',
+ 'SparseDownsample': 'spatial',
+ 'SparseUpsample': 'spatial',
+ 'SparseSubdivide' : 'spatial'
+}
+
+__submodules = ['transformer']
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .basic import *
+ from .norm import *
+ from .nonlinearity import *
+ from .linear import *
+ from .attention import *
+ from .conv import *
+ from .spatial import *
+ import transformer
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/attention/__init__.py b/OmniPart/modules/part_synthesis/modules/sparse/attention/__init__.py
new file mode 100644
index 0000000..32b3c2c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/attention/__init__.py
@@ -0,0 +1,4 @@
+from .full_attn import *
+from .serialized_attn import *
+from .windowed_attn import *
+from .modules import *
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/attention/full_attn.py b/OmniPart/modules/part_synthesis/modules/sparse/attention/full_attn.py
new file mode 100644
index 0000000..e9e27ae
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/attention/full_attn.py
@@ -0,0 +1,215 @@
+from typing import *
+import torch
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_scaled_dot_product_attention',
+]
+
+
+@overload
+def sparse_scaled_dot_product_attention(qkv: SparseTensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): A [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, kv: Union[SparseTensor, torch.Tensor]) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, C] sparse tensor containing Qs.
+ kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor or a [N, L, 2, H, C] dense tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: torch.Tensor, kv: SparseTensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, L, H, C] dense tensor containing Qs.
+ kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, k: SparseTensor, v: SparseTensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs.
+ k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks.
+ v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs.
+
+ Note:
+ k and v are assumed to have the same coordinate map.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, k: torch.Tensor, v: torch.Tensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs.
+ k (torch.Tensor): A [N, L, H, Ci] dense tensor containing Ks.
+ v (torch.Tensor): A [N, L, H, Co] dense tensor containing Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: torch.Tensor, k: SparseTensor, v: SparseTensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, Ci] dense tensor containing Qs.
+ k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks.
+ v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs.
+ """
+ ...
+
+def sparse_scaled_dot_product_attention(*args, **kwargs):
+ arg_names_dict = {
+ 1: ['qkv'],
+ 2: ['q', 'kv'],
+ 3: ['q', 'k', 'v']
+ }
+ num_all_args = len(args) + len(kwargs)
+ assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3"
+ for key in arg_names_dict[num_all_args][len(args):]:
+ assert key in kwargs, f"Missing argument {key}"
+
+ if num_all_args == 1:
+ qkv = args[0] if len(args) > 0 else kwargs['qkv']
+ assert isinstance(qkv, SparseTensor), f"qkv must be a SparseTensor, got {type(qkv)}"
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+ device = qkv.device
+
+ s = qkv
+ q_seqlen = [qkv.layout[i].stop - qkv.layout[i].start for i in range(qkv.shape[0])]
+ kv_seqlen = q_seqlen
+ qkv = qkv.feats # [T, 3, H, C]
+
+ elif num_all_args == 2:
+ q = args[0] if len(args) > 0 else kwargs['q']
+ kv = args[1] if len(args) > 1 else kwargs['kv']
+ assert isinstance(q, SparseTensor) and isinstance(kv, (SparseTensor, torch.Tensor)) or \
+ isinstance(q, torch.Tensor) and isinstance(kv, SparseTensor), \
+ f"Invalid types, got {type(q)} and {type(kv)}"
+ assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}"
+ device = q.device
+
+ if isinstance(q, SparseTensor):
+ assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, C]"
+ s = q
+ q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])]
+ q = q.feats # [T_Q, H, C]
+ else:
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]"
+ s = None
+ N, L, H, C = q.shape
+ q_seqlen = [L] * N
+ q = q.reshape(N * L, H, C) # [T_Q, H, C]
+
+ if isinstance(kv, SparseTensor):
+ assert len(kv.shape) == 4 and kv.shape[1] == 2, f"Invalid shape for kv, got {kv.shape}, expected [N, *, 2, H, C]"
+ kv_seqlen = [kv.layout[i].stop - kv.layout[i].start for i in range(kv.shape[0])]
+ kv = kv.feats # [T_KV, 2, H, C]
+ else:
+ assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]"
+ N, L, _, H, C = kv.shape
+ kv_seqlen = [L] * N
+ kv = kv.reshape(N * L, 2, H, C) # [T_KV, 2, H, C]
+
+ elif num_all_args == 3:
+ q = args[0] if len(args) > 0 else kwargs['q']
+ k = args[1] if len(args) > 1 else kwargs['k']
+ v = args[2] if len(args) > 2 else kwargs['v']
+ assert isinstance(q, SparseTensor) and isinstance(k, (SparseTensor, torch.Tensor)) and type(k) == type(v) or \
+ isinstance(q, torch.Tensor) and isinstance(k, SparseTensor) and isinstance(v, SparseTensor), \
+ f"Invalid types, got {type(q)}, {type(k)}, and {type(v)}"
+ assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}"
+ device = q.device
+
+ if isinstance(q, SparseTensor):
+ assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, Ci]"
+ s = q
+ q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])]
+ q = q.feats # [T_Q, H, Ci]
+ else:
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]"
+ s = None
+ N, L, H, CI = q.shape
+ q_seqlen = [L] * N
+ q = q.reshape(N * L, H, CI) # [T_Q, H, Ci]
+
+ if isinstance(k, SparseTensor):
+ assert len(k.shape) == 3, f"Invalid shape for k, got {k.shape}, expected [N, *, H, Ci]"
+ assert len(v.shape) == 3, f"Invalid shape for v, got {v.shape}, expected [N, *, H, Co]"
+ kv_seqlen = [k.layout[i].stop - k.layout[i].start for i in range(k.shape[0])]
+ k = k.feats # [T_KV, H, Ci]
+ v = v.feats # [T_KV, H, Co]
+ else:
+ assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]"
+ assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]"
+ N, L, H, CI, CO = *k.shape, v.shape[-1]
+ kv_seqlen = [L] * N
+ k = k.reshape(N * L, H, CI) # [T_KV, H, Ci]
+ v = v.reshape(N * L, H, CO) # [T_KV, H, Co]
+
+ if DEBUG:
+ if s is not None:
+ for i in range(s.shape[0]):
+ assert (s.coords[s.layout[i]] == i).all(), f"SparseScaledDotProductSelfAttention: batch index mismatch"
+ if num_all_args in [2, 3]:
+ assert q.shape[:2] == [1, sum(q_seqlen)], f"SparseScaledDotProductSelfAttention: q shape mismatch"
+ if num_all_args == 3:
+ assert k.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: k shape mismatch"
+ assert v.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: v shape mismatch"
+
+ if ATTN == 'xformers':
+ if num_all_args == 1:
+ q, k, v = qkv.unbind(dim=1)
+ elif num_all_args == 2:
+ k, v = kv.unbind(dim=1)
+ q = q.unsqueeze(0)
+ k = k.unsqueeze(0)
+ v = v.unsqueeze(0)
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(q_seqlen, kv_seqlen)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0]
+ elif ATTN == 'flash_attn':
+ cu_seqlens_q = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(q_seqlen), dim=0)]).int().to(device)
+ if num_all_args in [2, 3]:
+ cu_seqlens_kv = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(kv_seqlen), dim=0)]).int().to(device)
+ if num_all_args == 1:
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv, cu_seqlens_q, max(q_seqlen))
+ elif num_all_args == 2:
+ out = flash_attn.flash_attn_varlen_kvpacked_func(q, kv, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen))
+ elif num_all_args == 3:
+ out = flash_attn.flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen))
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+ if s is not None:
+ return s.replace(out)
+ else:
+ return out.reshape(N, L, H, -1)
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/attention/modules.py b/OmniPart/modules/part_synthesis/modules/sparse/attention/modules.py
new file mode 100644
index 0000000..5d2fe78
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/attention/modules.py
@@ -0,0 +1,139 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .. import SparseTensor
+from .full_attn import sparse_scaled_dot_product_attention
+from .serialized_attn import SerializeMode, sparse_serialized_scaled_dot_product_self_attention
+from .windowed_attn import sparse_windowed_scaled_dot_product_self_attention
+from ...attention import RotaryPositionEmbedder
+
+
+class SparseMultiHeadRMSNorm(nn.Module):
+ def __init__(self, dim: int, heads: int):
+ super().__init__()
+ self.scale = dim ** 0.5
+ self.gamma = nn.Parameter(torch.ones(heads, dim))
+
+ def forward(self, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]:
+ x_type = x.dtype
+ x = x.float()
+ if isinstance(x, SparseTensor):
+ x = x.replace(F.normalize(x.feats, dim=-1))
+ else:
+ x = F.normalize(x, dim=-1)
+ return (x * self.gamma * self.scale).to(x_type)
+
+
+class SparseMultiHeadAttention(nn.Module):
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ ctx_channels: Optional[int] = None,
+ type: Literal["self", "cross"] = "self",
+ attn_mode: Literal["full", "serialized", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ qkv_bias: bool = True,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ super().__init__()
+ assert channels % num_heads == 0
+ assert type in ["self", "cross"], f"Invalid attention type: {type}"
+ assert attn_mode in ["full", "serialized", "windowed"], f"Invalid attention mode: {attn_mode}"
+ assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention"
+ assert type == "self" or use_rope is False, "Rotary position embeddings only supported for self-attention"
+ self.channels = channels
+ self.ctx_channels = ctx_channels if ctx_channels is not None else channels
+ self.num_heads = num_heads
+ self._type = type
+ self.attn_mode = attn_mode
+ self.window_size = window_size
+ self.shift_sequence = shift_sequence
+ self.shift_window = shift_window
+ self.serialize_mode = serialize_mode
+ self.use_rope = use_rope
+ self.qk_rms_norm = qk_rms_norm
+
+ if self._type == "self":
+ self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias)
+ else:
+ self.to_q = nn.Linear(channels, channels, bias=qkv_bias)
+ self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias)
+
+ if self.qk_rms_norm:
+ self.q_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads)
+ self.k_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads)
+
+ self.to_out = nn.Linear(channels, channels)
+
+ if use_rope:
+ self.rope = RotaryPositionEmbedder(channels)
+
+ @staticmethod
+ def _linear(module: nn.Linear, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ return x.replace(module(x.feats))
+ else:
+ return module(x)
+
+ @staticmethod
+ def _reshape_chs(x: Union[SparseTensor, torch.Tensor], shape: Tuple[int, ...]) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ return x.reshape(*shape)
+ else:
+ return x.reshape(*x.shape[:2], *shape)
+
+ def _fused_pre(self, x: Union[SparseTensor, torch.Tensor], num_fused: int) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ x_feats = x.feats.unsqueeze(0)
+ else:
+ x_feats = x
+ x_feats = x_feats.reshape(*x_feats.shape[:2], num_fused, self.num_heads, -1)
+ return x.replace(x_feats.squeeze(0)) if isinstance(x, SparseTensor) else x_feats
+
+ def _rope(self, qkv: SparseTensor) -> SparseTensor:
+ q, k, v = qkv.feats.unbind(dim=1) # [T, H, C]
+ q, k = self.rope(q, k, qkv.coords[:, 1:])
+ qkv = qkv.replace(torch.stack([q, k, v], dim=1))
+ return qkv
+
+ def forward(self, x: Union[SparseTensor, torch.Tensor], context: Optional[Union[SparseTensor, torch.Tensor]] = None) -> Union[SparseTensor, torch.Tensor]:
+ if self._type == "self":
+ qkv = self._linear(self.to_qkv, x)
+ qkv = self._fused_pre(qkv, num_fused=3)
+ if self.use_rope:
+ qkv = self._rope(qkv)
+ if self.qk_rms_norm:
+ q, k, v = qkv.unbind(dim=1)
+ q = self.q_rms_norm(q)
+ k = self.k_rms_norm(k)
+ qkv = qkv.replace(torch.stack([q.feats, k.feats, v.feats], dim=1))
+ if self.attn_mode == "full":
+ h = sparse_scaled_dot_product_attention(qkv)
+ elif self.attn_mode == "serialized":
+ h = sparse_serialized_scaled_dot_product_self_attention(
+ qkv, self.window_size, serialize_mode=self.serialize_mode, shift_sequence=self.shift_sequence, shift_window=self.shift_window
+ )
+ elif self.attn_mode == "windowed":
+ h = sparse_windowed_scaled_dot_product_self_attention(
+ qkv, self.window_size, shift_window=self.shift_window
+ )
+ else:
+ q = self._linear(self.to_q, x)
+ q = self._reshape_chs(q, (self.num_heads, -1))
+ kv = self._linear(self.to_kv, context)
+ kv = self._fused_pre(kv, num_fused=2)
+ if self.qk_rms_norm:
+ q = self.q_rms_norm(q)
+ k, v = kv.unbind(dim=1)
+ k = self.k_rms_norm(k)
+ kv = kv.replace(torch.stack([k.feats, v.feats], dim=1))
+ h = sparse_scaled_dot_product_attention(q, kv)
+ h = self._reshape_chs(h, (-1,))
+ h = self._linear(self.to_out, h)
+ return h
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/attention/serialized_attn.py b/OmniPart/modules/part_synthesis/modules/sparse/attention/serialized_attn.py
new file mode 100644
index 0000000..5950b75
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/attention/serialized_attn.py
@@ -0,0 +1,193 @@
+from typing import *
+from enum import Enum
+import torch
+import math
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_serialized_scaled_dot_product_self_attention',
+]
+
+
+class SerializeMode(Enum):
+ Z_ORDER = 0
+ Z_ORDER_TRANSPOSED = 1
+ HILBERT = 2
+ HILBERT_TRANSPOSED = 3
+
+
+SerializeModes = [
+ SerializeMode.Z_ORDER,
+ SerializeMode.Z_ORDER_TRANSPOSED,
+ SerializeMode.HILBERT,
+ SerializeMode.HILBERT_TRANSPOSED
+]
+
+
+def calc_serialization(
+ tensor: SparseTensor,
+ window_size: int,
+ serialize_mode: SerializeMode = SerializeMode.Z_ORDER,
+ shift_sequence: int = 0,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> Tuple[torch.Tensor, torch.Tensor, List[int]]:
+ """
+ Calculate serialization and partitioning for a set of coordinates.
+
+ Args:
+ tensor (SparseTensor): The input tensor.
+ window_size (int): The window size to use.
+ serialize_mode (SerializeMode): The serialization mode to use.
+ shift_sequence (int): The shift of serialized sequence.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+
+ Returns:
+ (torch.Tensor, torch.Tensor): Forwards and backwards indices.
+ """
+ fwd_indices = []
+ bwd_indices = []
+ seq_lens = []
+ seq_batch_indices = []
+ offsets = [0]
+
+ if 'vox2seq' not in globals():
+ import vox2seq
+
+ # Serialize the input
+ serialize_coords = tensor.coords[:, 1:].clone()
+ serialize_coords += torch.tensor(shift_window, dtype=torch.int32, device=tensor.device).reshape(1, 3)
+ if serialize_mode == SerializeMode.Z_ORDER:
+ code = vox2seq.encode(serialize_coords, mode='z_order', permute=[0, 1, 2])
+ elif serialize_mode == SerializeMode.Z_ORDER_TRANSPOSED:
+ code = vox2seq.encode(serialize_coords, mode='z_order', permute=[1, 0, 2])
+ elif serialize_mode == SerializeMode.HILBERT:
+ code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[0, 1, 2])
+ elif serialize_mode == SerializeMode.HILBERT_TRANSPOSED:
+ code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[1, 0, 2])
+ else:
+ raise ValueError(f"Unknown serialize mode: {serialize_mode}")
+
+ for bi, s in enumerate(tensor.layout):
+ num_points = s.stop - s.start
+ num_windows = (num_points + window_size - 1) // window_size
+ valid_window_size = num_points / num_windows
+ to_ordered = torch.argsort(code[s.start:s.stop])
+ if num_windows == 1:
+ fwd_indices.append(to_ordered)
+ bwd_indices.append(torch.zeros_like(to_ordered).scatter_(0, to_ordered, torch.arange(num_points, device=tensor.device)))
+ fwd_indices[-1] += s.start
+ bwd_indices[-1] += offsets[-1]
+ seq_lens.append(num_points)
+ seq_batch_indices.append(bi)
+ offsets.append(offsets[-1] + seq_lens[-1])
+ else:
+ # Partition the input
+ offset = 0
+ mids = [(i + 0.5) * valid_window_size + shift_sequence for i in range(num_windows)]
+ split = [math.floor(i * valid_window_size + shift_sequence) for i in range(num_windows + 1)]
+ bwd_index = torch.zeros((num_points,), dtype=torch.int64, device=tensor.device)
+ for i in range(num_windows):
+ mid = mids[i]
+ valid_start = split[i]
+ valid_end = split[i + 1]
+ padded_start = math.floor(mid - 0.5 * window_size)
+ padded_end = padded_start + window_size
+ fwd_indices.append(to_ordered[torch.arange(padded_start, padded_end, device=tensor.device) % num_points])
+ offset += valid_start - padded_start
+ bwd_index.scatter_(0, fwd_indices[-1][valid_start-padded_start:valid_end-padded_start], torch.arange(offset, offset + valid_end - valid_start, device=tensor.device))
+ offset += padded_end - valid_start
+ fwd_indices[-1] += s.start
+ seq_lens.extend([window_size] * num_windows)
+ seq_batch_indices.extend([bi] * num_windows)
+ bwd_indices.append(bwd_index + offsets[-1])
+ offsets.append(offsets[-1] + num_windows * window_size)
+
+ fwd_indices = torch.cat(fwd_indices)
+ bwd_indices = torch.cat(bwd_indices)
+
+ return fwd_indices, bwd_indices, seq_lens, seq_batch_indices
+
+
+def sparse_serialized_scaled_dot_product_self_attention(
+ qkv: SparseTensor,
+ window_size: int,
+ serialize_mode: SerializeMode = SerializeMode.Z_ORDER,
+ shift_sequence: int = 0,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> SparseTensor:
+ """
+ Apply serialized scaled dot product self attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ window_size (int): The window size to use.
+ serialize_mode (SerializeMode): The serialization mode to use.
+ shift_sequence (int): The shift of serialized sequence.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+ shift (int): The shift to use.
+ """
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+
+ serialization_spatial_cache_name = f'serialization_{serialize_mode}_{window_size}_{shift_sequence}_{shift_window}'
+ serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name)
+ if serialization_spatial_cache is None:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_serialization(qkv, window_size, serialize_mode, shift_sequence, shift_window)
+ qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices))
+ else:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache
+
+ M = fwd_indices.shape[0]
+ T = qkv.feats.shape[0]
+ H = qkv.feats.shape[2]
+ C = qkv.feats.shape[3]
+
+ qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C]
+
+ if DEBUG:
+ start = 0
+ qkv_coords = qkv.coords[fwd_indices]
+ for i in range(len(seq_lens)):
+ assert (qkv_coords[start:start+seq_lens[i], 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch"
+ start += seq_lens[i]
+
+ if all([seq_len == window_size for seq_len in seq_lens]):
+ B = len(seq_lens)
+ N = window_size
+ qkv_feats = qkv_feats.reshape(B, N, 3, H, C)
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C]
+ out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C]
+ elif ATTN == 'flash_attn':
+ out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C]
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+ out = out.reshape(B * N, H, C) # [M, H, C]
+ else:
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=1) # [M, H, C]
+ q = q.unsqueeze(0) # [1, M, H, C]
+ k = k.unsqueeze(0) # [1, M, H, C]
+ v = v.unsqueeze(0) # [1, M, H, C]
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C]
+ elif ATTN == 'flash_attn':
+ cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \
+ .to(qkv.device).int()
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C]
+
+ out = out[bwd_indices] # [T, H, C]
+
+ if DEBUG:
+ qkv_coords = qkv_coords[bwd_indices]
+ assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch"
+
+ return qkv.replace(out)
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/attention/windowed_attn.py b/OmniPart/modules/part_synthesis/modules/sparse/attention/windowed_attn.py
new file mode 100644
index 0000000..cd642c5
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/attention/windowed_attn.py
@@ -0,0 +1,135 @@
+from typing import *
+import torch
+import math
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_windowed_scaled_dot_product_self_attention',
+]
+
+
+def calc_window_partition(
+ tensor: SparseTensor,
+ window_size: Union[int, Tuple[int, ...]],
+ shift_window: Union[int, Tuple[int, ...]] = 0
+) -> Tuple[torch.Tensor, torch.Tensor, List[int], List[int]]:
+ """
+ Calculate serialization and partitioning for a set of coordinates.
+
+ Args:
+ tensor (SparseTensor): The input tensor.
+ window_size (int): The window size to use.
+ shift_window (Tuple[int, ...]): The shift of serialized coordinates.
+
+ Returns:
+ (torch.Tensor): Forwards indices.
+ (torch.Tensor): Backwards indices.
+ (List[int]): Sequence lengths.
+ (List[int]): Sequence batch indices.
+ """
+ DIM = tensor.coords.shape[1] - 1
+ shift_window = (shift_window,) * DIM if isinstance(shift_window, int) else shift_window
+ window_size = (window_size,) * DIM if isinstance(window_size, int) else window_size
+ shifted_coords = tensor.coords.clone().detach()
+ shifted_coords[:, 1:] += torch.tensor(shift_window, device=tensor.device, dtype=torch.int32).unsqueeze(0)
+
+ MAX_COORDS = shifted_coords[:, 1:].max(dim=0).values.tolist()
+ NUM_WINDOWS = [math.ceil((mc + 1) / ws) for mc, ws in zip(MAX_COORDS, window_size)]
+ OFFSET = torch.cumprod(torch.tensor([1] + NUM_WINDOWS[::-1]), dim=0).tolist()[::-1]
+
+ shifted_coords[:, 1:] //= torch.tensor(window_size, device=tensor.device, dtype=torch.int32).unsqueeze(0)
+ shifted_indices = (shifted_coords * torch.tensor(OFFSET, device=tensor.device, dtype=torch.int32).unsqueeze(0)).sum(dim=1)
+ fwd_indices = torch.argsort(shifted_indices)
+ bwd_indices = torch.empty_like(fwd_indices)
+ bwd_indices[fwd_indices] = torch.arange(fwd_indices.shape[0], device=tensor.device)
+ seq_lens = torch.bincount(shifted_indices)
+ seq_batch_indices = torch.arange(seq_lens.shape[0], device=tensor.device, dtype=torch.int32) // OFFSET[0]
+ mask = seq_lens != 0
+ seq_lens = seq_lens[mask].tolist()
+ seq_batch_indices = seq_batch_indices[mask].tolist()
+
+ return fwd_indices, bwd_indices, seq_lens, seq_batch_indices
+
+
+def sparse_windowed_scaled_dot_product_self_attention(
+ qkv: SparseTensor,
+ window_size: int,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> SparseTensor:
+ """
+ Apply windowed scaled dot product self attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ window_size (int): The window size to use.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+ shift (int): The shift to use.
+ """
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+
+ serialization_spatial_cache_name = f'window_partition_{window_size}_{shift_window}'
+ serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name)
+ if serialization_spatial_cache is None:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_window_partition(qkv, window_size, shift_window)
+ qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices))
+ else:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache
+
+ M = fwd_indices.shape[0]
+ T = qkv.feats.shape[0]
+ H = qkv.feats.shape[2]
+ C = qkv.feats.shape[3]
+
+ qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C]
+
+ if DEBUG:
+ start = 0
+ qkv_coords = qkv.coords[fwd_indices]
+ for i in range(len(seq_lens)):
+ seq_coords = qkv_coords[start:start+seq_lens[i]]
+ assert (seq_coords[:, 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch"
+ assert (seq_coords[:, 1:].max(dim=0).values - seq_coords[:, 1:].min(dim=0).values < window_size).all(), \
+ f"SparseWindowedScaledDotProductSelfAttention: window size exceeded"
+ start += seq_lens[i]
+
+ if all([seq_len == window_size for seq_len in seq_lens]):
+ B = len(seq_lens)
+ N = window_size
+ qkv_feats = qkv_feats.reshape(B, N, 3, H, C)
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C]
+ out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C]
+ elif ATTN == 'flash_attn':
+ out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C]
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+ out = out.reshape(B * N, H, C) # [M, H, C]
+ else:
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=1) # [M, H, C]
+ q = q.unsqueeze(0) # [1, M, H, C]
+ k = k.unsqueeze(0) # [1, M, H, C]
+ v = v.unsqueeze(0) # [1, M, H, C]
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C]
+ elif ATTN == 'flash_attn':
+ cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \
+ .to(qkv.device).int()
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C]
+
+ out = out[bwd_indices] # [T, H, C]
+
+ if DEBUG:
+ qkv_coords = qkv_coords[bwd_indices]
+ assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch"
+
+ return qkv.replace(out)
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/basic.py b/OmniPart/modules/part_synthesis/modules/sparse/basic.py
new file mode 100644
index 0000000..f856b8a
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/basic.py
@@ -0,0 +1,691 @@
+"""
+Sparse Tensor Implementation for TRELLIS
+----------------------------------------
+
+This file implements a unified sparse tensor interface that supports multiple backends (torchsparse and spconv).
+Sparse tensors are efficient representations of tensors where most values are zero, storing only non-zero values
+and their coordinates. This is particularly useful for 3D point clouds and voxel grids in computer vision and
+robotics applications where data is naturally sparse.
+
+The main components of this file are:
+- SparseTensor: Core class providing a unified API over different sparse tensor backends
+- Utility functions for sparse tensor operations (concatenation, unbinding, broadcasting, etc.)
+- Backend-agnostic arithmetic operations for sparse tensors
+
+The implementation abstracts away backend-specific details to allow seamless switching between
+torchsparse and spconv while maintaining a consistent interface.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+from . import BACKEND, DEBUG
+SparseTensorData = None # Lazy import
+
+
+__all__ = [
+ 'SparseTensor',
+ 'sparse_batch_broadcast',
+ 'sparse_batch_op',
+ 'sparse_cat',
+ 'sparse_unbind',
+]
+
+
+class SparseTensor:
+ """
+ Sparse tensor with support for both torchsparse and spconv backends.
+
+ Parameters:
+ - feats (torch.Tensor): Features of the sparse tensor.
+ - coords (torch.Tensor): Coordinates of the sparse tensor.
+ - shape (torch.Size): Shape of the sparse tensor.
+ - layout (List[slice]): Layout of the sparse tensor for each batch
+ - data (SparseTensorData): Sparse tensor data used for convolusion
+
+ NOTE:
+ - Data corresponding to a same batch should be contiguous.
+ - Coords should be in [0, 1023]
+ """
+ @overload
+ def __init__(self, feats: torch.Tensor, coords: torch.Tensor, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ...
+
+ @overload
+ def __init__(self, data, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ...
+
+ def __init__(self, *args, **kwargs):
+ # Lazy import of sparse tensor backend to avoid circular imports and improve startup time
+ global SparseTensorData
+ if SparseTensorData is None:
+ import importlib
+ if BACKEND == 'torchsparse':
+ SparseTensorData = importlib.import_module('torchsparse').SparseTensor
+ elif BACKEND == 'spconv':
+ SparseTensorData = importlib.import_module('spconv.pytorch').SparseConvTensor
+
+ # print(SparseTensorData)
+ # exit(0)
+
+ # Determine initialization method based on arguments (method 0: from tensors, method 1: from existing data)
+ method_id = 0
+ if len(args) != 0:
+ method_id = 0 if isinstance(args[0], torch.Tensor) else 1
+ else:
+ method_id = 1 if 'data' in kwargs else 0
+
+ self.old_index = None # Placeholder for old indices, if needed
+
+ if method_id == 0:
+ # Initialize from feature and coordinate tensors
+ feats, coords, shape, layout = args + (None,) * (4 - len(args))
+ if 'feats' in kwargs:
+ feats = kwargs['feats']
+ del kwargs['feats']
+ if 'coords' in kwargs:
+ coords = kwargs['coords']
+ del kwargs['coords']
+ if 'shape' in kwargs:
+ shape = kwargs['shape']
+ del kwargs['shape']
+ if 'layout' in kwargs:
+ layout = kwargs['layout']
+ del kwargs['layout']
+
+ if shape is None:
+ shape = self.__cal_shape(feats, coords)
+ if layout is None:
+ layout = self.__cal_layout(coords, shape[0])
+
+ # Create backend-specific tensor representation
+ if BACKEND == 'torchsparse':
+ self.data = SparseTensorData(feats, coords, **kwargs)
+ elif BACKEND == 'spconv':
+ spatial_shape = list(coords.max(0)[0] + 1)[1:]
+ self.data = SparseTensorData(feats.reshape(feats.shape[0], -1), coords, spatial_shape, shape[0], **kwargs)
+ self.data._features = feats
+ elif method_id == 1:
+ # Initialize from existing sparse tensor data
+ data, shape, layout = args + (None,) * (3 - len(args))
+ if 'data' in kwargs:
+ data = kwargs['data']
+ del kwargs['data']
+ if 'shape' in kwargs:
+ shape = kwargs['shape']
+ del kwargs['shape']
+ if 'layout' in kwargs:
+ layout = kwargs['layout']
+ del kwargs['layout']
+
+ self.data = data
+ if shape is None:
+ shape = self.__cal_shape(self.feats, self.coords)
+ if layout is None:
+ layout = self.__cal_layout(self.coords, shape[0])
+
+ # Store metadata
+ self._shape = shape
+ self._layout = layout
+ self._scale = kwargs.get('scale', (1, 1, 1))
+ self._spatial_cache = kwargs.get('spatial_cache', {})
+
+ # Validate tensor properties in debug mode
+ if DEBUG:
+ try:
+ assert self.feats.shape[0] == self.coords.shape[0], f"Invalid feats shape: {self.feats.shape}, coords shape: {self.coords.shape}"
+ assert self.shape == self.__cal_shape(self.feats, self.coords), f"Invalid shape: {self.shape}"
+ assert self.layout == self.__cal_layout(self.coords, self.shape[0]), f"Invalid layout: {self.layout}"
+ for i in range(self.shape[0]):
+ assert torch.all(self.coords[self.layout[i], 0] == i), f"The data of batch {i} is not contiguous"
+ except Exception as e:
+ print('Debugging information:')
+ print(f"- Shape: {self.shape}")
+ print(f"- Layout: {self.layout}")
+ print(f"- Scale: {self._scale}")
+ print(f"- Coords: {self.coords}")
+ raise e
+
+ def __cal_shape(self, feats, coords):
+ """
+ Calculate the shape of the sparse tensor from features and coordinates.
+
+ This method determines the overall shape of the sparse tensor by examining:
+ - The batch dimension (from max coordinate value in first column + 1)
+ - The feature dimensions (from the feature tensor shape)
+
+ Args:
+ feats (torch.Tensor): Feature tensor of shape (N, C1, C2, ...)
+ coords (torch.Tensor): Coordinate tensor of shape (N, D+1) where
+ first column contains batch indices
+
+ Returns:
+ torch.Size: Shape of the sparse tensor as (batch_size, C1, C2, ...)
+ """
+ shape = []
+ # First dimension is the batch size (max batch index + 1)
+ shape.append(coords[:, 0].max().item() + 1)
+ # Remaining dimensions match the feature tensor's dimensions
+ shape.extend([*feats.shape[1:]])
+ return torch.Size(shape)
+
+ def __cal_layout(self, coords, batch_size):
+ """
+ Calculate the layout of each batch in the sparse tensor.
+
+ This method computes slice objects to efficiently index into specific batches
+ within the coordinate and feature tensors. It assumes that coordinates are
+ sorted by batch index (first column).
+
+ Algorithm:
+ 1. Count how many elements belong to each batch using bincount
+ 2. Calculate cumulative sums to find ending offsets for each batch
+ 3. Create slice objects representing the range of indices for each batch
+
+ Args:
+ coords (torch.Tensor): Coordinate tensor with first column as batch indices
+ batch_size (int): Number of batches in the sparse tensor
+
+ Returns:
+ List[slice]: List of slice objects where layout[i] indexes all elements
+ belonging to batch i
+ """
+ # Count number of points in each batch
+ seq_len = torch.bincount(coords[:, 0], minlength=batch_size)
+ # Calculate ending position of each batch
+ offset = torch.cumsum(seq_len, dim=0)
+ # Create slices for each batch from (end_prev_batch, end_current_batch)
+ layout = [slice((offset[i] - seq_len[i]).item(), offset[i].item()) for i in range(batch_size)]
+ return layout
+
+ @property
+ def shape(self) -> torch.Size:
+ """Return the shape of the sparse tensor"""
+ return self._shape
+
+ def dim(self) -> int:
+ """Return the number of dimensions of the sparse tensor"""
+ return len(self.shape)
+
+ @property
+ def layout(self) -> List[slice]:
+ """Return the layout of each batch in the sparse tensor"""
+ return self._layout
+
+ @property
+ def feats(self) -> torch.Tensor:
+ """Return the features tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ return self.data.F
+ elif BACKEND == 'spconv':
+ return self.data.features
+
+ @feats.setter
+ def feats(self, value: torch.Tensor):
+ """Set the features tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ self.data.F = value
+ elif BACKEND == 'spconv':
+ self.data.features = value
+
+ @property
+ def coords(self) -> torch.Tensor:
+ """Return the coordinates tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ return self.data.C
+ elif BACKEND == 'spconv':
+ return self.data.indices
+
+ @coords.setter
+ def coords(self, value: torch.Tensor):
+ """Set the coordinates tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ self.data.C = value
+ elif BACKEND == 'spconv':
+ self.data.indices = value
+
+ @property
+ def dtype(self):
+ """Return the data type of the sparse tensor's features"""
+ return self.feats.dtype
+
+ @property
+ def device(self):
+ """Return the device of the sparse tensor's features"""
+ return self.feats.device
+
+ @overload
+ def to(self, dtype: torch.dtype) -> 'SparseTensor': ...
+
+ @overload
+ def to(self, device: Optional[Union[str, torch.device]] = None, dtype: Optional[torch.dtype] = None) -> 'SparseTensor': ...
+
+ def to(self, *args, **kwargs) -> 'SparseTensor':
+ """
+ Move the sparse tensor to the specified device and/or change its data type.
+ Mimics the PyTorch tensor.to() method.
+ """
+ device = None
+ dtype = None
+ if len(args) == 2:
+ device, dtype = args
+ elif len(args) == 1:
+ if isinstance(args[0], torch.dtype):
+ dtype = args[0]
+ else:
+ device = args[0]
+ if 'dtype' in kwargs:
+ assert dtype is None, "to() received multiple values for argument 'dtype'"
+ dtype = kwargs['dtype']
+ if 'device' in kwargs:
+ assert device is None, "to() received multiple values for argument 'device'"
+ device = kwargs['device']
+
+ # print(self.feats)
+ # print(self.coords)
+ # print(SparseTensorData)
+ new_feats = self.feats.to(device=device, dtype=dtype)
+ new_coords = self.coords.to(device=device)
+ return self.replace(new_feats, new_coords)
+
+ def type(self, dtype):
+ """Convert the sparse tensor to the specified data type"""
+ new_feats = self.feats.type(dtype)
+ return self.replace(new_feats)
+
+ def cpu(self) -> 'SparseTensor':
+ """Move the sparse tensor to CPU memory"""
+ new_feats = self.feats.cpu()
+ new_coords = self.coords.cpu()
+ return self.replace(new_feats, new_coords)
+
+ def cuda(self) -> 'SparseTensor':
+ """Move the sparse tensor to CUDA memory"""
+ new_feats = self.feats.cuda()
+ new_coords = self.coords.cuda()
+ return self.replace(new_feats, new_coords)
+
+ def half(self) -> 'SparseTensor':
+ """Convert the sparse tensor to half precision"""
+ new_feats = self.feats.half()
+ return self.replace(new_feats)
+
+ def float(self) -> 'SparseTensor':
+ """Convert the sparse tensor to single precision"""
+ new_feats = self.feats.float()
+ return self.replace(new_feats)
+
+ def detach(self) -> 'SparseTensor':
+ """Detach the sparse tensor from the computation graph"""
+ new_coords = self.coords.detach()
+ new_feats = self.feats.detach()
+ return self.replace(new_feats, new_coords)
+
+ def dense(self) -> torch.Tensor:
+ """Convert the sparse tensor to a dense tensor representation"""
+ if BACKEND == 'torchsparse':
+ return self.data.dense()
+ elif BACKEND == 'spconv':
+ return self.data.dense()
+
+ def reshape(self, *shape) -> 'SparseTensor':
+ """Reshape the feature dimensions of the sparse tensor"""
+ new_feats = self.feats.reshape(self.feats.shape[0], *shape)
+ return self.replace(new_feats)
+
+ def unbind(self, dim: int) -> List['SparseTensor']:
+ """Unbind the sparse tensor along the specified dimension"""
+ return sparse_unbind(self, dim)
+
+ def replace(self, feats: torch.Tensor, coords: Optional[torch.Tensor] = None) -> 'SparseTensor':
+ """
+ Create a new sparse tensor with the specified features and optionally new coordinates.
+ Preserves other properties like stride, spatial range, and caches.
+ """
+ new_shape = [self.shape[0]]
+ new_shape.extend(feats.shape[1:])
+ if BACKEND == 'torchsparse':
+ new_data = SparseTensorData(
+ feats=feats,
+ coords=self.data.coords if coords is None else coords,
+ stride=self.data.stride,
+ spatial_range=self.data.spatial_range,
+ )
+ new_data._caches = self.data._caches
+ elif BACKEND == 'spconv':
+ new_data = SparseTensorData(
+ self.data.features.reshape(self.data.features.shape[0], -1),
+ self.data.indices,
+ self.data.spatial_shape,
+ self.data.batch_size,
+ self.data.grid,
+ self.data.voxel_num,
+ self.data.indice_dict
+ )
+ new_data._features = feats
+ new_data.benchmark = self.data.benchmark
+ new_data.benchmark_record = self.data.benchmark_record
+ new_data.thrust_allocator = self.data.thrust_allocator
+ new_data._timer = self.data._timer
+ new_data.force_algo = self.data.force_algo
+ new_data.int8_scale = self.data.int8_scale
+ if coords is not None:
+ new_data.indices = coords
+ new_tensor = SparseTensor(new_data, shape=torch.Size(new_shape), layout=self.layout, scale=self._scale, spatial_cache=self._spatial_cache)
+ return new_tensor
+
+ @staticmethod
+ def full(aabb, dim, value, dtype=torch.float32, device=None) -> 'SparseTensor':
+ """
+ Create a sparse tensor with uniform values within an axis-aligned bounding box.
+
+ Args:
+ aabb: [x_min, y_min, z_min, x_max, y_max, z_max] defining the bounding box
+ dim: (batch_size, feature_dim) tuple defining tensor dimensions
+ value: Value to fill the tensor with
+ dtype: Data type for features
+ device: Device to create the tensor on
+ """
+ N, C = dim
+ x = torch.arange(aabb[0], aabb[3] + 1)
+ y = torch.arange(aabb[1], aabb[4] + 1)
+ z = torch.arange(aabb[2], aabb[5] + 1)
+ coords = torch.stack(torch.meshgrid(x, y, z, indexing='ij'), dim=-1).reshape(-1, 3)
+ coords = torch.cat([
+ torch.arange(N).view(-1, 1).repeat(1, coords.shape[0]).view(-1, 1),
+ coords.repeat(N, 1),
+ ], dim=1).to(dtype=torch.int32, device=device)
+ feats = torch.full((coords.shape[0], C), value, dtype=dtype, device=device)
+ return SparseTensor(feats=feats, coords=coords)
+
+ def __merge_sparse_cache(self, other: 'SparseTensor') -> dict:
+ """Merge the spatial caches of two sparse tensors"""
+ new_cache = {}
+ for k in set(list(self._spatial_cache.keys()) + list(other._spatial_cache.keys())):
+ if k in self._spatial_cache:
+ new_cache[k] = self._spatial_cache[k]
+ if k in other._spatial_cache:
+ if k not in new_cache:
+ new_cache[k] = other._spatial_cache[k]
+ else:
+ new_cache[k].update(other._spatial_cache[k])
+ return new_cache
+
+ def __neg__(self) -> 'SparseTensor':
+ """Negate the sparse tensor's values"""
+ return self.replace(-self.feats)
+
+ def __elemwise__(self, other: Union[torch.Tensor, 'SparseTensor'], op: callable) -> 'SparseTensor':
+ """
+ Apply an elementwise operation between this sparse tensor and another tensor.
+ Handles broadcasting when necessary.
+ """
+ if isinstance(other, torch.Tensor):
+ try:
+ other = torch.broadcast_to(other, self.shape)
+ other = sparse_batch_broadcast(self, other)
+ except:
+ pass
+ if isinstance(other, SparseTensor):
+ other = other.feats
+ new_feats = op(self.feats, other)
+ new_tensor = self.replace(new_feats)
+ if isinstance(other, SparseTensor):
+ new_tensor._spatial_cache = self.__merge_sparse_cache(other)
+ return new_tensor
+
+ def __add__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Add a tensor or value to this sparse tensor"""
+ return self.__elemwise__(other, torch.add)
+
+ def __radd__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Add this sparse tensor to a tensor or value (reversed)"""
+ return self.__elemwise__(other, torch.add)
+
+ def __sub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Subtract a tensor or value from this sparse tensor"""
+ return self.__elemwise__(other, torch.sub)
+
+ def __rsub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Subtract this sparse tensor from a tensor or value (reversed)"""
+ return self.__elemwise__(other, lambda x, y: torch.sub(y, x))
+
+ def __mul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Multiply this sparse tensor by a tensor or value"""
+ return self.__elemwise__(other, torch.mul)
+
+ def __rmul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Multiply a tensor or value by this sparse tensor (reversed)"""
+ return self.__elemwise__(other, torch.mul)
+
+ def __truediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Divide this sparse tensor by a tensor or value"""
+ return self.__elemwise__(other, torch.div)
+
+ def __rtruediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Divide a tensor or value by this sparse tensor (reversed)"""
+ return self.__elemwise__(other, lambda x, y: torch.div(y, x))
+
+ def __getitem__(self, idx):
+ """
+ Extract a batch or subset of batches from the sparse tensor.
+ Support for integer, slice, and tensor indexing.
+ """
+ if isinstance(idx, int):
+ idx = [idx]
+ elif isinstance(idx, slice):
+ idx = range(*idx.indices(self.shape[0]))
+ elif isinstance(idx, torch.Tensor):
+ if idx.dtype == torch.bool:
+ assert idx.shape == (self.shape[0],), f"Invalid index shape: {idx.shape}"
+ idx = idx.nonzero().squeeze(1)
+ elif idx.dtype in [torch.int32, torch.int64]:
+ assert len(idx.shape) == 1, f"Invalid index shape: {idx.shape}"
+ else:
+ raise ValueError(f"Unknown index type: {idx.dtype}")
+ else:
+ raise ValueError(f"Unknown index type: {type(idx)}")
+
+ coords = []
+ feats = []
+ old_index_list = []
+ for new_idx, old_idx in enumerate(idx):
+ coords.append(self.coords[self.layout[old_idx]].clone())
+ # print(f"slice: old index{old_idx}, new index: {new_idx}")
+ old_index_list.append(old_idx)
+ coords[-1][:, 0] = new_idx
+ feats.append(self.feats[self.layout[old_idx]])
+ coords = torch.cat(coords, dim=0).contiguous()
+ feats = torch.cat(feats, dim=0).contiguous()
+ self.old_index = old_index_list
+ return SparseTensor(feats=feats, coords=coords)
+
+ # def get_item_preserve_batch(self, idx):
+ # """
+ # Extract a batch or subset of batches from the sparse tensor without renumbering batch indices.
+ # Unlike __getitem__, this method preserves the original batch IDs in the coords tensor.
+
+ # Args:
+ # idx: Integer, slice, torch.Tensor, or tuple specifying which batch(es) to extract.
+ # When a tuple is provided, it's used for direct slicing of the underlying data.
+
+ # Returns:
+ # SparseTensor: A new sparse tensor with the selected batches and original batch IDs
+ # """
+ # if isinstance(idx, tuple):
+ # # Direct slice-based indexing
+ # coords_slice = self.coords[idx]
+ # feats_slice = self.feats[idx]
+ # return SparseTensor(feats=feats_slice, coords=coords_slice)
+
+ # if isinstance(idx, int):
+ # idx = [idx]
+ # elif isinstance(idx, slice):
+ # idx = range(*idx.indices(self.shape[0]))
+ # elif isinstance(idx, torch.Tensor):
+ # if idx.dtype == torch.bool:
+ # assert idx.shape == (self.shape[0],), f"Invalid index shape: {idx.shape}"
+ # idx = idx.nonzero().squeeze(1)
+ # elif idx.dtype in [torch.int32, torch.int64]:
+ # assert len(idx.shape) == 1, f"Invalid index shape: {idx.shape}"
+ # else:
+ # raise ValueError(f"Unknown index type: {idx.dtype}")
+ # else:
+ # raise ValueError(f"Unknown index type: {type(idx)}")
+
+ # coords = []
+ # feats = []
+ # for old_idx in idx:
+ # coords.append(self.coords[self.layout[old_idx]].clone())
+ # # Keep original batch ID (don't modify coords[:, 0])
+ # feats.append(self.feats[self.layout[old_idx]])
+
+ # coords = torch.cat(coords, dim=0).contiguous()
+ # feats = torch.cat(feats, dim=0).contiguous()
+
+ # # Create new SparseTensor with preserved batch IDs
+ # return SparseTensor(feats=feats, coords=coords)
+
+
+ def register_spatial_cache(self, key, value) -> None:
+ """
+ Register a spatial cache.
+ The spatial cache can be any thing you want to cache.
+ The registery and retrieval of the cache is based on current scale.
+ """
+ scale_key = str(self._scale)
+ if scale_key not in self._spatial_cache:
+ self._spatial_cache[scale_key] = {}
+ self._spatial_cache[scale_key][key] = value
+
+ def get_spatial_cache(self, key=None):
+ """
+ Get a spatial cache.
+ If key is None, return all caches for the current scale.
+ Otherwise, return the cache associated with the specified key.
+ """
+ scale_key = str(self._scale)
+ cur_scale_cache = self._spatial_cache.get(scale_key, {})
+ if key is None:
+ return cur_scale_cache
+ return cur_scale_cache.get(key, None)
+
+
+def sparse_batch_broadcast(input: SparseTensor, other: torch.Tensor) -> torch.Tensor:
+ """
+ Broadcast a tensor to a sparse tensor along the batch dimension.
+
+ Args:
+ input (SparseTensor): Sparse tensor to broadcast to
+ other (torch.Tensor): Tensor to broadcast
+
+ Returns:
+ torch.Tensor: Broadcasted tensor matching the sparse tensor's layout
+ """
+ coords, feats = input.coords, input.feats
+ broadcasted = torch.zeros_like(feats)
+ for k in range(input.shape[0]):
+ broadcasted[input.layout[k]] = other[k]
+ return broadcasted
+
+
+def sparse_batch_op(input: SparseTensor, other: torch.Tensor, op: callable = torch.add) -> SparseTensor:
+ """
+ Broadcast a 1D tensor to a sparse tensor along the batch dimension then perform an operation.
+
+ Args:
+ input (SparseTensor): Sparse tensor to operate on
+ other (torch.Tensor): 1D tensor to broadcast
+ op (callable): Operation to perform after broadcasting. Defaults to torch.add.
+
+ Returns:
+ SparseTensor: Result of the operation
+ """
+ return input.replace(op(input.feats, sparse_batch_broadcast(input, other)))
+
+def sparse_cat(inputs: List[SparseTensor], dim: int = 0) -> SparseTensor:
+ """
+ Concatenate a list of sparse tensors along a specified dimension.
+
+ This function handles two types of concatenation:
+ 1. Batch concatenation (dim=0): Combines multiple sparse tensors by stacking their batches,
+ adjusting batch indices to maintain proper batch ordering.
+ 2. Feature concatenation (dim>0): Combines features while maintaining the same coordinate structure,
+ useful for concatenating different feature channels for the same spatial locations.
+
+ Args:
+ inputs (List[SparseTensor]): List of sparse tensors to concatenate. All tensors must have
+ compatible shapes for the requested concatenation dimension.
+ dim (int): Dimension along which to concatenate.
+ - If 0, batches are concatenated (increasing batch indices)
+ - If >0, features are concatenated (same coordinates, more features)
+
+ Returns:
+ SparseTensor: A new sparse tensor with concatenated data
+ """
+ if dim == 0:
+ # Concatenate batches - requires adjusting batch indices in coordinates
+ start = 0
+ coords = []
+
+ # Process each input sparse tensor
+ for input in inputs:
+ # Create a copy of coordinates to avoid modifying the original
+ current_coords = input.coords.clone()
+
+ # print("current coords", current_coords[:, 0])
+
+ # Adjust batch indices (first column of coordinates) to maintain proper batch ordering
+ # Each tensor's batch indices are offset by the sum of previous tensors' batch sizes
+ current_coords[:, 0] += start
+
+ # print("current coords", current_coords[:, 0])
+ # Add to coordinate list and update the batch counter
+ coords.append(current_coords)
+
+ # print("shape of input", input.shape)
+
+ start += input.shape[0]
+
+ # print("start number", start)
+
+ # Concatenate all adjusted coordinates into a single tensor
+ coords = torch.cat(coords, dim=0)
+
+ # Concatenate feature values in the same order as coordinates
+ feats = torch.cat([input.feats for input in inputs], dim=0)
+
+ # Create a new sparse tensor with combined coordinates and features
+ output = SparseTensor(
+ coords=coords,
+ feats=feats,
+ )
+ else:
+ # Concatenate features only - coordinates remain unchanged
+ # This works when all input tensors share the same coordinate structure
+ # but have different feature dimensions to combine
+
+ # Combine features along the specified dimension
+ feats = torch.cat([input.feats for input in inputs], dim=dim)
+
+ # Create new sparse tensor using the first input's coordinates
+ # but with the concatenated features
+ output = inputs[0].replace(feats)
+
+ return output
+
+
+def sparse_unbind(input: SparseTensor, dim: int) -> List[SparseTensor]:
+ """
+ Unbind a sparse tensor along a dimension.
+
+ Args:
+ input (SparseTensor): Sparse tensor to unbind
+ dim (int): Dimension to unbind
+
+ Returns:
+ List[SparseTensor]: List of sparse tensors, each representing a slice along the dimension
+ """
+ if dim == 0:
+ return [input[i] for i in range(input.shape[0])]
+ else:
+ feats = input.feats.unbind(dim)
+ return [input.replace(f) for f in feats]
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/conv/__init__.py b/OmniPart/modules/part_synthesis/modules/sparse/conv/__init__.py
new file mode 100644
index 0000000..340a871
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/conv/__init__.py
@@ -0,0 +1,21 @@
+from .. import BACKEND
+
+
+SPCONV_ALGO = 'auto' # 'auto', 'implicit_gemm', 'native'
+
+def __from_env():
+ import os
+
+ global SPCONV_ALGO
+ env_spconv_algo = os.environ.get('SPCONV_ALGO')
+ if env_spconv_algo is not None and env_spconv_algo in ['auto', 'implicit_gemm', 'native']:
+ SPCONV_ALGO = env_spconv_algo
+ print(f"[SPARSE][CONV] spconv algo: {SPCONV_ALGO}")
+
+
+__from_env()
+
+if BACKEND == 'torchsparse':
+ from .conv_torchsparse import *
+elif BACKEND == 'spconv':
+ from .conv_spconv import *
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_spconv.py b/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_spconv.py
new file mode 100644
index 0000000..524bcd4
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_spconv.py
@@ -0,0 +1,80 @@
+import torch
+import torch.nn as nn
+from .. import SparseTensor
+from .. import DEBUG
+from . import SPCONV_ALGO
+
+class SparseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, padding=None, bias=True, indice_key=None):
+ super(SparseConv3d, self).__init__()
+ if 'spconv' not in globals():
+ import spconv.pytorch as spconv
+ algo = None
+ if SPCONV_ALGO == 'native':
+ algo = spconv.ConvAlgo.Native
+ elif SPCONV_ALGO == 'implicit_gemm':
+ algo = spconv.ConvAlgo.MaskImplicitGemm
+ if stride == 1 and (padding is None):
+ self.conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, dilation=dilation, bias=bias, indice_key=indice_key, algo=algo)
+ else:
+ self.conv = spconv.SparseConv3d(in_channels, out_channels, kernel_size, stride=stride, dilation=dilation, padding=padding, bias=bias, indice_key=indice_key, algo=algo)
+ self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride)
+ self.padding = padding
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ spatial_changed = any(s != 1 for s in self.stride) or (self.padding is not None)
+ new_data = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ new_layout = None if spatial_changed else x.layout
+
+ if spatial_changed and (x.shape[0] != 1):
+ # spconv was non-1 stride will break the contiguous of the output tensor, sort by the coords
+ fwd = new_data.indices[:, 0].argsort()
+ bwd = torch.zeros_like(fwd).scatter_(0, fwd, torch.arange(fwd.shape[0], device=fwd.device))
+ sorted_feats = new_data.features[fwd]
+ sorted_coords = new_data.indices[fwd]
+ unsorted_data = new_data
+ new_data = spconv.SparseConvTensor(sorted_feats, sorted_coords, unsorted_data.spatial_shape, unsorted_data.batch_size) # type: ignore
+
+ out = SparseTensor(
+ new_data, shape=torch.Size(new_shape), layout=new_layout,
+ scale=tuple([s * stride for s, stride in zip(x._scale, self.stride)]),
+ spatial_cache=x._spatial_cache,
+ )
+
+ if spatial_changed and (x.shape[0] != 1):
+ out.register_spatial_cache(f'conv_{self.stride}_unsorted_data', unsorted_data)
+ out.register_spatial_cache(f'conv_{self.stride}_sort_bwd', bwd)
+
+ return out
+
+
+class SparseInverseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseInverseConv3d, self).__init__()
+ if 'spconv' not in globals():
+ import spconv.pytorch as spconv
+ self.conv = spconv.SparseInverseConv3d(in_channels, out_channels, kernel_size, bias=bias, indice_key=indice_key)
+ self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ spatial_changed = any(s != 1 for s in self.stride)
+ if spatial_changed:
+ # recover the original spconv order
+ data = x.get_spatial_cache(f'conv_{self.stride}_unsorted_data')
+ bwd = x.get_spatial_cache(f'conv_{self.stride}_sort_bwd')
+ data = data.replace_feature(x.feats[bwd])
+ if DEBUG:
+ assert torch.equal(data.indices, x.coords[bwd]), 'Recover the original order failed'
+ else:
+ data = x.data
+
+ new_data = self.conv(data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ new_layout = None if spatial_changed else x.layout
+ out = SparseTensor(
+ new_data, shape=torch.Size(new_shape), layout=new_layout,
+ scale=tuple([s // stride for s, stride in zip(x._scale, self.stride)]),
+ spatial_cache=x._spatial_cache,
+ )
+ return out
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_torchsparse.py b/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_torchsparse.py
new file mode 100644
index 0000000..1d61258
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/conv/conv_torchsparse.py
@@ -0,0 +1,38 @@
+import torch
+import torch.nn as nn
+from .. import SparseTensor
+
+
+class SparseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseConv3d, self).__init__()
+ if 'torchsparse' not in globals():
+ import torchsparse
+ self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ out = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None)
+ out._spatial_cache = x._spatial_cache
+ out._scale = tuple([s * stride for s, stride in zip(x._scale, self.conv.stride)])
+ return out
+
+
+class SparseInverseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseInverseConv3d, self).__init__()
+ if 'torchsparse' not in globals():
+ import torchsparse
+ self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias, transposed=True)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ out = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None)
+ out._spatial_cache = x._spatial_cache
+ out._scale = tuple([s // stride for s, stride in zip(x._scale, self.conv.stride)])
+ return out
+
+
+
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/linear.py b/OmniPart/modules/part_synthesis/modules/sparse/linear.py
new file mode 100644
index 0000000..a854e77
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/linear.py
@@ -0,0 +1,15 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseLinear'
+]
+
+
+class SparseLinear(nn.Linear):
+ def __init__(self, in_features, out_features, bias=True):
+ super(SparseLinear, self).__init__(in_features, out_features, bias)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/nonlinearity.py b/OmniPart/modules/part_synthesis/modules/sparse/nonlinearity.py
new file mode 100644
index 0000000..f200098
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/nonlinearity.py
@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseReLU',
+ 'SparseSiLU',
+ 'SparseGELU',
+ 'SparseActivation'
+]
+
+
+class SparseReLU(nn.ReLU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseSiLU(nn.SiLU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseGELU(nn.GELU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseActivation(nn.Module):
+ def __init__(self, activation: nn.Module):
+ super().__init__()
+ self.activation = activation
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(self.activation(input.feats))
+
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/norm.py b/OmniPart/modules/part_synthesis/modules/sparse/norm.py
new file mode 100644
index 0000000..6b38a36
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/norm.py
@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+from . import DEBUG
+
+__all__ = [
+ 'SparseGroupNorm',
+ 'SparseLayerNorm',
+ 'SparseGroupNorm32',
+ 'SparseLayerNorm32',
+]
+
+
+class SparseGroupNorm(nn.GroupNorm):
+ def __init__(self, num_groups, num_channels, eps=1e-5, affine=True):
+ super(SparseGroupNorm, self).__init__(num_groups, num_channels, eps, affine)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ nfeats = torch.zeros_like(input.feats)
+ for k in range(input.shape[0]):
+ if DEBUG:
+ assert (input.coords[input.layout[k], 0] == k).all(), f"SparseGroupNorm: batch index mismatch"
+ bfeats = input.feats[input.layout[k]]
+ bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1)
+ bfeats = super().forward(bfeats)
+ bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0)
+ nfeats[input.layout[k]] = bfeats
+ return input.replace(nfeats)
+
+
+class SparseLayerNorm(nn.LayerNorm):
+ def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True):
+ super(SparseLayerNorm, self).__init__(normalized_shape, eps, elementwise_affine)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ nfeats = torch.zeros_like(input.feats)
+ for k in range(input.shape[0]):
+ bfeats = input.feats[input.layout[k]]
+ bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1)
+ bfeats = super().forward(bfeats)
+ bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0)
+ nfeats[input.layout[k]] = bfeats
+ return input.replace(nfeats)
+
+
+class SparseGroupNorm32(SparseGroupNorm):
+ """
+ A GroupNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return super().forward(x.float()).type(x.dtype)
+
+class SparseLayerNorm32(SparseLayerNorm):
+ """
+ A LayerNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return super().forward(x.float()).type(x.dtype)
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/spatial.py b/OmniPart/modules/part_synthesis/modules/sparse/spatial.py
new file mode 100644
index 0000000..ad71214
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/spatial.py
@@ -0,0 +1,110 @@
+from typing import *
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseDownsample',
+ 'SparseUpsample',
+ 'SparseSubdivide'
+]
+
+
+class SparseDownsample(nn.Module):
+ """
+ Downsample a sparse tensor by a factor of `factor`.
+ Implemented as average pooling.
+ """
+ def __init__(self, factor: Union[int, Tuple[int, ...], List[int]]):
+ super(SparseDownsample, self).__init__()
+ self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM
+ assert DIM == len(factor), 'Input coordinates must have the same dimension as the downsample factor.'
+
+ coord = list(input.coords.unbind(dim=-1))
+ for i, f in enumerate(factor):
+ coord[i+1] = coord[i+1] // f
+
+ MAX = [coord[i+1].max().item() + 1 for i in range(DIM)]
+ OFFSET = torch.cumprod(torch.tensor(MAX[::-1]), 0).tolist()[::-1] + [1]
+ code = sum([c * o for c, o in zip(coord, OFFSET)])
+ code, idx = code.unique(return_inverse=True)
+
+ new_feats = torch.scatter_reduce(
+ torch.zeros(code.shape[0], input.feats.shape[1], device=input.feats.device, dtype=input.feats.dtype),
+ dim=0,
+ index=idx.unsqueeze(1).expand(-1, input.feats.shape[1]),
+ src=input.feats,
+ reduce='mean'
+ )
+ new_coords = torch.stack(
+ [code // OFFSET[0]] +
+ [(code // OFFSET[i+1]) % MAX[i] for i in range(DIM)],
+ dim=-1
+ )
+ out = SparseTensor(new_feats, new_coords, input.shape,)
+ out._scale = tuple([s // f for s, f in zip(input._scale, factor)])
+ out._spatial_cache = input._spatial_cache
+
+ out.register_spatial_cache(f'upsample_{factor}_coords', input.coords)
+ out.register_spatial_cache(f'upsample_{factor}_layout', input.layout)
+ out.register_spatial_cache(f'upsample_{factor}_idx', idx)
+
+ return out
+
+
+class SparseUpsample(nn.Module):
+ """
+ Upsample a sparse tensor by a factor of `factor`.
+ Implemented as nearest neighbor interpolation.
+ """
+ def __init__(self, factor: Union[int, Tuple[int, int, int], List[int]]):
+ super(SparseUpsample, self).__init__()
+ self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM
+ assert DIM == len(factor), 'Input coordinates must have the same dimension as the upsample factor.'
+
+ new_coords = input.get_spatial_cache(f'upsample_{factor}_coords')
+ new_layout = input.get_spatial_cache(f'upsample_{factor}_layout')
+ idx = input.get_spatial_cache(f'upsample_{factor}_idx')
+ if any([x is None for x in [new_coords, new_layout, idx]]):
+ raise ValueError('Upsample cache not found. SparseUpsample must be paired with SparseDownsample.')
+ new_feats = input.feats[idx]
+ out = SparseTensor(new_feats, new_coords, input.shape, new_layout)
+ out._scale = tuple([s * f for s, f in zip(input._scale, factor)])
+ out._spatial_cache = input._spatial_cache
+ return out
+
+class SparseSubdivide(nn.Module):
+ """
+ Upsample a sparse tensor by a factor of `factor`.
+ Implemented as nearest neighbor interpolation.
+ """
+ def __init__(self):
+ super(SparseSubdivide, self).__init__()
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ # upsample scale=2^DIM
+ n_cube = torch.ones([2] * DIM, device=input.device, dtype=torch.int)
+ n_coords = torch.nonzero(n_cube)
+ n_coords = torch.cat([torch.zeros_like(n_coords[:, :1]), n_coords], dim=-1)
+ factor = n_coords.shape[0]
+ assert factor == 2 ** DIM
+ # print(n_coords.shape)
+ new_coords = input.coords.clone()
+ new_coords[:, 1:] *= 2
+ new_coords = new_coords.unsqueeze(1) + n_coords.unsqueeze(0).to(new_coords.dtype)
+
+ new_feats = input.feats.unsqueeze(1).expand(input.feats.shape[0], factor, *input.feats.shape[1:])
+ out = SparseTensor(new_feats.flatten(0, 1), new_coords.flatten(0, 1), input.shape)
+ out._scale = input._scale * 2
+ out._spatial_cache = input._spatial_cache
+ return out
+
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/transformer/__init__.py b/OmniPart/modules/part_synthesis/modules/sparse/transformer/__init__.py
new file mode 100644
index 0000000..b08b0d4
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/transformer/__init__.py
@@ -0,0 +1,2 @@
+from .blocks import *
+from .modulated import *
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/transformer/blocks.py b/OmniPart/modules/part_synthesis/modules/sparse/transformer/blocks.py
new file mode 100644
index 0000000..9d037a4
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/transformer/blocks.py
@@ -0,0 +1,151 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..basic import SparseTensor
+from ..linear import SparseLinear
+from ..nonlinearity import SparseGELU
+from ..attention import SparseMultiHeadAttention, SerializeMode
+from ...norm import LayerNorm32
+
+
+class SparseFeedForwardNet(nn.Module):
+ def __init__(self, channels: int, mlp_ratio: float = 4.0):
+ super().__init__()
+ self.mlp = nn.Sequential(
+ SparseLinear(channels, int(channels * mlp_ratio)),
+ SparseGELU(approximate="tanh"),
+ SparseLinear(int(channels * mlp_ratio), channels),
+ )
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return self.mlp(x)
+
+
+class SparseTransformerBlock(nn.Module):
+ """
+ Sparse Transformer block (MSA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: SparseTensor) -> SparseTensor:
+ h = x.replace(self.norm1(x.feats))
+ h = self.attn(h)
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False)
+ else:
+ return self._forward(x)
+
+
+class SparseTransformerCrossBlock(nn.Module):
+ """
+ Sparse Transformer cross-attention block (MSA + MCA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.self_attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = SparseMultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor):
+ h = x.replace(self.norm1(x.feats))
+ h = self.self_attn(h)
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = x.replace(self.norm3(x.feats))
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, context: torch.Tensor):
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False)
+ else:
+ return self._forward(x, context)
diff --git a/OmniPart/modules/part_synthesis/modules/sparse/transformer/modulated.py b/OmniPart/modules/part_synthesis/modules/sparse/transformer/modulated.py
new file mode 100644
index 0000000..4a84165
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/sparse/transformer/modulated.py
@@ -0,0 +1,166 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..basic import SparseTensor
+from ..attention import SparseMultiHeadAttention, SerializeMode
+from ...norm import LayerNorm32
+from .blocks import SparseFeedForwardNet
+
+
+class ModulatedSparseTransformerBlock(nn.Module):
+ """
+ Sparse Transformer block (MSA + FFN) with adaptive layer norm conditioning.
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ share_mod: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True)
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor:
+ if self.share_mod:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+ h = x.replace(self.norm1(x.feats))
+ h = h * (1 + scale_msa) + shift_msa
+ h = self.attn(h)
+ h = h * gate_msa
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = h * (1 + scale_mlp) + shift_mlp
+ h = self.mlp(h)
+ h = h * gate_mlp
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False)
+ else:
+ return self._forward(x, mod)
+
+
+class ModulatedSparseTransformerCrossBlock(nn.Module):
+ """
+ Sparse Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning.
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ share_mod: bool = False,
+
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.self_attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = SparseMultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True)
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor:
+ if self.share_mod:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+ h = x.replace(self.norm1(x.feats))
+ h = h * (1 + scale_msa) + shift_msa
+ h = self.self_attn(h)
+ h = h * gate_msa
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = x.replace(self.norm3(x.feats))
+ h = h * (1 + scale_mlp) + shift_mlp
+ h = self.mlp(h)
+ h = h * gate_mlp
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False)
+ else:
+ return self._forward(x, mod, context)
diff --git a/OmniPart/modules/part_synthesis/modules/spatial.py b/OmniPart/modules/part_synthesis/modules/spatial.py
new file mode 100644
index 0000000..79e268d
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/spatial.py
@@ -0,0 +1,48 @@
+import torch
+
+
+def pixel_shuffle_3d(x: torch.Tensor, scale_factor: int) -> torch.Tensor:
+ """
+ 3D pixel shuffle.
+ """
+ B, C, H, W, D = x.shape
+ C_ = C // scale_factor**3
+ x = x.reshape(B, C_, scale_factor, scale_factor, scale_factor, H, W, D)
+ x = x.permute(0, 1, 5, 2, 6, 3, 7, 4)
+ x = x.reshape(B, C_, H*scale_factor, W*scale_factor, D*scale_factor)
+ return x
+
+
+def patchify(x: torch.Tensor, patch_size: int):
+ """
+ Patchify a tensor.
+
+ Args:
+ x (torch.Tensor): (N, C, *spatial) tensor
+ patch_size (int): Patch size
+ """
+ DIM = x.dim() - 2
+ for d in range(2, DIM + 2):
+ assert x.shape[d] % patch_size == 0, f"Dimension {d} of input tensor must be divisible by patch size, got {x.shape[d]} and {patch_size}"
+
+ x = x.reshape(*x.shape[:2], *sum([[x.shape[d] // patch_size, patch_size] for d in range(2, DIM + 2)], []))
+ x = x.permute(0, 1, *([2 * i + 3 for i in range(DIM)] + [2 * i + 2 for i in range(DIM)]))
+ x = x.reshape(x.shape[0], x.shape[1] * (patch_size ** DIM), *(x.shape[-DIM:]))
+ return x
+
+
+def unpatchify(x: torch.Tensor, patch_size: int):
+ """
+ Unpatchify a tensor.
+
+ Args:
+ x (torch.Tensor): (N, C, *spatial) tensor
+ patch_size (int): Patch size
+ """
+ DIM = x.dim() - 2
+ assert x.shape[1] % (patch_size ** DIM) == 0, f"Second dimension of input tensor must be divisible by patch size to unpatchify, got {x.shape[1]} and {patch_size ** DIM}"
+
+ x = x.reshape(x.shape[0], x.shape[1] // (patch_size ** DIM), *([patch_size] * DIM), *(x.shape[-DIM:]))
+ x = x.permute(0, 1, *(sum([[2 + DIM + i, 2 + i] for i in range(DIM)], [])))
+ x = x.reshape(x.shape[0], x.shape[1], *[x.shape[2 + 2 * i] * patch_size for i in range(DIM)])
+ return x
diff --git a/OmniPart/modules/part_synthesis/modules/transformer/__init__.py b/OmniPart/modules/part_synthesis/modules/transformer/__init__.py
new file mode 100644
index 0000000..b08b0d4
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/transformer/__init__.py
@@ -0,0 +1,2 @@
+from .blocks import *
+from .modulated import *
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/modules/transformer/blocks.py b/OmniPart/modules/part_synthesis/modules/transformer/blocks.py
new file mode 100644
index 0000000..c37eb7e
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/transformer/blocks.py
@@ -0,0 +1,182 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..attention import MultiHeadAttention
+from ..norm import LayerNorm32
+
+
+class AbsolutePositionEmbedder(nn.Module):
+ """
+ Embeds spatial positions into vector representations.
+ """
+ def __init__(self, channels: int, in_channels: int = 3):
+ super().__init__()
+ self.channels = channels
+ self.in_channels = in_channels
+ self.freq_dim = channels // in_channels // 2
+ self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim
+ self.freqs = 1.0 / (10000 ** self.freqs)
+
+ def _sin_cos_embedding(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Create sinusoidal position embeddings.
+
+ Args:
+ x: a 1-D Tensor of N indices
+
+ Returns:
+ an (N, D) Tensor of positional embeddings.
+ """
+ self.freqs = self.freqs.to(x.device)
+ out = torch.outer(x, self.freqs)
+ out = torch.cat([torch.sin(out), torch.cos(out)], dim=-1)
+ return out
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ x (torch.Tensor): (N, D) tensor of spatial positions
+ """
+ N, D = x.shape
+ assert D == self.in_channels, "Input dimension must match number of input channels"
+ embed = self._sin_cos_embedding(x.reshape(-1))
+ embed = embed.reshape(N, -1)
+ if embed.shape[1] < self.channels:
+ embed = torch.cat([embed, torch.zeros(N, self.channels - embed.shape[1], device=embed.device)], dim=-1)
+ return embed
+
+
+class FeedForwardNet(nn.Module):
+ def __init__(self, channels: int, mlp_ratio: float = 4.0):
+ super().__init__()
+ self.mlp = nn.Sequential(
+ nn.Linear(channels, int(channels * mlp_ratio)),
+ nn.GELU(approximate="tanh"),
+ nn.Linear(int(channels * mlp_ratio), channels),
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return self.mlp(x)
+
+
+class TransformerBlock(nn.Module):
+ """
+ Transformer block (MSA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[int] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: torch.Tensor) -> torch.Tensor:
+ h = self.norm1(x)
+ h = self.attn(h)
+ x = x + h
+ h = self.norm2(x)
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False)
+ else:
+ return self._forward(x)
+
+
+class TransformerCrossBlock(nn.Module):
+ """
+ Transformer cross-attention block (MSA + MCA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.self_attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = MultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: torch.Tensor, context: torch.Tensor):
+ h = self.norm1(x)
+ h = self.self_attn(h)
+ x = x + h
+ h = self.norm2(x)
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = self.norm3(x)
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: torch.Tensor, context: torch.Tensor):
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False)
+ else:
+ return self._forward(x, context)
+
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/modules/transformer/modulated.py b/OmniPart/modules/part_synthesis/modules/transformer/modulated.py
new file mode 100644
index 0000000..7c676b5
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/transformer/modulated.py
@@ -0,0 +1,252 @@
+"""
+This file implements modulated transformer blocks for conditional generation.
+These blocks extend standard transformer architectures by incorporating adaptive layer normalization (adaLN),
+which modulates the transformer's behavior based on conditioning information.
+The modulation is applied through shift and scale parameters derived from a condition vector,
+allowing the model to adapt its processing to different inputs or conditions.
+
+The file provides two main components:
+1. ModulatedTransformerBlock: A standard transformer block with self-attention and FFN, modified with adaLN
+2. ModulatedTransformerCrossBlock: An extended transformer block with self-attention, cross-attention, and FFN with adaLN
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+from ..attention import MultiHeadAttention
+from ..norm import LayerNorm32
+from .blocks import FeedForwardNet
+
+
+class ModulatedTransformerBlock(nn.Module):
+ """
+ Transformer block (MSA + FFN) with adaptive layer norm conditioning.
+
+ This block combines multi-head self-attention with a feed-forward network,
+ and uses adaptive layer normalization to condition the processing on external information.
+ """
+ def __init__(
+ self,
+ channels: int, # Number of input/output channels
+ num_heads: int, # Number of attention heads
+ mlp_ratio: float = 4.0, # Ratio determining MLP hidden dimension size
+ attn_mode: Literal["full", "windowed"] = "full", # Attention computation mode
+ window_size: Optional[int] = None, # Size of attention window if using windowed attention
+ shift_window: Optional[Tuple[int, int, int]] = None, # Parameters for shifted window attention
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing to save memory
+ use_rope: bool = False, # Whether to use Rotary Position Embedding
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for query and key
+ qkv_bias: bool = True, # Whether to use bias in QKV projection
+ share_mod: bool = False, # Whether to share modulation parameters externally
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+
+ # Layer normalization without affine parameters (will be modulated)
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+
+ # Multi-head self-attention layer
+ self.attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+
+ # Feed-forward network
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ # Modulation network to generate adaptive parameters if not shared
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True) # 6 channels: shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp
+ )
+
+ def _forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor:
+ """
+ Internal forward function for the modulated transformer block.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ # Split modulation vector into shift, scale, and gate parameters for MSA and FFN
+ if self.share_mod:
+ # Use externally provided modulation parameters
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ # Generate modulation parameters from the conditioning vector
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+
+ # Apply modulated self-attention
+ h = self.norm1(x) # Normalize
+ h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) # Apply modulation
+ h = self.attn(h) # Self-attention
+ h = h * gate_msa.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ # Apply modulated feed-forward network
+ h = self.norm2(x) # Normalize
+ h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) # Apply modulation
+ h = self.mlp(h) # Feed-forward
+ h = h * gate_mlp.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ return x
+
+ def forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass with optional gradient checkpointing to save memory.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False)
+ else:
+ return self._forward(x, mod)
+
+
+class ModulatedTransformerCrossBlock(nn.Module):
+ """
+ Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning.
+
+ This block extends the standard transformer block with an additional cross-attention
+ layer, allowing it to attend to a separate context input.
+ """
+ def __init__(
+ self,
+ channels: int, # Number of input/output channels
+ ctx_channels: int, # Number of context channels
+ num_heads: int, # Number of attention heads
+ mlp_ratio: float = 4.0, # Ratio determining MLP hidden dimension size
+ attn_mode: Literal["full", "windowed"] = "full", # Attention computation mode
+ window_size: Optional[int] = None, # Size of attention window if using windowed attention
+ shift_window: Optional[Tuple[int, int, int]] = None, # Parameters for shifted window attention
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing to save memory
+ use_rope: bool = False, # Whether to use Rotary Position Embedding
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for query and key in self-attention
+ qk_rms_norm_cross: bool = False, # Whether to use RMS normalization for query and key in cross-attention
+ qkv_bias: bool = True, # Whether to use bias in QKV projection
+ share_mod: bool = False, # Whether to share modulation parameters externally
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+
+ # Layer normalizations
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) # For self-attention, will be modulated
+ self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6) # For cross-attention, standard normalization
+ self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) # For FFN, will be modulated
+
+ # Self-attention layer
+ self.self_attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+
+ # Cross-attention layer
+ self.cross_attn = MultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full", # Cross-attention always uses full attention
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+
+ # Feed-forward network
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ # Modulation network to generate adaptive parameters if not shared
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True) # 6 channels: shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp
+ )
+
+ def _forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor):
+ """
+ Internal forward function for the modulated transformer cross-attention block.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+ context: Context tensor for cross-attention [batch, context_len, ctx_channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ # Split modulation vector into shift, scale, and gate parameters for MSA and FFN
+ if self.share_mod:
+ # Use externally provided modulation parameters
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ # Generate modulation parameters from the conditioning vector
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+
+ # Apply modulated self-attention
+ h = self.norm1(x) # Normalize
+ h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) # Apply modulation
+ h = self.self_attn(h) # Self-attention
+ h = h * gate_msa.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ # Apply cross-attention (not modulated)
+ h = self.norm2(x) # Normalize
+ h = self.cross_attn(h, context) # Cross-attention with context
+ x = x + h # Residual connection
+
+ # Apply modulated feed-forward network
+ h = self.norm3(x) # Normalize
+ h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) # Apply modulation
+ h = self.mlp(h) # Feed-forward
+ h = h * gate_mlp.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ return x
+
+ def forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor):
+ """
+ Forward pass with optional gradient checkpointing to save memory.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+ context: Context tensor for cross-attention [batch, context_len, ctx_channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False)
+ else:
+ return self._forward(x, mod, context)
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/modules/utils.py b/OmniPart/modules/part_synthesis/modules/utils.py
new file mode 100644
index 0000000..f0afb1b
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/modules/utils.py
@@ -0,0 +1,54 @@
+import torch.nn as nn
+from ..modules import sparse as sp
+
+FP16_MODULES = (
+ nn.Conv1d,
+ nn.Conv2d,
+ nn.Conv3d,
+ nn.ConvTranspose1d,
+ nn.ConvTranspose2d,
+ nn.ConvTranspose3d,
+ nn.Linear,
+ sp.SparseConv3d,
+ sp.SparseInverseConv3d,
+ sp.SparseLinear,
+)
+
+def convert_module_to_f16(l):
+ """
+ Convert primitive modules to float16.
+ """
+ if isinstance(l, FP16_MODULES):
+ for p in l.parameters():
+ p.data = p.data.half()
+
+
+def convert_module_to_f32(l):
+ """
+ Convert primitive modules to float32, undoing convert_module_to_f16().
+ """
+ if isinstance(l, FP16_MODULES):
+ for p in l.parameters():
+ p.data = p.data.float()
+
+
+def zero_module(module):
+ """
+ Zero out the parameters of a module and return it.
+ """
+ for p in module.parameters():
+ p.detach().zero_()
+ return module
+
+
+def scale_module(module, scale):
+ """
+ Scale the parameters of a module and return it.
+ """
+ for p in module.parameters():
+ p.detach().mul_(scale)
+ return module
+
+
+def modulate(x, shift, scale):
+ return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
diff --git a/OmniPart/modules/part_synthesis/pipelines/__init__.py b/OmniPart/modules/part_synthesis/pipelines/__init__.py
new file mode 100644
index 0000000..fe64eba
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/__init__.py
@@ -0,0 +1,24 @@
+from . import samplers
+from .omnipart_image_to_parts import OmniPartImageTo3DPipeline
+
+
+def from_pretrained(path: str):
+ """
+ Load a pipeline from a model folder or a Hugging Face model hub.
+
+ Args:
+ path: The path to the model. Can be either local path or a Hugging Face model name.
+ """
+ import os
+ import json
+ is_local = os.path.exists(f"{path}/pipeline.json")
+
+ if is_local:
+ config_file = f"{path}/pipeline.json"
+ else:
+ from huggingface_hub import hf_hub_download
+ config_file = hf_hub_download(path, "pipeline.json")
+
+ with open(config_file, 'r') as f:
+ config = json.load(f)
+ return globals()[config['name']].from_pretrained(path)
diff --git a/OmniPart/modules/part_synthesis/pipelines/base.py b/OmniPart/modules/part_synthesis/pipelines/base.py
new file mode 100644
index 0000000..981a75a
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/base.py
@@ -0,0 +1,68 @@
+from typing import *
+import torch
+import torch.nn as nn
+from .. import models
+
+class Pipeline:
+ """
+ A base class for pipelines.
+ """
+ def __init__(
+ self,
+ models: Dict[str, nn.Module] = None,
+ ):
+ if models is None:
+ return
+ self.models = models
+ for model in self.models.values():
+ model.eval()
+
+ @staticmethod
+ def from_pretrained(path: str) -> "Pipeline":
+
+ import os
+ import json
+
+ # Standard loading from directory or Hugging Face
+ is_local = os.path.exists(f"{path}/pipeline.json")
+
+ if is_local:
+ print(f"Loading pipeline configuration from local path: {path}/pipeline.json")
+ config_file = f"{path}/pipeline.json"
+ else:
+ from huggingface_hub import hf_hub_download
+ print(f"Downloading pipeline configuration from Hugging Face: {path}")
+ config_file = hf_hub_download(path, "pipeline.json")
+
+ with open(config_file, 'r') as f:
+ args = json.load(f)['args']
+
+ print(f"loading models from {path}")
+ _models = {}
+ for k, v in args['models'].items():
+ print(f"Loading model {k} from local path: {path}/{v}")
+ _models[k] = models.from_pretrained(f"{path}/{v}")
+
+ new_pipeline = Pipeline(_models)
+ new_pipeline._pretrained_args = args
+ return new_pipeline
+
+ @property
+ def device(self) -> torch.device:
+ for model in self.models.values():
+ if hasattr(model, 'device'):
+ return model.device
+ for model in self.models.values():
+ if hasattr(model, 'parameters'):
+ return next(model.parameters()).device
+ raise RuntimeError("No device found.")
+
+ def to(self, device: torch.device) -> None:
+ for model in self.models.values():
+ model.to(device)
+
+ def cuda(self) -> None:
+ self.to(torch.device("cuda"))
+
+ def cpu(self) -> None:
+ self.to(torch.device("cpu"))
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/pipelines/omnipart_image_to_parts.py b/OmniPart/modules/part_synthesis/pipelines/omnipart_image_to_parts.py
new file mode 100644
index 0000000..7ded495
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/omnipart_image_to_parts.py
@@ -0,0 +1,545 @@
+from typing import *
+from contextlib import contextmanager
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from torchvision import transforms
+from PIL import Image
+import rembg
+from transformers import AutoModel
+from .base import Pipeline
+from . import samplers
+from ..modules import sparse as sp
+from ..modules.sparse.basic import SparseTensor, sparse_cat
+
+class OmniPartImageTo3DPipeline(Pipeline):
+ """
+ Pipeline for inferring OmniPart image-to-3D models.
+
+ Args:
+ models (dict[str, nn.Module]): The models to use in the pipeline.
+ sparse_structure_sampler (samplers.Sampler): The sampler for the sparse structure.
+ slat_sampler (samplers.Sampler): The sampler for the structured latent.
+ slat_normalization (dict): The normalization parameters for the structured latent.
+ image_cond_model (str): The name of the image conditioning model.
+ """
+ def __init__(
+ self,
+ models: Dict[str, nn.Module] = None,
+ sparse_structure_sampler: samplers.Sampler = None,
+ slat_sampler: samplers.Sampler = None,
+ slat_normalization: dict = None,
+ image_cond_model: str = None,
+ dino: str='facebookresearch/dinov2',
+ dino_moudel: str = "facebookresearch/dinov2",
+ device_: torch.device = torch.device("cpu"),
+
+ ):
+ # Skip initialization if models is None (used in from_pretrained)
+ if models is None:
+ return
+
+ super().__init__(models)
+ self.sparse_structure_sampler = sparse_structure_sampler
+ self.slat_sampler = slat_sampler
+ self.sparse_structure_sampler_params = {}
+ self.slat_sampler_params = {}
+ self.slat_normalization = slat_normalization
+ self.rembg_session = None
+ self.device_=device_
+ self._init_image_cond_model(image_cond_model)
+ self.dino_moudel=dino_moudel
+ self.dino=dino
+
+
+ @staticmethod
+ def from_pretrained(path: str,dino_ckpt='facebookresearch/dinov2',dino_moudel='facebookresearch/dinov2',device_="cuda") -> "OmniPartImageTo3DPipeline":
+ """
+ Load a pretrained model.
+
+ Args:
+ path (str): The path to the model. Can be either local path or a Hugging Face repository.
+
+ Returns:
+ OmniPartImageTo3DPipeline: Loaded pipeline instance
+ """
+ pipeline = super(OmniPartImageTo3DPipeline, OmniPartImageTo3DPipeline).from_pretrained(path)
+ new_pipeline = OmniPartImageTo3DPipeline()
+ new_pipeline.__dict__ = pipeline.__dict__
+ args = pipeline._pretrained_args
+ if not hasattr(new_pipeline, 'dino_moudel'):
+ new_pipeline.dino_moudel = dino_moudel
+ if not hasattr(new_pipeline, 'dino'):
+ new_pipeline.dino = dino_ckpt
+ if not hasattr(new_pipeline, 'device_'):
+ new_pipeline.device_ = device_
+
+ # Initialize samplers from saved arguments
+ new_pipeline.sparse_structure_sampler = getattr(samplers, args['sparse_structure_sampler']['name'])(
+ **args['sparse_structure_sampler']['args'])
+ new_pipeline.sparse_structure_sampler_params = args['sparse_structure_sampler']['params']
+
+ new_pipeline.slat_sampler = getattr(samplers, args['slat_sampler']['name'])(
+ **args['slat_sampler']['args'])
+ new_pipeline.slat_sampler_params = args['slat_sampler']['params']
+
+ new_pipeline.slat_normalization = args['slat_normalization']
+
+
+ new_pipeline._init_image_cond_model(args['image_cond_model'])
+
+ return new_pipeline
+
+ def _init_image_cond_model(self, name: str):
+ """
+ Initialize the image conditioning model.
+
+ Args:
+ name (str): Name of the DINOv2 model to load
+ """
+ dinov2_model = torch.hub.load(self.dino_moudel,name, weights=self.dino,source="local",pretrained=True)
+ #dinov2_model = torch.hub.load('facebookresearch/dinov2', name)
+ dinov2_model.eval()
+ self.dino_model_load=dinov2_model
+ self.models['image_cond_model'] = dinov2_model
+ transform = transforms.Compose([
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+ self.image_cond_model_transform = transform
+
+
+ def preprocess_image(self, input: Image.Image, size=(518, 518)) -> Image.Image:
+ """
+ Preprocess the input image for the model.
+
+ Args:
+ input (Image.Image): Input image
+ size (tuple): Target size for resizing
+
+ Returns:
+ Image.Image: Preprocessed image
+ """
+ img = np.array(input)
+ if img.shape[-1] == 4:
+ # Handle alpha channel by replacing transparent pixels with black
+ mask_img = img[..., 3] == 0
+ img[mask_img] = [0, 0, 0, 255]
+ img = img[..., :3]
+ img_rgb = Image.fromarray(img.astype('uint8'))
+ # Resize to target size
+ img_rgb = img_rgb.resize(size, resample=Image.Resampling.BILINEAR)
+ return img_rgb
+
+ @torch.no_grad()
+ def encode_image(self, image: Union[torch.Tensor, List[Image.Image]]) -> torch.Tensor:
+ """
+ Encode the image using the conditioning model.
+
+ Args:
+ image (Union[torch.Tensor, list[Image.Image]]): The image(s) to encode
+
+ Returns:
+ torch.Tensor: The encoded features
+ """
+ if isinstance(image, torch.Tensor):
+ assert image.ndim == 4, "Image tensor should be batched (B, C, H, W)"
+ elif isinstance(image, list):
+ assert all(isinstance(i, Image.Image) for i in image), "Image list should be list of PIL images"
+ # Convert PIL images to tensors
+ image = [i.resize((518, 518), Image.LANCZOS) for i in image]
+ image = [np.array(i.convert('RGB')).astype(np.float32) / 255 for i in image]
+ image = [torch.from_numpy(i).permute(2, 0, 1).float() for i in image]
+ image = torch.stack(image).to(self.device_)
+ else:
+ raise ValueError(f"Unsupported type of image: {type(image)}")
+
+ # Apply normalization and run through DINOv2 model
+
+ image = self.image_cond_model_transform(image).to(self.device_)
+ features = self.models['image_cond_model'].to(self.device_)(image, is_training=True)['x_prenorm']
+ patchtokens = F.layer_norm(features, features.shape[-1:])
+ self.dino_model_load.to("cpu")
+ return patchtokens
+
+ def get_cond(self, image: Union[torch.Tensor, List[Image.Image]]) -> dict:
+ """
+ Get the conditioning information for the model.
+
+ Args:
+ image (Union[torch.Tensor, list[Image.Image]]): The image prompts.
+
+ Returns:
+ dict: Dictionary with conditioning information
+ """
+ cond = self.encode_image(image)
+ neg_cond = torch.zeros_like(cond) # Negative conditioning (zero)
+ return {
+ 'cond': cond,
+ 'neg_cond': neg_cond,
+ }
+
+
+ def sample_sparse_structure(
+ self,
+ cond: dict,
+ num_samples: int = 1,
+ sampler_params: dict = {},
+ save_coords: bool = False,
+ device: str = "cuda",
+ ) -> torch.Tensor:
+ """
+ Sample sparse structures with the given conditioning.
+
+ Args:
+ cond (dict): The conditioning information.
+ num_samples (int): The number of samples to generate.
+ sampler_params (dict): Additional parameters for the sampler.
+ save_coords (bool): Whether to save coordinates internally.
+
+ Returns:
+ torch.Tensor: Coordinates of the sparse structure
+ """
+ # Sample occupancy latent
+ flow_model = self.models['sparse_structure_flow_model']
+ #flow_model.to(device)
+ reso = flow_model.resolution
+ noise = torch.randn(num_samples, flow_model.in_channels, reso, reso, reso).to(self.device)
+
+ # Merge default and custom sampler parameters
+ sampler_params = {**self.sparse_structure_sampler_params, **sampler_params}
+
+ # Generate samples using the sampler
+ z_s = self.sparse_structure_sampler.sample(
+ flow_model,
+ noise,
+ **cond,
+ **sampler_params,
+ verbose=True
+ ).samples
+
+ # Decode occupancy latent to get coordinates
+ decoder = self.models['sparse_structure_decoder']
+ coords = torch.argwhere(decoder(z_s)>0)[:, [0, 2, 3, 4]].int()
+
+ if save_coords:
+ self.save_coordinates = coords
+ flow_model.to("cpu")
+ return coords
+
+ @torch.no_grad()
+ def get_coords(
+ self,
+ image: Union[Image.Image, List[Image.Image]],
+ num_samples: int = 1,
+ seed: int = 42,
+ sparse_structure_sampler_params: dict = {},
+ preprocess_image: bool = True,
+ save_coords: bool = False,
+ ) -> dict:
+ """
+ Get coordinates of the sparse structure from an input image.
+
+ Args:
+ image: Input image or list of images
+ num_samples: Number of samples to generate
+ seed: Random seed
+ sparse_structure_sampler_params: Additional parameters for the sparse structure sampler
+ preprocess_image: Whether to preprocess the image
+ save_coords: Whether to save coordinates internally
+
+ Returns:
+ torch.Tensor: Coordinates of the sparse structure
+ """
+ if isinstance(image, Image.Image):
+ if preprocess_image:
+ image = self.preprocess_image(image)
+ cond = self.get_cond([image])
+ torch.manual_seed(seed)
+ coords = self.sample_sparse_structure(cond, num_samples, sparse_structure_sampler_params, save_coords)
+ return coords
+ elif isinstance(image, torch.Tensor):
+ cond = self.get_cond(image.unsqueeze(0))
+ torch.manual_seed(seed)
+ coords = self.sample_sparse_structure(cond, num_samples, sparse_structure_sampler_params, save_coords)
+ return coords
+ elif isinstance(image, list):
+ if preprocess_image:
+ image = [self.preprocess_image(i) for i in image]
+ cond = self.get_cond(image)
+ torch.manual_seed(seed)
+ coords = self.sample_sparse_structure(cond, num_samples, sparse_structure_sampler_params, save_coords)
+ return coords
+ else:
+ raise ValueError(f"Unsupported type of image: {type(image)}")
+
+
+ def sample_slat(
+ self,
+ cond: dict,
+ coords: torch.Tensor,
+ part_layouts: List[slice] = None,
+ masks: torch.Tensor = None,
+ sampler_params: dict = {},
+ **kwargs
+ ) -> sp.SparseTensor:
+ # Sample structured latent
+ flow_model = self.models['slat_flow_model']
+ #flow_model.to(self.device_)
+ # Create noise tensor with same coordinates as the sparse structure
+ noise = sp.SparseTensor(
+ feats=torch.randn(coords.shape[0], flow_model.in_channels).to(self.device),
+ coords=coords,
+ )
+
+ # Merge default and custom sampler parameters
+ sampler_params = {**self.slat_sampler_params, **sampler_params}
+
+ # Add part information if provided
+ if part_layouts is not None:
+ kwargs['part_layouts'] = part_layouts
+ if masks is not None:
+ kwargs['masks'] = masks
+
+ # Generate samples
+ slat = self.slat_sampler.sample(
+ flow_model,
+ noise,
+ **cond,
+ **sampler_params,
+ verbose=True,
+ **kwargs
+ ).samples
+
+ # Normalize the features
+ feat_dim = slat.feats.shape[1]
+ base_std = torch.tensor(self.slat_normalization['std']).to(slat.device)
+ base_mean = torch.tensor(self.slat_normalization['mean']).to(slat.device)
+
+ # Handle different dimensionality cases
+ if feat_dim == len(base_std):
+ # Dimensions match, apply directly
+ std = base_std[None, :]
+ mean = base_mean[None, :]
+ elif feat_dim == 8 and len(base_std) == 9:
+ # Use first 8 dimensions when latent is 8-dimensional but normalization is 9-dimensional
+ std = base_std[:8][None, :]
+ mean = base_mean[:8][None, :]
+ print(f"Warning: Normalizing {feat_dim}-dimensional features with first 8 dimensions of 9-dimensional parameters")
+ else:
+ # Handle general case of dimension mismatch
+ std = torch.ones((1, feat_dim), device=slat.device)
+ mean = torch.zeros((1, feat_dim), device=slat.device)
+
+ copy_dim = min(feat_dim, len(base_std))
+ std[0, :copy_dim] = base_std[:copy_dim]
+ mean[0, :copy_dim] = base_mean[:copy_dim]
+ print(f"Warning: Feature dimensions mismatch. Using {copy_dim} dimensions for normalization")
+
+ # Apply normalization
+ slat = slat * std + mean
+ flow_model.to("cpu")
+ return slat
+
+ @torch.no_grad()
+ def get_slat(
+ self,
+ image: Union[Image.Image, List[Image.Image], torch.Tensor],
+ coords: torch.Tensor,
+ part_layouts: List[slice],
+ masks: torch.Tensor,
+ seed: int = 42,
+ slat_sampler_params: dict = {},
+ formats: List[str] = ['mesh', 'gaussian', 'radiance_field'],
+ preprocess_image: bool = True,
+ ) -> dict:
+
+ if isinstance(image, Image.Image):
+ if preprocess_image:
+ image = self.preprocess_image(image)
+ cond = self.get_cond([image])
+ torch.manual_seed(seed)
+ slat = self.sample_slat(cond, coords, part_layouts, masks, slat_sampler_params)
+ return self.decode_slat(self.divide_slat(slat, part_layouts), formats)
+ elif isinstance(image, list):
+ if preprocess_image:
+ image = [self.preprocess_image(i) for i in image]
+ cond = self.get_cond(image)
+ torch.manual_seed(seed)
+ slat = self.sample_slat(cond, coords, part_layouts, masks, slat_sampler_params)
+ return self.decode_slat(self.divide_slat(slat, part_layouts), formats)
+ elif isinstance(image, torch.Tensor):
+ cond = self.get_cond(image.unsqueeze(0))
+ torch.manual_seed(seed)
+ slat = self.sample_slat(cond, coords, part_layouts, masks, slat_sampler_params)
+ return self.decode_slat(self.divide_slat(slat, part_layouts), formats)
+ else:
+ raise ValueError(f"Unsupported type of image: {type(image)}")
+
+ def decode_slat(
+ self,
+ slat: sp.SparseTensor,
+ formats: List[str] = ['mesh', 'gaussian', 'radiance_field'],
+ ) -> dict:
+ """
+ Decode the structured latent.
+
+ Args:
+ slat (sp.SparseTensor): The structured latent
+ formats (List[str]): The formats to decode to
+
+ Returns:
+ dict: Decoded outputs in requested formats
+ """
+ ret = {}
+ if 'mesh' in formats:
+ ret['mesh'] = self.models['slat_decoder_mesh'](slat)
+ if 'gaussian' in formats:
+ ret['gaussian'] = self.models['slat_decoder_gs'](slat)
+ if 'radiance_field' in formats:
+ ret['radiance_field'] = self.models['slat_decoder_rf'](slat)
+ return ret
+
+ def divide_slat(
+ self,
+ slat: sp.SparseTensor,
+ part_layouts: List[slice],
+ ) -> List[sp.SparseTensor]:
+ """
+ Divide the structured latent into parts.
+
+ Args:
+ slat (sp.SparseTensor): The structured latent
+ part_layouts (List[slice]): Layout information for parts
+
+ Returns:
+ sp.SparseTensor: Processed and divided latent
+ """
+ sparse_part = []
+ for part_id, part_layout in enumerate(part_layouts):
+ for part_obj_id, part_slice in enumerate(part_layout):
+ part_x_sparse_tensor = SparseTensor(
+ coords=slat[part_id].coords[part_slice],
+ feats=slat[part_id].feats[part_slice],
+ )
+ sparse_part.append(part_x_sparse_tensor)
+
+ slat = sparse_cat(sparse_part)
+
+ return self.remove_noise(slat)
+
+ def remove_noise(self, z_batch):
+ """
+ Remove noise from latent vectors by filtering out points with low confidence.
+
+ Args:
+ z_batch: Latent vectors to process
+
+ Returns:
+ sp.SparseTensor: Processed latent with noise removed
+ """
+ # Create a new list for processed tensors
+ processed_batch = []
+
+ for i, z in enumerate(z_batch):
+ coords = z.coords
+ feats = z.feats
+
+ # Only filter if features have a confidence dimension (9th dimension)
+ if feats.shape[1] == 9:
+ # Get the confidence values (last dimension)
+ last_dim = feats[:, -1]
+ sigmoid_val = torch.sigmoid(last_dim)
+
+ # Calculate filtering statistics
+ total_points = coords.shape[0]
+ to_keep = sigmoid_val >= 0.3
+ kept_points = to_keep.sum().item()
+ discarded_points = total_points - kept_points
+ discard_percentage = (discarded_points / total_points) * 100 if total_points > 0 else 0
+
+ if kept_points == 0:
+ print(f"No points kept for part {i}")
+ continue
+
+ print(f"Discarded {discarded_points}/{total_points} points ({discard_percentage:.2f}%)")
+
+ # Filter coordinates and features
+ coords = coords[to_keep]
+ feats = feats[to_keep]
+ feats = feats[:, :-1] # Remove the confidence dimension
+
+ # Create a filtered SparseTensor
+ processed_z = z.replace(coords=coords, feats=feats)
+ else:
+ processed_z = z
+
+ processed_batch.append(processed_z)
+
+ return sparse_cat(processed_batch)
+
+
+ @contextmanager
+ def inject_sampler_multi_image(
+ self,
+ sampler_name: str,
+ num_images: int,
+ num_steps: int,
+ mode: Literal['stochastic', 'multidiffusion'] = 'stochastic',
+ ):
+ """
+ Inject a sampler with multiple images as condition.
+
+ Args:
+ sampler_name (str): The name of the sampler to inject
+ num_images (int): The number of images to condition on
+ num_steps (int): The number of steps to run the sampler for
+ mode (str): Sampling strategy ('stochastic' or 'multidiffusion')
+ """
+ sampler = getattr(self, sampler_name)
+ setattr(sampler, f'_old_inference_model', sampler._inference_model)
+
+ if mode == 'stochastic':
+ if num_images > num_steps:
+ print(f"\033[93mWarning: number of conditioning images is greater than number of steps for {sampler_name}. "
+ "This may lead to performance degradation.\033[0m")
+
+ # Create schedule for which image to use at each step
+ cond_indices = (np.arange(num_steps) % num_images).tolist()
+
+ def _new_inference_model(self, model, x_t, t, cond, **kwargs):
+ cond_idx = cond_indices.pop(0)
+ cond_i = cond[cond_idx:cond_idx+1]
+ return self._old_inference_model(model, x_t, t, cond=cond_i, **kwargs)
+
+ elif mode == 'multidiffusion':
+ from .samplers import FlowEulerSampler
+
+ def _new_inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, cfg_interval, **kwargs):
+ if cfg_interval[0] <= t <= cfg_interval[1]:
+ # Average predictions from all conditions when within CFG interval
+ preds = []
+ for i in range(len(cond)):
+ preds.append(FlowEulerSampler._inference_model(self, model, x_t, t, cond[i:i+1], **kwargs))
+ pred = sum(preds) / len(preds)
+ neg_pred = FlowEulerSampler._inference_model(self, model, x_t, t, neg_cond, **kwargs)
+ return (1 + cfg_strength) * pred - cfg_strength * neg_pred
+ else:
+ # Average predictions from all conditions when outside CFG interval
+ preds = []
+ for i in range(len(cond)):
+ preds.append(FlowEulerSampler._inference_model(self, model, x_t, t, cond[i:i+1], **kwargs))
+ pred = sum(preds) / len(preds)
+ return pred
+
+ else:
+ raise ValueError(f"Unsupported mode: {mode}")
+
+ sampler._inference_model = _new_inference_model.__get__(sampler, type(sampler))
+
+ try:
+ yield
+ finally:
+ # Restore original inference model
+ sampler._inference_model = sampler._old_inference_model
+ delattr(sampler, f'_old_inference_model')
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/pipelines/samplers/__init__.py b/OmniPart/modules/part_synthesis/pipelines/samplers/__init__.py
new file mode 100644
index 0000000..54d412f
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/samplers/__init__.py
@@ -0,0 +1,2 @@
+from .base import Sampler
+from .flow_euler import FlowEulerSampler, FlowEulerCfgSampler, FlowEulerGuidanceIntervalSampler
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/pipelines/samplers/base.py b/OmniPart/modules/part_synthesis/pipelines/samplers/base.py
new file mode 100644
index 0000000..1966ce7
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/samplers/base.py
@@ -0,0 +1,20 @@
+from typing import *
+from abc import ABC, abstractmethod
+
+
+class Sampler(ABC):
+ """
+ A base class for samplers.
+ """
+
+ @abstractmethod
+ def sample(
+ self,
+ model,
+ **kwargs
+ ):
+ """
+ Sample from a model.
+ """
+ pass
+
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/pipelines/samplers/classifier_free_guidance_mixin.py b/OmniPart/modules/part_synthesis/pipelines/samplers/classifier_free_guidance_mixin.py
new file mode 100644
index 0000000..5d8af5e
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/samplers/classifier_free_guidance_mixin.py
@@ -0,0 +1,15 @@
+from typing import *
+import torch
+
+
+class ClassifierFreeGuidanceSamplerMixin:
+ """
+ A mixin class for samplers that apply classifier-free guidance.
+ """
+
+ def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, **kwargs):
+ pred = super()._inference_model(model, x_t, t, cond, **kwargs)
+ if 'masks' in kwargs:
+ kwargs['masks'] = torch.zeros_like(kwargs['masks'])
+ neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs)
+ return (1 + cfg_strength) * pred - cfg_strength * neg_pred
diff --git a/OmniPart/modules/part_synthesis/pipelines/samplers/flow_euler.py b/OmniPart/modules/part_synthesis/pipelines/samplers/flow_euler.py
new file mode 100644
index 0000000..d4ca3b7
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/samplers/flow_euler.py
@@ -0,0 +1,296 @@
+"""
+Flow Euler Samplers for Generative Models
+
+This file implements samplers for flow-matching generative models using the Euler integration method.
+It contains three main sampler classes:
+1. FlowEulerSampler: Base implementation of Euler sampling for flow-matching models
+2. FlowEulerCfgSampler: Adds classifier-free guidance to the Euler sampler
+3. FlowEulerGuidanceIntervalSampler: Enhances the sampler with both classifier-free guidance and guidance intervals
+
+Flow-matching models define continuous paths from noise to data, and these samplers implement
+ODE solvers (specifically Euler method) to follow these paths and generate samples.
+"""
+
+from typing import *
+import torch
+import numpy as np
+from tqdm import tqdm
+from easydict import EasyDict as edict
+from .base import Sampler
+from .classifier_free_guidance_mixin import ClassifierFreeGuidanceSamplerMixin
+from .guidance_interval_mixin import GuidanceIntervalSamplerMixin
+
+
+class FlowEulerSampler(Sampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling.
+
+ Args:
+ sigma_min: The minimum scale of noise in flow.
+ """
+ def __init__(
+ self,
+ sigma_min: float,
+ ):
+ # sigma_min controls the minimum noise level in the flow
+ self.sigma_min = sigma_min
+
+ def _eps_to_xstart(self, x_t, t, eps):
+ """
+ Convert noise prediction (epsilon) to predicted clean data (x_0).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ eps: Predicted noise
+
+ Returns:
+ Predicted clean data x_0
+ """
+ assert x_t.shape == eps.shape
+ return (x_t - (self.sigma_min + (1 - self.sigma_min) * t) * eps) / (1 - t)
+
+ def _xstart_to_eps(self, x_t, t, x_0):
+ """
+ Convert predicted clean data (x_0) to noise prediction (epsilon).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ x_0: Predicted clean data
+
+ Returns:
+ Implied noise prediction epsilon
+ """
+ assert x_t.shape == x_0.shape
+ return (x_t - (1 - t) * x_0) / (self.sigma_min + (1 - self.sigma_min) * t)
+
+ def _v_to_xstart_eps(self, x_t, t, v):
+ """
+ Convert velocity prediction (v) to predicted clean data (x_0) and noise (epsilon).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ v: Predicted velocity
+
+ Returns:
+ Tuple of (x_0, epsilon) derived from velocity
+ """
+ assert x_t.shape == v.shape
+ eps = (1 - t) * v + x_t
+ x_0 = (1 - self.sigma_min) * x_t - (self.sigma_min + (1 - self.sigma_min) * t) * v
+ return x_0, eps
+
+ def _inference_model(self, model, x_t, t, cond=None, **kwargs):
+ """
+ Run inference with the model.
+
+ Args:
+ model: The flow model
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep (will be scaled by 1000)
+ cond: Conditional information
+ kwargs: Additional arguments for model
+
+ Returns:
+ Model's predicted velocity
+ """
+ # Scale timestep by 1000 for model input
+ t = torch.tensor([1000 * t] * x_t.shape[0], device=x_t.device, dtype=torch.float32)
+ # Broadcast single condition to match batch size if needed
+ # print(f"cond shape: {cond.shape}")
+ if cond is not None and cond.shape[0] == 1 and x_t.shape[0] > 1:
+ cond = cond.repeat(x_t.shape[0], *([1] * (len(cond.shape) - 1)))
+ # print(f"cond shape after repeat: {cond.shape}")
+ return model(x_t, t, cond, **kwargs)
+
+ def _get_model_prediction(self, model, x_t, t, cond=None, **kwargs):
+ """
+ Get model predictions and convert to various formats.
+
+ Args:
+ model: The flow model
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ cond: Conditional information
+ kwargs: Additional arguments for model
+
+ Returns:
+ Tuple of (x_0, epsilon, velocity) predictions
+ """
+ pred_v = self._inference_model(model, x_t, t, cond, **kwargs)
+ pred_x_0, pred_eps = self._v_to_xstart_eps(x_t=x_t, t=t, v=pred_v)
+ return pred_x_0, pred_eps, pred_v
+
+ @torch.no_grad()
+ def sample_once(
+ self,
+ model,
+ x_t,
+ t: float,
+ t_prev: float,
+ cond: Optional[Any] = None,
+ **kwargs
+ ):
+ """
+ Sample x_{t-1} from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ x_t: The [N x C x ...] tensor of noisy inputs at time t.
+ t: The current timestep.
+ t_prev: The previous timestep.
+ cond: conditional information.
+ **kwargs: Additional arguments for model inference.
+
+ Returns:
+ a dict containing the following
+ - 'pred_x_prev': x_{t-1}.
+ - 'pred_x_0': a prediction of x_0.
+ """
+ # Get model predictions
+ pred_x_0, pred_eps, pred_v = self._get_model_prediction(model, x_t, t, cond, **kwargs)
+ # Euler step: x_{t-1} = x_t - (t - t_prev) * v_t
+ pred_x_prev = x_t - (t - t_prev) * pred_v
+ return edict({"pred_x_prev": pred_x_prev, "pred_x_0": pred_x_0})
+
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond: Optional[Any] = None,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ sample = noise
+ # Create a linearly spaced timestep sequence from 1 to 0
+ t_seq = np.linspace(1, 0, steps + 1)
+ # Apply rescaling to timesteps if needed
+ t_seq = rescale_t * t_seq / (1 + (rescale_t - 1) * t_seq)
+ # Create pairs of consecutive timesteps
+ t_pairs = list((t_seq[i], t_seq[i + 1]) for i in range(steps))
+
+ # Initialize return dictionary
+ ret = edict({"samples": None, "pred_x_t": [], "pred_x_0": []})
+ # print(f"shape of cond: {cond.shape}") # shape of cond: torch.Size([4, 1374, 1024])
+ # Perform Euler sampling steps
+ for t, t_prev in tqdm(t_pairs, desc="Sampling", disable=not verbose):
+ out = self.sample_once(model, sample, t, t_prev, cond, **kwargs)
+ sample = out.pred_x_prev
+ ret.pred_x_t.append(out.pred_x_prev)
+ ret.pred_x_0.append(out.pred_x_0)
+
+ ret.samples = sample
+ return ret
+
+
+class FlowEulerCfgSampler(ClassifierFreeGuidanceSamplerMixin, FlowEulerSampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling with classifier-free guidance.
+
+ This class adds classifier-free guidance to the Euler sampler, enabling conditional
+ generation with guidance strength control.
+ """
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond,
+ neg_cond,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ cfg_strength: float = 3.0,
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ neg_cond: negative conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ cfg_strength: The strength of classifier-free guidance.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ # Call the parent sample method with CFG parameters
+ return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, **kwargs)
+
+
+class FlowEulerGuidanceIntervalSampler(GuidanceIntervalSamplerMixin, FlowEulerSampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling with classifier-free guidance and interval.
+
+ This class extends the Euler sampler with both classifier-free guidance and the ability
+ to specify timestep intervals where guidance is applied.
+ """
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond,
+ neg_cond,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ cfg_strength: float = 3.0,
+ cfg_interval: Tuple[float, float] = (0.0, 1.0),
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ neg_cond: negative conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ cfg_strength: The strength of classifier-free guidance.
+ cfg_interval: The interval for classifier-free guidance.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ # Call the parent sample method with CFG and interval parameters
+ return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, cfg_interval=cfg_interval, **kwargs)
diff --git a/OmniPart/modules/part_synthesis/pipelines/samplers/guidance_interval_mixin.py b/OmniPart/modules/part_synthesis/pipelines/samplers/guidance_interval_mixin.py
new file mode 100644
index 0000000..c7e694e
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/pipelines/samplers/guidance_interval_mixin.py
@@ -0,0 +1,18 @@
+from typing import *
+import torch
+
+
+class GuidanceIntervalSamplerMixin:
+ """
+ A mixin class for samplers that apply classifier-free guidance with interval.
+ """
+
+ def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, cfg_interval, **kwargs):
+ if cfg_interval[0] <= t <= cfg_interval[1]:
+ pred = super()._inference_model(model, x_t, t, cond, **kwargs)
+ if 'masks' in kwargs:
+ kwargs['masks'] = torch.zeros_like(kwargs['masks'])
+ neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs)
+ return (1 + cfg_strength) * pred - cfg_strength * neg_pred
+ else:
+ return super()._inference_model(model, x_t, t, cond, **kwargs)
diff --git a/OmniPart/modules/part_synthesis/process_utils.py b/OmniPart/modules/part_synthesis/process_utils.py
new file mode 100644
index 0000000..d6de3b7
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/process_utils.py
@@ -0,0 +1,196 @@
+import os
+import imageio
+import torch
+from .utils import render_utils, postprocessing_utils
+from .representations.gaussian.gaussian_model import Gaussian
+
+
+def save_parts_outputs(outputs, output_dir, simplify_ratio, save_video=True, save_glb=True, textured=True,prefix="omini"):
+ os.makedirs(output_dir, exist_ok=True)
+
+ # num_parts = min(len(outputs['gaussian']), len(outputs['radiance_field']), len(outputs['mesh']))
+ num_parts = min(len(outputs['gaussian']), len(outputs['mesh']))
+ gs_list = []
+
+ for i in range(num_parts):
+ if i == 0:
+ continue
+ if save_video:
+ video = render_utils.render_video(outputs['gaussian'][i])['color']
+ gaussian_video_path = f"{output_dir}/part{i}_gs_text.mp4"
+ if os.path.exists(gaussian_video_path):
+ os.remove(gaussian_video_path)
+ imageio.mimsave(gaussian_video_path, video, fps=30)
+
+ video = render_utils.render_video(outputs['radiance_field'][i])['color']
+ rf_video_path = f"{output_dir}/part{i}_rf_text.mp4"
+ if os.path.exists(rf_video_path):
+ os.remove(rf_video_path)
+ imageio.mimsave(rf_video_path, video, fps=30)
+
+ video = render_utils.render_video(outputs['mesh'][i])['normal']
+ mesh_video_path = f"{output_dir}/part{i}_mesh_text.mp4"
+ if os.path.exists(mesh_video_path):
+ os.remove(mesh_video_path)
+ imageio.mimsave(mesh_video_path, video, fps=30)
+
+ if save_glb:
+ glb = postprocessing_utils.to_glb(
+ outputs['gaussian'][i],
+ outputs['mesh'][i],
+ simplify=simplify_ratio, # Mesh simplification factor
+ texture_size=1024,
+ textured=textured,
+ )
+ if glb is None:
+ continue
+ glb_path = f"{output_dir}/part{i}.glb"
+ if os.path.exists(glb_path):
+ os.remove(glb_path)
+ glb.export(glb_path)
+
+ if i == 0:
+ ply_path = f"{output_dir}/part{i}_gs.ply"
+ if os.path.exists(ply_path):
+ os.remove(ply_path)
+ outputs['gaussian'][i].save_ply(ply_path)
+ else:
+ gs_list.append(outputs['gaussian'][i])
+
+ merged_gaussian = merge_gaussians(gs_list)
+ merged_gaussian.save_ply(f"{output_dir}/{prefix}_merged_gs.ply")
+
+ exploded_gs = exploded_gaussians(gs_list, explosion_scale=0.3)
+ exploded_gs.save_ply(f"{output_dir}/{prefix}_exploded_gs.ply")
+ return
+
+
+def merge_gaussians(gaussians_list):
+ if not gaussians_list:
+ raise ValueError("gaussians_list is empty")
+
+ first_gaussian = gaussians_list[0]
+ merged_gaussian = Gaussian(**first_gaussian.init_params, device=first_gaussian.device)
+
+ xyz_list = []
+ features_dc_list = []
+ features_rest_list = []
+ scaling_list = []
+ rotation_list = []
+ opacity_list = []
+
+ for gaussian in gaussians_list:
+ if (gaussian.sh_degree != first_gaussian.sh_degree or
+ not torch.allclose(gaussian.aabb, first_gaussian.aabb)):
+ raise ValueError("All Gaussian objects must have the same sh_degree and aabb parameters")
+
+ if gaussian._xyz is not None:
+ xyz_list.append(gaussian._xyz)
+ if gaussian._features_dc is not None:
+ features_dc_list.append(gaussian._features_dc)
+ if gaussian._features_rest is not None:
+ features_rest_list.append(gaussian._features_rest)
+ if gaussian._scaling is not None:
+ scaling_list.append(gaussian._scaling)
+ if gaussian._rotation is not None:
+ rotation_list.append(gaussian._rotation)
+ if gaussian._opacity is not None:
+ opacity_list.append(gaussian._opacity)
+
+ if xyz_list:
+ merged_gaussian._xyz = torch.cat(xyz_list, dim=0)
+ if features_dc_list:
+ merged_gaussian._features_dc = torch.cat(features_dc_list, dim=0)
+ if features_rest_list:
+ merged_gaussian._features_rest = torch.cat(features_rest_list, dim=0)
+ else:
+ merged_gaussian._features_rest = None
+ if scaling_list:
+ merged_gaussian._scaling = torch.cat(scaling_list, dim=0)
+ if rotation_list:
+ merged_gaussian._rotation = torch.cat(rotation_list, dim=0)
+ if opacity_list:
+ merged_gaussian._opacity = torch.cat(opacity_list, dim=0)
+
+ return merged_gaussian
+
+
+def exploded_gaussians(gaussians_list, explosion_scale=0.4):
+
+ if not gaussians_list:
+ raise ValueError("gaussians_list is empty")
+
+ first_gaussian = gaussians_list[0]
+ merged_gaussian = Gaussian(**first_gaussian.init_params, device=first_gaussian.device)
+
+ xyz_list = []
+ features_dc_list = []
+ features_rest_list = []
+ scaling_list = []
+ rotation_list = []
+ opacity_list = []
+
+ all_centers = []
+ for gaussian in gaussians_list:
+ if gaussian._xyz is not None:
+ center = gaussian.get_xyz.mean(dim=0)
+ all_centers.append(center)
+
+ if not all_centers:
+ raise ValueError("No valid gaussians with xyz data found")
+
+ all_centers = torch.stack(all_centers)
+ global_center = all_centers.mean(dim=0)
+
+ for i, gaussian in enumerate(gaussians_list):
+ if (gaussian.sh_degree != first_gaussian.sh_degree or
+ not torch.allclose(gaussian.aabb, first_gaussian.aabb)):
+ raise ValueError("All Gaussian objects must have the same sh_degree and aabb parameters")
+
+ if i < len(all_centers):
+ part_center = all_centers[i]
+ direction = part_center - global_center
+ direction_norm = torch.norm(direction)
+ if direction_norm > 1e-6:
+ direction = direction / direction_norm
+ else:
+ direction = torch.randn(3, device=gaussian.device)
+ direction = direction / torch.norm(direction)
+
+ offset = direction * explosion_scale
+ else:
+ offset = torch.zeros(3, device=gaussian.device)
+
+ if gaussian._xyz is not None:
+ original_xyz = gaussian.get_xyz
+ exploded_xyz = original_xyz + offset
+ exploded_xyz_normalized = (exploded_xyz - gaussian.aabb[None, :3]) / gaussian.aabb[None, 3:]
+ xyz_list.append(exploded_xyz_normalized)
+
+ if gaussian._features_dc is not None:
+ features_dc_list.append(gaussian._features_dc)
+ if gaussian._features_rest is not None:
+ features_rest_list.append(gaussian._features_rest)
+ if gaussian._scaling is not None:
+ scaling_list.append(gaussian._scaling)
+ if gaussian._rotation is not None:
+ rotation_list.append(gaussian._rotation)
+ if gaussian._opacity is not None:
+ opacity_list.append(gaussian._opacity)
+
+ if xyz_list:
+ merged_gaussian._xyz = torch.cat(xyz_list, dim=0)
+ if features_dc_list:
+ merged_gaussian._features_dc = torch.cat(features_dc_list, dim=0)
+ if features_rest_list:
+ merged_gaussian._features_rest = torch.cat(features_rest_list, dim=0)
+ else:
+ merged_gaussian._features_rest = None
+ if scaling_list:
+ merged_gaussian._scaling = torch.cat(scaling_list, dim=0)
+ if rotation_list:
+ merged_gaussian._rotation = torch.cat(rotation_list, dim=0)
+ if opacity_list:
+ merged_gaussian._opacity = torch.cat(opacity_list, dim=0)
+
+ return merged_gaussian
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/renderers/__init__.py b/OmniPart/modules/part_synthesis/renderers/__init__.py
new file mode 100644
index 0000000..0339355
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/renderers/__init__.py
@@ -0,0 +1,31 @@
+import importlib
+
+__attributes = {
+ 'OctreeRenderer': 'octree_renderer',
+ 'GaussianRenderer': 'gaussian_render',
+ 'MeshRenderer': 'mesh_renderer',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .octree_renderer import OctreeRenderer
+ from .gaussian_render import GaussianRenderer
+ from .mesh_renderer import MeshRenderer
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/renderers/gaussian_render.py b/OmniPart/modules/part_synthesis/renderers/gaussian_render.py
new file mode 100644
index 0000000..bfc164d
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/renderers/gaussian_render.py
@@ -0,0 +1,307 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact george.drettakis@inria.fr
+#
+
+import torch
+import math
+from easydict import EasyDict as edict
+import numpy as np
+from ..representations.gaussian import Gaussian
+from .sh_utils import eval_sh
+import torch.nn.functional as F
+from easydict import EasyDict as edict
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ Convert OpenCV-style camera intrinsics matrix to OpenGL perspective projection matrix.
+
+ This function transforms a standard 3x3 camera intrinsics matrix into a 4x4 perspective
+ projection matrix compatible with OpenGL rendering pipeline. The resulting matrix
+ properly handles the coordinate system differences between computer vision and
+ computer graphics conventions.
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix containing focal lengths
+ and principal point coordinates
+ near (float): Distance to the near clipping plane (must be positive)
+ far (float): Distance to the far clipping plane (must be greater than near)
+
+ Returns:
+ torch.Tensor: [4, 4] OpenGL perspective projection matrix for rendering
+ """
+
+ # Extract focal lengths and principal point from intrinsics matrix
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1] # Focal lengths in x and y directions
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2] # Principal point coordinates
+
+ # Initialize empty 4x4 projection matrix
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+
+ # Fill in the projection matrix components
+ ret[0, 0] = 2 * fx # Scale for x axis based on horizontal focal length
+ ret[1, 1] = 2 * fy # Scale for y axis based on vertical focal length
+ ret[0, 2] = 2 * cx - 1 # X offset based on principal point (OpenCV to OpenGL conversion)
+ ret[1, 2] = - 2 * cy + 1 # Y offset based on principal point (with flipped Y axis)
+ ret[2, 2] = far / (far - near) # Handle depth mapping to clip space
+ ret[2, 3] = near * far / (near - far) # Term for perspective division in clip space
+ ret[3, 2] = 1. # Enable perspective division
+
+ return ret
+
+def render(viewpoint_camera, pc : Gaussian, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None):
+ """
+ Render the scene using 3D Gaussians.
+
+ This function performs the rasterization of 3D Gaussian points into a 2D image from a given viewpoint.
+
+ Args:
+ viewpoint_camera: Camera parameters including position, view transform, and projection
+ pc (Gaussian): Point cloud represented as 3D Gaussians
+ pipe: Pipeline configuration parameters
+ bg_color (torch.Tensor): Background color tensor (must be on GPU)
+ scaling_modifier (float): Scale modifier for the Gaussian splats
+ override_color (torch.Tensor, optional): Custom colors to override computed SH-based colors
+
+ Returns:
+ edict: Dictionary containing rendered image, viewspace points, visibility filter, and radii information
+ """
+ # Lazy import of the rasterization module to avoid circular dependencies
+ # or to improve startup performance when not needed immediately
+ if 'GaussianRasterizer' not in globals():
+ from diff_gaussian_rasterization import GaussianRasterizer, GaussianRasterizationSettings
+
+ # Create zero tensor for screen space points
+ # This tensor will hold gradients of the 2D (screen-space) means for optimization
+ screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0
+ try:
+ screenspace_points.retain_grad()
+ except:
+ pass
+
+ # Calculate camera frustum parameters from the field of view
+ tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
+ tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
+
+ # Get kernel size from the pipeline configuration
+ kernel_size = pipe.kernel_size
+
+ # Initialize subpixel offset for all pixels (used for anti-aliasing)
+ subpixel_offset = torch.zeros((int(viewpoint_camera.image_height), int(viewpoint_camera.image_width), 2),
+ dtype=torch.float32, device="cuda")
+
+ # Configure the Gaussian rasterization settings with all necessary parameters
+ raster_settings = GaussianRasterizationSettings(
+ image_height=int(viewpoint_camera.image_height),
+ image_width=int(viewpoint_camera.image_width),
+ tanfovx=tanfovx,
+ tanfovy=tanfovy,
+ kernel_size=kernel_size,
+ subpixel_offset=subpixel_offset,
+ bg=bg_color,
+ scale_modifier=scaling_modifier,
+ viewmatrix=viewpoint_camera.world_view_transform,
+ projmatrix=viewpoint_camera.full_proj_transform,
+ sh_degree=pc.active_sh_degree,
+ campos=viewpoint_camera.camera_center,
+ prefiltered=False,
+ debug=pipe.debug
+ )
+
+ # Create the rasterizer with the configured settings
+ rasterizer = GaussianRasterizer(raster_settings=raster_settings)
+
+ # Get the Gaussian 3D positions and opacities
+ means3D = pc.get_xyz
+ means2D = screenspace_points
+ opacity = pc.get_opacity
+
+ # Handle covariance computation options
+ # Either use precomputed 3D covariance or let the rasterizer compute it from scales and rotations
+ scales = None
+ rotations = None
+ cov3D_precomp = None
+ if pipe.compute_cov3D_python:
+ # Compute 3D covariances in Python before rasterization
+ cov3D_precomp = pc.get_covariance(scaling_modifier)
+ else:
+ # Let the rasterizer compute covariances from scale and rotation
+ scales = pc.get_scaling
+ rotations = pc.get_rotation
+
+ # Handle color computation options
+ # Either use override colors, precomputed colors from SHs, or let the rasterizer compute colors from SHs
+ shs = None
+ colors_precomp = None
+ if override_color is None:
+ if pipe.convert_SHs_python:
+ # Convert spherical harmonics to RGB colors in Python
+ shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2)
+ # Calculate the view direction from Gaussian center to camera
+ dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1))
+ dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True)
+ # Evaluate spherical harmonics to get RGB colors
+ sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
+ # Apply offset and clamp to ensure valid color values
+ colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
+ else:
+ # Let the rasterizer convert SHs to colors
+ shs = pc.get_features
+ else:
+ # Use provided override colors
+ colors_precomp = override_color
+
+ # Perform the rasterization to generate the final rendered image
+ # This projects the 3D Gaussians to 2D and blends them according to their opacities
+ rendered_image, radii = rasterizer(
+ means3D = means3D,
+ means2D = means2D,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ opacities = opacity,
+ scales = scales,
+ rotations = rotations,
+ cov3D_precomp = cov3D_precomp
+ )
+
+ # Return the rendering results in a dictionary
+ # radii > 0 creates a filter for visible Gaussians (those not frustum-culled)
+ return edict({"render": rendered_image,
+ "viewspace_points": screenspace_points,
+ "visibility_filter" : radii > 0,
+ "radii": radii})
+
+class GaussianRenderer:
+ """
+ A renderer for Gaussian Splatting that converts 3D Gaussian primitives into 2D images.
+
+ This renderer projects 3D Gaussian splats onto a 2D image plane using the provided
+ camera parameters, handling the rasterization process through an optimized backend.
+
+ Args:
+ rendering_options (dict): Configuration options for rendering including resolution,
+ depth range, background color, and supersampling level.
+ """
+
+ def __init__(self, rendering_options={}) -> None:
+ # Initialize default pipeline parameters
+ self.pipe = edict({
+ "kernel_size": 0.1, # Size of the Gaussian kernel for rasterization
+ "convert_SHs_python": False, # Whether to convert Spherical Harmonics to colors in Python
+ "compute_cov3D_python": False, # Whether to compute 3D covariance matrices in Python
+ "scale_modifier": 1.0, # Global scaling factor for all Gaussians
+ "debug": False # Enable/disable debug mode
+ })
+
+ # Initialize default rendering options
+ self.rendering_options = edict({
+ "resolution": None, # Output image resolution (width and height)
+ "near": None, # Near clipping plane distance
+ "far": None, # Far clipping plane distance
+ "ssaa": 1, # Super-sampling anti-aliasing factor (1 = disabled)
+ "bg_color": 'random', # Background color ('random' or specific color)
+ })
+
+ # Update with user-provided options
+ self.rendering_options.update(rendering_options)
+
+ # Initialize background color (will be set during rendering)
+ self.bg_color = None
+
+ def render(
+ self,
+ gausssian: Gaussian,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ colors_overwrite: torch.Tensor = None
+ ) -> edict:
+ """
+ Render the 3D Gaussian representation from a given camera viewpoint.
+
+ This method projects the 3D Gaussians onto a 2D image plane using the provided camera parameters,
+ handling the full rendering pipeline including projection, rasterization, and optional supersampling.
+
+ Args:
+ gaussian: The Gaussian representation containing positions, features, and other attributes
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics matrix defining camera position and orientation
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics matrix with focal lengths and principal point
+ colors_overwrite (torch.Tensor): Optional (N, 3) tensor to override Gaussian colors
+
+ Returns:
+ edict containing:
+ color (torch.Tensor): (3, H, W) rendered color image
+ """
+ # Extract rendering parameters from options
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"] # Super-sampling anti-aliasing factor
+
+ # Set background color based on rendering options
+ if self.rendering_options["bg_color"] == 'random':
+ # Randomly choose either black or white background
+ self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda")
+ if np.random.rand() < 0.5:
+ self.bg_color += 1
+ else:
+ # Use specified background color
+ self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda")
+
+ # Prepare camera parameters for the renderer
+ view = extrinsics # World-to-camera transform
+
+ # Convert OpenCV intrinsics to OpenGL projection matrix
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+
+ # Extract camera center from extrinsics (inverse of view matrix)
+ camera = torch.inverse(view)[:3, 3]
+
+ # Calculate field of view from focal lengths
+ focalx = intrinsics[0, 0]
+ focaly = intrinsics[1, 1]
+ fovx = 2 * torch.atan(0.5 / focalx) # Horizontal FoV in radians
+ fovy = 2 * torch.atan(0.5 / focaly) # Vertical FoV in radians
+
+ # Build complete camera parameter dictionary
+ camera_dict = edict({
+ "image_height": resolution * ssaa, # Apply supersampling if enabled
+ "image_width": resolution * ssaa,
+ "FoVx": fovx,
+ "FoVy": fovy,
+ "znear": near,
+ "zfar": far,
+ "world_view_transform": view.T.contiguous(), # Transpose for OpenGL convention
+ "projection_matrix": perspective.T.contiguous(),
+ "full_proj_transform": (perspective @ view).T.contiguous(), # Combined projection and view
+ "camera_center": camera
+ })
+
+ # Perform the actual rendering using the 3D Gaussian rasterizer
+ render_ret = render(camera_dict, gausssian, self.pipe, self.bg_color,
+ override_color=colors_overwrite, scaling_modifier=self.pipe.scale_modifier)
+
+ # Handle supersampling by downsampling the high-resolution render to the target resolution
+ if ssaa > 1:
+ # Use bilinear interpolation with antialiasing to downsample the image
+ render_ret.render = F.interpolate(render_ret.render[None],
+ size=(resolution, resolution),
+ mode='bilinear',
+ align_corners=False,
+ antialias=True).squeeze()
+
+ # Return the final rendered color image
+ ret = edict({
+ 'color': render_ret['render']
+ })
+ return ret
diff --git a/OmniPart/modules/part_synthesis/renderers/mesh_renderer.py b/OmniPart/modules/part_synthesis/renderers/mesh_renderer.py
new file mode 100644
index 0000000..b504fa4
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/renderers/mesh_renderer.py
@@ -0,0 +1,133 @@
+import torch
+import nvdiffrast.torch as dr
+from easydict import EasyDict as edict
+from ..representations.mesh import MeshExtractResult
+import torch.nn.functional as F
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ OpenCV intrinsics to OpenGL perspective matrix
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix
+ near (float): near plane to clip
+ far (float): far plane to clip
+ Returns:
+ (torch.Tensor): [4, 4] OpenGL perspective matrix
+ """
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1]
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2]
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+ ret[0, 0] = 2 * fx
+ ret[1, 1] = 2 * fy
+ ret[0, 2] = 2 * cx - 1
+ ret[1, 2] = - 2 * cy + 1
+ ret[2, 2] = far / (far - near)
+ ret[2, 3] = near * far / (near - far)
+ ret[3, 2] = 1.
+ return ret
+
+
+class MeshRenderer:
+ """
+ Renderer for the Mesh representation.
+
+ Args:
+ rendering_options (dict): Rendering options.
+ glctx (nvdiffrast.torch.RasterizeGLContext): RasterizeGLContext object for CUDA/OpenGL interop.
+ """
+ def __init__(self, rendering_options={}, device='cuda'):
+ self.rendering_options = edict({
+ "resolution": None,
+ "near": None,
+ "far": None,
+ "ssaa": 1
+ })
+ self.rendering_options.update(rendering_options)
+ self.glctx = dr.RasterizeCudaContext(device=device)
+ self.device=device
+
+ def render(
+ self,
+ mesh : MeshExtractResult,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ return_types = ["mask", "normal", "depth"]
+ ) -> edict:
+ """
+ Render the mesh.
+
+ Args:
+ mesh : meshmodel
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics
+ return_types (list): list of return types, can be "mask", "depth", "normal_map", "normal", "color"
+
+ Returns:
+ edict based on return_types containing:
+ color (torch.Tensor): [3, H, W] rendered color image
+ depth (torch.Tensor): [H, W] rendered depth image
+ normal (torch.Tensor): [3, H, W] rendered normal image
+ normal_map (torch.Tensor): [3, H, W] rendered normal map image
+ mask (torch.Tensor): [H, W] rendered mask image
+ """
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"]
+
+ if mesh.vertices.shape[0] == 0 or mesh.faces.shape[0] == 0:
+ default_img = torch.zeros((1, resolution, resolution, 3), dtype=torch.float32, device=self.device)
+ ret_dict = {k : default_img if k in ['normal', 'normal_map', 'color'] else default_img[..., :1] for k in return_types}
+ return ret_dict
+
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+
+ RT = extrinsics.unsqueeze(0)
+ full_proj = (perspective @ extrinsics).unsqueeze(0)
+
+ vertices = mesh.vertices.unsqueeze(0)
+
+ vertices_homo = torch.cat([vertices, torch.ones_like(vertices[..., :1])], dim=-1)
+ vertices_camera = torch.bmm(vertices_homo, RT.transpose(-1, -2))
+ vertices_clip = torch.bmm(vertices_homo, full_proj.transpose(-1, -2))
+ faces_int = mesh.faces.int()
+ rast, _ = dr.rasterize(
+ self.glctx, vertices_clip, faces_int, (resolution * ssaa, resolution * ssaa))
+
+ out_dict = edict()
+ for type in return_types:
+ img = None
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int)
+ elif type == "depth":
+ img = dr.interpolate(vertices_camera[..., 2:3].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ elif type == "normal" :
+ img = dr.interpolate(
+ mesh.face_normal.reshape(1, -1, 3), rast,
+ torch.arange(mesh.faces.shape[0] * 3, device=self.device, dtype=torch.int).reshape(-1, 3)
+ )[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ # normalize norm pictures
+ img = (img + 1) / 2
+ elif type == "normal_map" :
+ img = dr.interpolate(mesh.vertex_attrs[:, 3:].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ elif type == "color" :
+ img = dr.interpolate(mesh.vertex_attrs[:, :3].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+
+ if ssaa > 1:
+ img = F.interpolate(img.permute(0, 3, 1, 2), (resolution, resolution), mode='bilinear', align_corners=False, antialias=True)
+ img = img.squeeze()
+ else:
+ img = img.permute(0, 3, 1, 2).squeeze()
+ out_dict[type] = img
+
+ return out_dict
diff --git a/OmniPart/modules/part_synthesis/renderers/octree_renderer.py b/OmniPart/modules/part_synthesis/renderers/octree_renderer.py
new file mode 100644
index 0000000..136069c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/renderers/octree_renderer.py
@@ -0,0 +1,300 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+import math
+import cv2
+from scipy.stats import qmc
+from easydict import EasyDict as edict
+from ..representations.octree import DfsOctree
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ OpenCV intrinsics to OpenGL perspective matrix
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix
+ near (float): near plane to clip
+ far (float): far plane to clip
+ Returns:
+ (torch.Tensor): [4, 4] OpenGL perspective matrix
+ """
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1]
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2]
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+ ret[0, 0] = 2 * fx
+ ret[1, 1] = 2 * fy
+ ret[0, 2] = 2 * cx - 1
+ ret[1, 2] = - 2 * cy + 1
+ ret[2, 2] = far / (far - near)
+ ret[2, 3] = near * far / (near - far)
+ ret[3, 2] = 1.
+ return ret
+
+
+def render(viewpoint_camera, octree : DfsOctree, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, used_rank = None, colors_overwrite = None, aux=None, halton_sampler=None):
+ """
+ Render the scene.
+
+ Background tensor (bg_color) must be on GPU!
+ """
+ # lazy import
+ if 'OctreeTrivecRasterizer' not in globals():
+ from diffoctreerast import OctreeVoxelRasterizer, OctreeGaussianRasterizer, OctreeTrivecRasterizer, OctreeDecoupolyRasterizer
+
+ # Set up rasterization configuration
+ tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
+ tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
+
+ raster_settings = edict(
+ image_height=int(viewpoint_camera.image_height),
+ image_width=int(viewpoint_camera.image_width),
+ tanfovx=tanfovx,
+ tanfovy=tanfovy,
+ bg=bg_color,
+ scale_modifier=scaling_modifier,
+ viewmatrix=viewpoint_camera.world_view_transform,
+ projmatrix=viewpoint_camera.full_proj_transform,
+ sh_degree=octree.active_sh_degree,
+ campos=viewpoint_camera.camera_center,
+ with_distloss=pipe.with_distloss,
+ jitter=pipe.jitter,
+ debug=pipe.debug,
+ )
+
+ positions = octree.get_xyz
+ if octree.primitive == "voxel":
+ densities = octree.get_density
+ elif octree.primitive == "gaussian":
+ opacities = octree.get_opacity
+ elif octree.primitive == "trivec":
+ trivecs = octree.get_trivec
+ densities = octree.get_density
+ raster_settings.density_shift = octree.density_shift
+ elif octree.primitive == "decoupoly":
+ decoupolys_V, decoupolys_g = octree.get_decoupoly
+ densities = octree.get_density
+ raster_settings.density_shift = octree.density_shift
+ else:
+ raise ValueError(f"Unknown primitive {octree.primitive}")
+ depths = octree.get_depth
+
+ # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors
+ # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer.
+ colors_precomp = None
+ shs = octree.get_features
+ if octree.primitive in ["voxel", "gaussian"] and colors_overwrite is not None:
+ colors_precomp = colors_overwrite
+ shs = None
+
+ ret = edict()
+
+ if octree.primitive == "voxel":
+ renderer = OctreeVoxelRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha, distloss = renderer(
+ positions = positions,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ ret['distloss'] = distloss
+ elif octree.primitive == "gaussian":
+ renderer = OctreeGaussianRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha = renderer(
+ positions = positions,
+ opacities = opacities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ elif octree.primitive == "trivec":
+ raster_settings.used_rank = used_rank if used_rank is not None else trivecs.shape[1]
+ renderer = OctreeTrivecRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha, percent_depth = renderer(
+ positions = positions,
+ trivecs = trivecs,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ colors_overwrite = colors_overwrite,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ halton_sampler = halton_sampler,
+ )
+ ret['percent_depth'] = percent_depth
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ elif octree.primitive == "decoupoly":
+ raster_settings.used_rank = used_rank if used_rank is not None else decoupolys_V.shape[1]
+ renderer = OctreeDecoupolyRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha = renderer(
+ positions = positions,
+ decoupolys_V = decoupolys_V,
+ decoupolys_g = decoupolys_g,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+
+ return ret
+
+
+class OctreeRenderer:
+ """
+ Renderer for the Voxel representation.
+
+ Args:
+ rendering_options (dict): Rendering options.
+ """
+
+ def __init__(self, rendering_options={}) -> None:
+ try:
+ import diffoctreerast
+ except ImportError:
+ print("\033[93m[WARNING] diffoctreerast is not installed. The renderer will be disabled.\033[0m")
+ self.unsupported = True
+ else:
+ self.unsupported = False
+
+ self.pipe = edict({
+ "with_distloss": False,
+ "with_aux": False,
+ "scale_modifier": 1.0,
+ "used_rank": None,
+ "jitter": False,
+ "debug": False,
+ })
+ self.rendering_options = edict({
+ "resolution": None,
+ "near": None,
+ "far": None,
+ "ssaa": 1,
+ "bg_color": 'random',
+ })
+ self.halton_sampler = qmc.Halton(2, scramble=False)
+ self.rendering_options.update(rendering_options)
+ self.bg_color = None
+
+ def render(
+ self,
+ octree: DfsOctree,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ colors_overwrite: torch.Tensor = None,
+ ) -> edict:
+ """
+ Render the octree.
+
+ Args:
+ octree (Octree): octree
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics
+ colors_overwrite (torch.Tensor): (N, 3) override color
+
+ Returns:
+ edict containing:
+ color (torch.Tensor): (3, H, W) rendered color
+ depth (torch.Tensor): (H, W) rendered depth
+ alpha (torch.Tensor): (H, W) rendered alpha
+ distloss (Optional[torch.Tensor]): (H, W) rendered distance loss
+ percent_depth (Optional[torch.Tensor]): (H, W) rendered percent depth
+ aux (Optional[edict]): auxiliary tensors
+ """
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"]
+
+ if self.unsupported:
+ image = np.zeros((512, 512, 3), dtype=np.uint8)
+ text_bbox = cv2.getTextSize("Unsupported", cv2.FONT_HERSHEY_SIMPLEX, 2, 3)[0]
+ origin = (512 - text_bbox[0]) // 2, (512 - text_bbox[1]) // 2
+ image = cv2.putText(image, "Unsupported", origin, cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 3, cv2.LINE_AA)
+ return {
+ 'color': torch.tensor(image, dtype=torch.float32).permute(2, 0, 1) / 255,
+ }
+
+ if self.rendering_options["bg_color"] == 'random':
+ self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda")
+ if np.random.rand() < 0.5:
+ self.bg_color += 1
+ else:
+ self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda")
+
+ if self.pipe["with_aux"]:
+ aux = {
+ 'grad_color2': torch.zeros((octree.num_leaf_nodes, 3), dtype=torch.float32, requires_grad=True, device="cuda") + 0,
+ 'contributions': torch.zeros((octree.num_leaf_nodes, 1), dtype=torch.float32, requires_grad=True, device="cuda") + 0,
+ }
+ for k in aux.keys():
+ aux[k].requires_grad_()
+ aux[k].retain_grad()
+ else:
+ aux = None
+
+ view = extrinsics
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+ camera = torch.inverse(view)[:3, 3]
+ focalx = intrinsics[0, 0]
+ focaly = intrinsics[1, 1]
+ fovx = 2 * torch.atan(0.5 / focalx)
+ fovy = 2 * torch.atan(0.5 / focaly)
+
+ camera_dict = edict({
+ "image_height": resolution * ssaa,
+ "image_width": resolution * ssaa,
+ "FoVx": fovx,
+ "FoVy": fovy,
+ "znear": near,
+ "zfar": far,
+ "world_view_transform": view.T.contiguous(),
+ "projection_matrix": perspective.T.contiguous(),
+ "full_proj_transform": (perspective @ view).T.contiguous(),
+ "camera_center": camera
+ })
+
+ # Render
+ render_ret = render(camera_dict, octree, self.pipe, self.bg_color, aux=aux, colors_overwrite=colors_overwrite, scaling_modifier=self.pipe.scale_modifier, used_rank=self.pipe.used_rank, halton_sampler=self.halton_sampler)
+
+ if ssaa > 1:
+ render_ret.rgb = F.interpolate(render_ret.rgb[None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ render_ret.depth = F.interpolate(render_ret.depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ render_ret.alpha = F.interpolate(render_ret.alpha[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ if hasattr(render_ret, 'percent_depth'):
+ render_ret.percent_depth = F.interpolate(render_ret.percent_depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+
+ ret = edict({
+ 'color': render_ret.rgb,
+ 'depth': render_ret.depth,
+ 'alpha': render_ret.alpha,
+ })
+ if self.pipe["with_distloss"] and 'distloss' in render_ret:
+ ret['distloss'] = render_ret.distloss
+ if self.pipe["with_aux"]:
+ ret['aux'] = aux
+ if hasattr(render_ret, 'percent_depth'):
+ ret['percent_depth'] = render_ret.percent_depth
+ return ret
diff --git a/OmniPart/modules/part_synthesis/renderers/sh_utils.py b/OmniPart/modules/part_synthesis/renderers/sh_utils.py
new file mode 100644
index 0000000..bbca7d1
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/renderers/sh_utils.py
@@ -0,0 +1,118 @@
+# Copyright 2021 The PlenOctree Authors.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+import torch
+
+C0 = 0.28209479177387814
+C1 = 0.4886025119029199
+C2 = [
+ 1.0925484305920792,
+ -1.0925484305920792,
+ 0.31539156525252005,
+ -1.0925484305920792,
+ 0.5462742152960396
+]
+C3 = [
+ -0.5900435899266435,
+ 2.890611442640554,
+ -0.4570457994644658,
+ 0.3731763325901154,
+ -0.4570457994644658,
+ 1.445305721320277,
+ -0.5900435899266435
+]
+C4 = [
+ 2.5033429417967046,
+ -1.7701307697799304,
+ 0.9461746957575601,
+ -0.6690465435572892,
+ 0.10578554691520431,
+ -0.6690465435572892,
+ 0.47308734787878004,
+ -1.7701307697799304,
+ 0.6258357354491761,
+]
+
+
+def eval_sh(deg, sh, dirs):
+ """
+ Evaluate spherical harmonics at unit directions
+ using hardcoded SH polynomials.
+ Works with torch/np/jnp.
+ ... Can be 0 or more batch dimensions.
+ Args:
+ deg: int SH deg. Currently, 0-3 supported
+ sh: jnp.ndarray SH coeffs [..., C, (deg + 1) ** 2]
+ dirs: jnp.ndarray unit directions [..., 3]
+ Returns:
+ [..., C]
+ """
+ assert deg <= 4 and deg >= 0
+ coeff = (deg + 1) ** 2
+ assert sh.shape[-1] >= coeff
+
+ result = C0 * sh[..., 0]
+ if deg > 0:
+ x, y, z = dirs[..., 0:1], dirs[..., 1:2], dirs[..., 2:3]
+ result = (result -
+ C1 * y * sh[..., 1] +
+ C1 * z * sh[..., 2] -
+ C1 * x * sh[..., 3])
+
+ if deg > 1:
+ xx, yy, zz = x * x, y * y, z * z
+ xy, yz, xz = x * y, y * z, x * z
+ result = (result +
+ C2[0] * xy * sh[..., 4] +
+ C2[1] * yz * sh[..., 5] +
+ C2[2] * (2.0 * zz - xx - yy) * sh[..., 6] +
+ C2[3] * xz * sh[..., 7] +
+ C2[4] * (xx - yy) * sh[..., 8])
+
+ if deg > 2:
+ result = (result +
+ C3[0] * y * (3 * xx - yy) * sh[..., 9] +
+ C3[1] * xy * z * sh[..., 10] +
+ C3[2] * y * (4 * zz - xx - yy)* sh[..., 11] +
+ C3[3] * z * (2 * zz - 3 * xx - 3 * yy) * sh[..., 12] +
+ C3[4] * x * (4 * zz - xx - yy) * sh[..., 13] +
+ C3[5] * z * (xx - yy) * sh[..., 14] +
+ C3[6] * x * (xx - 3 * yy) * sh[..., 15])
+
+ if deg > 3:
+ result = (result + C4[0] * xy * (xx - yy) * sh[..., 16] +
+ C4[1] * yz * (3 * xx - yy) * sh[..., 17] +
+ C4[2] * xy * (7 * zz - 1) * sh[..., 18] +
+ C4[3] * yz * (7 * zz - 3) * sh[..., 19] +
+ C4[4] * (zz * (35 * zz - 30) + 3) * sh[..., 20] +
+ C4[5] * xz * (7 * zz - 3) * sh[..., 21] +
+ C4[6] * (xx - yy) * (7 * zz - 1) * sh[..., 22] +
+ C4[7] * xz * (xx - 3 * yy) * sh[..., 23] +
+ C4[8] * (xx * (xx - 3 * yy) - yy * (3 * xx - yy)) * sh[..., 24])
+ return result
+
+def RGB2SH(rgb):
+ return (rgb - 0.5) / C0
+
+def SH2RGB(sh):
+ return sh * C0 + 0.5
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/__init__.py b/OmniPart/modules/part_synthesis/representations/__init__.py
new file mode 100644
index 0000000..549ffdb
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/__init__.py
@@ -0,0 +1,4 @@
+from .radiance_field import Strivec
+from .octree import DfsOctree as Octree
+from .gaussian import Gaussian
+from .mesh import MeshExtractResult
diff --git a/OmniPart/modules/part_synthesis/representations/gaussian/__init__.py b/OmniPart/modules/part_synthesis/representations/gaussian/__init__.py
new file mode 100644
index 0000000..e3de6e1
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/gaussian/__init__.py
@@ -0,0 +1 @@
+from .gaussian_model import Gaussian
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/gaussian/gaussian_model.py b/OmniPart/modules/part_synthesis/representations/gaussian/gaussian_model.py
new file mode 100644
index 0000000..b312a57
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/gaussian/gaussian_model.py
@@ -0,0 +1,210 @@
+import torch
+import numpy as np
+from plyfile import PlyData, PlyElement
+from .general_utils import inverse_sigmoid, strip_symmetric, build_scaling_rotation
+import utils3d
+
+
+class Gaussian:
+ def __init__(
+ self,
+ aabb : list,
+ sh_degree : int = 0,
+ mininum_kernel_size : float = 0.0,
+ scaling_bias : float = 0.01,
+ opacity_bias : float = 0.1,
+ scaling_activation : str = "exp",
+ device='cuda'
+ ):
+ self.init_params = {
+ 'aabb': aabb,
+ 'sh_degree': sh_degree,
+ 'mininum_kernel_size': mininum_kernel_size,
+ 'scaling_bias': scaling_bias,
+ 'opacity_bias': opacity_bias,
+ 'scaling_activation': scaling_activation,
+ }
+
+ self.sh_degree = sh_degree
+ self.active_sh_degree = sh_degree
+ self.mininum_kernel_size = mininum_kernel_size
+ self.scaling_bias = scaling_bias
+ self.opacity_bias = opacity_bias
+ self.scaling_activation_type = scaling_activation
+ self.device = device
+ self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device)
+ self.setup_functions()
+
+ self._xyz = None
+ self._features_dc = None
+ self._features_rest = None
+ self._scaling = None
+ self._rotation = None
+ self._opacity = None
+
+ def setup_functions(self):
+ def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation):
+ L = build_scaling_rotation(scaling_modifier * scaling, rotation)
+ actual_covariance = L @ L.transpose(1, 2)
+ symm = strip_symmetric(actual_covariance)
+ return symm
+
+ if self.scaling_activation_type == "exp":
+ self.scaling_activation = torch.exp
+ self.inverse_scaling_activation = torch.log
+ elif self.scaling_activation_type == "softplus":
+ self.scaling_activation = torch.nn.functional.softplus
+ self.inverse_scaling_activation = lambda x: x + torch.log(-torch.expm1(-x))
+
+ self.covariance_activation = build_covariance_from_scaling_rotation
+
+ self.opacity_activation = torch.sigmoid
+ self.inverse_opacity_activation = inverse_sigmoid
+
+ self.rotation_activation = torch.nn.functional.normalize
+
+ self.scale_bias = self.inverse_scaling_activation(torch.tensor(self.scaling_bias)).cuda()
+ self.rots_bias = torch.zeros((4)).cuda()
+ self.rots_bias[0] = 1
+ self.opacity_bias = self.inverse_opacity_activation(torch.tensor(self.opacity_bias)).cuda()
+
+ @property
+ def get_scaling(self):
+ scales = self.scaling_activation(self._scaling + self.scale_bias)
+ scales = torch.square(scales) + self.mininum_kernel_size ** 2
+ scales = torch.sqrt(scales)
+ return scales
+
+ @property
+ def get_rotation(self):
+ return self.rotation_activation(self._rotation + self.rots_bias[None, :])
+
+ @property
+ def get_xyz(self):
+ return self._xyz * self.aabb[None, 3:] + self.aabb[None, :3]
+
+ @property
+ def get_features(self):
+ return torch.cat((self._features_dc, self._features_rest), dim=2) if self._features_rest is not None else self._features_dc
+
+ @property
+ def get_opacity(self):
+ return self.opacity_activation(self._opacity + self.opacity_bias)
+
+ def get_covariance(self, scaling_modifier = 1):
+ return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation + self.rots_bias[None, :])
+
+ def from_scaling(self, scales):
+ scales = torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2)
+ self._scaling = self.inverse_scaling_activation(scales) - self.scale_bias
+
+ def from_rotation(self, rots):
+ self._rotation = rots - self.rots_bias[None, :]
+
+ def from_xyz(self, xyz):
+ self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:]
+
+ def from_features(self, features):
+ self._features_dc = features
+
+ def from_opacity(self, opacities):
+ self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias
+
+ def construct_list_of_attributes(self):
+ l = ['x', 'y', 'z', 'nx', 'ny', 'nz']
+ # All channels except the 3 DC
+ for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]):
+ l.append('f_dc_{}'.format(i))
+ l.append('opacity')
+ for i in range(self._scaling.shape[1]):
+ l.append('scale_{}'.format(i))
+ for i in range(self._rotation.shape[1]):
+ l.append('rot_{}'.format(i))
+ return l
+
+ def save_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]):
+ xyz = self.get_xyz.detach().cpu().numpy()
+ normals = np.zeros_like(xyz)
+ f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
+ opacities = inverse_sigmoid(self.get_opacity).detach().cpu().numpy()
+ scale = torch.log(self.get_scaling).detach().cpu().numpy()
+ rotation = (self._rotation + self.rots_bias[None, :]).detach().cpu().numpy()
+
+ if transform is not None:
+ transform = np.array(transform)
+ xyz = np.matmul(xyz, transform.T)
+ rotation = utils3d.numpy.quaternion_to_matrix(rotation)
+ rotation = np.matmul(transform, rotation)
+ rotation = utils3d.numpy.matrix_to_quaternion(rotation)
+
+ dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()]
+
+ elements = np.empty(xyz.shape[0], dtype=dtype_full)
+ attributes = np.concatenate((xyz, normals, f_dc, opacities, scale, rotation), axis=1)
+ elements[:] = list(map(tuple, attributes))
+ el = PlyElement.describe(elements, 'vertex')
+ PlyData([el]).write(path)
+
+ def load_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]):
+ plydata = PlyData.read(path)
+
+ xyz = np.stack((np.asarray(plydata.elements[0]["x"]),
+ np.asarray(plydata.elements[0]["y"]),
+ np.asarray(plydata.elements[0]["z"])), axis=1)
+ opacities = np.asarray(plydata.elements[0]["opacity"])[..., np.newaxis]
+
+ features_dc = np.zeros((xyz.shape[0], 3, 1))
+ features_dc[:, 0, 0] = np.asarray(plydata.elements[0]["f_dc_0"])
+ features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"])
+ features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"])
+
+ if self.sh_degree > 0:
+ extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")]
+ extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1]))
+ assert len(extra_f_names)==3*(self.sh_degree + 1) ** 2 - 3
+ features_extra = np.zeros((xyz.shape[0], len(extra_f_names)))
+ for idx, attr_name in enumerate(extra_f_names):
+ features_extra[:, idx] = np.asarray(plydata.elements[0][attr_name])
+ # Reshape (P,F*SH_coeffs) to (P, F, SH_coeffs except DC)
+ features_extra = features_extra.reshape((features_extra.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1))
+
+ scale_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("scale_")]
+ scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1]))
+ scales = np.zeros((xyz.shape[0], len(scale_names)))
+ for idx, attr_name in enumerate(scale_names):
+ scales[:, idx] = np.asarray(plydata.elements[0][attr_name])
+
+ rot_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("rot")]
+ rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1]))
+ rots = np.zeros((xyz.shape[0], len(rot_names)))
+ for idx, attr_name in enumerate(rot_names):
+ rots[:, idx] = np.asarray(plydata.elements[0][attr_name])
+
+ if transform is not None:
+ transform = np.array(transform)
+ xyz = np.matmul(xyz, transform)
+ rotation = utils3d.numpy.quaternion_to_matrix(rotation)
+ rotation = np.matmul(rotation, transform)
+ rotation = utils3d.numpy.matrix_to_quaternion(rotation)
+
+ # convert to actual gaussian attributes
+ xyz = torch.tensor(xyz, dtype=torch.float, device=self.device)
+ features_dc = torch.tensor(features_dc, dtype=torch.float, device=self.device).transpose(1, 2).contiguous()
+ if self.sh_degree > 0:
+ features_extra = torch.tensor(features_extra, dtype=torch.float, device=self.device).transpose(1, 2).contiguous()
+ opacities = torch.sigmoid(torch.tensor(opacities, dtype=torch.float, device=self.device))
+ scales = torch.exp(torch.tensor(scales, dtype=torch.float, device=self.device))
+ rots = torch.tensor(rots, dtype=torch.float, device=self.device)
+
+ # convert to _hidden attributes
+ self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:]
+ self._features_dc = features_dc
+ if self.sh_degree > 0:
+ self._features_rest = features_extra
+ else:
+ self._features_rest = None
+ self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias
+ self._scaling = self.inverse_scaling_activation(torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2)) - self.scale_bias
+ self._rotation = rots - self.rots_bias[None, :]
+
+
diff --git a/OmniPart/modules/part_synthesis/representations/gaussian/general_utils.py b/OmniPart/modules/part_synthesis/representations/gaussian/general_utils.py
new file mode 100644
index 0000000..541c082
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/gaussian/general_utils.py
@@ -0,0 +1,133 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact george.drettakis@inria.fr
+#
+
+import torch
+import sys
+from datetime import datetime
+import numpy as np
+import random
+
+def inverse_sigmoid(x):
+ return torch.log(x/(1-x))
+
+def PILtoTorch(pil_image, resolution):
+ resized_image_PIL = pil_image.resize(resolution)
+ resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0
+ if len(resized_image.shape) == 3:
+ return resized_image.permute(2, 0, 1)
+ else:
+ return resized_image.unsqueeze(dim=-1).permute(2, 0, 1)
+
+def get_expon_lr_func(
+ lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000
+):
+ """
+ Copied from Plenoxels
+
+ Continuous learning rate decay function. Adapted from JaxNeRF
+ The returned rate is lr_init when step=0 and lr_final when step=max_steps, and
+ is log-linearly interpolated elsewhere (equivalent to exponential decay).
+ If lr_delay_steps>0 then the learning rate will be scaled by some smooth
+ function of lr_delay_mult, such that the initial learning rate is
+ lr_init*lr_delay_mult at the beginning of optimization but will be eased back
+ to the normal learning rate when steps>lr_delay_steps.
+ :param conf: config subtree 'lr' or similar
+ :param max_steps: int, the number of steps during optimization.
+ :return HoF which takes step as input
+ """
+
+ def helper(step):
+ if step < 0 or (lr_init == 0.0 and lr_final == 0.0):
+ # Disable this parameter
+ return 0.0
+ if lr_delay_steps > 0:
+ # A kind of reverse cosine decay.
+ delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(
+ 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)
+ )
+ else:
+ delay_rate = 1.0
+ t = np.clip(step / max_steps, 0, 1)
+ log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t)
+ return delay_rate * log_lerp
+
+ return helper
+
+def strip_lowerdiag(L):
+ uncertainty = torch.zeros((L.shape[0], 6), dtype=torch.float, device="cuda")
+
+ uncertainty[:, 0] = L[:, 0, 0]
+ uncertainty[:, 1] = L[:, 0, 1]
+ uncertainty[:, 2] = L[:, 0, 2]
+ uncertainty[:, 3] = L[:, 1, 1]
+ uncertainty[:, 4] = L[:, 1, 2]
+ uncertainty[:, 5] = L[:, 2, 2]
+ return uncertainty
+
+def strip_symmetric(sym):
+ return strip_lowerdiag(sym)
+
+def build_rotation(r):
+ norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3])
+
+ q = r / norm[:, None]
+
+ R = torch.zeros((q.size(0), 3, 3), device='cuda')
+
+ r = q[:, 0]
+ x = q[:, 1]
+ y = q[:, 2]
+ z = q[:, 3]
+
+ R[:, 0, 0] = 1 - 2 * (y*y + z*z)
+ R[:, 0, 1] = 2 * (x*y - r*z)
+ R[:, 0, 2] = 2 * (x*z + r*y)
+ R[:, 1, 0] = 2 * (x*y + r*z)
+ R[:, 1, 1] = 1 - 2 * (x*x + z*z)
+ R[:, 1, 2] = 2 * (y*z - r*x)
+ R[:, 2, 0] = 2 * (x*z - r*y)
+ R[:, 2, 1] = 2 * (y*z + r*x)
+ R[:, 2, 2] = 1 - 2 * (x*x + y*y)
+ return R
+
+def build_scaling_rotation(s, r):
+ L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device="cuda")
+ R = build_rotation(r)
+
+ L[:,0,0] = s[:,0]
+ L[:,1,1] = s[:,1]
+ L[:,2,2] = s[:,2]
+
+ L = R @ L
+ return L
+
+def safe_state(silent):
+ old_f = sys.stdout
+ class F:
+ def __init__(self, silent):
+ self.silent = silent
+
+ def write(self, x):
+ if not self.silent:
+ if x.endswith("\n"):
+ old_f.write(x.replace("\n", " [{}]\n".format(str(datetime.now().strftime("%d/%m %H:%M:%S")))))
+ else:
+ old_f.write(x)
+
+ def flush(self):
+ old_f.flush()
+
+ sys.stdout = F(silent)
+
+ random.seed(0)
+ np.random.seed(0)
+ torch.manual_seed(0)
+ torch.cuda.set_device(torch.device("cuda:0"))
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/__init__.py b/OmniPart/modules/part_synthesis/representations/mesh/__init__.py
new file mode 100644
index 0000000..38cf35c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/__init__.py
@@ -0,0 +1 @@
+from .cube2mesh import SparseFeatures2Mesh, MeshExtractResult
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/cube2mesh.py b/OmniPart/modules/part_synthesis/representations/mesh/cube2mesh.py
new file mode 100644
index 0000000..44e8776
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/cube2mesh.py
@@ -0,0 +1,143 @@
+import torch
+from ...modules.sparse import SparseTensor
+from easydict import EasyDict as edict
+from .utils_cube import *
+from .flexicubes.flexicubes import FlexiCubes
+
+
+class MeshExtractResult:
+ def __init__(self,
+ vertices,
+ faces,
+ vertex_attrs=None,
+ res=64
+ ):
+ self.vertices = vertices
+ self.faces = faces.long()
+ self.vertex_attrs = vertex_attrs
+ self.face_normal = self.comput_face_normals(vertices, faces)
+ self.res = res
+ self.success = (vertices.shape[0] != 0 and faces.shape[0] != 0)
+
+ # training only
+ self.tsdf_v = None
+ self.tsdf_s = None
+ self.reg_loss = None
+
+ def comput_face_normals(self, verts, faces):
+ i0 = faces[..., 0].long()
+ i1 = faces[..., 1].long()
+ i2 = faces[..., 2].long()
+
+ v0 = verts[i0, :]
+ v1 = verts[i1, :]
+ v2 = verts[i2, :]
+ face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1)
+ face_normals = torch.nn.functional.normalize(face_normals, dim=1)
+ # print(face_normals.min(), face_normals.max(), face_normals.shape)
+ return face_normals[:, None, :].repeat(1, 3, 1)
+
+ def comput_v_normals(self, verts, faces):
+ i0 = faces[..., 0].long()
+ i1 = faces[..., 1].long()
+ i2 = faces[..., 2].long()
+
+ v0 = verts[i0, :]
+ v1 = verts[i1, :]
+ v2 = verts[i2, :]
+ face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1)
+ v_normals = torch.zeros_like(verts)
+ v_normals.scatter_add_(0, i0[..., None].repeat(1, 3), face_normals)
+ v_normals.scatter_add_(0, i1[..., None].repeat(1, 3), face_normals)
+ v_normals.scatter_add_(0, i2[..., None].repeat(1, 3), face_normals)
+
+ v_normals = torch.nn.functional.normalize(v_normals, dim=1)
+ return v_normals
+
+
+class SparseFeatures2Mesh:
+ def __init__(self, device="cuda", res=64, use_color=True):
+ '''
+ a model to generate a mesh from sparse features structures using flexicube
+ '''
+ super().__init__()
+ self.device=device
+ self.res = res
+ self.mesh_extractor = FlexiCubes(device=device)
+ self.sdf_bias = -1.0 / res
+ verts, cube = construct_dense_grid(self.res, self.device)
+ self.reg_c = cube.to(self.device)
+ self.reg_v = verts.to(self.device)
+ self.use_color = use_color
+ self._calc_layout()
+
+ def _calc_layout(self):
+ LAYOUTS = {
+ 'sdf': {'shape': (8, 1), 'size': 8},
+ 'deform': {'shape': (8, 3), 'size': 8 * 3},
+ 'weights': {'shape': (21,), 'size': 21}
+ }
+ if self.use_color:
+ '''
+ 6 channel color including normal map
+ '''
+ LAYOUTS['color'] = {'shape': (8, 6,), 'size': 8 * 6}
+ self.layouts = edict(LAYOUTS)
+ start = 0
+ for k, v in self.layouts.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.feats_channels = start
+
+ def get_layout(self, feats : torch.Tensor, name : str):
+ if name not in self.layouts:
+ return None
+ return feats[:, self.layouts[name]['range'][0]:self.layouts[name]['range'][1]].reshape(-1, *self.layouts[name]['shape'])
+
+ def __call__(self, cubefeats : SparseTensor, training=False):
+ """
+ Generates a mesh based on the specified sparse voxel structures.
+ Args:
+ cube_attrs [Nx21] : Sparse Tensor attrs about cube weights
+ verts_attrs [Nx10] : [0:1] SDF [1:4] deform [4:7] color [7:10] normal
+ Returns:
+ return the success tag and ni you loss,
+ """
+ # add sdf bias to verts_attrs
+ coords = cubefeats.coords[:, 1:]
+ feats = cubefeats.feats
+
+ sdf, deform, color, weights = [self.get_layout(feats, name) for name in ['sdf', 'deform', 'color', 'weights']]
+ sdf += self.sdf_bias
+ v_attrs = [sdf, deform, color] if self.use_color else [sdf, deform]
+ v_pos, v_attrs, reg_loss = sparse_cube2verts(coords, torch.cat(v_attrs, dim=-1), training=training)
+ v_attrs_d = get_dense_attrs(v_pos, v_attrs, res=self.res+1, sdf_init=True)
+ weights_d = get_dense_attrs(coords, weights, res=self.res, sdf_init=False)
+ if self.use_color:
+ sdf_d, deform_d, colors_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4], v_attrs_d[..., 4:]
+ else:
+ sdf_d, deform_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4]
+ colors_d = None
+
+ x_nx3 = get_defomed_verts(self.reg_v, deform_d, self.res)
+
+ vertices, faces, L_dev, colors = self.mesh_extractor(
+ voxelgrid_vertices=x_nx3,
+ scalar_field=sdf_d,
+ cube_idx=self.reg_c,
+ resolution=self.res,
+ beta=weights_d[:, :12],
+ alpha=weights_d[:, 12:20],
+ gamma_f=weights_d[:, 20],
+ voxelgrid_colors=colors_d,
+ training=training)
+
+ mesh = MeshExtractResult(vertices=vertices, faces=faces, vertex_attrs=colors, res=self.res)
+ if training:
+ if mesh.success:
+ reg_loss += L_dev.mean() * 0.5
+ reg_loss += (weights[:,:20]).abs().mean() * 0.2
+ mesh.reg_loss = reg_loss
+ mesh.tsdf_v = get_defomed_verts(v_pos, v_attrs[:, 1:4], self.res)
+ mesh.tsdf_s = v_attrs[:, 0]
+ return mesh
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/LICENSE.txt b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/LICENSE.txt
new file mode 100644
index 0000000..40e8f76
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/LICENSE.txt
@@ -0,0 +1,90 @@
+Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+
+NVIDIA Source Code License for FlexiCubes
+
+
+=======================================================================
+
+1. Definitions
+
+“Licensor” means any person or entity that distributes its Work.
+
+“Work” means (a) the original work of authorship made available under
+this license, which may include software, documentation, or other files,
+and (b) any additions to or derivative works thereof that are made
+available under this license.
+
+The terms “reproduce,” “reproduction,” “derivative works,” and
+“distribution” have the meaning as provided under U.S. copyright law;
+provided, however, that 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.
+
+Works are “made available” under this license by including in or with
+the Work either (a) a copyright notice referencing the applicability of
+this license to the Work, or (b) a copy of this license.
+
+2. License Grant
+
+ 2.1 Copyright Grant. Subject to the terms and conditions of this license,
+ each Licensor grants to you a perpetual, worldwide, non-exclusive,
+ royalty-free, copyright license to use, reproduce, prepare derivative
+ works of, publicly display, publicly perform, sublicense and distribute
+ its Work and any resulting derivative works in any form.
+
+3. Limitations
+
+ 3.1 Redistribution. You may reproduce or distribute the Work only if
+ (a) you do so under this license, (b) you include a complete copy of
+ this license with your distribution, and (c) you retain without
+ modification any copyright, patent, trademark, or attribution notices
+ that are present in the Work.
+
+ 3.2 Derivative Works. You may specify that additional or different terms
+ apply to the use, reproduction, and distribution of your derivative
+ works of the Work (“Your Terms”) only if (a) Your Terms provide that the
+ use limitation in Section 3.3 applies to your derivative works, and (b)
+ you identify the specific derivative works that are subject to Your Terms.
+ Notwithstanding Your Terms, this license (including the redistribution
+ requirements in Section 3.1) will continue to apply to the Work itself.
+
+ 3.3 Use Limitation. The Work and any derivative works thereof only may be
+ used or intended for use non-commercially. Notwithstanding the foregoing,
+ NVIDIA Corporation and its affiliates may use the Work and any derivative
+ works commercially. As used herein, “non-commercially” means for research
+ or evaluation purposes only.
+
+ 3.4 Patent Claims. If you bring or threaten to bring a patent claim against
+ any Licensor (including any claim, cross-claim or counterclaim in a lawsuit)
+ to enforce any patents that you allege are infringed by any Work, then your
+ rights under this license from such Licensor (including the grant in
+ Section 2.1) will terminate immediately.
+
+ 3.5 Trademarks. This license does not grant any rights to use any Licensor’s
+ or its affiliates’ names, logos, or trademarks, except as necessary to
+ reproduce the notices described in this license.
+
+ 3.6 Termination. If you violate any term of this license, then your rights
+ under this license (including the grant in Section 2.1) will terminate
+ immediately.
+
+4. Disclaimer of Warranty.
+
+THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT.
+YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE.
+
+5. Limitation of Liability.
+
+EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY,
+WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY
+LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE,
+THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF
+GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR
+MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+=======================================================================
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/README.md b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/README.md
new file mode 100644
index 0000000..8f8b460
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/README.md
@@ -0,0 +1,110 @@
+## Flexible Isosurface Extraction for Gradient-Based Mesh Optimization (FlexiCubes)
Official PyTorch implementation
+
+![Teaser image]()
+
+FlexiCubes is a high-quality isosurface representation specifically designed for gradient-based mesh optimization with respect to geometric, visual, or even physical objectives. For more details, please refer to our [paper](https://arxiv.org/abs/2308.05371) and [project page](https://research.nvidia.com/labs/toronto-ai/flexicubes/).
+
+## Highlights
+* [Getting started](https://github.com/nv-tlabs/FlexiCubes#getting-started)
+* [Basic workflow](https://github.com/nv-tlabs/FlexiCubes#example-usage)
+* [nvdiffrec: image-based reconstruction example](https://github.com/NVlabs/nvdiffrec#news)
+* [GET3D: generative AI example](https://github.com/nv-tlabs/GET3D#employing-flexicubes)
+* [Bibtex](https://github.com/nv-tlabs/FlexiCubes#citation)
+
+## Getting Started
+
+The core functions of FlexiCubes are now in [Kaolin](https://github.com/NVIDIAGameWorks/kaolin/) starting from v0.15.0. See installation instructions [here](https://kaolin.readthedocs.io/en/latest/notes/installation.html) and API documentations [here](https://kaolin.readthedocs.io/en/latest/modules/kaolin.non_commercial.html#kaolin.non_commercial.FlexiCubes)
+
+The original code of the paper is still visible in `flexicube.py`.
+
+## Example Usage
+
+### Gradient-Based Mesh Optimization
+We provide examples demonstrating how to use FlexiCubes for reconstructing unknown meshes through gradient-based optimization. Specifically, starting from randomly initialized SDF, we optimize the shape towards the reference mesh by minimizing their geometric difference, measured by multiview mask and depth losses. This workflow is a simplified version of `nvdiffrec` with code largely borrowed from the [nvdiffrec GitHub](https://github.com/NVlabs/nvdiffrec). We use the same pipeline to conduct the analysis in Section 3 and the main experiments described in Section 5 of our paper. We provide a detailed tutorial in `examples/optimization.ipynb`, along with an optimization script in `examples/optimize.py` which accepts command-line arguments.
+
+
+To run the examples, it is suggested to install the Conda environment as detailed below:
+```sh
+conda create -n flexicubes python=3.9
+conda activate flexicubes
+conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 -c pytorch
+pip install imageio trimesh tqdm matplotlib torch_scatter ninja
+pip install git+https://github.com/NVlabs/nvdiffrast/
+pip install kaolin==0.15.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-1.12.0_cu113.html
+```
+
+Then download the dataset collected by [Myles et al.](https://vcg.isti.cnr.it/Publications/2014/MPZ14/) as follows. We include one shape in 'examples/data/inputmodels/block.obj' if you want to test without downloading the full dataset.
+
+```sh
+cd examples
+python download_data.py
+```
+
+After downloading the data, run shape optimization with the following example command:
+```sh
+python optimize.py --ref_mesh data/inputmodels/block.obj --out_dir out/block
+```
+You can find visualization and output meshes in the `out/block`. Below, we show the initial and final shapes during optimization, with the reference shape on the right.
+
+
+
+
+
+
+To further demonstrate the flexibility of our FlexiCubes representation, which can accommodates both reconstruction objectives and regularizers defined on the extracted mesh, you can add a developability regularizer (proposed by [Stein et al.](https://www.cs.cmu.edu/~kmcrane/Projects/DiscreteDevelopable/)) to the previous reconstruction pipeline to encourage fabricability from panels:
+```sh
+python optimize.py --ref_mesh data/inputmodels/david.obj --out_dir out/david_dev --develop_reg True --iter=1250
+```
+
+### Extract mesh from known signed distance field
+While not its designated use case, our function can extract a mesh from a known Signed Distance Field (SDF) without optimization. Please refer to the tutorial found in `examples/extraction.ipynb` for details.
+
+## Tips for using FlexiCubes
+### Regularization losses:
+We commonly use three regularizers in our mesh optimization pipelines, referenced in lines `L104-L106` in `examples/optimize.py`. The weights of these regularizers should be scaled according to the your application objectives. Initially, it is suggested to employ low weights because strong regularization can hinder convergence. You can incrementally increase the weights if you notice artifacts appearing in the optimized meshes. Specifically:
+
+* The loss function at `L104` helps to remove floaters in areas of the shape that are not supervised by the application objective, such as internal faces when using image supervision only.
+* The L_dev loss at `L105` can be increased if you observe artifacts in flat areas, as illustrated in the image below.
+* Generally, the L1 regularizer on flexible weights at `L106` does not have a significant impact during the optimization of a single shape. However, we found it to be effective in stabilizing training in generative pipelines such as GET3D.
+
+
+### Resolution of voxel grid vs. tetrahedral grid:
+If you are switching from our previous work, DMTet, it's important to note the difference in grid resolution when compared to FlexiCubes. In both implementations, the resolution is defined by the edge length: a grid resolution of `n` means the grid edge length is 1/n for both the voxel and tetrahedral grids. However, a tetrahedral grid with a resolution of `n` contains only `(n/2+1)³` grid vertices, in contrast to the `(n+1)³` vertices in a voxel grid. Consequently, if you are switching from DMTet to FlexiCubes while maintaining the same resolution, you will notice not only a denser output mesh but also a substantial increase in computational cost. To align the triangle count in the output meshes more closely, we recommend adopting a 4:5 resolution ratio between the voxel grid and the tetrahedral grid. For instance, in our paper, `64³` FlexiCubes generate approximately the same number of triangles as `80³` DMTet.
+
+## Applications
+FlexiCubes is now integrated into NVIDIA applications as a drop-in replacement for DMTet. You can visit their GitHub pages to see how FlexiCubes is used in advanced photogrammetry and 3D generative pipelines.
+
+[Extracting Triangular 3D Models, Materials, and Lighting From Images (nvdiffrec)](https://github.com/NVlabs/nvdiffrec#news)
+
+[GET3D: A Generative Model of High Quality 3D Textured Shapes Learned from Images](https://github.com/nv-tlabs/GET3D#employing-flexicubes)
+
+
+
+## License
+Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+This work is made available under the [Nvidia Source Code License](LICENSE.txt).
+
+For business inquiries, please visit our website and submit the form: [NVIDIA Research Licensing](https://www.nvidia.com/en-us/research/inquiries/).
+
+## Citation
+```bibtex
+@article{shen2023flexicubes,
+author = {Shen, Tianchang and Munkberg, Jacob and Hasselgren, Jon and Yin, Kangxue and Wang, Zian
+ and Chen, Wenzheng and Gojcic, Zan and Fidler, Sanja and Sharp, Nicholas and Gao, Jun},
+title = {Flexible Isosurface Extraction for Gradient-Based Mesh Optimization},
+year = {2023},
+issue_date = {August 2023},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+volume = {42},
+number = {4},
+issn = {0730-0301},
+url = {https://doi.org/10.1145/3592430},
+doi = {10.1145/3592430},
+journal = {ACM Trans. Graph.},
+month = {jul},
+articleno = {37},
+numpages = {16}
+}
+```
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/download_data.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/download_data.py
new file mode 100644
index 0000000..3d0ea2d
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/download_data.py
@@ -0,0 +1,41 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import requests
+from zipfile import ZipFile
+from tqdm import tqdm
+import os
+
+def download_file(url, output_path):
+ response = requests.get(url, stream=True)
+ response.raise_for_status()
+ total_size_in_bytes = int(response.headers.get('content-length', 0))
+ block_size = 1024 #1 Kibibyte
+ progress_bar = tqdm(total=total_size_in_bytes, unit='iB', unit_scale=True)
+
+ with open(output_path, 'wb') as file:
+ for data in response.iter_content(block_size):
+ progress_bar.update(len(data))
+ file.write(data)
+ progress_bar.close()
+ if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:
+ raise Exception("ERROR, something went wrong")
+
+
+url = "https://vcg.isti.cnr.it/Publications/2014/MPZ14/inputmodels.zip"
+zip_file_path = './data/inputmodels.zip'
+
+os.makedirs('./data', exist_ok=True)
+
+download_file(url, zip_file_path)
+
+with ZipFile(zip_file_path, 'r') as zip_ref:
+ zip_ref.extractall('./data')
+
+os.remove(zip_file_path)
+
+print("Download and extraction complete.")
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/loss.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/loss.py
new file mode 100644
index 0000000..ba507f0
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/loss.py
@@ -0,0 +1,95 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import torch
+import torch_scatter
+
+###############################################################################
+# Pytorch implementation of the developability regularizer introduced in paper
+# "Developability of Triangle Meshes" by Stein et al.
+###############################################################################
+def mesh_developable_reg(mesh):
+
+ verts = mesh.vertices
+ tris = mesh.faces
+
+ device = verts.device
+ V = verts.shape[0]
+ F = tris.shape[0]
+
+ POS_EPS = 1e-6
+ REL_EPS = 1e-6
+
+ def normalize(vecs):
+ return vecs / (torch.linalg.norm(vecs, dim=-1, keepdim=True) + POS_EPS)
+
+ tri_pos = verts[tris]
+
+ vert_normal_covariance_sum = torch.zeros((V, 9), device=device)
+ vert_area = torch.zeros(V, device=device)
+ vert_degree = torch.zeros(V, dtype=torch.int32, device=device)
+
+ for iC in range(3): # loop over three corners of each triangle
+
+ # gather tri verts
+ pRoot = tri_pos[:, iC, :]
+ pA = tri_pos[:, (iC + 1) % 3, :]
+ pB = tri_pos[:, (iC + 2) % 3, :]
+
+ # compute the corner angle & normal
+ vA = pA - pRoot
+ vAn = normalize(vA)
+ vB = pB - pRoot
+ vBn = normalize(vB)
+ area_normal = torch.linalg.cross(vA, vB, dim=-1)
+ face_area = 0.5 * torch.linalg.norm(area_normal, dim=-1)
+ normal = normalize(area_normal)
+ corner_angle = torch.acos(torch.clamp(torch.sum(vAn * vBn, dim=-1), min=-1., max=1.))
+
+ # add up the contribution to the covariance matrix
+ outer = normal[:, :, None] @ normal[:, None, :]
+ contrib = corner_angle[:, None] * outer.reshape(-1, 9)
+
+ # scatter the result to the appropriate matrices
+ vert_normal_covariance_sum = torch_scatter.scatter_add(src=contrib,
+ index=tris[:, iC],
+ dim=-2,
+ out=vert_normal_covariance_sum)
+
+ vert_area = torch_scatter.scatter_add(src=face_area / 3.,
+ index=tris[:, iC],
+ dim=-1,
+ out=vert_area)
+
+ vert_degree = torch_scatter.scatter_add(src=torch.ones(F, dtype=torch.int32, device=device),
+ index=tris[:, iC],
+ dim=-1,
+ out=vert_degree)
+
+ # The energy is the smallest eigenvalue of the outer-product matrix
+ vert_normal_covariance_sum = vert_normal_covariance_sum.reshape(
+ -1, 3, 3) # reshape to a batch of matrices
+ vert_normal_covariance_sum = vert_normal_covariance_sum + torch.eye(
+ 3, device=device)[None, :, :] * REL_EPS
+
+ min_eigvals = torch.min(torch.linalg.eigvals(vert_normal_covariance_sum).abs(), dim=-1).values
+
+ # Mask out degree-3 vertices
+ vert_area = torch.where(vert_degree == 3, torch.tensor(0, dtype=vert_area.dtype,device=vert_area.device), vert_area)
+
+ # Adjust the vertex area weighting so it is unit-less, and 1 on average
+ vert_area = vert_area * (V / torch.sum(vert_area, dim=-1, keepdim=True))
+
+ return vert_area * min_eigvals
+
+def sdf_reg_loss(sdf, all_edges):
+ sdf_f1x6x2 = sdf[all_edges.reshape(-1)].reshape(-1,2)
+ mask = torch.sign(sdf_f1x6x2[...,0]) != torch.sign(sdf_f1x6x2[...,1])
+ sdf_f1x6x2 = sdf_f1x6x2[mask]
+ sdf_diff = torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,0], (sdf_f1x6x2[...,1] > 0).float()) + \
+ torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,1], (sdf_f1x6x2[...,0] > 0).float())
+ return sdf_diff
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/optimize.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/optimize.py
new file mode 100644
index 0000000..332fa2c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/optimize.py
@@ -0,0 +1,150 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import argparse
+import numpy as np
+import torch
+import nvdiffrast.torch as dr
+import trimesh
+import os
+from util import *
+import render
+import loss
+import imageio
+
+import sys
+sys.path.append('..')
+from flexicubes import FlexiCubes
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def lr_schedule(iter):
+ return max(0.0, 10**(-(iter)*0.0002)) # Exponential falloff from [1.0, 0.1] over 5k epochs.
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(description='flexicubes optimization')
+ parser.add_argument('-o', '--out_dir', type=str, default=None)
+ parser.add_argument('-rm', '--ref_mesh', type=str)
+
+ parser.add_argument('-i', '--iter', type=int, default=1000)
+ parser.add_argument('-b', '--batch', type=int, default=8)
+ parser.add_argument('-r', '--train_res', nargs=2, type=int, default=[2048, 2048])
+ parser.add_argument('-lr', '--learning_rate', type=float, default=0.01)
+ parser.add_argument('--voxel_grid_res', type=int, default=64)
+
+ parser.add_argument('--sdf_loss', type=bool, default=True)
+ parser.add_argument('--develop_reg', type=bool, default=False)
+ parser.add_argument('--sdf_regularizer', type=float, default=0.2)
+
+ parser.add_argument('-dr', '--display_res', nargs=2, type=int, default=[512, 512])
+ parser.add_argument('-si', '--save_interval', type=int, default=20)
+ FLAGS = parser.parse_args()
+ device = 'cuda'
+
+ os.makedirs(FLAGS.out_dir, exist_ok=True)
+ glctx = dr.RasterizeGLContext()
+
+ # Load GT mesh
+ gt_mesh = load_mesh(FLAGS.ref_mesh, device)
+ gt_mesh.auto_normals() # compute face normals for visualization
+
+ # ==============================================================================================
+ # Create and initialize FlexiCubes
+ # ==============================================================================================
+ fc = FlexiCubes(device)
+ x_nx3, cube_fx8 = fc.construct_voxel_grid(FLAGS.voxel_grid_res)
+ x_nx3 *= 2 # scale up the grid so that it's larger than the target object
+
+ sdf = torch.rand_like(x_nx3[:,0]) - 0.1 # randomly init SDF
+ sdf = torch.nn.Parameter(sdf.clone().detach(), requires_grad=True)
+ # set per-cube learnable weights to zeros
+ weight = torch.zeros((cube_fx8.shape[0], 21), dtype=torch.float, device='cuda')
+ weight = torch.nn.Parameter(weight.clone().detach(), requires_grad=True)
+ deform = torch.nn.Parameter(torch.zeros_like(x_nx3), requires_grad=True)
+
+ # Retrieve all the edges of the voxel grid; these edges will be utilized to
+ # compute the regularization loss in subsequent steps of the process.
+ all_edges = cube_fx8[:, fc.cube_edges].reshape(-1, 2)
+ grid_edges = torch.unique(all_edges, dim=0)
+
+ # ==============================================================================================
+ # Setup optimizer
+ # ==============================================================================================
+ optimizer = torch.optim.Adam([sdf, weight,deform], lr=FLAGS.learning_rate)
+ scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda x: lr_schedule(x))
+
+ # ==============================================================================================
+ # Train loop
+ # ==============================================================================================
+ for it in range(FLAGS.iter):
+ optimizer.zero_grad()
+ # sample random camera poses
+ mv, mvp = render.get_random_camera_batch(FLAGS.batch, iter_res=FLAGS.train_res, device=device, use_kaolin=False)
+ # render gt mesh
+ target = render.render_mesh_paper(gt_mesh, mv, mvp, FLAGS.train_res)
+ # extract and render FlexiCubes mesh
+ grid_verts = x_nx3 + (2-1e-8) / (FLAGS.voxel_grid_res * 2) * torch.tanh(deform)
+ vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20],
+ gamma_f=weight[:,20], training=True)
+ flexicubes_mesh = Mesh(vertices, faces)
+ buffers = render.render_mesh_paper(flexicubes_mesh, mv, mvp, FLAGS.train_res)
+
+ # evaluate reconstruction loss
+ mask_loss = (buffers['mask'] - target['mask']).abs().mean()
+ depth_loss = (((((buffers['depth'] - (target['depth']))* target['mask'])**2).sum(-1)+1e-8)).sqrt().mean() * 10
+
+ t_iter = it / FLAGS.iter
+ sdf_weight = FLAGS.sdf_regularizer - (FLAGS.sdf_regularizer - FLAGS.sdf_regularizer/20)*min(1.0, 4.0 * t_iter)
+ reg_loss = loss.sdf_reg_loss(sdf, grid_edges).mean() * sdf_weight # Loss to eliminate internal floaters that are not visible
+ reg_loss += L_dev.mean() * 0.5
+ reg_loss += (weight[:,:20]).abs().mean() * 0.1
+ total_loss = mask_loss + depth_loss + reg_loss
+
+ if FLAGS.sdf_loss: # optionally add SDF loss to eliminate internal structures
+ with torch.no_grad():
+ pts = sample_random_points(1000, gt_mesh)
+ gt_sdf = compute_sdf(pts, gt_mesh.vertices, gt_mesh.faces)
+ pred_sdf = compute_sdf(pts, flexicubes_mesh.vertices, flexicubes_mesh.faces)
+ total_loss += torch.nn.functional.mse_loss(pred_sdf, gt_sdf) * 2e3
+
+ # optionally add developability regularizer, as described in paper section 5.2
+ if FLAGS.develop_reg:
+ reg_weight = max(0, t_iter - 0.8) * 5
+ if reg_weight > 0: # only applied after shape converges
+ reg_loss = loss.mesh_developable_reg(flexicubes_mesh).mean() * 10
+ reg_loss += (deform).abs().mean()
+ reg_loss += (weight[:,:20]).abs().mean()
+ total_loss = mask_loss + depth_loss + reg_loss
+
+ total_loss.backward()
+ optimizer.step()
+ scheduler.step()
+
+ if (it % FLAGS.save_interval == 0 or it == (FLAGS.iter-1)): # save normal image for visualization
+ with torch.no_grad():
+ # extract mesh with training=False
+ vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20],
+ gamma_f=weight[:,20], training=False)
+ flexicubes_mesh = Mesh(vertices, faces)
+
+ flexicubes_mesh.auto_normals() # compute face normals for visualization
+ mv, mvp = render.get_rotate_camera(it//FLAGS.save_interval, iter_res=FLAGS.display_res, device=device,use_kaolin=False)
+ val_buffers = render.render_mesh_paper(flexicubes_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True)
+ val_image = ((val_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8)
+
+ gt_buffers = render.render_mesh_paper(gt_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True)
+ gt_image = ((gt_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8)
+ imageio.imwrite(os.path.join(FLAGS.out_dir, '{:04d}.png'.format(it)), np.concatenate([val_image, gt_image], 1))
+ print(f"Optimization Step [{it}/{FLAGS.iter}], Loss: {total_loss.item():.4f}")
+
+ # ==============================================================================================
+ # Save ouput
+ # ==============================================================================================
+ mesh_np = trimesh.Trimesh(vertices = vertices.detach().cpu().numpy(), faces=faces.detach().cpu().numpy(), process=False)
+ mesh_np.export(os.path.join(FLAGS.out_dir, 'output_mesh.obj'))
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/render.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/render.py
new file mode 100644
index 0000000..034f961
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/render.py
@@ -0,0 +1,267 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import numpy as np
+import copy
+import math
+from ipywidgets import interactive, HBox, VBox, FloatLogSlider, IntSlider
+
+import torch
+import nvdiffrast.torch as dr
+import kaolin as kal
+import util
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def get_random_camera_batch(batch_size, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True):
+ if use_kaolin:
+ camera_pos = torch.stack(kal.ops.coords.spherical2cartesian(
+ *kal.ops.random.sample_spherical_coords((batch_size,), azimuth_low=0., azimuth_high=math.pi * 2,
+ elevation_low=-math.pi / 2., elevation_high=math.pi / 2., device='cuda'),
+ cam_radius
+ ), dim=-1)
+ return kal.render.camera.Camera.from_args(
+ eye=camera_pos + torch.rand((batch_size, 1), device='cuda') * 0.5 - 0.25,
+ at=torch.zeros(batch_size, 3),
+ up=torch.tensor([[0., 1., 0.]]),
+ fov=fovy,
+ near=cam_near_far[0], far=cam_near_far[1],
+ height=iter_res[0], width=iter_res[1],
+ device='cuda'
+ )
+ else:
+ def get_random_camera():
+ proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1])
+ mv = util.translate(0, 0, -cam_radius) @ util.random_rotation_translation(0.25)
+ mvp = proj_mtx @ mv
+ return mv, mvp
+ mv_batch = []
+ mvp_batch = []
+ for i in range(batch_size):
+ mv, mvp = get_random_camera()
+ mv_batch.append(mv)
+ mvp_batch.append(mvp)
+ return torch.stack(mv_batch).to(device), torch.stack(mvp_batch).to(device)
+
+def get_rotate_camera(itr, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True):
+ if use_kaolin:
+ ang = (itr / 10) * np.pi * 2
+ camera_pos = torch.stack(kal.ops.coords.spherical2cartesian(torch.tensor(ang), torch.tensor(0.4), -torch.tensor(cam_radius)))
+ return kal.render.camera.Camera.from_args(
+ eye=camera_pos,
+ at=torch.zeros(3),
+ up=torch.tensor([0., 1., 0.]),
+ fov=fovy,
+ near=cam_near_far[0], far=cam_near_far[1],
+ height=iter_res[0], width=iter_res[1],
+ device='cuda'
+ )
+ else:
+ proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1])
+
+ # Smooth rotation for display.
+ ang = (itr / 10) * np.pi * 2
+ mv = util.translate(0, 0, -cam_radius) @ (util.rotate_x(-0.4) @ util.rotate_y(ang))
+ mvp = proj_mtx @ mv
+ return mv.to(device), mvp.to(device)
+
+glctx = dr.RasterizeGLContext()
+def render_mesh(mesh, camera, iter_res, return_types = ["mask", "depth"], white_bg=False, wireframe_thickness=0.4):
+ vertices_camera = camera.extrinsics.transform(mesh.vertices)
+ face_vertices_camera = kal.ops.mesh.index_vertices_by_faces(
+ vertices_camera, mesh.faces
+ )
+
+ # Projection: nvdiffrast take clip coordinates as input to apply barycentric perspective correction.
+ # Using `camera.intrinsics.transform(vertices_camera) would return the normalized device coordinates.
+ proj = camera.projection_matrix().unsqueeze(1)
+ proj[:, :, 1, 1] = -proj[:, :, 1, 1]
+ homogeneous_vecs = kal.render.camera.up_to_homogeneous(
+ vertices_camera
+ )
+ vertices_clip = (proj @ homogeneous_vecs.unsqueeze(-1)).squeeze(-1)
+ faces_int = mesh.faces.int()
+
+ rast, _ = dr.rasterize(
+ glctx, vertices_clip, faces_int, iter_res)
+
+ out_dict = {}
+ for type in return_types:
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int)
+ elif type == "depth":
+ img = dr.interpolate(homogeneous_vecs, rast, faces_int)[0]
+ elif type == "wireframe":
+ img = torch.logical_or(
+ torch.logical_or(rast[..., 0] < wireframe_thickness, rast[..., 1] < wireframe_thickness),
+ (rast[..., 0] + rast[..., 1]) > (1. - wireframe_thickness)
+ ).unsqueeze(-1)
+ elif type == "normals" :
+ img = dr.interpolate(
+ mesh.face_normals.reshape(len(mesh), -1, 3), rast,
+ torch.arange(mesh.faces.shape[0] * 3, device='cuda', dtype=torch.int).reshape(-1, 3)
+ )[0]
+ if white_bg:
+ bg = torch.ones_like(img)
+ alpha = (rast[..., -1:] > 0).float()
+ img = torch.lerp(bg, img, alpha)
+ out_dict[type] = img
+
+
+ return out_dict
+
+def render_mesh_paper(mesh, mv, mvp, iter_res, return_types = ["mask", "depth"], white_bg=False):
+ '''
+ The rendering function used to produce the results in the paper.
+ '''
+ v_pos_clip = util.xfm_points(mesh.vertices.unsqueeze(0), mvp) # Rotate it to camera coordinates
+ rast, db = dr.rasterize(
+ dr.RasterizeGLContext(), v_pos_clip, mesh.faces.int(), iter_res)
+
+ out_dict = {}
+ for type in return_types:
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, v_pos_clip, mesh.faces.int())
+ elif type == "depth":
+ v_pos_cam = util.xfm_points(mesh.vertices.unsqueeze(0), mv)
+ img, _ = util.interpolate(v_pos_cam, rast, mesh.faces.int())
+ elif type == "normal" :
+ normal_indices = (torch.arange(0, mesh.nrm.shape[0], dtype=torch.int64, device='cuda')[:, None]).repeat(1, 3)
+ img, _ = util.interpolate(mesh.nrm.unsqueeze(0).contiguous(), rast, normal_indices.int())
+ elif type == "vertex_normal":
+ img, _ = util.interpolate(mesh.v_nrm.unsqueeze(0).contiguous(), rast, mesh.faces.int())
+ img = dr.antialias((img + 1) * 0.5, rast, v_pos_clip, mesh.faces.int())
+ if white_bg:
+ bg = torch.ones_like(img)
+ alpha = (rast[..., -1:] > 0).float()
+ img = torch.lerp(bg, img, alpha)
+ out_dict[type] = img
+ return out_dict
+
+class SplitVisualizer():
+ def __init__(self, lh_mesh, rh_mesh, height, width):
+ self.lh_mesh = lh_mesh
+ self.rh_mesh = rh_mesh
+ self.height = height
+ self.width = width
+ self.wireframe_thickness = 0.4
+
+
+ def render(self, camera):
+ lh_outputs = render_mesh(
+ self.lh_mesh, camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+ rh_outputs = render_mesh(
+ self.rh_mesh, camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+ outputs = {
+ k: torch.cat(
+ [lh_outputs[k][0].permute(1, 0, 2), rh_outputs[k][0].permute(1, 0, 2)],
+ dim=0
+ ).permute(1, 0, 2) for k in ["normals", "wireframe"]
+ }
+ return {
+ 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8),
+ 'normals': outputs['normals']
+ }
+
+ def show(self, init_camera):
+ visualizer = kal.visualize.IpyTurntableVisualizer(
+ self.height, self.width * 2, copy.deepcopy(init_camera), self.render,
+ max_fps=24, world_up_axis=1)
+
+ def slider_callback(new_wireframe_thickness):
+ """ipywidgets sliders callback"""
+ with visualizer.out: # This is in case of bug
+ self.wireframe_thickness = new_wireframe_thickness
+ # this is how we request a new update
+ visualizer.render_update()
+
+ wireframe_thickness_slider = FloatLogSlider(
+ value=self.wireframe_thickness,
+ base=10,
+ min=-3,
+ max=-0.4,
+ step=0.1,
+ description='wireframe_thickness',
+ continuous_update=True,
+ readout=True,
+ readout_format='.3f',
+ )
+
+ interactive_slider = interactive(
+ slider_callback,
+ new_wireframe_thickness=wireframe_thickness_slider,
+ )
+
+ full_output = VBox([visualizer.canvas, interactive_slider])
+ display(full_output, visualizer.out)
+
+class TimelineVisualizer():
+ def __init__(self, meshes, height, width):
+ self.meshes = meshes
+ self.height = height
+ self.width = width
+ self.wireframe_thickness = 0.4
+ self.idx = len(meshes) - 1
+
+ def render(self, camera):
+ outputs = render_mesh(
+ self.meshes[self.idx], camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+
+ return {
+ 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8)[0],
+ 'normals': outputs['normals'][0]
+ }
+
+ def show(self, init_camera):
+ visualizer = kal.visualize.IpyTurntableVisualizer(
+ self.height, self.width, copy.deepcopy(init_camera), self.render,
+ max_fps=24, world_up_axis=1)
+
+ def slider_callback(new_wireframe_thickness, new_idx):
+ """ipywidgets sliders callback"""
+ with visualizer.out: # This is in case of bug
+ self.wireframe_thickness = new_wireframe_thickness
+ self.idx = new_idx
+ # this is how we request a new update
+ visualizer.render_update()
+
+ wireframe_thickness_slider = FloatLogSlider(
+ value=self.wireframe_thickness,
+ base=10,
+ min=-3,
+ max=-0.4,
+ step=0.1,
+ description='wireframe_thickness',
+ continuous_update=True,
+ readout=True,
+ readout_format='.3f',
+ )
+
+ idx_slider = IntSlider(
+ value=self.idx,
+ min=0,
+ max=len(self.meshes) - 1,
+ description='idx',
+ continuous_update=True,
+ readout=True
+ )
+
+ interactive_slider = interactive(
+ slider_callback,
+ new_wireframe_thickness=wireframe_thickness_slider,
+ new_idx=idx_slider
+ )
+ full_output = HBox([visualizer.canvas, interactive_slider])
+ display(full_output, visualizer.out)
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/util.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/util.py
new file mode 100644
index 0000000..f39ea1c
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/examples/util.py
@@ -0,0 +1,122 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import numpy as np
+import torch
+import trimesh
+import kaolin
+import nvdiffrast.torch as dr
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+ return torch.sum(x*y, -1, keepdim=True)
+
+def length(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor:
+ return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN
+
+def safe_normalize(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor:
+ return x / length(x, eps)
+
+def perspective(fovy=0.7854, aspect=1.0, n=0.1, f=1000.0, device=None):
+ y = np.tan(fovy / 2)
+ return torch.tensor([[1/(y*aspect), 0, 0, 0],
+ [ 0, 1/-y, 0, 0],
+ [ 0, 0, -(f+n)/(f-n), -(2*f*n)/(f-n)],
+ [ 0, 0, -1, 0]], dtype=torch.float32, device=device)
+
+def translate(x, y, z, device=None):
+ return torch.tensor([[1, 0, 0, x],
+ [0, 1, 0, y],
+ [0, 0, 1, z],
+ [0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+@torch.no_grad()
+def random_rotation_translation(t, device=None):
+ m = np.random.normal(size=[3, 3])
+ m[1] = np.cross(m[0], m[2])
+ m[2] = np.cross(m[0], m[1])
+ m = m / np.linalg.norm(m, axis=1, keepdims=True)
+ m = np.pad(m, [[0, 1], [0, 1]], mode='constant')
+ m[3, 3] = 1.0
+ m[:3, 3] = np.random.uniform(-t, t, size=[3])
+ return torch.tensor(m, dtype=torch.float32, device=device)
+
+def rotate_x(a, device=None):
+ s, c = np.sin(a), np.cos(a)
+ return torch.tensor([[1, 0, 0, 0],
+ [0, c, s, 0],
+ [0, -s, c, 0],
+ [0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+def rotate_y(a, device=None):
+ s, c = np.sin(a), np.cos(a)
+ return torch.tensor([[ c, 0, s, 0],
+ [ 0, 1, 0, 0],
+ [-s, 0, c, 0],
+ [ 0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+class Mesh:
+ def __init__(self, vertices, faces):
+ self.vertices = vertices
+ self.faces = faces
+
+ def auto_normals(self):
+ v0 = self.vertices[self.faces[:, 0], :]
+ v1 = self.vertices[self.faces[:, 1], :]
+ v2 = self.vertices[self.faces[:, 2], :]
+ nrm = safe_normalize(torch.cross(v1 - v0, v2 - v0))
+ self.nrm = nrm
+
+def load_mesh(path, device):
+ mesh_np = trimesh.load(path)
+ vertices = torch.tensor(mesh_np.vertices, device=device, dtype=torch.float)
+ faces = torch.tensor(mesh_np.faces, device=device, dtype=torch.long)
+
+ # Normalize
+ vmin, vmax = vertices.min(dim=0)[0], vertices.max(dim=0)[0]
+ scale = 1.8 / torch.max(vmax - vmin).item()
+ vertices = vertices - (vmax + vmin) / 2 # Center mesh on origin
+ vertices = vertices * scale # Rescale to [-0.9, 0.9]
+ return Mesh(vertices, faces)
+
+def compute_sdf(points, vertices, faces):
+ face_vertices = kaolin.ops.mesh.index_vertices_by_faces(vertices.clone().unsqueeze(0), faces)
+ distance = kaolin.metrics.trianglemesh.point_to_mesh_distance(points.unsqueeze(0), face_vertices)[0]
+ with torch.no_grad():
+ sign = (kaolin.ops.mesh.check_sign(vertices.unsqueeze(0), faces, points.unsqueeze(0))<1).float() * 2 - 1
+ sdf = (sign*distance).squeeze(0)
+ return sdf
+
+def sample_random_points(n, mesh):
+ pts_random = (torch.rand((n//2,3),device='cuda') - 0.5) * 2
+ pts_surface = kaolin.ops.mesh.sample_points(mesh.vertices.unsqueeze(0), mesh.faces, 500)[0].squeeze(0)
+ pts_surface += torch.randn_like(pts_surface) * 0.05
+ pts = torch.cat([pts_random, pts_surface])
+ return pts
+
+def xfm_points(points, matrix):
+ '''Transform points.
+ Args:
+ points: Tensor containing 3D points with shape [minibatch_size, num_vertices, 3] or [1, num_vertices, 3]
+ matrix: A 4x4 transform matrix with shape [minibatch_size, 4, 4]
+ use_python: Use PyTorch's torch.matmul (for validation)
+ Returns:
+ Transformed points in homogeneous 4D with shape [minibatch_size, num_vertices, 4].
+ '''
+ out = torch.matmul(
+ torch.nn.functional.pad(points, pad=(0, 1), mode='constant', value=1.0), torch.transpose(matrix, 1, 2))
+ if torch.is_anomaly_enabled():
+ assert torch.all(torch.isfinite(out)), "Output of xfm_points contains inf or NaN"
+ return out
+
+def interpolate(attr, rast, attr_idx, rast_db=None):
+ return dr.interpolate(
+ attr, rast, attr_idx, rast_db=rast_db,
+ diff_attrs=None if rast_db is None else 'all')
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/flexicubes.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/flexicubes.py
new file mode 100644
index 0000000..0dd84af
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/flexicubes.py
@@ -0,0 +1,384 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+
+import torch
+from .tables import *
+# from kaolin.utils.testing import check_tensor
+
+__all__ = [
+ 'FlexiCubes'
+]
+
+
+class FlexiCubes:
+ def __init__(self, device="cuda"):
+
+ self.device = device
+ self.dmc_table = torch.tensor(dmc_table, dtype=torch.long, device=device, requires_grad=False)
+ self.num_vd_table = torch.tensor(num_vd_table,
+ dtype=torch.long, device=device, requires_grad=False)
+ self.check_table = torch.tensor(
+ check_table,
+ dtype=torch.long, device=device, requires_grad=False)
+
+ self.tet_table = torch.tensor(tet_table, dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_1 = torch.tensor([0, 1, 2, 0, 2, 3], dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_2 = torch.tensor([0, 1, 3, 3, 1, 2], dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_train = torch.tensor(
+ [0, 1, 1, 2, 2, 3, 3, 0], dtype=torch.long, device=device, requires_grad=False)
+
+ self.cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [
+ 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.float, device=device)
+ self.cube_corners_idx = torch.pow(2, torch.arange(8, requires_grad=False))
+ self.cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6,
+ 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, device=device, requires_grad=False)
+
+ self.edge_dir_table = torch.tensor([0, 2, 0, 2, 0, 2, 0, 2, 1, 1, 1, 1],
+ dtype=torch.long, device=device)
+ self.dir_faces_table = torch.tensor([
+ [[5, 4], [3, 2], [4, 5], [2, 3]],
+ [[5, 4], [1, 0], [4, 5], [0, 1]],
+ [[3, 2], [1, 0], [2, 3], [0, 1]]
+ ], dtype=torch.long, device=device)
+ self.adj_pairs = torch.tensor([0, 1, 1, 3, 3, 2, 2, 0], dtype=torch.long, device=device)
+
+ def __call__(self, voxelgrid_vertices, scalar_field, cube_idx, resolution, qef_reg_scale=1e-3,
+ weight_scale=0.99, beta=None, alpha=None, gamma_f=None, voxelgrid_colors=None, training=False):
+ # assert torch.is_tensor(voxelgrid_vertices) and \
+ # check_tensor(voxelgrid_vertices, (None, 3), throw=False), \
+ # "'voxelgrid_vertices' should be a tensor of shape (num_vertices, 3)"
+ # num_vertices = voxelgrid_vertices.shape[0]
+ # assert torch.is_tensor(scalar_field) and \
+ # check_tensor(scalar_field, (num_vertices,), throw=False), \
+ # "'scalar_field' should be a tensor of shape (num_vertices,)"
+ # assert torch.is_tensor(cube_idx) and \
+ # check_tensor(cube_idx, (None, 8), throw=False), \
+ # "'cube_idx' should be a tensor of shape (num_cubes, 8)"
+ # num_cubes = cube_idx.shape[0]
+ # assert beta is None or (
+ # torch.is_tensor(beta) and
+ # check_tensor(beta, (num_cubes, 12), throw=False)
+ # ), "'beta' should be a tensor of shape (num_cubes, 12)"
+ # assert alpha is None or (
+ # torch.is_tensor(alpha) and
+ # check_tensor(alpha, (num_cubes, 8), throw=False)
+ # ), "'alpha' should be a tensor of shape (num_cubes, 8)"
+ # assert gamma_f is None or (
+ # torch.is_tensor(gamma_f) and
+ # check_tensor(gamma_f, (num_cubes,), throw=False)
+ # ), "'gamma_f' should be a tensor of shape (num_cubes,)"
+
+ surf_cubes, occ_fx8 = self._identify_surf_cubes(scalar_field, cube_idx)
+ if surf_cubes.sum() == 0:
+ return (
+ torch.zeros((0, 3), device=self.device),
+ torch.zeros((0, 3), dtype=torch.long, device=self.device),
+ torch.zeros((0), device=self.device),
+ torch.zeros((0, voxelgrid_colors.shape[-1]), device=self.device) if voxelgrid_colors is not None else None
+ )
+ beta, alpha, gamma_f = self._normalize_weights(
+ beta, alpha, gamma_f, surf_cubes, weight_scale)
+
+ if voxelgrid_colors is not None:
+ voxelgrid_colors = torch.sigmoid(voxelgrid_colors)
+
+ case_ids = self._get_case_id(occ_fx8, surf_cubes, resolution)
+
+ surf_edges, idx_map, edge_counts, surf_edges_mask = self._identify_surf_edges(
+ scalar_field, cube_idx, surf_cubes
+ )
+
+ vd, L_dev, vd_gamma, vd_idx_map, vd_color = self._compute_vd(
+ voxelgrid_vertices, cube_idx[surf_cubes], surf_edges, scalar_field,
+ case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors)
+ vertices, faces, s_edges, edge_indices, vertices_color = self._triangulate(
+ scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map,
+ vd_idx_map, surf_edges_mask, training, vd_color)
+ return vertices, faces, L_dev, vertices_color
+
+ def _compute_reg_loss(self, vd, ue, edge_group_to_vd, vd_num_edges):
+ """
+ Regularizer L_dev as in Equation 8
+ """
+ dist = torch.norm(ue - torch.index_select(input=vd, index=edge_group_to_vd, dim=0), dim=-1)
+ mean_l2 = torch.zeros_like(vd[:, 0])
+ mean_l2 = (mean_l2).index_add_(0, edge_group_to_vd, dist) / vd_num_edges.squeeze(1).float()
+ mad = (dist - torch.index_select(input=mean_l2, index=edge_group_to_vd, dim=0)).abs()
+ return mad
+
+ def _normalize_weights(self, beta, alpha, gamma_f, surf_cubes, weight_scale):
+ """
+ Normalizes the given weights to be non-negative. If input weights are None, it creates and returns a set of weights of ones.
+ """
+ n_cubes = surf_cubes.shape[0]
+
+ if beta is not None:
+ beta = (torch.tanh(beta) * weight_scale + 1)
+ else:
+ beta = torch.ones((n_cubes, 12), dtype=torch.float, device=self.device)
+
+ if alpha is not None:
+ alpha = (torch.tanh(alpha) * weight_scale + 1)
+ else:
+ alpha = torch.ones((n_cubes, 8), dtype=torch.float, device=self.device)
+
+ if gamma_f is not None:
+ gamma_f = torch.sigmoid(gamma_f) * weight_scale + (1 - weight_scale) / 2
+ else:
+ gamma_f = torch.ones((n_cubes), dtype=torch.float, device=self.device)
+
+ return beta[surf_cubes], alpha[surf_cubes], gamma_f[surf_cubes]
+
+ @torch.no_grad()
+ def _get_case_id(self, occ_fx8, surf_cubes, res):
+ """
+ Obtains the ID of topology cases based on cell corner occupancy. This function resolves the
+ ambiguity in the Dual Marching Cubes (DMC) configurations as described in Section 1.3 of the
+ supplementary material. It should be noted that this function assumes a regular grid.
+ """
+ case_ids = (occ_fx8[surf_cubes] * self.cube_corners_idx.to(self.device).unsqueeze(0)).sum(-1)
+
+ problem_config = self.check_table.to(self.device)[case_ids]
+ to_check = problem_config[..., 0] == 1
+ problem_config = problem_config[to_check]
+ if not isinstance(res, (list, tuple)):
+ res = [res, res, res]
+
+ # The 'problematic_configs' only contain configurations for surface cubes. Next, we construct a 3D array,
+ # 'problem_config_full', to store configurations for all cubes (with default config for non-surface cubes).
+ # This allows efficient checking on adjacent cubes.
+ problem_config_full = torch.zeros(list(res) + [5], device=self.device, dtype=torch.long)
+ vol_idx = torch.nonzero(problem_config_full[..., 0] == 0) # N, 3
+ vol_idx_problem = vol_idx[surf_cubes][to_check]
+ problem_config_full[vol_idx_problem[..., 0], vol_idx_problem[..., 1], vol_idx_problem[..., 2]] = problem_config
+ vol_idx_problem_adj = vol_idx_problem + problem_config[..., 1:4]
+
+ within_range = (
+ vol_idx_problem_adj[..., 0] >= 0) & (
+ vol_idx_problem_adj[..., 0] < res[0]) & (
+ vol_idx_problem_adj[..., 1] >= 0) & (
+ vol_idx_problem_adj[..., 1] < res[1]) & (
+ vol_idx_problem_adj[..., 2] >= 0) & (
+ vol_idx_problem_adj[..., 2] < res[2])
+
+ vol_idx_problem = vol_idx_problem[within_range]
+ vol_idx_problem_adj = vol_idx_problem_adj[within_range]
+ problem_config = problem_config[within_range]
+ problem_config_adj = problem_config_full[vol_idx_problem_adj[..., 0],
+ vol_idx_problem_adj[..., 1], vol_idx_problem_adj[..., 2]]
+ # If two cubes with cases C16 and C19 share an ambiguous face, both cases are inverted.
+ to_invert = (problem_config_adj[..., 0] == 1)
+ idx = torch.arange(case_ids.shape[0], device=self.device)[to_check][within_range][to_invert]
+ case_ids.index_put_((idx,), problem_config[to_invert][..., -1])
+ return case_ids
+
+ @torch.no_grad()
+ def _identify_surf_edges(self, scalar_field, cube_idx, surf_cubes):
+ """
+ Identifies grid edges that intersect with the underlying surface by checking for opposite signs. As each edge
+ can be shared by multiple cubes, this function also assigns a unique index to each surface-intersecting edge
+ and marks the cube edges with this index.
+ """
+ occ_n = scalar_field < 0
+ all_edges = cube_idx[surf_cubes][:, self.cube_edges].reshape(-1, 2)
+ unique_edges, _idx_map, counts = torch.unique(all_edges, dim=0, return_inverse=True, return_counts=True)
+
+ unique_edges = unique_edges.long()
+ mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1, 2).sum(-1) == 1
+
+ surf_edges_mask = mask_edges[_idx_map]
+ counts = counts[_idx_map]
+
+ mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device=cube_idx.device) * -1
+ mapping[mask_edges] = torch.arange(mask_edges.sum(), device=cube_idx.device)
+ # Shaped as [number of cubes x 12 edges per cube]. This is later used to map a cube edge to the unique index
+ # for a surface-intersecting edge. Non-surface-intersecting edges are marked with -1.
+ idx_map = mapping[_idx_map]
+ surf_edges = unique_edges[mask_edges]
+ return surf_edges, idx_map, counts, surf_edges_mask
+
+ @torch.no_grad()
+ def _identify_surf_cubes(self, scalar_field, cube_idx):
+ """
+ Identifies grid cubes that intersect with the underlying surface by checking if the signs at
+ all corners are not identical.
+ """
+ occ_n = scalar_field < 0
+ occ_fx8 = occ_n[cube_idx.reshape(-1)].reshape(-1, 8)
+ _occ_sum = torch.sum(occ_fx8, -1)
+ surf_cubes = (_occ_sum > 0) & (_occ_sum < 8)
+ return surf_cubes, occ_fx8
+
+ def _linear_interp(self, edges_weight, edges_x):
+ """
+ Computes the location of zero-crossings on 'edges_x' using linear interpolation with 'edges_weight'.
+ """
+ edge_dim = edges_weight.dim() - 2
+ assert edges_weight.shape[edge_dim] == 2
+ edges_weight = torch.cat([torch.index_select(input=edges_weight, index=torch.tensor(1, device=self.device), dim=edge_dim), -
+ torch.index_select(input=edges_weight, index=torch.tensor(0, device=self.device), dim=edge_dim)]
+ , edge_dim)
+ denominator = edges_weight.sum(edge_dim)
+ ue = (edges_x * edges_weight).sum(edge_dim) / denominator
+ return ue
+
+ def _solve_vd_QEF(self, p_bxnx3, norm_bxnx3, c_bx3, qef_reg_scale):
+ p_bxnx3 = p_bxnx3.reshape(-1, 7, 3)
+ norm_bxnx3 = norm_bxnx3.reshape(-1, 7, 3)
+ c_bx3 = c_bx3.reshape(-1, 3)
+ A = norm_bxnx3
+ B = ((p_bxnx3) * norm_bxnx3).sum(-1, keepdims=True)
+
+ A_reg = (torch.eye(3, device=p_bxnx3.device) * qef_reg_scale).unsqueeze(0).repeat(p_bxnx3.shape[0], 1, 1)
+ B_reg = (qef_reg_scale * c_bx3).unsqueeze(-1)
+ A = torch.cat([A, A_reg], 1)
+ B = torch.cat([B, B_reg], 1)
+ dual_verts = torch.linalg.lstsq(A, B).solution.squeeze(-1)
+ return dual_verts
+
+ def _compute_vd(self, voxelgrid_vertices, surf_cubes_fx8, surf_edges, scalar_field,
+ case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors):
+ """
+ Computes the location of dual vertices as described in Section 4.2
+ """
+ alpha_nx12x2 = torch.index_select(input=alpha, index=self.cube_edges, dim=1).reshape(-1, 12, 2)
+ surf_edges_x = torch.index_select(input=voxelgrid_vertices, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 3)
+ surf_edges_s = torch.index_select(input=scalar_field, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 1)
+ zero_crossing = self._linear_interp(surf_edges_s, surf_edges_x)
+
+ if voxelgrid_colors is not None:
+ C = voxelgrid_colors.shape[-1]
+ surf_edges_c = torch.index_select(input=voxelgrid_colors, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, C)
+
+ idx_map = idx_map.reshape(-1, 12)
+ num_vd = torch.index_select(input=self.num_vd_table, index=case_ids, dim=0)
+ edge_group, edge_group_to_vd, edge_group_to_cube, vd_num_edges, vd_gamma = [], [], [], [], []
+
+ # if color is not None:
+ # vd_color = []
+
+ total_num_vd = 0
+ vd_idx_map = torch.zeros((case_ids.shape[0], 12), dtype=torch.long, device=self.device, requires_grad=False)
+
+ for num in torch.unique(num_vd):
+ cur_cubes = (num_vd == num) # consider cubes with the same numbers of vd emitted (for batching)
+ curr_num_vd = cur_cubes.sum() * num
+ curr_edge_group = self.dmc_table[case_ids[cur_cubes], :num].reshape(-1, num * 7)
+ curr_edge_group_to_vd = torch.arange(
+ curr_num_vd, device=self.device).unsqueeze(-1).repeat(1, 7) + total_num_vd
+ total_num_vd += curr_num_vd
+ curr_edge_group_to_cube = torch.arange(idx_map.shape[0], device=self.device)[
+ cur_cubes].unsqueeze(-1).repeat(1, num * 7).reshape_as(curr_edge_group)
+
+ curr_mask = (curr_edge_group != -1)
+ edge_group.append(torch.masked_select(curr_edge_group, curr_mask))
+ edge_group_to_vd.append(torch.masked_select(curr_edge_group_to_vd.reshape_as(curr_edge_group), curr_mask))
+ edge_group_to_cube.append(torch.masked_select(curr_edge_group_to_cube, curr_mask))
+ vd_num_edges.append(curr_mask.reshape(-1, 7).sum(-1, keepdims=True))
+ vd_gamma.append(torch.masked_select(gamma_f, cur_cubes).unsqueeze(-1).repeat(1, num).reshape(-1))
+ # if color is not None:
+ # vd_color.append(color[cur_cubes].unsqueeze(1).repeat(1, num, 1).reshape(-1, 3))
+
+ edge_group = torch.cat(edge_group)
+ edge_group_to_vd = torch.cat(edge_group_to_vd)
+ edge_group_to_cube = torch.cat(edge_group_to_cube)
+ vd_num_edges = torch.cat(vd_num_edges)
+ vd_gamma = torch.cat(vd_gamma)
+ # if color is not None:
+ # vd_color = torch.cat(vd_color)
+ # else:
+ # vd_color = None
+
+ vd = torch.zeros((total_num_vd, 3), device=self.device)
+ beta_sum = torch.zeros((total_num_vd, 1), device=self.device)
+
+ idx_group = torch.gather(input=idx_map.reshape(-1), dim=0, index=edge_group_to_cube * 12 + edge_group)
+
+ x_group = torch.index_select(input=surf_edges_x, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 3)
+ s_group = torch.index_select(input=surf_edges_s, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 1)
+
+
+ zero_crossing_group = torch.index_select(
+ input=zero_crossing, index=idx_group.reshape(-1), dim=0).reshape(-1, 3)
+
+ alpha_group = torch.index_select(input=alpha_nx12x2.reshape(-1, 2), dim=0,
+ index=edge_group_to_cube * 12 + edge_group).reshape(-1, 2, 1)
+ ue_group = self._linear_interp(s_group * alpha_group, x_group)
+
+ beta_group = torch.gather(input=beta.reshape(-1), dim=0,
+ index=edge_group_to_cube * 12 + edge_group).reshape(-1, 1)
+ beta_sum = beta_sum.index_add_(0, index=edge_group_to_vd, source=beta_group)
+ vd = vd.index_add_(0, index=edge_group_to_vd, source=ue_group * beta_group) / beta_sum
+
+ '''
+ interpolate colors use the same method as dual vertices
+ '''
+ if voxelgrid_colors is not None:
+ vd_color = torch.zeros((total_num_vd, C), device=self.device)
+ c_group = torch.index_select(input=surf_edges_c, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, C)
+ uc_group = self._linear_interp(s_group * alpha_group, c_group)
+ vd_color = vd_color.index_add_(0, index=edge_group_to_vd, source=uc_group * beta_group) / beta_sum
+ else:
+ vd_color = None
+
+ L_dev = self._compute_reg_loss(vd, zero_crossing_group, edge_group_to_vd, vd_num_edges)
+
+ v_idx = torch.arange(vd.shape[0], device=self.device) # + total_num_vd
+
+ vd_idx_map = (vd_idx_map.reshape(-1)).scatter(dim=0, index=edge_group_to_cube *
+ 12 + edge_group, src=v_idx[edge_group_to_vd])
+
+ return vd, L_dev, vd_gamma, vd_idx_map, vd_color
+
+ def _triangulate(self, scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map, vd_idx_map, surf_edges_mask, training, vd_color):
+ """
+ Connects four neighboring dual vertices to form a quadrilateral. The quadrilaterals are then split into
+ triangles based on the gamma parameter, as described in Section 4.3.
+ """
+ with torch.no_grad():
+ group_mask = (edge_counts == 4) & surf_edges_mask # surface edges shared by 4 cubes.
+ group = idx_map.reshape(-1)[group_mask]
+ vd_idx = vd_idx_map[group_mask]
+ edge_indices, indices = torch.sort(group, stable=True)
+ quad_vd_idx = vd_idx[indices].reshape(-1, 4)
+
+ # Ensure all face directions point towards the positive SDF to maintain consistent winding.
+ s_edges = scalar_field[surf_edges[edge_indices.reshape(-1, 4)[:, 0]].reshape(-1)].reshape(-1, 2)
+ flip_mask = s_edges[:, 0] > 0
+ quad_vd_idx = torch.cat((quad_vd_idx[flip_mask][:, [0, 1, 3, 2]],
+ quad_vd_idx[~flip_mask][:, [2, 3, 1, 0]]))
+
+ quad_gamma = torch.index_select(input=vd_gamma, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4)
+ gamma_02 = quad_gamma[:, 0] * quad_gamma[:, 2]
+ gamma_13 = quad_gamma[:, 1] * quad_gamma[:, 3]
+ if not training:
+ mask = (gamma_02 > gamma_13)
+ faces = torch.zeros((quad_gamma.shape[0], 6), dtype=torch.long, device=quad_vd_idx.device)
+ faces[mask] = quad_vd_idx[mask][:, self.quad_split_1]
+ faces[~mask] = quad_vd_idx[~mask][:, self.quad_split_2]
+ faces = faces.reshape(-1, 3)
+ else:
+ vd_quad = torch.index_select(input=vd, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, 3)
+ vd_02 = (vd_quad[:, 0] + vd_quad[:, 2]) / 2
+ vd_13 = (vd_quad[:, 1] + vd_quad[:, 3]) / 2
+ weight_sum = (gamma_02 + gamma_13) + 1e-8
+ vd_center = (vd_02 * gamma_02.unsqueeze(-1) + vd_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1)
+
+ if vd_color is not None:
+ color_quad = torch.index_select(input=vd_color, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, vd_color.shape[-1])
+ color_02 = (color_quad[:, 0] + color_quad[:, 2]) / 2
+ color_13 = (color_quad[:, 1] + color_quad[:, 3]) / 2
+ color_center = (color_02 * gamma_02.unsqueeze(-1) + color_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1)
+ vd_color = torch.cat([vd_color, color_center])
+
+
+ vd_center_idx = torch.arange(vd_center.shape[0], device=self.device) + vd.shape[0]
+ vd = torch.cat([vd, vd_center])
+ faces = quad_vd_idx[:, self.quad_split_train].reshape(-1, 4, 2)
+ faces = torch.cat([faces, vd_center_idx.reshape(-1, 1, 1).repeat(1, 4, 1)], -1).reshape(-1, 3)
+ return vd, faces, s_edges, edge_indices, vd_color
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/ablate_L_dev.jpg b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/ablate_L_dev.jpg
new file mode 100644
index 0000000..461bd1c
Binary files /dev/null and b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/ablate_L_dev.jpg differ
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/block_final.png b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/block_final.png
new file mode 100644
index 0000000..8b19771
Binary files /dev/null and b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/images/block_final.png differ
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/tables.py b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/tables.py
new file mode 100644
index 0000000..5873e77
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/flexicubes/tables.py
@@ -0,0 +1,791 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+dmc_table = [
+[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 6, 7, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 5, 6, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 6, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, 6, 7, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 6, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 4, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 4, 5, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]]
+]
+num_vd_table = [0, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 2, 2,
+2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 3, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 2,
+1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 3, 2, 2, 1, 1, 1, 1,
+1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 2, 2, 1, 3, 4, 2,
+2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2,
+3, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 3, 2, 3, 2, 4, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1,
+2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1,
+1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2,
+1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
+check_table = [
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 194],
+[1, -1, 0, 0, 193],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 164],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 161],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 152],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 145],
+[1, 0, 0, 1, 144],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 137],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 133],
+[1, 0, 1, 0, 132],
+[1, 1, 0, 0, 131],
+[1, 1, 0, 0, 130],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 100],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 98],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 96],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 88],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 82],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 74],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 72],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 70],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 67],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 65],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 56],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 52],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 44],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 40],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 38],
+[1, 0, -1, 0, 37],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 33],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 28],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 26],
+[1, 0, 0, -1, 25],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 20],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 18],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 9],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 6],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0]
+]
+tet_table = [
+[-1, -1, -1, -1, -1, -1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, -1],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[0, 4, 0, 4, 4, -1],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[5, 5, 5, 5, 5, 5],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, -1, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, -1, 2, 4, 4, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 4, 4, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 4, 2, 4, 4, 2],
+[0, 4, 0, 4, 4, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 5, 2, 5, 5, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, -1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[4, 1, 1, 4, 4, 1],
+[0, 1, 1, 0, 0, 1],
+[4, 0, 0, 4, 4, 0],
+[2, 2, 2, 2, 2, 2],
+[-1, 1, 1, 4, 4, 1],
+[0, 1, 1, 4, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[5, 1, 1, 5, 5, 1],
+[0, 1, 1, 0, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[8, 8, 8, 8, 8, 8],
+[1, 1, 1, 4, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 4, 4, 1],
+[0, 4, 0, 4, 4, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 5, 5, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[6, 6, 6, 6, 6, 6],
+[6, -1, 0, 6, 0, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 1, 1, 6, 1, 6],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[6, 4, -1, 6, 4, 6],
+[6, 4, 0, 6, 4, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 1, 1, 6, 1, 6],
+[5, 5, 5, 5, 5, 5],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 4, 2, 2, 4, 2],
+[0, 4, 0, 4, 4, 0],
+[2, 0, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[6, 1, 1, 6, -1, 6],
+[6, 1, 1, 6, 0, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 2, 2, 6, 2, 6],
+[4, 1, 1, 4, 4, 1],
+[0, 1, 1, 0, 0, 1],
+[4, 0, 0, 4, 4, 4],
+[2, 2, 2, 2, 2, 2],
+[6, 1, 1, 6, 4, 6],
+[6, 1, 1, 6, 4, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 2, 2, 6, 2, 6],
+[5, 1, 1, 5, 5, 1],
+[0, 1, 1, 0, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[6, 6, 6, 6, 6, 6],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 4, 1],
+[0, 4, 0, 4, 4, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 5, 0, 5, 0, 5],
+[5, 5, 5, 5, 5, 5],
+[5, 5, 5, 5, 5, 5],
+[0, 5, 0, 5, 0, 5],
+[-1, 5, 0, 5, 0, 5],
+[1, 5, 1, 5, 1, 5],
+[4, 5, -1, 5, 4, 5],
+[0, 5, 0, 5, 0, 5],
+[4, 5, 0, 5, 4, 5],
+[1, 5, 1, 5, 1, 5],
+[4, 4, 4, 4, 4, 4],
+[0, 4, 0, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[6, 6, 6, 6, 6, 6],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 5, 2, 5, -1, 5],
+[0, 5, 0, 5, 0, 5],
+[2, 5, 2, 5, 0, 5],
+[1, 5, 1, 5, 1, 5],
+[2, 5, 2, 5, 4, 5],
+[0, 5, 0, 5, 0, 5],
+[2, 5, 2, 5, 4, 5],
+[1, 5, 1, 5, 1, 5],
+[2, 4, 2, 4, 4, 2],
+[0, 4, 0, 4, 4, 4],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 6, 2, 6, 6, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, 1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[4, 1, 1, 1, 4, 1],
+[0, 1, 1, 1, 0, 1],
+[4, 0, 0, 4, 4, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[1, 1, 1, 1, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[6, 0, 0, 6, 0, 6],
+[0, 0, 0, 0, 0, 0],
+[6, 6, 6, 6, 6, 6],
+[5, 5, 5, 5, 5, 5],
+[5, 5, 0, 5, 0, 5],
+[5, 5, 0, 5, 0, 5],
+[5, 5, 1, 5, 1, 5],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 0, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[4, 4, 0, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[8, 8, 8, 8, 8, 8],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 1, 1, 4, 4, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 4, 2, 4, 4, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[12, 12, 12, 12, 12, 12]
+]
diff --git a/OmniPart/modules/part_synthesis/representations/mesh/utils_cube.py b/OmniPart/modules/part_synthesis/representations/mesh/utils_cube.py
new file mode 100644
index 0000000..23913c9
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/mesh/utils_cube.py
@@ -0,0 +1,61 @@
+import torch
+cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [
+ 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.int)
+cube_neighbor = torch.tensor([[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]])
+cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6,
+ 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, requires_grad=False)
+
+def construct_dense_grid(res, device='cuda'):
+ '''construct a dense grid based on resolution'''
+ res_v = res + 1
+ vertsid = torch.arange(res_v ** 3, device=device)
+ coordsid = vertsid.reshape(res_v, res_v, res_v)[:res, :res, :res].flatten()
+ cube_corners_bias = (cube_corners[:, 0] * res_v + cube_corners[:, 1]) * res_v + cube_corners[:, 2]
+ cube_fx8 = (coordsid.unsqueeze(1) + cube_corners_bias.unsqueeze(0).to(device))
+ verts = torch.stack([vertsid // (res_v ** 2), (vertsid // res_v) % res_v, vertsid % res_v], dim=1)
+ return verts, cube_fx8
+
+
+def construct_voxel_grid(coords):
+ verts = (cube_corners.unsqueeze(0).to(coords) + coords.unsqueeze(1)).reshape(-1, 3)
+ verts_unique, inverse_indices = torch.unique(verts, dim=0, return_inverse=True)
+ cubes = inverse_indices.reshape(-1, 8)
+ return verts_unique, cubes
+
+
+def cubes_to_verts(num_verts, cubes, value, reduce='mean'):
+ """
+ Args:
+ cubes [Vx8] verts index for each cube
+ value [Vx8xM] value to be scattered
+ Operation:
+ reduced[cubes[i][j]][k] += value[i][k]
+ """
+ M = value.shape[2] # number of channels
+ reduced = torch.zeros(num_verts, M, device=cubes.device)
+ return torch.scatter_reduce(reduced, 0,
+ cubes.unsqueeze(-1).expand(-1, -1, M).flatten(0, 1),
+ value.flatten(0, 1), reduce=reduce, include_self=False)
+
+def sparse_cube2verts(coords, feats, training=True):
+ new_coords, cubes = construct_voxel_grid(coords)
+ new_feats = cubes_to_verts(new_coords.shape[0], cubes, feats)
+ if training:
+ con_loss = torch.mean((feats - new_feats[cubes]) ** 2)
+ else:
+ con_loss = 0.0
+ return new_coords, new_feats, con_loss
+
+
+def get_dense_attrs(coords : torch.Tensor, feats : torch.Tensor, res : int, sdf_init=True):
+ F = feats.shape[-1]
+ dense_attrs = torch.zeros([res] * 3 + [F], device=feats.device)
+ if sdf_init:
+ dense_attrs[..., 0] = 1 # initial outside sdf value
+ dense_attrs[coords[:, 0], coords[:, 1], coords[:, 2], :] = feats
+ return dense_attrs.reshape(-1, F)
+
+
+def get_defomed_verts(v_pos : torch.Tensor, deform : torch.Tensor, res):
+ return v_pos / res - 0.5 + (1 - 1e-8) / (res * 2) * torch.tanh(deform)
+
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/octree/__init__.py b/OmniPart/modules/part_synthesis/representations/octree/__init__.py
new file mode 100644
index 0000000..f66a39a
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/octree/__init__.py
@@ -0,0 +1 @@
+from .octree_dfs import DfsOctree
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/octree/octree_dfs.py b/OmniPart/modules/part_synthesis/representations/octree/octree_dfs.py
new file mode 100644
index 0000000..c2bd4dc
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/octree/octree_dfs.py
@@ -0,0 +1,347 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DfsOctree:
+ """
+ Sparse Voxel Octree (SVO) implementation for PyTorch.
+ Using Depth-First Search (DFS) order to store the octree.
+ DFS order suits rendering and ray tracing.
+
+ The structure and data are separatedly stored.
+ Structure is stored as a continuous array, each element is a 3*32 bits descriptor.
+ |-----------------------------------------|
+ | 0:3 bits | 4:31 bits |
+ | leaf num | unused |
+ |-----------------------------------------|
+ | 0:31 bits |
+ | child ptr |
+ |-----------------------------------------|
+ | 0:31 bits |
+ | data ptr |
+ |-----------------------------------------|
+ Each element represents a non-leaf node in the octree.
+ The valid mask is used to indicate whether the children are valid.
+ The leaf mask is used to indicate whether the children are leaf nodes.
+ The child ptr is used to point to the first non-leaf child. Non-leaf children descriptors are stored continuously from the child ptr.
+ The data ptr is used to point to the data of leaf children. Leaf children data are stored continuously from the data ptr.
+
+ There are also auxiliary arrays to store the additional structural information to facilitate parallel processing.
+ - Position: the position of the octree nodes.
+ - Depth: the depth of the octree nodes.
+
+ Args:
+ depth (int): the depth of the octree.
+ """
+
+ def __init__(
+ self,
+ depth,
+ aabb=[0,0,0,1,1,1],
+ sh_degree=2,
+ primitive='voxel',
+ primitive_config={},
+ device='cuda',
+ ):
+ self.max_depth = depth
+ self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device)
+ self.device = device
+ self.sh_degree = sh_degree
+ self.active_sh_degree = sh_degree
+ self.primitive = primitive
+ self.primitive_config = primitive_config
+
+ self.structure = torch.tensor([[8, 1, 0]], dtype=torch.int32, device=self.device)
+ self.position = torch.zeros((8, 3), dtype=torch.float32, device=self.device)
+ self.depth = torch.zeros((8, 1), dtype=torch.uint8, device=self.device)
+ self.position[:, 0] = torch.tensor([0.25, 0.75, 0.25, 0.75, 0.25, 0.75, 0.25, 0.75], device=self.device)
+ self.position[:, 1] = torch.tensor([0.25, 0.25, 0.75, 0.75, 0.25, 0.25, 0.75, 0.75], device=self.device)
+ self.position[:, 2] = torch.tensor([0.25, 0.25, 0.25, 0.25, 0.75, 0.75, 0.75, 0.75], device=self.device)
+ self.depth[:, 0] = 1
+
+ self.data = ['position', 'depth']
+ self.param_names = []
+
+ if primitive == 'voxel':
+ self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.data += ['features_dc', 'features_ac']
+ self.param_names += ['features_dc', 'features_ac']
+ if not primitive_config.get('solid', False):
+ self.density = torch.zeros((8, 1), dtype=torch.float32, device=self.device)
+ self.data.append('density')
+ self.param_names.append('density')
+ elif primitive == 'gaussian':
+ self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.opacity = torch.zeros((8, 1), dtype=torch.float32, device=self.device)
+ self.data += ['features_dc', 'features_ac', 'opacity']
+ self.param_names += ['features_dc', 'features_ac', 'opacity']
+ elif primitive == 'trivec':
+ self.trivec = torch.zeros((8, primitive_config['rank'], 3, primitive_config['dim']), dtype=torch.float32, device=self.device)
+ self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device)
+ self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.density_shift = 0
+ self.data += ['trivec', 'density', 'features_dc', 'features_ac']
+ self.param_names += ['trivec', 'density', 'features_dc', 'features_ac']
+ elif primitive == 'decoupoly':
+ self.decoupoly_V = torch.zeros((8, primitive_config['rank'], 3), dtype=torch.float32, device=self.device)
+ self.decoupoly_g = torch.zeros((8, primitive_config['rank'], primitive_config['degree']), dtype=torch.float32, device=self.device)
+ self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device)
+ self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.density_shift = 0
+ self.data += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac']
+ self.param_names += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac']
+
+ self.setup_functions()
+
+ def setup_functions(self):
+ self.density_activation = (lambda x: torch.exp(x - 2)) if self.primitive != 'trivec' else (lambda x: x)
+ self.opacity_activation = lambda x: torch.sigmoid(x - 6)
+ self.inverse_opacity_activation = lambda x: torch.log(x / (1 - x)) + 6
+ self.color_activation = lambda x: torch.sigmoid(x)
+
+ @property
+ def num_non_leaf_nodes(self):
+ return self.structure.shape[0]
+
+ @property
+ def num_leaf_nodes(self):
+ return self.depth.shape[0]
+
+ @property
+ def cur_depth(self):
+ return self.depth.max().item()
+
+ @property
+ def occupancy(self):
+ return self.num_leaf_nodes / 8 ** self.cur_depth
+
+ @property
+ def get_xyz(self):
+ return self.position
+
+ @property
+ def get_depth(self):
+ return self.depth
+
+ @property
+ def get_density(self):
+ if self.primitive == 'voxel' and self.primitive_config.get('solid', False):
+ return torch.full((self.position.shape[0], 1), torch.finfo(torch.float32).max, dtype=torch.float32, device=self.device)
+ return self.density_activation(self.density)
+
+ @property
+ def get_opacity(self):
+ return self.opacity_activation(self.density)
+
+ @property
+ def get_trivec(self):
+ return self.trivec
+
+ @property
+ def get_decoupoly(self):
+ return F.normalize(self.decoupoly_V, dim=-1), self.decoupoly_g
+
+ @property
+ def get_color(self):
+ return self.color_activation(self.colors)
+
+ @property
+ def get_features(self):
+ if self.sh_degree == 0:
+ return self.features_dc
+ return torch.cat([self.features_dc, self.features_ac], dim=-2)
+
+ def state_dict(self):
+ ret = {'structure': self.structure, 'position': self.position, 'depth': self.depth, 'sh_degree': self.sh_degree, 'active_sh_degree': self.active_sh_degree, 'primitive_config': self.primitive_config, 'primitive': self.primitive}
+ if hasattr(self, 'density_shift'):
+ ret['density_shift'] = self.density_shift
+ for data in set(self.data + self.param_names):
+ if not isinstance(getattr(self, data), nn.Module):
+ ret[data] = getattr(self, data)
+ else:
+ ret[data] = getattr(self, data).state_dict()
+ return ret
+
+ def load_state_dict(self, state_dict):
+ keys = list(set(self.data + self.param_names + list(state_dict.keys()) + ['structure', 'position', 'depth']))
+ for key in keys:
+ if key not in state_dict:
+ print(f"Warning: key {key} not found in the state_dict.")
+ continue
+ try:
+ if not isinstance(getattr(self, key), nn.Module):
+ setattr(self, key, state_dict[key])
+ else:
+ getattr(self, key).load_state_dict(state_dict[key])
+ except Exception as e:
+ print(e)
+ raise ValueError(f"Error loading key {key}.")
+
+ def gather_from_leaf_children(self, data):
+ """
+ Gather the data from the leaf children.
+
+ Args:
+ data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes.
+ """
+ leaf_cnt = self.structure[:, 0]
+ leaf_cnt_masks = [leaf_cnt == i for i in range(1, 9)]
+ ret = torch.zeros((self.num_non_leaf_nodes,), dtype=data.dtype, device=self.device)
+ for i in range(8):
+ if leaf_cnt_masks[i].sum() == 0:
+ continue
+ start = self.structure[leaf_cnt_masks[i], 2]
+ for j in range(i+1):
+ ret[leaf_cnt_masks[i]] += data[start + j]
+ return ret
+
+ def gather_from_non_leaf_children(self, data):
+ """
+ Gather the data from the non-leaf children.
+
+ Args:
+ data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes.
+ """
+ non_leaf_cnt = 8 - self.structure[:, 0]
+ non_leaf_cnt_masks = [non_leaf_cnt == i for i in range(1, 9)]
+ ret = torch.zeros_like(data, device=self.device)
+ for i in range(8):
+ if non_leaf_cnt_masks[i].sum() == 0:
+ continue
+ start = self.structure[non_leaf_cnt_masks[i], 1]
+ for j in range(i+1):
+ ret[non_leaf_cnt_masks[i]] += data[start + j]
+ return ret
+
+ def structure_control(self, mask):
+ """
+ Control the structure of the octree.
+
+ Args:
+ mask (torch.Tensor): the mask to control the structure. 1 for subdivide, -1 for merge, 0 for keep.
+ """
+ # Dont subdivide when the depth is the maximum.
+ mask[self.depth.squeeze() == self.max_depth] = torch.clamp_max(mask[self.depth.squeeze() == self.max_depth], 0)
+ # Dont merge when the depth is the minimum.
+ mask[self.depth.squeeze() == 1] = torch.clamp_min(mask[self.depth.squeeze() == 1], 0)
+
+ # Gather control mask
+ structre_ctrl = self.gather_from_leaf_children(mask)
+ structre_ctrl[structre_ctrl==-8] = -1
+
+ new_leaf_num = self.structure[:, 0].clone()
+ # Modify the leaf num.
+ structre_valid = structre_ctrl >= 0
+ new_leaf_num[structre_valid] -= structre_ctrl[structre_valid] # Add the new nodes.
+ structre_delete = structre_ctrl < 0
+ merged_nodes = self.gather_from_non_leaf_children(structre_delete.int())
+ new_leaf_num += merged_nodes # Delete the merged nodes.
+
+ # Update the structure array to allocate new nodes.
+ mem_offset = torch.zeros((self.num_non_leaf_nodes + 1,), dtype=torch.int32, device=self.device)
+ mem_offset.index_add_(0, self.structure[structre_valid, 1], structre_ctrl[structre_valid]) # Add the new nodes.
+ mem_offset[:-1] -= structre_delete.int() # Delete the merged nodes.
+ new_structre_idx = torch.arange(0, self.num_non_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0)
+ new_structure_length = new_structre_idx[-1].item()
+ new_structre_idx = new_structre_idx[:-1]
+ new_structure = torch.empty((new_structure_length, 3), dtype=torch.int32, device=self.device)
+ new_structure[new_structre_idx[structre_valid], 0] = new_leaf_num[structre_valid]
+
+ # Initialize the new nodes.
+ new_node_mask = torch.ones((new_structure_length,), dtype=torch.bool, device=self.device)
+ new_node_mask[new_structre_idx[structre_valid]] = False
+ new_structure[new_node_mask, 0] = 8 # Initialize to all leaf nodes.
+ new_node_num = new_node_mask.sum().item()
+
+ # Rebuild child ptr.
+ non_leaf_cnt = 8 - new_structure[:, 0]
+ new_child_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), non_leaf_cnt.cumsum(0)[:-1]])
+ new_structure[:, 1] = new_child_ptr + 1
+
+ # Rebuild data ptr with old data.
+ leaf_cnt = torch.zeros((new_structure_length,), dtype=torch.int32, device=self.device)
+ leaf_cnt.index_add_(0, new_structre_idx, self.structure[:, 0])
+ old_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]])
+
+ # Update the data array
+ subdivide_mask = mask == 1
+ merge_mask = mask == -1
+ data_valid = ~(subdivide_mask | merge_mask)
+ mem_offset = torch.zeros((self.num_leaf_nodes + 1,), dtype=torch.int32, device=self.device)
+ mem_offset.index_add_(0, old_data_ptr[new_node_mask], torch.full((new_node_num,), 8, dtype=torch.int32, device=self.device)) # Add data array for new nodes
+ mem_offset[:-1] -= subdivide_mask.int() # Delete data elements for subdivide nodes
+ mem_offset[:-1] -= merge_mask.int() # Delete data elements for merge nodes
+ mem_offset.index_add_(0, self.structure[structre_valid, 2], merged_nodes[structre_valid]) # Add data elements for merge nodes
+ new_data_idx = torch.arange(0, self.num_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0)
+ new_data_length = new_data_idx[-1].item()
+ new_data_idx = new_data_idx[:-1]
+ new_data = {data: torch.empty((new_data_length,) + getattr(self, data).shape[1:], dtype=getattr(self, data).dtype, device=self.device) for data in self.data}
+ for data in self.data:
+ new_data[data][new_data_idx[data_valid]] = getattr(self, data)[data_valid]
+
+ # Rebuild data ptr
+ leaf_cnt = new_structure[:, 0]
+ new_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]])
+ new_structure[:, 2] = new_data_ptr
+
+ # Initialize the new data array
+ ## For subdivide nodes
+ if subdivide_mask.sum() > 0:
+ subdivide_data_ptr = new_structure[new_node_mask, 2]
+ for data in self.data:
+ for i in range(8):
+ if data == 'position':
+ offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) - 0.5
+ scale = 2 ** (-1.0 - self.depth[subdivide_mask])
+ new_data['position'][subdivide_data_ptr + i] = self.position[subdivide_mask] + offset * scale
+ elif data == 'depth':
+ new_data['depth'][subdivide_data_ptr + i] = self.depth[subdivide_mask] + 1
+ elif data == 'opacity':
+ new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(torch.sqrt(self.opacity_activation(self.opacity[subdivide_mask])))
+ elif data == 'trivec':
+ offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) * 0.5
+ coord = (torch.linspace(0, 0.5, self.trivec.shape[-1], dtype=torch.float32, device=self.device)[None] + offset[:, None]).reshape(1, 3, self.trivec.shape[-1], 1)
+ axis = torch.linspace(0, 1, 3, dtype=torch.float32, device=self.device).reshape(1, 3, 1, 1).repeat(1, 1, self.trivec.shape[-1], 1)
+ coord = torch.stack([coord, axis], dim=3).reshape(1, 3, self.trivec.shape[-1], 2).expand(self.trivec[subdivide_mask].shape[0], -1, -1, -1) * 2 - 1
+ new_data['trivec'][subdivide_data_ptr + i] = F.grid_sample(self.trivec[subdivide_mask], coord, align_corners=True)
+ else:
+ new_data[data][subdivide_data_ptr + i] = getattr(self, data)[subdivide_mask]
+ ## For merge nodes
+ if merge_mask.sum() > 0:
+ merge_data_ptr = torch.empty((merged_nodes.sum().item(),), dtype=torch.int32, device=self.device)
+ merge_nodes_cumsum = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), merged_nodes.cumsum(0)[:-1]])
+ for i in range(8):
+ merge_data_ptr[merge_nodes_cumsum[merged_nodes > i] + i] = new_structure[new_structre_idx[merged_nodes > i], 2] + i
+ old_merge_data_ptr = self.structure[structre_delete, 2]
+ for data in self.data:
+ if data == 'position':
+ scale = 2 ** (1.0 - self.depth[old_merge_data_ptr])
+ new_data['position'][merge_data_ptr] = ((self.position[old_merge_data_ptr] + 0.5) / scale).floor() * scale + 0.5 * scale - 0.5
+ elif data == 'depth':
+ new_data['depth'][merge_data_ptr] = self.depth[old_merge_data_ptr] - 1
+ elif data == 'opacity':
+ new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(self.opacity_activation(self.opacity[subdivide_mask])**2)
+ elif data == 'trivec':
+ new_data['trivec'][merge_data_ptr] = self.trivec[old_merge_data_ptr]
+ else:
+ new_data[data][merge_data_ptr] = getattr(self, data)[old_merge_data_ptr]
+
+ # Update the structure and data array
+ self.structure = new_structure
+ for data in self.data:
+ setattr(self, data, new_data[data])
+
+ # Save data array control temp variables
+ self.data_rearrange_buffer = {
+ 'subdivide_mask': subdivide_mask,
+ 'merge_mask': merge_mask,
+ 'data_valid': data_valid,
+ 'new_data_idx': new_data_idx,
+ 'new_data_length': new_data_length,
+ 'new_data': new_data
+ }
diff --git a/OmniPart/modules/part_synthesis/representations/radiance_field/__init__.py b/OmniPart/modules/part_synthesis/representations/radiance_field/__init__.py
new file mode 100644
index 0000000..b72a1b7
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/radiance_field/__init__.py
@@ -0,0 +1 @@
+from .strivec import Strivec
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/representations/radiance_field/strivec.py b/OmniPart/modules/part_synthesis/representations/radiance_field/strivec.py
new file mode 100644
index 0000000..8fc4b74
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/representations/radiance_field/strivec.py
@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..octree import DfsOctree as Octree
+
+
+class Strivec(Octree):
+ def __init__(
+ self,
+ resolution: int,
+ aabb: list,
+ sh_degree: int = 0,
+ rank: int = 8,
+ dim: int = 8,
+ device: str = "cuda",
+ ):
+ assert np.log2(resolution) % 1 == 0, "Resolution must be a power of 2"
+ self.resolution = resolution
+ depth = int(np.round(np.log2(resolution)))
+ super().__init__(
+ depth=depth,
+ aabb=aabb,
+ sh_degree=sh_degree,
+ primitive="trivec",
+ primitive_config={"rank": rank, "dim": dim},
+ device=device,
+ )
diff --git a/OmniPart/modules/part_synthesis/utils/__init__.py b/OmniPart/modules/part_synthesis/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/OmniPart/modules/part_synthesis/utils/data_utils.py b/OmniPart/modules/part_synthesis/utils/data_utils.py
new file mode 100644
index 0000000..d0c2ac3
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/data_utils.py
@@ -0,0 +1,410 @@
+"""
+This file (`data_utils.py`) provides utility functions and classes for data handling in deep learning models.
+It includes tools for moving tensors to specific devices, load-balancing utilities for distributed training,
+and custom samplers for PyTorch DataLoaders that support resumable training and balanced data distribution.
+
+Key components:
+- Recursive device transfer functionality
+- Load balancing utilities for distributing data across processes
+- Cyclical iteration through data loaders
+- Custom resumable samplers for distributed training
+"""
+
+from typing import *
+import math
+import torch
+import numpy as np
+from torch.utils.data import Sampler, Dataset, DataLoader, DistributedSampler
+import torch.distributed as dist
+
+
+def recursive_to_device(
+ data: Any,
+ device: torch.device,
+ non_blocking: bool = False,
+) -> Any:
+ """
+ Recursively move all tensors in a data structure to a device.
+
+ This function traverses nested data structures (lists, tuples, dictionaries)
+ and moves any PyTorch tensor to the specified device.
+
+ Args:
+ data: The data structure containing tensors to be moved
+ device: The target device (CPU, GPU) to move tensors to
+ non_blocking: If True, allows asynchronous copy to device if possible
+
+ Returns:
+ The same data structure with all tensors moved to the specified device
+ """
+ if hasattr(data, "to"):
+ # print("Moving data to device")
+ # print(data)
+ return data.to(device, non_blocking=non_blocking)
+ elif isinstance(data, (list, tuple)):
+ # print("list or tuple detected")
+ return type(data)(recursive_to_device(d, device, non_blocking) for d in data)
+ elif isinstance(data, dict):
+ # print("dict detected")
+ return {k: recursive_to_device(v, device, non_blocking) for k, v in data.items()}
+ else:
+ # print(f"{type(data)} detected")
+ return data
+
+
+def load_balanced_group_indices(
+ load: List[int],
+ num_groups: int,
+ equal_size: bool = False,
+) -> List[List[int]]:
+ """
+ Split indices into groups with balanced load.
+
+ This function distributes indices across groups to achieve balanced workload.
+ It uses a greedy algorithm that assigns each index to the group with the
+ minimum current load.
+
+ Args:
+ load: List of load values for each index
+ num_groups: Number of groups to split indices into
+ equal_size: If True, each group will have the same number of elements
+
+ Returns:
+ List of lists, where each inner list contains indices assigned to a group
+ """
+ if equal_size:
+ group_size = len(load) // num_groups
+ indices = np.argsort(load)[::-1] # Sort indices by load in descending order
+ groups = [[] for _ in range(num_groups)]
+ group_load = np.zeros(num_groups)
+ for idx in indices:
+ min_group_idx = np.argmin(group_load)
+ groups[min_group_idx].append(idx)
+ if equal_size and len(groups[min_group_idx]) == group_size:
+ group_load[min_group_idx] = float('inf') # Mark group as full
+ else:
+ group_load[min_group_idx] += load[idx]
+ return groups
+
+
+def cycle(data_loader: DataLoader) -> Iterator:
+ """
+ Creates an infinite iterator over a data loader.
+
+ This function wraps a data loader to cycle through it repeatedly,
+ handling epoch tracking for various sampler types.
+
+ Args:
+ data_loader: The DataLoader to cycle through
+
+ Returns:
+ An iterator that indefinitely yields batches from the data loader
+ """
+ while True:
+ for data in data_loader:
+ if isinstance(data_loader.sampler, ResumableSampler):
+ data_loader.sampler.idx += data_loader.batch_size # Update position for resumability
+ yield data
+ if isinstance(data_loader.sampler, DistributedSampler):
+ data_loader.sampler.epoch += 1 # Update epoch for DistributedSampler
+ if isinstance(data_loader.sampler, ResumableSampler):
+ data_loader.sampler.epoch += 1 # Update epoch for ResumableSampler
+ data_loader.sampler.idx = 0 # Reset position index
+
+
+class ResumableSampler(Sampler):
+ """
+ Distributed sampler that is resumable.
+
+ This sampler extends PyTorch's Sampler to support resuming training from
+ a specific point. It tracks the current position (idx) and epoch to
+ enable checkpointing and resuming.
+
+ Args:
+ dataset: Dataset used for sampling.
+ rank (int, optional): Rank of the current process within :attr:`num_replicas`.
+ By default, :attr:`rank` is retrieved from the current distributed
+ group.
+ shuffle (bool, optional): If ``True`` (default), sampler will shuffle the
+ indices.
+ seed (int, optional): random seed used to shuffle the sampler if
+ :attr:`shuffle=True`. This number should be identical across all
+ processes in the distributed group. Default: ``0``.
+ drop_last (bool, optional): if ``True``, then the sampler will drop the
+ tail of the data to make it evenly divisible across the number of
+ replicas. If ``False``, the sampler will add extra indices to make
+ the data evenly divisible across the replicas. Default: ``False``.
+ """
+
+ def __init__(
+ self,
+ dataset: Dataset,
+ shuffle: bool = True,
+ seed: int = 0,
+ drop_last: bool = False,
+ ) -> None:
+ self.dataset = dataset
+ self.epoch = 0 # Current epoch counter
+ self.idx = 0 # Current index position for resuming
+ self.drop_last = drop_last
+ self.world_size = dist.get_world_size() if dist.is_initialized() else 1 # Get total number of processes
+ self.rank = dist.get_rank() if dist.is_initialized() else 0 # Get current process rank
+
+ # Calculate number of samples per process
+ if self.drop_last and len(self.dataset) % self.world_size != 0:
+ # Split to nearest available length that is evenly divisible
+ # This ensures each rank receives the same amount of data
+ self.num_samples = math.ceil(
+ (len(self.dataset) - self.world_size) / self.world_size
+ )
+ else:
+ self.num_samples = math.ceil(len(self.dataset) / self.world_size)
+
+ self.total_size = self.num_samples * self.world_size # Total size after padding
+ self.shuffle = shuffle
+ self.seed = seed
+
+ def __iter__(self) -> Iterator:
+ if self.shuffle:
+ # Deterministically shuffle based on epoch and seed
+ g = torch.Generator()
+ g.manual_seed(self.seed + self.epoch)
+ indices = torch.randperm(len(self.dataset), generator=g).tolist()
+ else:
+ indices = list(range(len(self.dataset)))
+
+ if not self.drop_last:
+ # Add extra samples to make it evenly divisible across processes
+ padding_size = self.total_size - len(indices)
+ if padding_size <= len(indices):
+ indices += indices[:padding_size] # Reuse some samples from the beginning
+ else:
+ indices += (indices * math.ceil(padding_size / len(indices)))[
+ :padding_size
+ ] # Repeat samples if padding_size > len(indices)
+ else:
+ # Remove tail of data to make it evenly divisible
+ indices = indices[: self.total_size]
+ assert len(indices) == self.total_size
+
+ # Subsample according to rank for distributed training
+ indices = indices[self.rank : self.total_size : self.world_size]
+
+ # Resume from previous state by skipping already processed indices
+ indices = indices[self.idx:]
+
+ return iter(indices)
+
+ def __len__(self) -> int:
+ return self.num_samples
+
+ def state_dict(self) -> Dict[str, int]:
+ """
+ Returns the state of the sampler as a dictionary.
+
+ This enables saving the sampler state for checkpointing.
+
+ Returns:
+ Dictionary containing epoch and current index
+ """
+ return {
+ 'epoch': self.epoch,
+ 'idx': self.idx,
+ }
+
+ def load_state_dict(self, state_dict):
+ """
+ Loads the sampler state from a dictionary.
+
+ This enables restoring the sampler state from a checkpoint.
+
+ Args:
+ state_dict: Dictionary containing sampler state
+ """
+ self.epoch = state_dict['epoch']
+ self.idx = state_dict['idx']
+
+
+class BalancedResumableSampler(ResumableSampler):
+ """
+ Distributed sampler that is resumable and balances the load among the processes.
+
+ This sampler extends ResumableSampler to distribute data across processes
+ in a load-balanced manner, ensuring that each process receives a similar
+ computational workload despite potentially varying sample processing times.
+
+ Args:
+ dataset: Dataset used for sampling. Must have 'loads' attribute.
+ shuffle (bool, optional): If ``True`` (default), sampler will shuffle the
+ indices.
+ seed (int, optional): random seed used to shuffle the sampler if
+ :attr:`shuffle=True`. This number should be identical across all
+ processes in the distributed group. Default: ``0``.
+ drop_last (bool, optional): if ``True``, then the sampler will drop the
+ tail of the data to make it evenly divisible across the number of
+ replicas. If ``False``, the sampler will add extra indices to make
+ the data evenly divisible across the replicas. Default: ``False``.
+ batch_size (int, optional): Size of mini-batches used for balancing. Default: 1.
+ """
+
+ def __init__(
+ self,
+ dataset: Dataset,
+ shuffle: bool = True,
+ seed: int = 0,
+ drop_last: bool = False,
+ batch_size: int = 1,
+ ) -> None:
+ assert hasattr(dataset, 'loads'), 'Dataset must have "loads" attribute to use BalancedResumableSampler'
+ super().__init__(dataset, shuffle, seed, drop_last)
+ self.batch_size = batch_size
+ self.loads = dataset.loads # Load values for each sample in the dataset
+
+ def __iter__(self) -> Iterator:
+ # print(f"[BalancedResumableSampler] Starting __iter__ for rank {self.rank}, epoch {self.epoch}")
+
+ if self.shuffle:
+ # Deterministically shuffle based on epoch and seed
+ g = torch.Generator()
+ g.manual_seed(self.seed + self.epoch)
+ # print(f"[BalancedResumableSampler] Shuffling with seed {self.seed + self.epoch}") # 0
+ indices = torch.randperm(len(self.dataset), generator=g).tolist()
+ else:
+ # print(f"[BalancedResumableSampler] No shuffle, using sequential indices")
+ indices = list(range(len(self.dataset)))
+ # print(indices)
+ # print(f"[BalancedResumableSampler] Initial indices length: {len(indices)}") # 128
+ if not self.drop_last:
+ # Add extra samples to make it evenly divisible
+ padding_size = self.total_size - len(indices)
+ # print(f"[BalancedResumableSampler] Adding padding of size {padding_size}") # 0
+ if padding_size <= len(indices):
+ indices += indices[:padding_size]
+ else:
+ indices += (indices * math.ceil(padding_size / len(indices)))[:padding_size]
+ else:
+ # Remove tail of data to make it evenly divisible
+ # print(f"[BalancedResumableSampler] Dropping last, trimming to {self.total_size}")
+ indices = indices[: self.total_size]
+ # print(indices)
+ assert len(indices) == self.total_size
+ # print(f"[BalancedResumableSampler] After padding/trimming, indices length: {len(indices)}") # 128
+
+ # Balance load among processes by distributing batches based on their loads
+ num_batches = len(indices) // (self.batch_size * self.world_size)
+ # print(f"[BalancedResumableSampler] Number of batches: {num_batches}") # 16
+ balanced_indices = []
+
+ if len(self.loads) < len(indices):
+ # repeat the loads to match the indices
+ self.loads = self.loads * (len(indices) // len(self.loads)) + self.loads[:len(indices) % len(self.loads)]
+
+ for i in range(num_batches):
+ start_idx = i * self.batch_size * self.world_size
+ end_idx = (i + 1) * self.batch_size * self.world_size
+ # print("start idx", start_idx) # 0
+ # print("end idx", end_idx) # 8
+ # print("batch size", self.batch_size) # 8
+ # print("world size", self.world_size) # 1
+ batch_indices = indices[start_idx:end_idx]
+ # print(f"[BalancedResumableSampler] Processing batch {i+1}/{num_batches}, size: {len(batch_indices)}") #1/16 8
+ batch_loads = [self.loads[idx] for idx in batch_indices]
+ groups = load_balanced_group_indices(batch_loads, self.world_size, equal_size=True)
+ balanced_indices.extend([batch_indices[j] for j in groups[self.rank]])
+
+ # print(f"[BalancedResumableSampler] Total balanced indices for rank {self.rank}: {len(balanced_indices)}")
+ # Resume from previous state
+ indices = balanced_indices[self.idx:]
+ # print(f"[BalancedResumableSampler] After resuming from idx {self.idx}, returning {len(indices)} indices")
+ return iter(indices)
+
+
+class DuplicatedDataset(torch.utils.data.Dataset):
+ """Dataset wrapper that duplicates a dataset multiple times."""
+
+ def __init__(self, dataset, repeat=1000):
+ """
+ Initialize the duplicated dataset.
+
+ Args:
+ dataset: Original dataset to duplicate
+ repeat: Number of times to repeat the dataset
+ """
+ self.dataset = dataset
+ self.repeat = repeat
+ self.original_length = len(dataset)
+
+ def __getitem__(self, idx):
+ """Get an item from the original dataset, repeating as needed."""
+ return self.dataset[idx % self.original_length]
+
+ def __len__(self):
+ """Return the length of the duplicated dataset."""
+ return self.original_length * self.repeat
+
+ def __getattr__(self, name):
+ """Forward all other attribute accesses to the original dataset."""
+ if name == 'dataset' or name == 'repeat' or name == 'original_length':
+ return object.__getattribute__(self, name)
+ return getattr(self.dataset, name)
+
+def save_coords_as_ply(coords, save_dir: str):
+ """
+ Save the coordinates to a PLY file using normalization similar to voxelize.py.
+
+ Args:
+ file_path (str): The directory path to save the PLY file.
+ """
+ import os
+ # import numpy as np
+
+ os.makedirs(save_dir, exist_ok=True) # Ensure the directory exists
+
+ # Get coordinates and convert to numpy
+ coords_np = coords.cpu().numpy()
+
+ # Print debug info
+ # print(f"Original coordinates shape: {coords_np.shape}")
+ # print(f"First few coordinates:\n{coords_np[:5]}")
+
+ if coords_np.shape[1] == 4:
+ # Extract XYZ coordinates (skip batch index at position 0)
+ vertices = coords_np[:, 1:4]
+ else:
+ vertices = coords_np
+
+ # Normalize coordinates to [-0.5, 0.5] like in voxelize.py
+ # Assuming the coordinates are in a 64³ grid
+ GRID_SIZE = 64
+ vertices = (vertices + 0.5) / GRID_SIZE - 0.5
+
+ # print(f"Normalized vertex range: min={np.min(vertices, axis=0)}, max={np.max(vertices, axis=0)}")
+
+ # Create PLY file (simplified format like in voxelize.py)
+ filename = os.path.join(save_dir, 'coords.ply')
+
+ try:
+ with open(filename, 'w') as f:
+ # Write header (no color, just XYZ coordinates)
+ f.write("ply\n")
+ f.write("format ascii 1.0\n")
+ f.write(f"element vertex {vertices.shape[0]}\n")
+ f.write("property float x\n")
+ f.write("property float y\n")
+ f.write("property float z\n")
+ f.write("end_header\n")
+
+ # Write vertices (no color)
+ for i in range(vertices.shape[0]):
+ f.write(f"{vertices[i, 0]} {vertices[i, 1]} {vertices[i, 2]}\n")
+
+ # print(f"PLY file saved to {filename} with {vertices.shape[0]} points")
+
+ # Verify file creation
+ # file_size = os.path.getsize(filename)
+ # print(f"File size: {file_size} bytes")
+
+ except Exception as e:
+ print(f"Error creating PLY file: {e}")
+
+ return filename
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/utils/dist_utils.py b/OmniPart/modules/part_synthesis/utils/dist_utils.py
new file mode 100644
index 0000000..de46a88
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/dist_utils.py
@@ -0,0 +1,147 @@
+"""
+Distributed Training Utilities
+
+This file contains utility functions for distributed training with PyTorch.
+It provides tools for setting up distributed environments, efficient file handling
+across processes, model unwrapping, and synchronization mechanisms to coordinate
+execution across multiple GPUs and nodes.
+"""
+
+import os
+import io
+from contextlib import contextmanager
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+
+def setup_dist(rank, local_rank, world_size, master_addr, master_port):
+ """
+ Set up the distributed training environment.
+
+ Args:
+ rank (int): Global rank of the current process
+ local_rank (int): Local rank of the current process on this node
+ world_size (int): Total number of processes in the distributed training
+ master_addr (str): IP address of the master node
+ master_port (str): Port on the master node for communication
+ """
+ os.environ['MASTER_ADDR'] = master_addr
+ os.environ['MASTER_PORT'] = master_port
+ os.environ['WORLD_SIZE'] = str(world_size)
+ os.environ['RANK'] = str(rank)
+ os.environ['LOCAL_RANK'] = str(local_rank)
+ # Set the device for the current process
+ torch.cuda.set_device(local_rank)
+ # Initialize the process group for distributed communication
+ dist.init_process_group('nccl', rank=rank, world_size=world_size)
+
+
+def read_file_dist(path):
+ """
+ Read the binary file distributedly.
+ File is only read once by the rank 0 process and broadcasted to other processes.
+ This reduces I/O overhead in distributed training.
+
+ Args:
+ path (str): Path to the file to be read
+
+ Returns:
+ data (io.BytesIO): The binary data read from the file.
+ """
+ if dist.is_initialized() and dist.get_world_size() > 1:
+ # Prepare tensor to store file size
+ size = torch.LongTensor(1).cuda()
+ if dist.get_rank() == 0:
+ # Master process reads the file
+ with open(path, 'rb') as f:
+ data = f.read()
+ # Convert binary data to CUDA tensor for broadcasting
+ data = torch.ByteTensor(
+ torch.UntypedStorage.from_buffer(data, dtype=torch.uint8)
+ ).cuda()
+ size[0] = data.shape[0]
+ # Broadcast file size to all processes
+ dist.broadcast(size, src=0)
+ if dist.get_rank() != 0:
+ # Non-master processes allocate buffer for receiving data
+ data = torch.ByteTensor(size[0].item()).cuda()
+ # Broadcast actual file data to all processes
+ dist.broadcast(data, src=0)
+ # Convert tensor back to binary data
+ data = data.cpu().numpy().tobytes()
+ data = io.BytesIO(data)
+ return data
+ else:
+ # For non-distributed or single-process case, just read directly
+ with open(path, 'rb') as f:
+ data = f.read()
+ data = io.BytesIO(data)
+ return data
+
+
+def unwrap_dist(model):
+ """
+ Unwrap the model from distributed training wrapper.
+
+ Args:
+ model: A potentially wrapped PyTorch model
+
+ Returns:
+ The underlying model without DistributedDataParallel wrapper
+ """
+ if isinstance(model, DDP):
+ return model.module
+ return model
+
+
+@contextmanager
+def master_first():
+ """
+ A context manager that ensures master process (rank 0) executes first.
+ All other processes wait for the master to finish before proceeding.
+
+ Usage:
+ with master_first():
+ # Code that should execute in master first, then others
+ """
+ if not dist.is_initialized():
+ # If not in distributed mode, just execute normally
+ yield
+ else:
+ if dist.get_rank() == 0:
+ # Master process executes the code
+ yield
+ # Signal completion to other processes
+ dist.barrier()
+ else:
+ # Other processes wait for master to finish
+ dist.barrier()
+ # Then execute the code
+ yield
+
+
+@contextmanager
+def local_master_first():
+ """
+ A context manager that ensures local master process (first process on each node)
+ executes first. Other processes on the same node wait before proceeding.
+
+ Usage:
+ with local_master_first():
+ # Code that should execute in local master first, then others
+ """
+ if not dist.is_initialized():
+ # If not in distributed mode, just execute normally
+ yield
+ else:
+ if dist.get_rank() % torch.cuda.device_count() == 0:
+ # Local master process executes the code
+ yield
+ # Signal completion to other processes
+ dist.barrier()
+ else:
+ # Other processes wait for local master to finish
+ dist.barrier()
+ # Then execute the code
+ yield
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/utils/elastic_utils.py b/OmniPart/modules/part_synthesis/utils/elastic_utils.py
new file mode 100644
index 0000000..cba3cf8
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/elastic_utils.py
@@ -0,0 +1,228 @@
+from abc import abstractmethod
+from contextlib import contextmanager
+from typing import Tuple
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class MemoryController:
+ """
+ Base class for memory management during training.
+ """
+
+ _last_input_size = None
+ _last_mem_ratio = []
+
+ @contextmanager
+ def record(self):
+ pass
+
+ def update_run_states(self, input_size=None, mem_ratio=None):
+ if self._last_input_size is None:
+ self._last_input_size = input_size
+ elif self._last_input_size!= input_size:
+ raise ValueError(f'Input size should not change for different ElasticModules.')
+ self._last_mem_ratio.append(mem_ratio)
+
+ @abstractmethod
+ def get_mem_ratio(self, input_size):
+ pass
+
+ @abstractmethod
+ def state_dict(self):
+ pass
+
+ @abstractmethod
+ def log(self):
+ pass
+
+
+class LinearMemoryController(MemoryController):
+ """
+ A simple controller for memory management during training.
+ The memory usage is modeled as a linear function of:
+ - the number of input parameters
+ - the ratio of memory the model use compared to the maximum usage (with no checkpointing)
+ memory_usage = k * input_size * mem_ratio + b
+ The controller keeps track of the memory usage and gives the
+ expected memory ratio to keep the memory usage under a target
+ """
+ def __init__(
+ self,
+ buffer_size=1000,
+ update_every=500,
+ target_ratio=0.8,
+ available_memory=None,
+ max_mem_ratio_start=0.1,
+ params=None,
+ device=None
+ ):
+ self.buffer_size = buffer_size
+ self.update_every = update_every
+ self.target_ratio = target_ratio
+ self.device = device or torch.cuda.current_device()
+ self.available_memory = available_memory or torch.cuda.get_device_properties(self.device).total_memory / 1024**3
+
+ self._memory = np.zeros(buffer_size, dtype=np.float32)
+ self._input_size = np.zeros(buffer_size, dtype=np.float32)
+ self._mem_ratio = np.zeros(buffer_size, dtype=np.float32)
+ self._buffer_ptr = 0
+ self._buffer_length = 0
+ self._params = tuple(params) if params is not None else (0.0, 0.0)
+ self._max_mem_ratio = max_mem_ratio_start
+ self.step = 0
+
+ def __repr__(self):
+ return f'LinearMemoryController(target_ratio={self.target_ratio}, available_memory={self.available_memory})'
+
+ def _add_sample(self, memory, input_size, mem_ratio):
+ self._memory[self._buffer_ptr] = memory
+ self._input_size[self._buffer_ptr] = input_size
+ self._mem_ratio[self._buffer_ptr] = mem_ratio
+ self._buffer_ptr = (self._buffer_ptr + 1) % self.buffer_size
+ self._buffer_length = min(self._buffer_length + 1, self.buffer_size)
+
+ @contextmanager
+ def record(self):
+ torch.cuda.reset_peak_memory_stats(self.device)
+ self._last_input_size = None
+ self._last_mem_ratio = []
+ yield
+ self._last_memory = torch.cuda.max_memory_allocated(self.device) / 1024**3
+ self._last_mem_ratio = sum(self._last_mem_ratio) / len(self._last_mem_ratio)
+ self._add_sample(self._last_memory, self._last_input_size, self._last_mem_ratio)
+ self.step += 1
+ if self.step % self.update_every == 0:
+ self._max_mem_ratio = min(1.0, self._max_mem_ratio + 0.1)
+ self._fit_params()
+
+ def _fit_params(self):
+ memory_usage = self._memory[:self._buffer_length]
+ input_size = self._input_size[:self._buffer_length]
+ mem_ratio = self._mem_ratio[:self._buffer_length]
+
+ x = input_size * mem_ratio
+ y = memory_usage
+ k, b = np.polyfit(x, y, 1)
+ self._params = (k, b)
+ # self._visualize()
+
+ def _visualize(self):
+ import matplotlib.pyplot as plt
+ memory_usage = self._memory[:self._buffer_length]
+ input_size = self._input_size[:self._buffer_length]
+ mem_ratio = self._mem_ratio[:self._buffer_length]
+ k, b = self._params
+
+ plt.scatter(input_size * mem_ratio, memory_usage, c=mem_ratio, cmap='viridis')
+ x = np.array([0.0, 20000.0])
+ plt.plot(x, k * x + b, c='r')
+ plt.savefig(f'linear_memory_controller_{self.step}.png')
+ plt.cla()
+
+ def get_mem_ratio(self, input_size):
+ k, b = self._params
+ if k == 0: return np.random.rand() * self._max_mem_ratio
+ pred = (self.available_memory * self.target_ratio - b) / (k * input_size)
+ return min(self._max_mem_ratio, max(0.0, pred))
+
+ def state_dict(self):
+ return {
+ 'params': self._params,
+ }
+
+ def load_state_dict(self, state_dict):
+ self._params = tuple(state_dict['params'])
+
+ def log(self):
+ return {
+ 'params/k': self._params[0],
+ 'params/b': self._params[1],
+ 'memory': self._last_memory,
+ 'input_size': self._last_input_size,
+ 'mem_ratio': self._last_mem_ratio,
+ }
+
+
+class ElasticModule(nn.Module):
+ """
+ Module for training with elastic memory management.
+ """
+ def __init__(self):
+ super().__init__()
+ self._memory_controller: MemoryController = None
+
+ @abstractmethod
+ def _get_input_size(self, *args, **kwargs) -> int:
+ """
+ Get the size of the input data.
+
+ Returns:
+ int: The size of the input data.
+ """
+ pass
+
+ @abstractmethod
+ def _forward_with_mem_ratio(self, *args, mem_ratio=0.0, **kwargs) -> Tuple[float, Tuple]:
+ """
+ Forward with a given memory ratio.
+ """
+ pass
+
+ def register_memory_controller(self, memory_controller: MemoryController):
+ self._memory_controller = memory_controller
+
+ def forward(self, *args, **kwargs):
+ if self._memory_controller is None or not torch.is_grad_enabled() or not self.training:
+ _, ret = self._forward_with_mem_ratio(*args, **kwargs)
+ else:
+ input_size = self._get_input_size(*args, **kwargs)
+ mem_ratio = self._memory_controller.get_mem_ratio(input_size)
+ mem_ratio, ret = self._forward_with_mem_ratio(*args, mem_ratio=mem_ratio, **kwargs)
+ self._memory_controller.update_run_states(input_size, mem_ratio)
+ return ret
+
+
+class ElasticModuleMixin:
+ """
+ Mixin for training with elastic memory management.
+ """
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._memory_controller: MemoryController = None
+
+ @abstractmethod
+ def _get_input_size(self, *args, **kwargs) -> int:
+ """
+ Get the size of the input data.
+
+ Returns:
+ int: The size of the input data.
+ """
+ pass
+
+ @abstractmethod
+ @contextmanager
+ def with_mem_ratio(self, mem_ratio=1.0) -> float:
+ """
+ Context manager for training with a reduced memory ratio compared to the full memory usage.
+
+ Returns:
+ float: The exact memory ratio used during the forward pass.
+ """
+ pass
+
+ def register_memory_controller(self, memory_controller: MemoryController):
+ self._memory_controller = memory_controller
+
+ def forward(self, *args, **kwargs):
+ if self._memory_controller is None or not torch.is_grad_enabled() or not self.training:
+ ret = super().forward(*args, **kwargs)
+ else:
+ input_size = self._get_input_size(*args, **kwargs)
+ mem_ratio = self._memory_controller.get_mem_ratio(input_size)
+ with self.with_mem_ratio(mem_ratio) as exact_mem_ratio:
+ ret = super().forward(*args, **kwargs)
+ self._memory_controller.update_run_states(input_size, exact_mem_ratio)
+ return ret
diff --git a/OmniPart/modules/part_synthesis/utils/general_utils.py b/OmniPart/modules/part_synthesis/utils/general_utils.py
new file mode 100644
index 0000000..6a0510e
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/general_utils.py
@@ -0,0 +1,365 @@
+"""
+General utility functions for the TRELLIS project.
+
+This module provides a collection of utility functions organized into several categories:
+- Dictionary utilities: Operations for merging, traversal, reduction, and flattening of dictionaries
+- Context management: Tools for managing nested context managers
+- Image utilities: Functions for creating image grids and annotating images
+- Debug utilities: Tools for numerical comparison and tolerance checking
+- Print utilities: Helpers for text formatting and display
+"""
+
+import re
+import numpy as np
+import cv2
+import torch
+import contextlib
+
+
+# Dictionary utils
+def _dict_merge(dicta, dictb, prefix=''):
+ """
+ Merge two dictionaries recursively with conflict detection.
+
+ Args:
+ dicta: First dictionary to merge
+ dictb: Second dictionary to merge
+ prefix: Used for error reporting to track nested keys
+
+ Returns:
+ A new merged dictionary
+
+ Raises:
+ ValueError: If the same key exists in both dictionaries but has different types
+ """
+ assert isinstance(dicta, dict), 'input must be a dictionary'
+ assert isinstance(dictb, dict), 'input must be a dictionary'
+ dict_ = {}
+ # Get all unique keys from both dictionaries
+ all_keys = set(dicta.keys()).union(set(dictb.keys()))
+ for key in all_keys:
+ if key in dicta.keys() and key in dictb.keys():
+ # If key exists in both, recursively merge if both are dictionaries
+ if isinstance(dicta[key], dict) and isinstance(dictb[key], dict):
+ dict_[key] = _dict_merge(dicta[key], dictb[key], prefix=f'{prefix}.{key}')
+ else:
+ # Raise error for conflicting non-dictionary values
+ raise ValueError(f'Duplicate key {prefix}.{key} found in both dictionaries. Types: {type(dicta[key])}, {type(dictb[key])}')
+ elif key in dicta.keys():
+ # Copy values from first dictionary
+ dict_[key] = dicta[key]
+ else:
+ # Copy values from second dictionary
+ dict_[key] = dictb[key]
+ return dict_
+
+
+def dict_merge(dicta, dictb):
+ """
+ Merge two dictionaries.
+
+ This is the public interface that wraps _dict_merge with default prefix.
+ """
+ return _dict_merge(dicta, dictb, prefix='')
+
+
+def dict_foreach(dic, func, special_func={}):
+ """
+ Recursively apply a function to all non-dictionary leaf values in a dictionary.
+
+ Args:
+ dic: Dictionary to process
+ func: Default function to apply to each leaf value
+ special_func: Dictionary mapping keys to special functions for specific keys
+
+ Returns:
+ Transformed dictionary with function applied to all leaf values
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively process nested dictionaries
+ dic[key] = dict_foreach(dic[key], func)
+ else:
+ # Apply special function if key is in special_func, otherwise use default
+ if key in special_func.keys():
+ dic[key] = special_func[key](dic[key])
+ else:
+ dic[key] = func(dic[key])
+ return dic
+
+
+def dict_reduce(dicts, func, special_func={}):
+ """
+ Reduce a list of dictionaries. Leaf values must be scalars.
+
+ Args:
+ dicts: List of dictionaries to reduce
+ func: Default reduction function (takes a list of values, returns single value)
+ special_func: Dictionary mapping keys to special reduction functions
+
+ Returns:
+ A single merged dictionary with values reduced according to the provided functions
+ """
+ assert isinstance(dicts, list), 'input must be a list of dictionaries'
+ assert all([isinstance(d, dict) for d in dicts]), 'input must be a list of dictionaries'
+ assert len(dicts) > 0, 'input must be a non-empty list of dictionaries'
+ # Collect all unique keys across all dictionaries
+ all_keys = set([key for dict_ in dicts for key in dict_.keys()])
+ reduced_dict = {}
+ for key in all_keys:
+ # Extract values for this key from all dictionaries
+ vlist = [dict_[key] for dict_ in dicts if key in dict_.keys()]
+ if isinstance(vlist[0], dict):
+ # Recursively reduce nested dictionaries
+ reduced_dict[key] = dict_reduce(vlist, func, special_func)
+ else:
+ # Apply special function if key is in special_func, otherwise use default
+ if key in special_func.keys():
+ reduced_dict[key] = special_func[key](vlist)
+ else:
+ reduced_dict[key] = func(vlist)
+ return reduced_dict
+
+
+def dict_any(dic, func):
+ """
+ Check if any value in the dictionary satisfies the given predicate function.
+
+ Args:
+ dic: Dictionary to check
+ func: Predicate function that returns True/False for each leaf value
+
+ Returns:
+ True if any leaf value satisfies the predicate, False otherwise
+
+ dict any time: {'step': 16.795613527297974, 'elapsed': 16.795613527297974}
+ dict any step: 16.795613527297974
+ dict any elapsed: 16.795613527297974
+ dict any loss: {'bin_3': {'mse': nan}, 'bin_5': {'mse': nan}, 'mse': nan, 'loss': nan, 'bin_4': {'mse': nan}, 'bin_7': {'mse': nan}, 'bin_8': {'mse': nan}}
+ dict any bin_3: {'mse': nan}
+ dict any mse: nan
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ # print(f"dict any {key}: {dic[key]}")
+ if isinstance(dic[key], dict):
+ # Recursively check nested dictionaries
+ if dict_any(dic[key], func):
+ return True
+ else:
+ # Check current value against predicate
+ if func(dic[key]):
+ return True
+ return False
+
+
+def dict_all(dic, func):
+ """
+ Check if all values in the dictionary satisfy the given predicate function.
+
+ Args:
+ dic: Dictionary to check
+ func: Predicate function that returns True/False for each leaf value
+
+ Returns:
+ True if all leaf values satisfy the predicate, False otherwise
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively check nested dictionaries
+ if not dict_all(dic[key], func):
+ return False
+ else:
+ # Check current value against predicate
+ if not func(dic[key]):
+ return False
+ return True
+
+
+def dict_flatten(dic, sep='.'):
+ """
+ Flatten a nested dictionary into a dictionary with no nested dictionaries.
+
+ Args:
+ dic: Dictionary to flatten
+ sep: Separator string used to join key levels in the flattened dictionary
+
+ Returns:
+ A flattened dictionary with compound keys joined by the separator
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ flat_dict = {}
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively flatten nested dictionaries and prefix with current key
+ sub_dict = dict_flatten(dic[key], sep=sep)
+ for sub_key in sub_dict.keys():
+ flat_dict[str(key) + sep + str(sub_key)] = sub_dict[sub_key]
+ else:
+ # Copy leaf values directly
+ flat_dict[key] = dic[key]
+ return flat_dict
+
+
+# Context utils
+@contextlib.contextmanager
+def nested_contexts(*contexts):
+ """
+ Create a single context manager from multiple context manager factories.
+
+ This utility allows combining multiple context managers into a single
+ context manager, simplifying code that needs to use multiple contexts.
+
+ Args:
+ *contexts: Context manager factory functions (functions that return context managers)
+
+ Yields:
+ Control to the inner block when all contexts are entered
+ """
+ with contextlib.ExitStack() as stack:
+ for ctx in contexts:
+ stack.enter_context(ctx())
+ yield
+
+
+# Image utils
+def make_grid(images, nrow=None, ncol=None, aspect_ratio=None):
+ """
+ Arrange multiple images into a grid.
+
+ Args:
+ images: List of images to arrange
+ nrow: Number of rows (calculated if not provided)
+ ncol: Number of columns (calculated if not provided)
+ aspect_ratio: Desired width/height ratio for the grid layout
+
+ Returns:
+ A single image containing the grid of input images
+ """
+ num_images = len(images)
+ # Calculate grid dimensions if not explicitly provided
+ if nrow is None and ncol is None:
+ if aspect_ratio is not None:
+ # Calculate rows to achieve desired aspect ratio
+ nrow = int(np.round(np.sqrt(num_images / aspect_ratio)))
+ else:
+ # Default to a roughly square grid
+ nrow = int(np.sqrt(num_images))
+ ncol = (num_images + nrow - 1) // nrow
+ elif nrow is None and ncol is not None:
+ # Calculate rows based on fixed columns
+ nrow = (num_images + ncol - 1) // ncol
+ elif nrow is not None and ncol is None:
+ # Calculate columns based on fixed rows
+ ncol = (num_images + nrow - 1) // nrow
+ else:
+ assert nrow * ncol >= num_images, 'nrow * ncol must be greater than or equal to the number of images'
+
+ # Create empty grid with appropriate dimensions
+ if images[0].ndim == 2:
+ # Grayscale images
+ grid = np.zeros((nrow * images[0].shape[0], ncol * images[0].shape[1]), dtype=images[0].dtype)
+ else:
+ # Color images
+ grid = np.zeros((nrow * images[0].shape[0], ncol * images[0].shape[1], images[0].shape[2]), dtype=images[0].dtype)
+
+ # Place each image in the grid
+ for i, img in enumerate(images):
+ row = i // ncol
+ col = i % ncol
+ grid[row * img.shape[0]:(row + 1) * img.shape[0], col * img.shape[1]:(col + 1) * img.shape[1]] = img
+ return grid
+
+
+def notes_on_image(img, notes=None):
+ """
+ Add text notes to an image by padding the bottom and adding text.
+
+ Args:
+ img: Input image
+ notes: Text to add at the bottom of the image
+
+ Returns:
+ Image with notes added
+ """
+ # Add padding at the bottom for the notes
+ img = np.pad(img, ((0, 32), (0, 0), (0, 0)), 'constant', constant_values=0)
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+ if notes is not None:
+ # Add text to the padded area
+ img = cv2.putText(img, notes, (0, img.shape[0] - 4), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1)
+ img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+ return img
+
+
+def save_image_with_notes(img, path, notes=None):
+ """
+ Save an image with optional text notes at the bottom.
+
+ Args:
+ img: Input image (numpy array or PyTorch tensor)
+ path: File path to save the image
+ notes: Optional text to add at the bottom of the image
+ """
+ # Convert PyTorch tensor to numpy if needed
+ if isinstance(img, torch.Tensor):
+ img = img.cpu().numpy().transpose(1, 2, 0)
+ # Scale floating point images to 0-255 range
+ if img.dtype == np.float32 or img.dtype == np.float64:
+ img = np.clip(img * 255, 0, 255).astype(np.uint8)
+ # Add notes to the image
+ img = notes_on_image(img, notes)
+ # Save with proper color conversion for OpenCV
+ cv2.imwrite(path, cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+
+
+# debug utils
+def atol(x, y):
+ """
+ Absolute tolerance - computes absolute difference between x and y.
+
+ Useful for numerical comparisons when absolute error matters.
+
+ Args:
+ x, y: Tensors to compare
+
+ Returns:
+ Absolute difference |x - y|
+ """
+ return torch.abs(x - y)
+
+
+def rtol(x, y):
+ """
+ Relative tolerance - computes relative difference between x and y.
+
+ Useful for numerical comparisons when relative error matters,
+ especially when comparing values of different magnitudes.
+
+ Args:
+ x, y: Tensors to compare
+
+ Returns:
+ Relative difference |x - y| / max(|x|, |y|)
+ """
+ return torch.abs(x - y) / torch.clamp_min(torch.maximum(torch.abs(x), torch.abs(y)), 1e-12)
+
+
+# print utils
+def indent(s, n=4):
+ """
+ Indent a multi-line string.
+
+ Args:
+ s: Input string to indent
+ n: Number of spaces to add before each line (except the first)
+
+ Returns:
+ Indented string with all lines except the first indented by n spaces
+ """
+ lines = s.split('\n')
+ for i in range(1, len(lines)):
+ lines[i] = ' ' * n + lines[i]
+ return '\n'.join(lines)
diff --git a/OmniPart/modules/part_synthesis/utils/grad_clip_utils.py b/OmniPart/modules/part_synthesis/utils/grad_clip_utils.py
new file mode 100644
index 0000000..990a435
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/grad_clip_utils.py
@@ -0,0 +1,81 @@
+from typing import *
+import torch
+import numpy as np
+import torch.utils
+
+
+class AdaptiveGradClipper:
+ """
+ Adaptive gradient clipping for training.
+ """
+ def __init__(
+ self,
+ max_norm=None,
+ clip_percentile=95.0,
+ buffer_size=1000,
+ ):
+ self.max_norm = max_norm
+ self.clip_percentile = clip_percentile
+ self.buffer_size = buffer_size
+
+ self._grad_norm = np.zeros(buffer_size, dtype=np.float32)
+ self._max_norm = max_norm
+ self._buffer_ptr = 0
+ self._buffer_length = 0
+
+ def __repr__(self):
+ return f'AdaptiveGradClipper(max_norm={self.max_norm}, clip_percentile={self.clip_percentile})'
+
+ def state_dict(self):
+ return {
+ 'grad_norm': self._grad_norm,
+ 'max_norm': self._max_norm,
+ 'buffer_ptr': self._buffer_ptr,
+ 'buffer_length': self._buffer_length,
+ }
+
+ def load_state_dict(self, state_dict):
+ self._grad_norm = state_dict['grad_norm']
+ self._max_norm = state_dict['max_norm']
+ self._buffer_ptr = state_dict['buffer_ptr']
+ self._buffer_length = state_dict['buffer_length']
+
+ def log(self):
+ return {
+ 'max_norm': self._max_norm,
+ }
+
+ def __call__(self, parameters, norm_type=2.0, error_if_nonfinite=False, foreach=None):
+ """Clip the gradient norm of an iterable of parameters.
+
+ The norm is computed over all gradients together, as if they were
+ concatenated into a single vector. Gradients are modified in-place.
+
+ Args:
+ parameters (Iterable[Tensor] or Tensor): an iterable of Tensors or a
+ single Tensor that will have gradients normalized
+ norm_type (float): type of the used p-norm. Can be ``'inf'`` for
+ infinity norm.
+ error_if_nonfinite (bool): if True, an error is thrown if the total
+ norm of the gradients from :attr:`parameters` is ``nan``,
+ ``inf``, or ``-inf``. Default: False (will switch to True in the future)
+ foreach (bool): use the faster foreach-based implementation.
+ If ``None``, use the foreach implementation for CUDA and CPU native tensors and silently
+ fall back to the slow implementation for other device types.
+ Default: ``None``
+
+ Returns:
+ Total norm of the parameter gradients (viewed as a single vector).
+ """
+ max_norm = self._max_norm if self._max_norm is not None else float('inf')
+ grad_norm = torch.nn.utils.clip_grad_norm_(parameters, max_norm=max_norm, norm_type=norm_type, error_if_nonfinite=error_if_nonfinite, foreach=foreach)
+
+ if torch.isfinite(grad_norm):
+ self._grad_norm[self._buffer_ptr] = grad_norm
+ self._buffer_ptr = (self._buffer_ptr + 1) % self.buffer_size
+ self._buffer_length = min(self._buffer_length + 1, self.buffer_size)
+ if self._buffer_length == self.buffer_size:
+ self._max_norm = np.percentile(self._grad_norm, self.clip_percentile)
+ self._max_norm = min(self._max_norm, self.max_norm) if self.max_norm is not None else self._max_norm
+
+ return grad_norm
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/utils/loss_utils.py b/OmniPart/modules/part_synthesis/utils/loss_utils.py
new file mode 100644
index 0000000..52049f6
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/loss_utils.py
@@ -0,0 +1,92 @@
+import torch
+import torch.nn.functional as F
+from torch.autograd import Variable
+from math import exp
+from lpips import LPIPS
+
+
+def smooth_l1_loss(pred, target, beta=1.0):
+ diff = torch.abs(pred - target)
+ loss = torch.where(diff < beta, 0.5 * diff ** 2 / beta, diff - 0.5 * beta)
+ return loss.mean()
+
+
+def l1_loss(network_output, gt):
+ return torch.abs((network_output - gt)).mean()
+
+
+def l2_loss(network_output, gt):
+ return ((network_output - gt) ** 2).mean()
+
+
+def gaussian(window_size, sigma):
+ gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)])
+ return gauss / gauss.sum()
+
+
+def create_window(window_size, channel):
+ _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+ _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
+ window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
+ return window
+
+
+def psnr(img1, img2, max_val=1.0):
+ mse = F.mse_loss(img1, img2)
+ return 20 * torch.log10(max_val / torch.sqrt(mse))
+
+
+def ssim(img1, img2, window_size=11, size_average=True):
+ channel = img1.size(-3)
+ window = create_window(window_size, channel)
+
+ if img1.is_cuda:
+ window = window.cuda(img1.get_device())
+ window = window.type_as(img1)
+
+ return _ssim(img1, img2, window, window_size, channel, size_average)
+
+def _ssim(img1, img2, window, window_size, channel, size_average=True):
+ mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel)
+ mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel)
+
+ mu1_sq = mu1.pow(2)
+ mu2_sq = mu2.pow(2)
+ mu1_mu2 = mu1 * mu2
+
+ sigma1_sq = F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) - mu1_sq
+ sigma2_sq = F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) - mu2_sq
+ sigma12 = F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) - mu1_mu2
+
+ C1 = 0.01 ** 2
+ C2 = 0.03 ** 2
+
+ ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
+
+ if size_average:
+ return ssim_map.mean()
+ else:
+ return ssim_map.mean(1).mean(1).mean(1)
+
+
+loss_fn_vgg = None
+def lpips(img1, img2, value_range=(0, 1)):
+ global loss_fn_vgg
+ if loss_fn_vgg is None:
+ loss_fn_vgg = LPIPS(net='vgg').cuda().eval()
+ # normalize to [-1, 1]
+ img1 = (img1 - value_range[0]) / (value_range[1] - value_range[0]) * 2 - 1
+ img2 = (img2 - value_range[0]) / (value_range[1] - value_range[0]) * 2 - 1
+ return loss_fn_vgg(img1, img2).mean()
+
+
+def normal_angle(pred, gt):
+ pred = pred * 2.0 - 1.0
+ gt = gt * 2.0 - 1.0
+ norms = pred.norm(dim=-1) * gt.norm(dim=-1)
+ cos_sim = (pred * gt).sum(-1) / (norms + 1e-9)
+ cos_sim = torch.clamp(cos_sim, -1.0, 1.0)
+ ang = torch.rad2deg(torch.acos(cos_sim[norms > 1e-9])).mean()
+ if ang.isnan():
+ return -1
+ return ang
diff --git a/OmniPart/modules/part_synthesis/utils/postprocessing_utils.py b/OmniPart/modules/part_synthesis/utils/postprocessing_utils.py
new file mode 100644
index 0000000..61f3bdf
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/postprocessing_utils.py
@@ -0,0 +1,720 @@
+from typing import *
+import numpy as np
+import torch
+import utils3d
+import nvdiffrast.torch as dr
+from tqdm import tqdm
+import trimesh
+import trimesh.visual
+import xatlas
+import pyvista as pv
+from pymeshfix import _meshfix
+import igraph
+import cv2
+from PIL import Image
+from .random_utils import sphere_hammersley_sequence
+from .render_utils import render_multiview
+from ..renderers import GaussianRenderer
+from ..representations import Strivec, Gaussian, MeshExtractResult
+
+def _rgb_to_srgb(f: torch.Tensor) -> torch.Tensor:
+ """
+ convert a tensor, in any form / dimension, from rgb space to srgb space
+ Args:
+ f (torch.Tensor): input tensor
+
+ """
+ return torch.where(f <= 0.0031308, f * 12.92, torch.pow(torch.clamp(f, 0.0031308), 1.0/2.4)*1.055 - 0.055)
+
+def rgb_to_srgb_image(f: torch.Tensor) -> torch.Tensor:
+ """
+ convert an image tensor from rgb space to srgb space
+ Args:
+ f (torch.Tensor): input tensor
+
+ """
+ assert f.shape[-1] == 3 or f.shape[-1] == 4
+ out = torch.cat((_rgb_to_srgb(f[..., 0:3]), f[..., 3:4]), dim=-1) if f.shape[-1] == 4 else _rgb_to_srgb(f)
+ assert out.shape[0] == f.shape[0] and out.shape[1] == f.shape[1] and out.shape[2] == f.shape[2]
+ return out
+
+@torch.no_grad()
+def _fill_holes(
+ verts,
+ faces,
+ max_hole_size=0.04,
+ max_hole_nbe=32,
+ resolution=128,
+ num_views=500,
+ debug=False,
+ verbose=False
+):
+ """
+ Rasterize a mesh from multiple views and remove invisible faces.
+ Also includes postprocessing to:
+ 1. Remove connected components that are have low visibility.
+ 2. Mincut to remove faces at the inner side of the mesh connected to the outer side with a small hole.
+
+ Args:
+ verts (torch.Tensor): Vertices of the mesh. Shape (V, 3).
+ faces (torch.Tensor): Faces of the mesh. Shape (F, 3).
+ max_hole_size (float): Maximum area of a hole to fill.
+ max_hole_nbe (int): Maximum number of boundary edges in a hole to fill.
+ resolution (int): Resolution of the rasterization.
+ num_views (int): Number of views to rasterize the mesh.
+ debug (bool): Whether to output debug information and meshes.
+ verbose (bool): Whether to print progress.
+ """
+ # Construct cameras at uniformly distributed positions on a sphere
+ yaws = []
+ pitchs = []
+ for i in range(num_views):
+ y, p = sphere_hammersley_sequence(i, num_views) # Generate uniformly distributed points on sphere
+ yaws.append(y)
+ pitchs.append(p)
+ yaws = torch.tensor(yaws).cuda()
+ pitchs = torch.tensor(pitchs).cuda()
+ radius = 2.0 # Camera distance from origin
+ fov = torch.deg2rad(torch.tensor(40)).cuda() # Camera field of view
+ projection = utils3d.torch.perspective_from_fov_xy(fov, fov, 1, 3) # Create projection matrix
+ views = []
+ for (yaw, pitch) in zip(yaws, pitchs):
+ # Calculate camera position from spherical coordinates
+ orig = torch.tensor([
+ torch.sin(yaw) * torch.cos(pitch),
+ torch.cos(yaw) * torch.cos(pitch),
+ torch.sin(pitch),
+ ]).cuda().float() * radius
+ # Create view matrix looking at origin
+ view = utils3d.torch.view_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ views.append(view)
+ views = torch.stack(views, dim=0)
+
+ # Rasterize mesh from multiple viewpoints to determine visible faces
+ visblity = torch.zeros(faces.shape[0], dtype=torch.int32, device=verts.device)
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+ for i in tqdm(range(views.shape[0]), total=views.shape[0], disable=not verbose, desc='Rasterizing'):
+ view = views[i]
+ # Render from current viewpoint
+ buffers = utils3d.torch.rasterize_triangle_faces(
+ rastctx, verts[None], faces, resolution, resolution, view=view, projection=projection
+ )
+ # Collect face IDs that are visible from this view
+ face_id = buffers['face_id'][0][buffers['mask'][0] > 0.95] - 1
+ face_id = torch.unique(face_id).long()
+ visblity[face_id] += 1
+ # Normalize visibility to [0,1]
+ visblity = visblity.float() / num_views
+
+ # Prepare for mincut-based mesh cleaning
+ ## Construct edge data structures
+ edges, face2edge, edge_degrees = utils3d.torch.compute_edges(faces)
+ boundary_edge_indices = torch.nonzero(edge_degrees == 1).reshape(-1)
+ connected_components = utils3d.torch.compute_connected_components(faces, edges, face2edge)
+
+ ## Identify outer faces (those with high visibility)
+ outer_face_indices = torch.zeros(faces.shape[0], dtype=torch.bool, device=faces.device)
+ for i in range(len(connected_components)):
+ # Use visibility threshold - faces visible in at least 25-50% of views are considered outer faces
+ outer_face_indices[connected_components[i]] = visblity[connected_components[i]] > min(max(visblity[connected_components[i]].quantile(0.75).item(), 0.25), 0.5)
+ outer_face_indices = outer_face_indices.nonzero().reshape(-1)
+
+ ## Identify inner faces (completely invisible)
+ inner_face_indices = torch.nonzero(visblity == 0).reshape(-1)
+ if verbose:
+ tqdm.write(f'Found {inner_face_indices.shape[0]} invisible faces')
+ if inner_face_indices.shape[0] == 0:
+ return verts, faces
+
+ ## Construct dual graph (faces as nodes, edges as edges)
+ dual_edges, dual_edge2edge = utils3d.torch.compute_dual_graph(face2edge)
+ dual_edge2edge = edges[dual_edge2edge]
+ # Edge weights based on edge length - used for min-cut algorithm
+ dual_edges_weights = torch.norm(verts[dual_edge2edge[:, 0]] - verts[dual_edge2edge[:, 1]], dim=1)
+ if verbose:
+ tqdm.write(f'Dual graph: {dual_edges.shape[0]} edges')
+
+ ## Solve mincut problem using igraph
+ ### Construct main graph
+ g = igraph.Graph()
+ g.add_vertices(faces.shape[0])
+ g.add_edges(dual_edges.cpu().numpy())
+ g.es['weight'] = dual_edges_weights.cpu().numpy()
+
+ ### Add source and target nodes
+ g.add_vertex('s')
+ g.add_vertex('t')
+
+ ### Connect invisible faces to source with weight 1
+ g.add_edges([(f, 's') for f in inner_face_indices], attributes={'weight': torch.ones(inner_face_indices.shape[0], dtype=torch.float32).cpu().numpy()})
+
+ ### Connect outer faces to target with weight 1
+ g.add_edges([(f, 't') for f in outer_face_indices], attributes={'weight': torch.ones(outer_face_indices.shape[0], dtype=torch.float32).cpu().numpy()})
+
+ ### Solve mincut to separate inner from outer faces
+ cut = g.mincut('s', 't', (np.array(g.es['weight']) * 1000).tolist())
+ remove_face_indices = torch.tensor([v for v in cut.partition[0] if v < faces.shape[0]], dtype=torch.long, device=faces.device)
+ if verbose:
+ tqdm.write(f'Mincut solved, start checking the cut')
+
+ ### Validate the cut by checking each connected component
+ to_remove_cc = utils3d.torch.compute_connected_components(faces[remove_face_indices])
+ if debug:
+ tqdm.write(f'Number of connected components of the cut: {len(to_remove_cc)}')
+ valid_remove_cc = []
+ cutting_edges = []
+ for cc in to_remove_cc:
+ #### Check if the connected component has low visibility
+ visblity_median = visblity[remove_face_indices[cc]].median()
+ if debug:
+ tqdm.write(f'visblity_median: {visblity_median}')
+ if visblity_median > 0.25:
+ continue
+
+ #### Check if the cutting loop is small enough
+ cc_edge_indices, cc_edges_degree = torch.unique(face2edge[remove_face_indices[cc]], return_counts=True)
+ cc_boundary_edge_indices = cc_edge_indices[cc_edges_degree == 1]
+ cc_new_boundary_edge_indices = cc_boundary_edge_indices[~torch.isin(cc_boundary_edge_indices, boundary_edge_indices)]
+ if len(cc_new_boundary_edge_indices) > 0:
+ # Group boundary edges into connected components
+ cc_new_boundary_edge_cc = utils3d.torch.compute_edge_connected_components(edges[cc_new_boundary_edge_indices])
+ # Calculate the center of each boundary loop
+ cc_new_boundary_edges_cc_center = [verts[edges[cc_new_boundary_edge_indices[edge_cc]]].mean(dim=1).mean(dim=0) for edge_cc in cc_new_boundary_edge_cc]
+ cc_new_boundary_edges_cc_area = []
+ # Calculate the area of each boundary loop
+ for i, edge_cc in enumerate(cc_new_boundary_edge_cc):
+ _e1 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 0]] - cc_new_boundary_edges_cc_center[i]
+ _e2 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 1]] - cc_new_boundary_edges_cc_center[i]
+ cc_new_boundary_edges_cc_area.append(torch.norm(torch.cross(_e1, _e2, dim=-1), dim=1).sum() * 0.5)
+ if debug:
+ cutting_edges.append(cc_new_boundary_edge_indices)
+ tqdm.write(f'Area of the cutting loop: {cc_new_boundary_edges_cc_area}')
+ # Skip if any loop is too large
+ if any([l > max_hole_size for l in cc_new_boundary_edges_cc_area]):
+ continue
+
+ valid_remove_cc.append(cc)
+
+ # Generate debug visualizations if requested
+ if debug:
+ face_v = verts[faces].mean(dim=1).cpu().numpy()
+ vis_dual_edges = dual_edges.cpu().numpy()
+ vis_colors = np.zeros((faces.shape[0], 3), dtype=np.uint8)
+ vis_colors[inner_face_indices.cpu().numpy()] = [0, 0, 255] # Blue for inner
+ vis_colors[outer_face_indices.cpu().numpy()] = [0, 255, 0] # Green for outer
+ vis_colors[remove_face_indices.cpu().numpy()] = [255, 0, 255] # Magenta for removed by mincut
+ if len(valid_remove_cc) > 0:
+ vis_colors[remove_face_indices[torch.cat(valid_remove_cc)].cpu().numpy()] = [255, 0, 0] # Red for valid removal
+ utils3d.io.write_ply('dbg_dual.ply', face_v, edges=vis_dual_edges, vertex_colors=vis_colors)
+
+ vis_verts = verts.cpu().numpy()
+ vis_edges = edges[torch.cat(cutting_edges)].cpu().numpy()
+ utils3d.io.write_ply('dbg_cut.ply', vis_verts, edges=vis_edges)
+
+ # Remove the identified faces
+ if len(valid_remove_cc) > 0:
+ remove_face_indices = remove_face_indices[torch.cat(valid_remove_cc)]
+ mask = torch.ones(faces.shape[0], dtype=torch.bool, device=faces.device)
+ mask[remove_face_indices] = 0
+ faces = faces[mask]
+ # Clean up disconnected vertices
+ faces, verts = utils3d.torch.remove_unreferenced_vertices(faces, verts)
+ if verbose:
+ tqdm.write(f'Removed {(~mask).sum()} faces by mincut')
+ else:
+ if verbose:
+ tqdm.write(f'Removed 0 faces by mincut')
+
+ # Use meshfix to fill small holes in the mesh
+ mesh = _meshfix.PyTMesh()
+ mesh.load_array(verts.cpu().numpy(), faces.cpu().numpy())
+ mesh.fill_small_boundaries(nbe=max_hole_nbe, refine=True)
+ verts, faces = mesh.return_arrays()
+ verts, faces = torch.tensor(verts, device='cuda', dtype=torch.float32), torch.tensor(faces, device='cuda', dtype=torch.int32)
+
+ return verts, faces
+
+
+def postprocess_mesh(
+ vertices: np.array,
+ faces: np.array,
+ simplify: bool = True,
+ simplify_ratio: float = 0.9,
+ fill_holes: bool = True,
+ fill_holes_max_hole_size: float = 0.04,
+ fill_holes_max_hole_nbe: int = 32,
+ fill_holes_resolution: int = 1024,
+ fill_holes_num_views: int = 1000,
+ debug: bool = False,
+ verbose: bool = False,
+):
+ """
+ Postprocess a mesh by simplifying, removing invisible faces, and removing isolated pieces.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+ simplify (bool): Whether to simplify the mesh, using quadric edge collapse.
+ simplify_ratio (float): Ratio of faces to keep after simplification.
+ fill_holes (bool): Whether to fill holes in the mesh.
+ fill_holes_max_hole_size (float): Maximum area of a hole to fill.
+ fill_holes_max_hole_nbe (int): Maximum number of boundary edges of a hole to fill.
+ fill_holes_resolution (int): Resolution of the rasterization.
+ fill_holes_num_views (int): Number of views to rasterize the mesh.
+ debug (bool): Whether to output debug visualizations.
+ verbose (bool): Whether to print progress.
+ """
+
+ if verbose:
+ tqdm.write(f'Before postprocess: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+
+ if vertices.shape[0] == 0 or faces.shape[0] == 0:
+ return vertices, faces
+
+ try:
+ # Simplify mesh using quadric edge collapse decimation
+ if simplify and simplify_ratio > 0:
+ mesh = pv.PolyData(vertices, np.concatenate([np.full((faces.shape[0], 1), 3), faces], axis=1))
+ mesh = mesh.decimate(simplify_ratio, progress_bar=verbose)
+ vertices, faces = mesh.points, mesh.faces.reshape(-1, 4)[:, 1:]
+ if verbose:
+ tqdm.write(f'After decimate: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+
+ # Remove invisible faces and fill small holes
+ if fill_holes:
+ vertices, faces = torch.tensor(vertices).cuda(), torch.tensor(faces.astype(np.int32)).cuda()
+ vertices, faces = _fill_holes(
+ vertices, faces,
+ max_hole_size=fill_holes_max_hole_size,
+ max_hole_nbe=fill_holes_max_hole_nbe,
+ resolution=fill_holes_resolution,
+ num_views=fill_holes_num_views,
+ debug=debug,
+ verbose=verbose,
+ )
+ vertices, faces = vertices.cpu().numpy(), faces.cpu().numpy()
+ if verbose:
+ tqdm.write(f'After remove invisible faces: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+ except Exception as e:
+ tqdm.write(f'Error in postprocess_mesh: {e}')
+ return None, None
+
+ return vertices, faces
+
+
+def parametrize_mesh(vertices: np.array, faces: np.array):
+ """
+ Parametrize a mesh to a texture space, using xatlas.
+ This creates UV coordinates for the mesh that can be used for texture mapping.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+
+ Returns:
+ tuple: (remapped_vertices, remapped_faces, uvs) where uvs are the texture coordinates
+ """
+
+ # Parametrize the mesh using xatlas
+ vmapping, indices, uvs = xatlas.parametrize(vertices, faces)
+
+ # Apply the vertex mapping to get the final vertices
+ vertices = vertices[vmapping]
+ faces = indices
+
+ return vertices, faces, uvs
+
+
+def bake_texture(
+ vertices: np.array,
+ faces: np.array,
+ uvs: np.array,
+ observations: List[np.array],
+ masks: List[np.array],
+ extrinsics: List[np.array],
+ intrinsics: List[np.array],
+ texture_size: int = 2048,
+ near: float = 0.1,
+ far: float = 10.0,
+ mode: Literal['fast', 'opt'] = 'opt',
+ lambda_tv: float = 1e-2,
+ verbose: bool = False,
+ srgb_space: bool = False,
+):
+ """
+ Bake texture to a mesh from multiple observations.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+ uvs (np.array): UV coordinates of the mesh. Shape (V, 2).
+ observations (List[np.array]): List of observations. Each observation is a 2D image. Shape (H, W, 3).
+ masks (List[np.array]): List of masks. Each mask is a 2D image. Shape (H, W).
+ extrinsics (List[np.array]): List of extrinsics. Shape (4, 4).
+ intrinsics (List[np.array]): List of intrinsics. Shape (3, 3).
+ texture_size (int): Size of the texture.
+ near (float): Near plane of the camera.
+ far (float): Far plane of the camera.
+ mode (Literal['fast', 'opt']): Mode of texture baking:
+ 'fast': Simple weighted averaging of observed colors.
+ 'opt': Optimization-based texture generation with regularization.
+ lambda_tv (float): Weight of total variation loss in optimization.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ np.array: The baked texture as an RGB image (H, W, 3)
+ """
+ # Move data to GPU
+ vertices = torch.tensor(vertices).cuda()
+ faces = torch.tensor(faces.astype(np.int32)).cuda()
+ uvs = torch.tensor(uvs).cuda()
+ observations = [torch.tensor(obs / 255.0).float().cuda() for obs in observations]
+ masks = [torch.tensor(m>0).bool().cuda() for m in masks]
+ views = [utils3d.torch.extrinsics_to_view(torch.tensor(extr).cuda()) for extr in extrinsics]
+ projections = [utils3d.torch.intrinsics_to_perspective(torch.tensor(intr).cuda(), near, far) for intr in intrinsics]
+
+ if mode == 'fast':
+ # Fast texture baking - weighted average of observed colors
+ texture = torch.zeros((texture_size * texture_size, 3), dtype=torch.float32).cuda()
+ texture_weights = torch.zeros((texture_size * texture_size), dtype=torch.float32).cuda()
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+
+ # Iterate through each observation and accumulate colors
+ for observation, view, projection in tqdm(zip(observations, views, projections), total=len(observations), disable=not verbose, desc='Texture baking (fast)'):
+ with torch.no_grad():
+ # Rasterize the mesh from this viewpoint
+ rast = utils3d.torch.rasterize_triangle_faces(
+ rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection
+ )
+ uv_map = rast['uv'][0].detach().flip(0) # Flip Y to match texture convention
+ mask = rast['mask'][0].detach().bool() & masks[0] # Only use valid mask pixels
+
+ # Map UV coordinates to texture pixels
+ uv_map = (uv_map * texture_size).floor().long()
+ obs = observation[mask]
+ uv_map = uv_map[mask]
+ # Convert 2D UV to 1D indices for scattering
+ idx = uv_map[:, 0] + (texture_size - uv_map[:, 1] - 1) * texture_size
+ # Accumulate colors and weights
+ texture = texture.scatter_add(0, idx.view(-1, 1).expand(-1, 3), obs)
+ texture_weights = texture_weights.scatter_add(0, idx, torch.ones((obs.shape[0]), dtype=torch.float32, device=texture.device))
+
+ # Normalize by summed weights
+ mask = texture_weights > 0
+ texture[mask] /= texture_weights[mask][:, None]
+ texture = np.clip(texture.reshape(texture_size, texture_size, 3).cpu().numpy() * 255, 0, 255).astype(np.uint8)
+
+ if srgb_space:
+ # convert the texture from rgb space to srgb
+ texture = rgb_to_srgb_image(texture)
+
+ # Fill holes in texture using inpainting
+ mask = (texture_weights == 0).cpu().numpy().astype(np.uint8).reshape(texture_size, texture_size)
+ texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA)
+
+ elif mode == 'opt':
+ # Optimization-based texture baking with total variation regularization
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+ observations = [observations.flip(0) for observations in observations] # Flip Y for rendering
+ masks = [m.flip(0) for m in masks]
+
+ # Precompute UV maps for efficiency
+ _uv = []
+ _uv_dr = []
+ for observation, view, projection in tqdm(zip(observations, views, projections), total=len(views), disable=not verbose, desc='Texture baking (opt): UV'):
+ with torch.no_grad():
+ rast = utils3d.torch.rasterize_triangle_faces(
+ rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection
+ )
+ _uv.append(rast['uv'].detach())
+ _uv_dr.append(rast['uv_dr'].detach()) # Gradient information for differentiable rendering
+
+ # Initialize texture as a learnable parameter
+ texture = torch.nn.Parameter(torch.zeros((1, texture_size, texture_size, 3), dtype=torch.float32).cuda())
+ optimizer = torch.optim.Adam([texture], betas=(0.5, 0.9), lr=1e-2)
+
+ # Learning rate scheduling functions
+ def exp_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Exponential learning rate annealing"""
+ return start_lr * (end_lr / start_lr) ** (step / total_steps)
+
+ def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Cosine learning rate annealing"""
+ return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps))
+
+ def tv_loss(texture):
+ """Total variation loss for regularization"""
+ return torch.nn.functional.l1_loss(texture[:, :-1, :, :], texture[:, 1:, :, :]) + \
+ torch.nn.functional.l1_loss(texture[:, :, :-1, :], texture[:, :, 1:, :])
+
+ # Optimization loop
+ total_steps = 2500
+ with tqdm(total=total_steps, disable=not verbose, desc='Texture baking (opt): optimizing') as pbar:
+ for step in range(total_steps):
+ optimizer.zero_grad()
+ # Random sample a view for stochastic optimization
+ selected = np.random.randint(0, len(views))
+ uv, uv_dr, observation, mask = _uv[selected], _uv_dr[selected], observations[selected], masks[selected]
+ # Differentiable rendering of texture
+ render = dr.texture(texture, uv, uv_dr)[0]
+ # Loss calculation - L1 reconstruction loss + TV regularization
+ loss = torch.nn.functional.l1_loss(render[mask], observation[mask])
+ if lambda_tv > 0:
+ loss += lambda_tv * tv_loss(texture)
+ loss.backward()
+ optimizer.step()
+ # Learning rate annealing
+ optimizer.param_groups[0]['lr'] = cosine_anealing(optimizer, step, total_steps, 1e-2, 1e-5)
+ pbar.set_postfix({'loss': loss.item()})
+ pbar.update()
+
+ if srgb_space:
+ # convert the texture from rgb space to srgb
+ texture = rgb_to_srgb_image(texture)
+
+ # Convert optimized texture to numpy array
+ texture = np.clip(texture[0].flip(0).detach().cpu().numpy() * 255, 0, 255).astype(np.uint8)
+
+ # Fill any remaining holes in the texture
+ mask = 1 - utils3d.torch.rasterize_triangle_faces(
+ rastctx, (uvs * 2 - 1)[None], faces, texture_size, texture_size
+ )['mask'][0].detach().cpu().numpy().astype(np.uint8)
+ texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA)
+ else:
+ raise ValueError(f'Unknown mode: {mode}')
+
+ return texture
+
+
+def to_glb(
+ app_rep: Union[Strivec, Gaussian],
+ mesh: MeshExtractResult,
+ simplify: float = 0.95,
+ fill_holes: bool = True,
+ fill_holes_max_size: float = 0.04,
+ texture_size: int = 1024,
+ debug: bool = False,
+ verbose: bool = True,
+ textured: bool = True,
+) -> trimesh.Trimesh:
+ """
+ Convert a generated asset to a glb file.
+
+ Args:
+ app_rep (Union[Strivec, Gaussian]): Appearance representation.
+ mesh (MeshExtractResult): Extracted mesh.
+ simplify (float): Ratio of faces to remove in simplification.
+ fill_holes (bool): Whether to fill holes in the mesh.
+ fill_holes_max_size (float): Maximum area of a hole to fill.
+ texture_size (int): Size of the texture.
+ debug (bool): Whether to print debug information.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ trimesh.Trimesh: The processed mesh with texture, ready for GLB export
+ """
+ # Extract mesh data from the result
+ vertices = mesh.vertices.cpu().numpy()
+ faces = mesh.faces.cpu().numpy()
+
+ # Apply mesh post-processing
+ vertices, faces = postprocess_mesh(
+ vertices, faces,
+ simplify=simplify > 0,
+ simplify_ratio=simplify,
+ fill_holes=fill_holes,
+ fill_holes_max_hole_size=fill_holes_max_size,
+ fill_holes_max_hole_nbe=int(250 * np.sqrt(1-simplify)), # Scale hole size by mesh complexity
+ fill_holes_resolution=1024,
+ fill_holes_num_views=1000,
+ debug=debug,
+ verbose=verbose,
+ )
+
+ if vertices is None or faces is None:
+ return None
+
+ if vertices.shape[0] == 0 or faces.shape[0] == 0:
+ return None
+
+ if textured:
+ # Create UV mapping for the mesh
+ vertices, faces, uvs = parametrize_mesh(vertices, faces)
+
+ # Render multi-view images from the appearance representation for texturing
+ observations, extrinsics, intrinsics = render_multiview(app_rep, resolution=1024, nviews=100)
+ # Create masks from the rendered images
+ masks = [np.any(observation > 0, axis=-1) for observation in observations]
+ # Convert camera parameters to numpy
+ extrinsics = [extrinsics[i].cpu().numpy() for i in range(len(extrinsics))]
+ intrinsics = [intrinsics[i].cpu().numpy() for i in range(len(intrinsics))]
+
+ # Bake texture from the rendered views onto the mesh
+ texture = bake_texture(
+ vertices, faces, uvs,
+ observations, masks, extrinsics, intrinsics,
+ texture_size=texture_size, mode='opt', # Use optimization-based texturing
+ lambda_tv=0.01, # Total variation regularization
+ verbose=verbose
+ )
+ texture = Image.fromarray(texture)
+
+ # Convert from z-up to y-up coordinate system (common in many 3D formats)
+ vertices = vertices @ np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]])
+
+ # Create PBR material for the mesh
+ material = trimesh.visual.material.PBRMaterial(
+ roughnessFactor=1.0,
+ baseColorTexture=texture,
+ baseColorFactor=np.array([255, 255, 255, 255], dtype=np.uint8)
+ )
+
+ # Create the final trimesh object with texture
+ mesh = trimesh.Trimesh(vertices, faces, visual=trimesh.visual.TextureVisuals(uv=uvs, material=material))
+
+ else:
+ vertices = vertices @ np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]])
+ mesh = trimesh.Trimesh(vertices, faces)
+ return mesh
+
+
+def simplify_gs(
+ gs: Gaussian,
+ simplify: float = 0.95,
+ verbose: bool = True,
+):
+ """
+ Simplify 3D Gaussians using an optimization-based approach
+ NOTE: this function is not used in the current implementation for the unsatisfactory performance.
+
+ Args:
+ gs (Gaussian): 3D Gaussian representation to simplify.
+ simplify (float): Ratio of Gaussians to remove in simplification.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ Gaussian: The simplified Gaussian representation
+ """
+ if simplify <= 0:
+ return gs
+
+ # Render multi-view images from the original Gaussian representation
+ observations, extrinsics, intrinsics = render_multiview(gs, resolution=1024, nviews=100)
+ observations = [torch.tensor(obs / 255.0).float().cuda().permute(2, 0, 1) for obs in observations]
+
+ # Following https://arxiv.org/pdf/2411.06019
+ # Initialize renderer
+ renderer = GaussianRenderer({
+ "resolution": 1024,
+ "near": 0.8,
+ "far": 1.6,
+ "ssaa": 1,
+ "bg_color": (0,0,0),
+ })
+
+ # Clone the Gaussian representation
+ new_gs = Gaussian(**gs.init_params)
+ new_gs._features_dc = gs._features_dc.clone()
+ new_gs._features_rest = gs._features_rest.clone() if gs._features_rest is not None else None
+ new_gs._opacity = torch.nn.Parameter(gs._opacity.clone())
+ new_gs._rotation = torch.nn.Parameter(gs._rotation.clone())
+ new_gs._scaling = torch.nn.Parameter(gs._scaling.clone())
+ new_gs._xyz = torch.nn.Parameter(gs._xyz.clone())
+
+ # Set up optimizer with different learning rates for different parameters
+ start_lr = [1e-4, 1e-3, 5e-3, 0.025] # Position, rotation, scaling, opacity
+ end_lr = [1e-6, 1e-5, 5e-5, 0.00025]
+ optimizer = torch.optim.Adam([
+ {"params": new_gs._xyz, "lr": start_lr[0]},
+ {"params": new_gs._rotation, "lr": start_lr[1]},
+ {"params": new_gs._scaling, "lr": start_lr[2]},
+ {"params": new_gs._opacity, "lr": start_lr[3]},
+ ], lr=start_lr[0])
+
+ # Learning rate scheduling functions
+ def exp_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Exponential learning rate annealing"""
+ return start_lr * (end_lr / start_lr) ** (step / total_steps)
+
+ def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Cosine learning rate annealing"""
+ return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps))
+
+ # Auxiliary variables for proximal optimization algorithm
+ _zeta = new_gs.get_opacity.clone().detach().squeeze()
+ _lambda = torch.zeros_like(_zeta)
+ _delta = 1e-7 # Regularization parameter
+ _interval = 10 # Interval for updates
+ num_target = int((1 - simplify) * _zeta.shape[0]) # Target number of Gaussians after simplification
+
+ # Optimization loop
+ with tqdm(total=2500, disable=not verbose, desc='Simplifying Gaussian') as pbar:
+ for i in range(2500):
+ # Prune low-opacity Gaussians periodically
+ if i % 100 == 0:
+ mask = new_gs.get_opacity.squeeze() > 0.05
+ mask = torch.nonzero(mask).squeeze()
+ # Update all relevant parameters
+ new_gs._xyz = torch.nn.Parameter(new_gs._xyz[mask])
+ new_gs._rotation = torch.nn.Parameter(new_gs._rotation[mask])
+ new_gs._scaling = torch.nn.Parameter(new_gs._scaling[mask])
+ new_gs._opacity = torch.nn.Parameter(new_gs._opacity[mask])
+ new_gs._features_dc = new_gs._features_dc[mask]
+ new_gs._features_rest = new_gs._features_rest[mask] if new_gs._features_rest is not None else None
+ _zeta = _zeta[mask]
+ _lambda = _lambda[mask]
+ # Update optimizer state
+ for param_group, new_param in zip(optimizer.param_groups, [new_gs._xyz, new_gs._rotation, new_gs._scaling, new_gs._opacity]):
+ stored_state = optimizer.state[param_group['params'][0]]
+ if 'exp_avg' in stored_state:
+ stored_state['exp_avg'] = stored_state['exp_avg'][mask]
+ stored_state['exp_avg_sq'] = stored_state['exp_avg_sq'][mask]
+ del optimizer.state[param_group['params'][0]]
+ param_group['params'][0] = new_param
+ optimizer.state[param_group['params'][0]] = stored_state
+
+ opacity = new_gs.get_opacity.squeeze()
+
+ # Sparsify using proximal gradient method
+ if i % _interval == 0:
+ _zeta = _lambda + opacity.detach()
+ if opacity.shape[0] > num_target:
+ # Keep only the top K Gaussians by importance
+ index = _zeta.topk(num_target)[1]
+ _m = torch.ones_like(_zeta, dtype=torch.bool)
+ _m[index] = 0
+ _zeta[_m] = 0
+ _lambda = _lambda + opacity.detach() - _zeta
+
+ # Sample a random view for this iteration
+ view_idx = np.random.randint(len(observations))
+ observation = observations[view_idx]
+ extrinsic = extrinsics[view_idx]
+ intrinsic = intrinsics[view_idx]
+
+ # Render and compute loss
+ color = renderer.render(new_gs, extrinsic, intrinsic)['color']
+ rgb_loss = torch.nn.functional.l1_loss(color, observation)
+ # Loss includes reconstruction and sparsity term
+ loss = rgb_loss + \
+ _delta * torch.sum(torch.pow(_lambda + opacity - _zeta, 2))
+
+ # Optimization step
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+ # Update learning rate
+ for j in range(len(optimizer.param_groups)):
+ optimizer.param_groups[j]['lr'] = cosine_anealing(optimizer, i, 2500, start_lr[j], end_lr[j])
+
+ pbar.set_postfix({'loss': rgb_loss.item(), 'num': opacity.shape[0], 'lambda': _lambda.mean().item()})
+ pbar.update()
+
+ # Convert parameters back to data
+ new_gs._xyz = new_gs._xyz.data
+ new_gs._rotation = new_gs._rotation.data
+ new_gs._scaling = new_gs._scaling.data
+ new_gs._opacity = new_gs._opacity.data
+
+ return new_gs
diff --git a/OmniPart/modules/part_synthesis/utils/random_utils.py b/OmniPart/modules/part_synthesis/utils/random_utils.py
new file mode 100644
index 0000000..5b668c2
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/random_utils.py
@@ -0,0 +1,30 @@
+import numpy as np
+
+PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
+
+def radical_inverse(base, n):
+ val = 0
+ inv_base = 1.0 / base
+ inv_base_n = inv_base
+ while n > 0:
+ digit = n % base
+ val += digit * inv_base_n
+ n //= base
+ inv_base_n *= inv_base
+ return val
+
+def halton_sequence(dim, n):
+ return [radical_inverse(PRIMES[dim], n) for dim in range(dim)]
+
+def hammersley_sequence(dim, n, num_samples):
+ return [n / num_samples] + halton_sequence(dim - 1, n)
+
+def sphere_hammersley_sequence(n, num_samples, offset=(0, 0), remap=False):
+ u, v = hammersley_sequence(2, n, num_samples)
+ u += offset[0] / num_samples
+ v += offset[1]
+ if remap:
+ u = 2 * u if u < 0.25 else 2 / 3 * u + 1 / 3
+ theta = np.arccos(1 - 2 * u) - np.pi / 2
+ phi = v * 2 * np.pi
+ return [phi, theta]
\ No newline at end of file
diff --git a/OmniPart/modules/part_synthesis/utils/render_utils.py b/OmniPart/modules/part_synthesis/utils/render_utils.py
new file mode 100644
index 0000000..dc5bf70
--- /dev/null
+++ b/OmniPart/modules/part_synthesis/utils/render_utils.py
@@ -0,0 +1,110 @@
+import torch
+import numpy as np
+from tqdm import tqdm
+import utils3d
+import json
+
+from ..renderers import OctreeRenderer, GaussianRenderer, MeshRenderer
+from ..representations import Octree, Gaussian, MeshExtractResult
+from .random_utils import sphere_hammersley_sequence
+
+
+def yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, rs, fovs):
+ is_list = isinstance(yaws, list)
+ if not is_list:
+ yaws = [yaws]
+ pitchs = [pitchs]
+ if not isinstance(rs, list):
+ rs = [rs] * len(yaws)
+ if not isinstance(fovs, list):
+ fovs = [fovs] * len(yaws)
+ extrinsics = []
+ intrinsics = []
+ for yaw, pitch, r, fov in zip(yaws, pitchs, rs, fovs):
+ fov = torch.deg2rad(torch.tensor(float(fov))).cuda()
+ yaw = torch.tensor(float(yaw)).cuda()
+ pitch = torch.tensor(float(pitch)).cuda()
+ orig = torch.tensor([
+ torch.sin(yaw) * torch.cos(pitch),
+ torch.cos(yaw) * torch.cos(pitch),
+ torch.sin(pitch),
+ ]).cuda() * r
+ extr = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intr = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ extrinsics.append(extr)
+ intrinsics.append(intr)
+ if not is_list:
+ extrinsics = extrinsics[0]
+ intrinsics = intrinsics[0]
+ return extrinsics, intrinsics
+
+
+def get_renderer(sample, **kwargs):
+ if isinstance(sample, Octree):
+ renderer = OctreeRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 0.8)
+ renderer.rendering_options.far = kwargs.get('far', 1.6)
+ renderer.rendering_options.bg_color = kwargs.get('bg_color', (0, 0, 0))
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 4)
+ renderer.pipe.primitive = sample.primitive
+ elif isinstance(sample, Gaussian):
+ renderer = GaussianRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 0.8)
+ renderer.rendering_options.far = kwargs.get('far', 1.6)
+ renderer.rendering_options.bg_color = kwargs.get('bg_color', (0, 0, 0))
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 1)
+ renderer.pipe.kernel_size = kwargs.get('kernel_size', 0.1)
+ renderer.pipe.use_mip_gaussian = True
+ elif isinstance(sample, MeshExtractResult):
+ renderer = MeshRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 1)
+ renderer.rendering_options.far = kwargs.get('far', 100)
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 4)
+ else:
+ raise ValueError(f'Unsupported sample type: {type(sample)}')
+ return renderer
+
+
+def render_frames(sample, extrinsics, intrinsics, options={}, colors_overwrite=None, verbose=True, **kwargs):
+ renderer = get_renderer(sample, **options)
+ rets = {}
+ for j, (extr, intr) in tqdm(enumerate(zip(extrinsics, intrinsics)), desc='Rendering', disable=not verbose):
+ if isinstance(sample, MeshExtractResult):
+ res = renderer.render(sample, extr, intr)
+ if 'normal' not in rets: rets['normal'] = []
+ rets['normal'].append(np.clip(res['normal'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
+ else:
+ res = renderer.render(sample, extr, intr, colors_overwrite=colors_overwrite)
+ if 'color' not in rets: rets['color'] = []
+ if 'depth' not in rets: rets['depth'] = []
+ rets['color'].append(np.clip(res['color'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
+ if 'percent_depth' in res:
+ rets['depth'].append(res['percent_depth'].detach().cpu().numpy())
+ elif 'depth' in res:
+ rets['depth'].append(res['depth'].detach().cpu().numpy())
+ else:
+ rets['depth'].append(None)
+ return rets
+
+
+def render_video(sample, resolution=512, bg_color=(0, 0, 0), num_frames=300, r=2, fov=40, **kwargs):
+ yaws = torch.linspace(0, 2 * 3.1415, num_frames)
+ pitch = 0.25 + 0.5 * torch.sin(torch.linspace(0, 2 * 3.1415, num_frames))
+ yaws = yaws.tolist()
+ pitch = pitch.tolist()
+ extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitch, r, fov)
+ return render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': bg_color}, **kwargs)
+
+
+def render_multiview(sample, resolution=512, nviews=30):
+ r = 2
+ fov = 40
+ cams = [sphere_hammersley_sequence(i, nviews) for i in range(nviews)]
+ yaws = [cam[0] for cam in cams]
+ pitchs = [cam[1] for cam in cams]
+ extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, r, fov)
+ res = render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': (0, 0, 0)})
+ return res['color'], extrinsics, intrinsics
\ No newline at end of file
diff --git a/OmniPart/requirements.txt b/OmniPart/requirements.txt
new file mode 100644
index 0000000..a9be3ea
--- /dev/null
+++ b/OmniPart/requirements.txt
@@ -0,0 +1,43 @@
+--extra-index-url https://download.pytorch.org/whl/cu121
+
+torch==2.4.0
+torchvision==0.19.0
+pillow==10.4.0
+imageio==2.36.1
+imageio-ffmpeg==0.5.1
+tqdm==4.67.1
+easydict==1.13
+opencv-python-headless==4.10.0.84
+scipy==1.14.1
+rembg==2.0.60
+onnxruntime==1.20.1
+trimesh==4.5.3
+xatlas==0.0.9
+pyvista==0.44.2
+pymeshfix==0.17.0
+igraph==0.11.8
+git+https://github.com/EasternJournalist/utils3d.git@9a4eb15e4021b67b12c460c7057d642626897ec8
+xformers==0.0.27.post2
+spconv-cu120==2.3.6
+transformers==4.50.3
+pydantic==2.10.6
+diffusers==0.32.0
+lightning==2.2
+mesh2sdf
+loguru
+tetgen==0.6.3
+pymeshfix
+igraph
+omegaconf
+pycocotools
+kornia
+timm
+h5py
+boto3
+git+https://github.com/facebookresearch/segment-anything.git
+git+https://github.com/facebookresearch/detectron2.git --find-links https://data.pyg.org/whl/torch-2.8.0+cu128.html
+torch-scatter
+
+https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.0.post2/flash_attn-2.7.0.post2+cu12torch2.4cxx11abiFALSE-cp310-cp310-linux_x86_64.whl
+https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/diff_gaussian_rasterization-0.0.0-cp310-cp310-linux_x86_64.whl?download=true
+https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/nvdiffrast-0.3.3-cp310-cp310-linux_x86_64.whl?download=true
\ No newline at end of file
diff --git a/OmniPart/scripts/inference_omnipart.py b/OmniPart/scripts/inference_omnipart.py
new file mode 100644
index 0000000..56b1b62
--- /dev/null
+++ b/OmniPart/scripts/inference_omnipart.py
@@ -0,0 +1,529 @@
+import os
+import numpy as np
+import torch
+import trimesh
+from PIL import Image
+from omegaconf import OmegaConf
+import cv2
+
+from ..modules.bbox_gen.models.autogressive_bbox_gen import BboxGen
+from ..modules.part_synthesis.process_utils import save_parts_outputs
+from ..modules.inference_utils import load_img_mask, prepare_bbox_gen_input, prepare_part_synthesis_input, gen_mesh_from_bounds, vis_voxel_coords, merge_parts
+from ..modules.part_synthesis.pipelines import OmniPartImageTo3DPipeline
+from ..modules.label_2d_mask.label_parts import (
+ prepare_image,
+ get_sam_mask,
+ get_mask,
+ clean_segment_edges,
+ resize_and_pad_to_square,
+ size_th as DEFAULT_SIZE_TH
+)
+from ..modules.label_2d_mask.visualizer import Visualizer
+
+
+def save_state_data(state, save_dir,threshold=2000):
+ """
+ 保存 state 中的非字符串数据到磁盘
+
+ Args:
+ state (dict): 包含状态信息的字典
+ save_dir (str): 保存目录路径
+ """
+
+ os.makedirs(save_dir, exist_ok=True)
+ image_array = np.array(state["image"])
+
+ image_pil = Image.fromarray(image_array.astype(np.uint8))
+ image_pil.save(os.path.join(save_dir, f"{state['img_name']}_image.png"))
+
+ np.save(os.path.join(save_dir, f"{state['img_name']}_image.npy"), image_array)
+
+ group_ids_array = np.array(state["group_ids"])
+ np.save(os.path.join(save_dir, f"{state['img_name']}_group_ids.npy"), group_ids_array)
+
+ original_group_ids_array = np.array(state["original_group_ids"])
+ np.save(os.path.join(save_dir, f"{state['img_name']}_original_group_ids.npy"), original_group_ids_array)
+
+ np.save(os.path.join(save_dir, f"{state['img_name']}_threshold.npy"), np.array(threshold))
+ print(f"State data saved to {save_dir}")
+
+def load_state_data(state, load_dir):
+ """
+ 从磁盘加载 state 数据
+
+ Args:
+ state (dict): 原始 state 字典
+ load_dir (str): 加载目录路径
+
+ Returns:
+ dict: 更新后的 state 字典
+ """
+ # 加载 image 数据
+ image_path = os.path.join(load_dir, f"{state['img_name']}_image.npy")
+ if os.path.exists(image_path):
+ state["image"] = np.load(image_path).tolist()
+
+ # 加载 group_ids 数据
+ group_ids_path = os.path.join(load_dir, f"{state['img_name']}_group_ids.npy")
+ if os.path.exists(group_ids_path):
+ state["group_ids"] = np.load(group_ids_path).tolist()
+
+ # 加载 original_group_ids 数据
+ orig_group_ids_path = os.path.join(load_dir, f"{state['img_name']}_original_group_ids.npy")
+ if os.path.exists(orig_group_ids_path):
+ state["original_group_ids"] = np.load(orig_group_ids_path).tolist()
+
+ threshold_path = os.path.join(load_dir, f"{state['img_name']}_threshold.npy")
+ if os.path.exists(threshold_path):
+ state["threshold"] = np.load(threshold_path).item() # 使用 .item() 获取标量值
+ return state
+
+
+
+def apply_base_model(part_synthesis_ckpt,partfield_encoder_path,bbox_gen_ckpt,dino_path,config_path,current_path):
+ # load part_synthesis model
+ OmniPartImageTo3DPipeline.dino=dino_path
+ OmniPartImageTo3DPipeline.dino_moudel=os.path.join(current_path,"facebookresearch/dinov2")
+ part_synthesis_pipeline = OmniPartImageTo3DPipeline.from_pretrained(part_synthesis_ckpt,dino_path,os.path.join(current_path,"facebookresearch/dinov2"))
+
+
+ print("[INFO] PartSynthesis model loaded")
+
+ # load bbox_gen model
+ bbox_gen_config = OmegaConf.load(config_path).model.args
+ bbox_gen_config.partfield_encoder_path = partfield_encoder_path
+ bbox_gen_model = BboxGen(bbox_gen_config,os.path.join(current_path,"OmniPart/configs/dinov2-with-registers-large"),ckpt="F:/ComfyUI311/ComfyUI/models/dinov2/model.safetensors")
+
+ bbox_gen_model.load_state_dict(torch.load(bbox_gen_ckpt,weights_only=False), strict=False)
+
+ bbox_gen_model.eval().half()
+ print("[INFO] BboxGen model loaded")
+
+ return part_synthesis_pipeline,bbox_gen_model
+
+def process_image(image_path, threshold, sam_mask_generator,rmbg_model,user_dir,DEVICE):
+ """Process image and generate initial segmentation"""
+
+
+ #user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ os.makedirs(user_dir, exist_ok=True)
+
+ img_name = os.path.basename(image_path).split(".")[0]
+
+ size_th = threshold
+
+ img = Image.open(image_path).convert("RGB")
+ processed_image = prepare_image(img, rmbg_net=rmbg_model.to(DEVICE))
+
+ processed_image = resize_and_pad_to_square(processed_image)
+ white_bg = Image.new("RGBA", processed_image.size, (255, 255, 255, 255))
+ white_bg_img = Image.alpha_composite(white_bg, processed_image.convert("RGBA"))
+ image = np.array(white_bg_img.convert('RGB'))
+
+ rgba_path = os.path.join(user_dir, f"{img_name}_processed.png")
+ processed_image.save(rgba_path)
+
+ print("Generating raw SAM masks without post-processing...")
+ raw_masks = sam_mask_generator.generate(image)
+
+ raw_sam_vis = np.copy(image)
+ raw_sam_vis = np.ones_like(image) * 255
+
+ sorted_masks = sorted(raw_masks, key=lambda x: x["area"], reverse=True)
+
+ for i, mask_data in enumerate(sorted_masks):
+ if mask_data["area"] < size_th:
+ continue
+
+ color_r = (i * 50 + 80) % 256
+ color_g = (i * 120 + 40) % 256
+ color_b = (i * 180 + 20) % 256
+ color = np.array([color_r, color_g, color_b])
+
+ mask = mask_data["segmentation"]
+ raw_sam_vis[mask] = color
+
+ visual = Visualizer(image)
+
+ group_ids, pre_merge_im = get_sam_mask(
+ image,
+ sam_mask_generator,
+ visual,
+ merge_groups=None,
+ rgba_image=processed_image,
+ img_name=img_name,
+ save_dir=user_dir,
+ size_threshold=size_th
+ )
+
+ pre_merge_path = os.path.join(user_dir, f"{img_name}_mask_pre_merge.png")
+
+ pre_merge_image=Image.fromarray(pre_merge_im)
+ pre_merge_image.save(pre_merge_path)
+ pre_split_vis = np.ones_like(image) * 255
+
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0]
+
+ for i, unique_id in enumerate(unique_ids):
+ color_r = (i * 50 + 80) % 256
+ color_g = (i * 120 + 40) % 256
+ color_b = (i * 180 + 20) % 256
+ color = np.array([color_r, color_g, color_b])
+
+ mask = (group_ids == unique_id)
+ pre_split_vis[mask] = color
+
+ y_indices, x_indices = np.where(mask)
+ if len(y_indices) > 0:
+ center_y = int(np.mean(y_indices))
+ center_x = int(np.mean(x_indices))
+ cv2.putText(pre_split_vis, str(unique_id),
+ (center_x, center_y), cv2.FONT_HERSHEY_SIMPLEX,
+ 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+
+ pre_split_path = os.path.join(user_dir, f"{img_name}_pre_split.png")
+ Image.fromarray(pre_split_vis).save(pre_split_path)
+ print(f"Pre-split segmentation (before disconnected parts handling) saved to {pre_split_path}")
+
+ get_mask(group_ids, image, ids=2, img_name=img_name, save_dir=user_dir)
+
+ init_seg_path = os.path.join(user_dir, f"{img_name}_mask_segments_2.png")
+
+ seg_img = Image.open(init_seg_path)
+ if seg_img.mode == 'RGBA':
+ white_bg = Image.new('RGBA', seg_img.size, (255, 255, 255, 255))
+ seg_img = Image.alpha_composite(white_bg, seg_img)
+ seg_img.save(init_seg_path)
+
+ state = {
+ "image": image.tolist(),
+ "processed_image": rgba_path,
+ "group_ids": group_ids.tolist() if isinstance(group_ids, np.ndarray) else group_ids,
+ "original_group_ids": group_ids.tolist() if isinstance(group_ids, np.ndarray) else group_ids,
+ "img_name": img_name,
+ "pre_split_path": pre_split_path,
+ }
+
+ return init_seg_path, pre_merge_image, state
+
+def apply_merge(merge_input,sam_mask_generator, state, user_dir,threshold):
+ """Apply merge parameters and generate merged segmentation"""
+
+
+ if not state:
+ return None, None, state
+
+ #user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+
+ # Convert back from list to numpy array
+ image = np.array(state["image"])
+ # Use original group IDs instead of the most recent ones
+ group_ids = np.array(state["original_group_ids"])
+ img_name = state["img_name"]
+
+ # Load processed image from path
+ processed_image = Image.open(state["processed_image"])
+
+ # Display the original IDs before merging, SORTED for easier reading
+ unique_ids = np.unique(group_ids)
+ unique_ids = unique_ids[unique_ids >= 0] # Exclude background
+ print(f"Original segment IDs (used for merging): {sorted(unique_ids.tolist())}")
+
+ # Parse merge groups
+ merge_groups = None
+ try:
+ if merge_input:
+ merge_groups = []
+ group_sets = merge_input.split(';')
+ for group_set in group_sets:
+ ids = [int(x) for x in group_set.split(',')]
+ if ids:
+ # Validate if these IDs exist in the segmentation
+ existing_ids = [id for id in ids if id in unique_ids]
+ missing_ids = [id for id in ids if id not in unique_ids]
+
+ if missing_ids:
+ print(f"Warning: These IDs don't exist in the segmentation: {missing_ids}")
+
+ # Only add group if it has valid IDs
+ if existing_ids:
+ merge_groups.append(ids)
+ print(f"Valid merge group: {ids} (missing: {missing_ids if missing_ids else 'none'})")
+ else:
+ print(f"Skipping merge group with no valid IDs: {ids}")
+
+ print(f"Using merge groups: {merge_groups}")
+ except Exception as e:
+ print(f"Error parsing merge groups: {e}")
+ return None, None, state
+
+ # Initialize visualizer
+ visual = Visualizer(image)
+
+ # Generate merged segmentation starting from original IDs
+ # Add skip_split=True to prevent splitting after merging
+ new_group_ids, merged_im = get_sam_mask(
+ image,
+ sam_mask_generator,
+ visual,
+ merge_groups=merge_groups,
+ existing_group_ids=group_ids,
+ rgba_image=processed_image,
+ skip_split=True,
+ img_name=img_name,
+ save_dir=user_dir,
+ size_threshold=threshold
+ )
+
+ # Display the new IDs after merging for future reference
+ new_unique_ids = np.unique(new_group_ids)
+ new_unique_ids = new_unique_ids[new_unique_ids >= 0] # Exclude background
+ print(f"New segment IDs (after merging): {new_unique_ids.tolist()}")
+
+ # Clean edges
+ new_group_ids = clean_segment_edges(new_group_ids)
+
+ # Save merged segmentation visualization
+ get_mask(new_group_ids, image, ids=3, img_name=img_name, save_dir=user_dir)
+
+ # Path to merged segmentation
+ merged_seg_path = os.path.join(user_dir, f"{img_name}_mask_segments_3.png")
+
+ save_mask = new_group_ids + 1
+ save_mask = save_mask.reshape(518, 518, 1).repeat(3, axis=-1)
+ try:
+ save_mask_path=os.path.join(user_dir, f"{img_name}_mask.exr")
+ cv2.imwrite(save_mask_path, save_mask.astype(np.float32))
+ except:
+ try:
+ save_mask_path = os.path.join(user_dir, f"{img_name}_mask.npy")
+ np.save(save_mask_path, save_mask.astype(np.float32))
+ except:
+ save_mask_path=os.path.join(user_dir, f"{img_name}_mask.png")
+ save_mask_normalized = (save_mask / np.max(save_mask) * 255).astype(np.uint8)
+ cv2.imwrite(save_mask_path, save_mask_normalized)
+
+ # Update state with the new group IDs but keep original IDs unchanged
+ state["group_ids"] = new_group_ids.tolist() if isinstance(new_group_ids, np.ndarray) else new_group_ids
+ state["save_mask_path"] = save_mask_path
+ print(f"Saved mask to {save_mask_path}")
+ return merged_seg_path, state
+
+def explode_mesh(mesh, explosion_scale=0.4):
+
+ if isinstance(mesh, trimesh.Scene):
+ scene = mesh
+ elif isinstance(mesh, trimesh.Trimesh):
+ print("Warning: Single mesh provided, can't create exploded view")
+ scene = trimesh.Scene(mesh)
+ return scene
+ else:
+ print(f"Warning: Unexpected mesh type: {type(mesh)}")
+ scene = mesh
+
+ if len(scene.geometry) <= 1:
+ print("Only one geometry found - nothing to explode")
+ return scene
+
+ print(f"[EXPLODE_MESH] Starting mesh explosion with scale {explosion_scale}")
+ print(f"[EXPLODE_MESH] Processing {len(scene.geometry)} parts")
+
+ exploded_scene = trimesh.Scene()
+
+ part_centers = []
+ geometry_names = []
+
+ for geometry_name, geometry in scene.geometry.items():
+ if hasattr(geometry, 'vertices'):
+ transform = scene.graph[geometry_name][0]
+ vertices_global = trimesh.transformations.transform_points(
+ geometry.vertices, transform)
+ center = np.mean(vertices_global, axis=0)
+ part_centers.append(center)
+ geometry_names.append(geometry_name)
+ print(f"[EXPLODE_MESH] Part {geometry_name}: center = {center}")
+
+ if not part_centers:
+ print("No valid geometries with vertices found")
+ return scene
+
+ part_centers = np.array(part_centers)
+ global_center = np.mean(part_centers, axis=0)
+
+ print(f"[EXPLODE_MESH] Global center: {global_center}")
+
+ for i, (geometry_name, geometry) in enumerate(scene.geometry.items()):
+ if hasattr(geometry, 'vertices'):
+ if i < len(part_centers):
+ part_center = part_centers[i]
+ direction = part_center - global_center
+
+ direction_norm = np.linalg.norm(direction)
+ if direction_norm > 1e-6:
+ direction = direction / direction_norm
+ else:
+ direction = np.random.randn(3)
+ direction = direction / np.linalg.norm(direction)
+
+ offset = direction * explosion_scale
+ else:
+ offset = np.zeros(3)
+
+ original_transform = scene.graph[geometry_name][0].copy()
+
+ new_transform = original_transform.copy()
+ new_transform[:3, 3] = new_transform[:3, 3] + offset
+
+ exploded_scene.add_geometry(
+ geometry,
+ transform=new_transform,
+ geom_name=geometry_name
+ )
+
+ print(f"[EXPLODE_MESH] Part {geometry_name}: moved by {np.linalg.norm(offset):.4f}")
+
+ print("[EXPLODE_MESH] Mesh explosion complete")
+ return exploded_scene
+
+
+def prepare_inputs(state,part_synthesis_pipeline,bbox_gen_model,user_dir,seed,output_dir,device):
+
+ img_path = state["processed_image"]
+ mask_path = state["save_mask_path"]
+ #user_dir = os.path.join(TMP_ROOT, str(req.session_hash))
+ img_white_bg, img_black_bg, ordered_mask_input, img_mask_vis = load_img_mask(img_path, mask_path)
+ img_mask_vis.save(os.path.join(user_dir, "img_mask_vis.png"))
+
+ if not os.path.isfile(os.path.join(user_dir, "voxel_coords.npy")) or not os.path.isfile(os.path.join(user_dir, "voxel_coords_vis.ply")):
+ part_synthesis_pipeline.to(device) # to save memory
+ voxel_coords = part_synthesis_pipeline.get_coords(img_black_bg, num_samples=1, seed=seed, sparse_structure_sampler_params={"steps": 25, "cfg_strength": 7.5})
+
+ voxel_coords = voxel_coords.cpu().numpy()
+ np.save(os.path.join(user_dir, "voxel_coords.npy"), voxel_coords)
+ voxel_coords_ply = vis_voxel_coords(voxel_coords)
+ voxel_coords_ply.export(os.path.join(user_dir, "voxel_coords_vis.ply"))
+ print("[INFO] Voxel coordinates saved")
+ else:
+ print("[INFO] Voxel coordinates already exists")
+ bbox_gen_input = prepare_bbox_gen_input(os.path.join(user_dir, "voxel_coords.npy"), img_white_bg, ordered_mask_input)
+
+ if not os.path.exists(os.path.join(user_dir, "bboxes.npy")) or not os.path.exists(os.path.join(user_dir, "bboxes_vis.glb")):
+ bbox_gen_model.to(device)
+ bbox_gen_output = bbox_gen_model.generate(bbox_gen_input)
+
+ np.save(os.path.join(user_dir, "bboxes.npy"), bbox_gen_output['bboxes'][0])
+ bboxes_vis = gen_mesh_from_bounds(bbox_gen_output['bboxes'][0])
+ bboxes_vis.export(os.path.join(user_dir, "bboxes_vis.glb"))
+ print("[INFO] BboxGen output saved")
+ else:
+ print("[INFO] BboxGen output already exists")
+ part_synthesis_input = prepare_part_synthesis_input(os.path.join(user_dir, "voxel_coords.npy"), os.path.join(user_dir, "bboxes.npy"), ordered_mask_input)
+ part_synthesis_input.update({"img_black_bg":img_black_bg,"output_dir":output_dir})
+ bbox_gen_model.to("cpu")
+ return part_synthesis_input
+
+
+
+def inference_omnipart(part_synthesis_pipeline,part_synthesis_input,num_inference_steps,guidance_scale,simplify_ratio,device):
+ part_synthesis_pipeline.to(device)
+ output_dir=part_synthesis_input["output_dir"]
+ part_synthesis_output = part_synthesis_pipeline.get_slat(
+ part_synthesis_input["img_black_bg"],
+ part_synthesis_input['coords'],
+ [part_synthesis_input['part_layouts']],
+ part_synthesis_input['masks'],
+ seed=part_synthesis_input["seed"],
+ slat_sampler_params={"steps": num_inference_steps, "cfg_strength": guidance_scale},
+ formats=['mesh', 'gaussian', 'radiance_field'],
+ preprocess_image=False,
+ )
+
+ save_parts_outputs(
+ part_synthesis_output,
+ output_dir=output_dir,
+ simplify_ratio=simplify_ratio,
+ save_video=False,
+ save_glb=True,
+ textured=False,
+ prefix=part_synthesis_input.get("img_name","omni"),
+ )
+ mesh_texture_path,mesh_segment_path=merge_parts(output_dir,part_synthesis_input.get("img_name","omni"))
+ print("[INFO] PartSynthesis output saved")
+
+ return mesh_texture_path,mesh_segment_path
+
+# if __name__ == "__main__":
+# device = "cuda"
+
+# parser = argparse.ArgumentParser()
+# parser.add_argument("--image-input", type=str, required=True)
+# parser.add_argument("--mask-input", type=str, required=True)
+# parser.add_argument("--output-root", type=str, default="./output")
+# parser.add_argument("--seed", type=int, default=42)
+# parser.add_argument("--num-inference-steps", type=int, default=25)
+# parser.add_argument("--guidance-scale", type=float, default=7.5)
+# parser.add_argument("--simplify_ratio", type=float, default=0.3)
+# parser.add_argument("--partfield_encoder_path", type=str, default="ckpt/model_objaverse.ckpt")
+# parser.add_argument("--bbox_gen_ckpt", type=str, default="ckpt/bbox_gen.ckpt")
+# parser.add_argument("--part_synthesis_ckpt", type=str, default="ckpt/part_synthesis")
+# args = parser.parse_args()
+
+# os.makedirs(args.output_root, exist_ok=True)
+# output_dir = os.path.join(args.output_root, args.image_input.split("/")[-1].split(".")[0])
+# os.makedirs(output_dir, exist_ok=True)
+
+# torch.manual_seed(args.seed)
+
+ # # load part_synthesis model
+ # part_synthesis_pipeline = OmniPartImageTo3DPipeline.from_pretrained(args.part_synthesis_ckpt)
+ # part_synthesis_pipeline.to(device)
+ # print("[INFO] PartSynthesis model loaded")
+
+ # # load bbox_gen model
+ # bbox_gen_config = OmegaConf.load("configs/bbox_gen.yaml").model.args
+ # bbox_gen_config.partfield_encoder_path = args.partfield_encoder_path
+ # bbox_gen_model = BboxGen(bbox_gen_config)
+ # bbox_gen_model.load_state_dict(torch.load(args.bbox_gen_ckpt), strict=False)
+ # bbox_gen_model.to(device)
+ # bbox_gen_model.eval().half()
+ # print("[INFO] BboxGen model loaded")
+
+ # img_white_bg, img_black_bg, ordered_mask_input, img_mask_vis = load_img_mask(args.image_input, args.mask_input)
+ # img_mask_vis.save(os.path.join(output_dir, "img_mask_vis.png"))
+
+ # voxel_coords = part_synthesis_pipeline.get_coords(img_black_bg, num_samples=1, seed=args.seed, sparse_structure_sampler_params={"steps": 25, "cfg_strength": 7.5})
+ # voxel_coords = voxel_coords.cpu().numpy()
+ # np.save(os.path.join(output_dir, "voxel_coords.npy"), voxel_coords)
+ # voxel_coords_ply = vis_voxel_coords(voxel_coords)
+ # voxel_coords_ply.export(os.path.join(output_dir, "voxel_coords_vis.ply"))
+ # print("[INFO] Voxel coordinates saved")
+
+ # bbox_gen_input = prepare_bbox_gen_input(os.path.join(output_dir, "voxel_coords.npy"), img_white_bg, ordered_mask_input)
+ # bbox_gen_output = bbox_gen_model.generate(bbox_gen_input)
+ # np.save(os.path.join(output_dir, "bboxes.npy"), bbox_gen_output['bboxes'][0])
+ # bboxes_vis = gen_mesh_from_bounds(bbox_gen_output['bboxes'][0])
+ # bboxes_vis.export(os.path.join(output_dir, "bboxes_vis.glb"))
+ # print("[INFO] BboxGen output saved")
+
+ #part_synthesis_input = prepare_part_synthesis_input(os.path.join(output_dir, "voxel_coords.npy"), os.path.join(output_dir, "bboxes.npy"), ordered_mask_input)
+ # part_synthesis_output = part_synthesis_pipeline.get_slat(
+ # img_black_bg,
+ # part_synthesis_input['coords'],
+ # [part_synthesis_input['part_layouts']],
+ # part_synthesis_input['masks'],
+ # seed=args.seed,
+ # slat_sampler_params={"steps": args.num_inference_steps, "cfg_strength": args.guidance_scale},
+ # formats=['mesh', 'gaussian', 'radiance_field'],
+ # preprocess_image=False,
+ # )
+ # save_parts_outputs(
+ # part_synthesis_output,
+ # output_dir=output_dir,
+ # simplify_ratio=args.simplify_ratio,
+ # save_video=False,
+ # save_glb=True,
+ # textured=False,
+ # )
+ # merge_parts(output_dir)
+ # print("[INFO] PartSynthesis output saved")
\ No newline at end of file
diff --git a/OmniPart/train.py b/OmniPart/train.py
new file mode 100644
index 0000000..d1f5d16
--- /dev/null
+++ b/OmniPart/train.py
@@ -0,0 +1,159 @@
+import os
+import sys
+import json
+import glob
+import argparse
+from easydict import EasyDict as edict
+
+import torch
+import torch.multiprocessing as mp
+import numpy as np
+import random
+
+from trellis import models, datasets, trainers
+from trellis.utils.dist_utils import setup_dist
+
+
+def find_ckpt(cfg):
+ cfg['load_ckpt'] = None
+ if cfg.load_dir != '':
+ if cfg.ckpt == 'latest':
+ files = glob.glob(os.path.join(cfg.load_dir, 'ckpts', 'misc_*.pt'))
+ if len(files) != 0:
+ cfg.load_ckpt = max([
+ int(os.path.basename(f).split('step')[-1].split('.')[0])
+ for f in files
+ ])
+ elif cfg.ckpt == 'none':
+ cfg.load_ckpt = None
+ else:
+ cfg.load_ckpt = int(cfg.ckpt)
+ return cfg
+
+
+def setup_rng(rank):
+ torch.manual_seed(rank)
+ torch.cuda.manual_seed_all(rank)
+ np.random.seed(rank)
+ random.seed(rank)
+
+
+def get_model_summary(model):
+ model_summary = 'Parameters:\n'
+ model_summary += '=' * 128 + '\n'
+ model_summary += f'{"Name":<{72}}{"Shape":<{32}}{"Type":<{16}}{"Grad"}\n'
+ num_params = 0
+ num_trainable_params = 0
+ for name, param in model.named_parameters():
+ model_summary += f'{name:<{72}}{str(param.shape):<{32}}{str(param.dtype):<{16}}{param.requires_grad}\n'
+ num_params += param.numel()
+ if param.requires_grad:
+ num_trainable_params += param.numel()
+ model_summary += '\n'
+ model_summary += f'Number of parameters: {num_params}\n'
+ model_summary += f'Number of trainable parameters: {num_trainable_params}\n'
+ return model_summary
+
+
+def main(local_rank, cfg):
+
+ rank = cfg.node_rank * cfg.num_gpus + local_rank
+ world_size = cfg.num_nodes * cfg.num_gpus
+ if world_size > 1:
+ # print(rank,local_rank, world_size)
+ setup_dist(rank, local_rank, world_size, cfg.master_addr, cfg.master_port)
+
+ # Seed random number generators for reproducibility
+ setup_rng(rank)
+ print("Load training dataset ...")
+ # Load dataset based on configuration
+ dataset = getattr(datasets, cfg.dataset.name)(cfg.data_dir, **cfg.dataset.args)
+
+ print("Load model ...")
+ # Build models dynamically based on configuration
+ model_dict = {
+ name: getattr(models, model.name)(**model.args).cuda()
+ for name, model in cfg.models.items()
+ }
+
+
+ print("Load trainer ...")
+ # Initialize trainer with models, dataset and configuration
+ trainer = getattr(trainers, cfg.trainer.name)(model_dict, dataset, **cfg.trainer.args,
+ output_dir=cfg.output_dir, load_dir=cfg.load_dir, step=cfg.load_ckpt)
+
+ # Start training or profiling based on configuration
+ if not cfg.tryrun:
+ if cfg.profile:
+ trainer.profile()
+ else:
+ trainer.run()
+
+if __name__ == '__main__':
+ # Parse command line arguments and load configuration
+ parser = argparse.ArgumentParser()
+ ## Config file
+ parser.add_argument('--config', type=str, required=True, help='Experiment config file')
+ ## Input/output and checkpoint options
+ parser.add_argument('--output_dir', type=str, required=True, help='Output directory')
+ parser.add_argument('--load_dir', type=str, default='', help='Load directory, default to output_dir')
+ parser.add_argument('--ckpt', type=str, default='latest', help='Checkpoint step to resume training, default to latest')
+ parser.add_argument('--data_dir', type=str, default='./data/', help='Data directory')
+ parser.add_argument('--auto_retry', type=int, default=3, help='Number of retries on error')
+ ## Debug options
+ parser.add_argument('--tryrun', action='store_true', help='Try run without training')
+ parser.add_argument('--profile', action='store_true', help='Profile training')
+ ## Distributed training options
+ parser.add_argument('--num_nodes', type=int, default=1, help='Number of nodes')
+ parser.add_argument('--node_rank', type=int, default=0, help='Node rank')
+ parser.add_argument('--num_gpus', type=int, default=-1, help='Number of GPUs per node, default to all')
+ parser.add_argument('--master_addr', type=str, default='localhost', help='Master address for distributed training')
+ parser.add_argument('--master_port', type=str, default='12345', help='Port for distributed training')
+
+ # Process arguments
+ opt = parser.parse_args()
+ opt.load_dir = opt.load_dir if opt.load_dir != '' else opt.output_dir
+ opt.num_gpus = torch.cuda.device_count() if opt.num_gpus == -1 else opt.num_gpus
+
+ # Load configuration from JSON file
+ config = json.load(open(opt.config, 'r'))
+
+ # Combine command-line arguments and JSON config
+ cfg = edict()
+ cfg.update(opt.__dict__)
+ cfg.update(config)
+ print('\n\nConfig:')
+ print('=' * 80)
+ print(json.dumps(cfg.__dict__, indent=4))
+
+ # Create output directory and save configuration (only on main node)
+ if cfg.node_rank == 0:
+ os.makedirs(cfg.output_dir, exist_ok=True)
+ ## Save command and config for reproducibility
+ with open(os.path.join(cfg.output_dir, 'command.txt'), 'w') as fp:
+ print(' '.join(['python'] + sys.argv), file=fp)
+ with open(os.path.join(cfg.output_dir, 'config.json'), 'w') as fp:
+ json.dump(config, fp, indent=4)
+
+ # Run training with optional auto-retry on errors
+ if cfg.auto_retry == 0:
+ # No retries - run once
+ cfg = find_ckpt(cfg)
+ if cfg.num_gpus > 1:
+ mp.spawn(main, args=(cfg,), nprocs=cfg.num_gpus, join=True)
+ else:
+ main(0, cfg)
+ else:
+ # Run training with retries
+ for rty in range(cfg.auto_retry):
+ print(f'Run {rty + 1}/{cfg.auto_retry}')
+ cfg = find_ckpt(cfg)
+ if cfg.num_gpus > 1:
+ mp.spawn(main, args=(cfg,), nprocs=cfg.num_gpus, join=True)
+ else:
+ main(0, cfg)
+
+ if rty < cfg.auto_retry - 1:
+ print(f'Completed run {rty + 1}/{cfg.auto_retry}')
+ else:
+ print(f'All {cfg.auto_retry} runs completed')
\ No newline at end of file
diff --git a/OmniPart/training/__init__.py b/OmniPart/training/__init__.py
new file mode 100644
index 0000000..20d240a
--- /dev/null
+++ b/OmniPart/training/__init__.py
@@ -0,0 +1,6 @@
+from . import models
+from . import modules
+from . import pipelines
+from . import renderers
+from . import representations
+from . import utils
diff --git a/OmniPart/training/datasets/__init__.py b/OmniPart/training/datasets/__init__.py
new file mode 100644
index 0000000..1a11f34
--- /dev/null
+++ b/OmniPart/training/datasets/__init__.py
@@ -0,0 +1,41 @@
+import importlib
+
+__attributes = {
+ 'SparseStructure': 'sparse_structure',
+
+ 'SparseFeat2Render': 'sparse_feat2render',
+ 'SLat2Render':'structured_latent2render',
+ 'Slat2RenderGeo':'structured_latent2render',
+
+ 'SparseStructureLatent': 'sparse_structure_latent',
+ 'TextConditionedSparseStructureLatent': 'sparse_structure_latent',
+ 'ImageConditionedSparseStructureLatent': 'sparse_structure_latent',
+
+ 'SLat': 'structured_latent',
+ 'ImageConditionedSLat': 'structured_latent_part',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .structured_latent_part import (
+ ImageConditionedSLat,
+ )
+
\ No newline at end of file
diff --git a/OmniPart/training/datasets/components.py b/OmniPart/training/datasets/components.py
new file mode 100644
index 0000000..845b939
--- /dev/null
+++ b/OmniPart/training/datasets/components.py
@@ -0,0 +1,340 @@
+from typing import *
+from abc import abstractmethod
+import os
+import json
+import torch
+import numpy as np
+import pandas as pd
+from PIL import Image
+from torch.utils.data import Dataset
+import torchvision.transforms.functional as TF
+import cv2
+import random
+
+class StandardDatasetBase(Dataset):
+ """
+ Base class for standard datasets.
+
+ This class provides the foundation for dataset handling with common functionality
+ like loading metadata from multiple data roots and filtering instances.
+
+ Args:
+ roots (str): Comma-separated paths to the dataset directories
+ """
+
+ def __init__(self,
+ roots: str,
+ ):
+ super().__init__()
+ self.roots = roots.split(',')
+ self.instances = []
+ self.metadata = pd.DataFrame()
+
+ @abstractmethod
+ def filter_metadata(self, metadata: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, int]]:
+ """
+ Filter metadata according to implementation-specific criteria.
+
+ Args:
+ metadata (pd.DataFrame): The raw metadata to filter
+
+ Returns:
+ Tuple[pd.DataFrame, Dict[str, int]]: Filtered metadata and statistics dictionary
+ """
+ pass
+
+ @abstractmethod
+ def get_instance(self, root: str, instance: str) -> Dict[str, Any]:
+ """
+ Get a specific instance from the dataset.
+
+ Args:
+ root (str): The root directory of the instance
+ instance (str): The instance identifier (SHA256)
+
+ Returns:
+ Dict[str, Any]: Dictionary containing the instance data
+ """
+ pass
+
+ def __len__(self):
+ """Return the total number of instances in the dataset"""
+ return len(self.instances)
+
+ def __getitem__(self, index) -> Dict[str, Any]:
+ """
+ Get an item from the dataset by index.
+
+ Includes error handling - if fetching an instance fails, returns a random instance.
+
+ Args:
+ index: Index of the item to retrieve
+
+ Returns:
+ Dict[str, Any]: Dictionary containing the instance data
+ """
+
+ try:
+ root, instance = self.instances[index]
+ return self.get_instance(root, instance)
+ except Exception as e:
+ print(e)
+ raise RuntimeError(
+ f"Failed to get instance {index} from dataset. And the length of dataset is {len(self)}")
+ # On error, return a random instance instead
+ return self.__getitem__(np.random.randint(0, len(self)))
+
+ # def __str__(self):
+ # """
+ # Return a string representation of the dataset, including statistics.
+
+ # Returns:
+ # str: Formatted dataset information
+ # """
+ # lines = []
+ # lines.append(self.__class__.__name__)
+ # lines.append(f' - Total instances: {len(self)}')
+ # lines.append(f' - Sources:')
+ # for key, stats in self._stats.items():
+ # lines.append(f' - {key}:')
+ # for k, v in stats.items():
+ # lines.append(f' - {k}: {v}')
+ # return '\n'.join(lines)
+
+
+class TextConditionedMixin:
+ """
+ Mixin class for datasets conditioned on text/captions.
+
+ Adds functionality for loading and accessing text captions associated with instances.
+ """
+ def __init__(self, roots, **kwargs):
+ super().__init__(roots, **kwargs)
+ self.captions = {}
+
+ # Load captions for all instances from metadata
+ for instance in self.instances:
+ sha256 = instance[1]
+ self.captions[sha256] = json.loads(self.metadata.loc[sha256]['captions'])
+
+ def filter_metadata(self, metadata):
+ """
+ Filter metadata to only include instances with captions.
+
+ Args:
+ metadata (pd.DataFrame): The metadata to filter
+
+ Returns:
+ Tuple[pd.DataFrame, Dict[str, int]]: Filtered metadata and updated statistics
+ """
+ metadata, stats = super().filter_metadata(metadata)
+ metadata = metadata[metadata['captions'].notna()] # Keep only instances with captions
+ stats['With captions'] = len(metadata) # Record count of instances with captions
+ return metadata, stats
+
+ def get_instance(self, root, instance):
+ """
+ Extends the base get_instance method to include a randomly chosen caption.
+
+ Args:
+ root (str): The root directory of the instance
+ instance (str): The instance identifier (SHA256)
+
+ Returns:
+ Dict[str, Any]: Dictionary with instance data plus caption as 'cond'
+ """
+ pack = super().get_instance(root, instance)
+ text = np.random.choice(self.captions[instance]) # Select a random caption
+ pack['cond'] = text # Add the caption as a condition
+ return pack
+
+
+class ImageConditionedMixin:
+ """
+ Mixin class for datasets conditioned on images.
+
+ Adds functionality for loading and preprocessing conditional images.
+ """
+ def __init__(self, roots, *, image_size=518, **kwargs):
+ """
+ Initialize the mixin with image size parameter.
+
+ Args:
+ roots (str): Dataset roots
+ image_size (int): Size to resize images to (square)
+ **kwargs: Additional arguments to pass to parent
+ """
+ self.image_size = image_size
+ super().__init__(roots, **kwargs)
+ self.img_data_root = "/mnt/pfs/data/vast_annotated_processed_part_v3/render_fix_animation"
+
+ def filter_metadata(self, metadata):
+ """
+ Filter metadata to only include instances with rendered conditional images.
+
+ Args:
+ metadata (pd.DataFrame): The metadata to filter
+
+ Returns:
+ Tuple[pd.DataFrame, Dict[str, int]]: Filtered metadata and updated statistics
+ """
+ metadata, stats = super().filter_metadata(metadata)
+ metadata = metadata[metadata[f'cond_rendered']] # Keep only instances with conditional renders
+ stats['Cond rendered'] = len(metadata) # Record count of instances with conditional renders
+ return metadata, stats
+
+ def process_image(self, image_path):
+ """
+ Process a conditional image by cropping to subject, resizing, and handling transparency.
+
+ Args:
+ image_path (str): Path to the input image file
+
+ Returns:
+ torch.Tensor: Processed image tensor with alpha compositing applied
+ """
+
+ image = Image.open(image_path)
+ alpha = np.array(image.getchannel(3))
+ bbox = np.array(alpha).nonzero()
+ bbox = [bbox[1].min(), bbox[0].min(), bbox[1].max(), bbox[0].max()]
+ center = [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2]
+
+ hsize = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) / 2
+ aug_size_ratio = 1.2
+ aug_hsize = hsize * aug_size_ratio
+ aug_center_offset = [0, 0]
+ aug_center = [center[0] + aug_center_offset[0], center[1] + aug_center_offset[1]]
+
+ aug_bbox = [int(aug_center[0] - aug_hsize), int(aug_center[1] - aug_hsize),
+ int(aug_center[0] + aug_hsize), int(aug_center[1] + aug_hsize)]
+ image = image.crop(aug_bbox)
+
+ image = image.resize((self.image_size, self.image_size), Image.Resampling.LANCZOS)
+
+ alpha = image.getchannel(3)
+ image = image.convert('RGB')
+
+ image = torch.tensor(np.array(image)).permute(2, 0, 1).float() / 255.0
+ alpha = torch.tensor(np.array(alpha)).float() / 255.0
+
+ image = image * alpha.unsqueeze(0)
+ return image
+
+ def load_image(self, image_path, size=(518, 518)):
+ img = np.array(Image.open(image_path))
+ if img.shape[-1] == 4:
+ mask_img = img[..., 3] == 0
+ img[mask_img] = [0, 0, 0, 255]
+ img = img[..., :3]
+ img_rgb = Image.fromarray(img.astype('uint8'))
+ img_rgb = img_rgb.resize(size, resample=Image.Resampling.BILINEAR)
+ img = TF.to_tensor(img_rgb)
+ return img, img_rgb
+
+ def get_instance(self, uuid, select_method='random_seg'):
+ """
+ Extends the base get_instance method to include a processed conditional image.
+
+ Includes sophisticated image preprocessing:
+ 1. Loads a random view from available renders
+ 2. Crops the image around the non-transparent content
+ 3. Resizes to the target resolution
+ 4. Applies alpha compositing
+
+ Args:
+ root (str): The root directory of the instance
+ instance (str): The instance identifier (SHA256)
+
+ Returns:
+ Dict[str, Any]: Dictionary with instance data plus image as 'cond'
+ """
+ # Call the second father class from MRO sequence to get the base instance
+ pack = super().get_instance(uuid)
+
+ # Load conditional image metadata
+ # image_root = os.path.join(root, 'renders_cond', instance)
+ # with open(os.path.join(image_root, 'transforms.json')) as f:
+ # metadata = json.load(f)
+
+ if select_method == 'random':
+ # Select a random view from available frames
+ n_views = len(metadata['frames'])
+ view = np.random.randint(n_views)
+
+ image_root= ""
+
+ metadata = metadata['frames'][view]
+ # Load the image from the selected view
+ image_path = os.path.join(image_root, metadata['file_path'])
+
+ image = self.process_image(image_path) # Process the image
+
+ pack['cond'] = image
+
+ elif select_method == "random_seg":
+
+ data_dir = os.path.join(self.img_data_root, uuid[:2], uuid)
+ random_index = random.choice([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25])
+ image_path = os.path.join(data_dir, f"color_{random_index:04d}.webp")
+ mask_path = os.path.join(data_dir, f"mask_{random_index:04d}.exr")
+
+ mask, mask_vis, ordered_mask_dino = self.load_bottom_up_mask(mask_path, size=(518, 518))
+ pack['ordered_mask_dino'] = ordered_mask_dino
+
+ if os.path.exists(image_path):
+ image, image_rgb = self.load_image(image_path)
+ pack['cond'] = image
+ else:
+ raise ValueError(f"Image not found: {image_path}")
+
+ else:
+ raise ValueError("Invalid select_method. Use 'random' or 'random_seg'.")
+
+ return pack
+
+ def load_bottom_up_mask(self, mask_path, size=(518, 518)):
+ """
+ Load mask and sort parts from bottom to top based on y-coordinate.
+
+ Args:
+ mask_path: Path to the mask file
+ size: Target size for resizing
+
+ Returns:
+ Ordered mask, visualization mask, and downsampled mask for DINO
+ """
+ mask = cv2.imread(mask_path, cv2.IMREAD_UNCHANGED)
+ mask = cv2.imread(mask_path, cv2.IMREAD_UNCHANGED)
+ mask = cv2.resize(mask, size, interpolation=cv2.INTER_NEAREST)
+ mask_dino = cv2.resize(mask, (37, 37), interpolation=cv2.INTER_NEAREST)
+ mask_vis = cv2.resize(mask_dino, (518, 518), interpolation=cv2.INTER_NEAREST)
+ mask_dino = np.array(mask_dino, dtype=np.int32)[..., 0]
+ mask_org = np.array(mask, dtype=np.int32)[..., 0]
+
+ unique_indices = np.unique(mask_org)
+ unique_indices = unique_indices[unique_indices > 0]
+
+ part_positions = {}
+ for idx in unique_indices:
+ y_coords, _ = np.where(mask_org == idx)
+ if len(y_coords) > 0:
+ part_positions[idx] = np.max(y_coords)
+
+ sorted_parts = sorted(part_positions.items(), key=lambda x: -x[1])
+
+ index_map = {}
+ for new_idx, (old_idx, _) in enumerate(sorted_parts, 1):
+ index_map[old_idx] = new_idx
+
+ ordered_mask = np.zeros_like(mask_org)
+ ordered_mask_dino = np.zeros_like(mask_dino)
+ for old_idx, new_idx in index_map.items():
+ ordered_mask[mask_org == old_idx] = new_idx
+ ordered_mask_dino[mask_dino == old_idx] = new_idx
+
+ mask = ordered_mask.astype(np.float32)
+ mask_vis = np.array(mask_vis, dtype=np.int32)[..., 0]
+ ordered_mask_dino = torch.from_numpy(ordered_mask_dino).long()
+
+ return mask, mask_vis, ordered_mask_dino
\ No newline at end of file
diff --git a/OmniPart/training/datasets/structured_latent_part.py b/OmniPart/training/datasets/structured_latent_part.py
new file mode 100644
index 0000000..867b88a
--- /dev/null
+++ b/OmniPart/training/datasets/structured_latent_part.py
@@ -0,0 +1,487 @@
+import json
+import os
+from typing import *
+import numpy as np
+import torch
+import utils3d.torch
+from .components import StandardDatasetBase, TextConditionedMixin, ImageConditionedMixin
+from ..modules.sparse.basic import SparseTensor, sparse_cat
+from .. import models
+from ..utils.render_utils import get_renderer
+from ..utils.dist_utils import read_file_dist
+from ..utils.data_utils import load_balanced_group_indices, save_coords_as_ply
+# from ..modules import sparse as sp
+
+
+class SLatVisMixin:
+ """
+ Mixin class that adds visualization capabilities for structured latent representations.
+ Handles loading of latent decoders and rendering 3D structures from latent codes.
+ """
+ def __init__(
+ self,
+ *args,
+ pretrained_slat_dec: str = 'JeffreyXiang/TRELLIS-image-large/ckpts/slat_dec_gs_swin8_B_64l8gs32_fp16',
+ slat_dec_path: Optional[str] = None,
+ slat_dec_ckpt: Optional[str] = None,
+ **kwargs
+ ):
+ """
+ Initialize the visualization mixin.
+
+ Args:
+ pretrained_slat_dec: Identifier for pretrained decoder model
+ slat_dec_path: Optional path to custom decoder model
+ slat_dec_ckpt: Optional checkpoint name for custom decoder
+ """
+ # super().__init__(*args, **kwargs)
+ self.slat_dec = None # Decoder model (loaded on demand)
+ self.pretrained_slat_dec = pretrained_slat_dec
+ self.slat_dec_path = slat_dec_path
+ self.slat_dec_ckpt = slat_dec_ckpt
+
+ def _loading_slat_dec(self):
+ """
+ Load the structured latent decoder model if not already loaded.
+ Uses either a custom path or pretrained model based on initialization parameters.
+ """
+ if self.slat_dec is not None:
+ return
+ if self.slat_dec_path is not None:
+ # Load from custom path
+ cfg = json.load(open(os.path.join(self.slat_dec_path, 'config.json'), 'r'))
+ decoder = getattr(models, cfg['models']['decoder']['name'])(**cfg['models']['decoder']['args'])
+ ckpt_path = os.path.join(self.slat_dec_path, 'ckpts', f'decoder_{self.slat_dec_ckpt}.pt')
+ decoder.load_state_dict(torch.load(read_file_dist(ckpt_path), map_location='cpu', weights_only=True))
+ else:
+ # Load pretrained model
+ decoder = models.from_pretrained(self.pretrained_slat_dec)
+ self.slat_dec = decoder.cuda().eval()
+
+ def _delete_slat_dec(self):
+ """
+ Delete the decoder model to free up memory.
+ """
+ del self.slat_dec
+ self.slat_dec = None
+
+ @torch.no_grad()
+ def decode_latent(self, z, batch_size=4):
+ """
+ Decode latent vectors into 3D representations.
+ """
+ self._loading_slat_dec()
+ reps = []
+ if self.normalization is not None:
+ # Apply normalization if needed
+ z = z * self.std.to(z.device) + self.mean.to(z.device)
+
+ for i in range(0, z.shape[0], batch_size):
+ z_batch = z[i:i+batch_size]
+ z_batch = self.remove_noise(z_batch)
+ if z_batch is not None:
+ reps.append(self.slat_dec(z_batch))
+
+ reps = sum(reps, [])
+ self._delete_slat_dec()
+ return reps
+
+ def remove_noise(self, z_batch):
+ """
+ Remove noise from latent vectors by filtering out points with low confidence.
+
+ Args:
+ z_batch: Latent vectors to process
+
+ Returns:
+ Processed latent vectors with noise removed
+ """
+ # Create a new list for processed tensors
+ processed_batch = []
+
+ for i, z in enumerate(z_batch):
+ coords = z.coords
+ feats = z.feats
+
+ if feats.shape[1] == 9:
+ last_dim = feats[:, -1]
+
+ sigmoid_val = torch.sigmoid(last_dim)
+
+ to_keep = sigmoid_val >= 0.5
+
+ if to_keep.any():
+ filtered_coords = coords[to_keep]
+ filtered_feats = feats[to_keep]
+ filtered_feats = filtered_feats[:, :-1]
+
+ processed_z = z.replace(coords=filtered_coords, feats=filtered_feats)
+ processed_batch.append(processed_z)
+ else:
+ processed_z = z
+
+ processed_batch.append(processed_z)
+ if len(processed_batch) > 0:
+ return sparse_cat(processed_batch)
+ else:
+ return None
+
+ @torch.no_grad()
+ def visualize_sample(self, x_0: Union[SparseTensor, dict]):
+ """
+ Generate multi-view renderings of a 3D representation.
+
+ Args:
+ x_0: Input sparse tensor or dictionary containing sparse tensor
+
+ Returns:
+ Tensor of rendered images from multiple viewpoints part_layouts
+ """
+ if isinstance(x_0, SparseTensor):
+ # If x_0 is already a SparseTensor, use it directly
+ part_layouts = slice(None, None)
+
+ else:
+ part_layouts = x_0['part_layouts']
+ x_0 = x_0['x_0']
+
+ if part_layouts != slice(None, None):
+ reps = []
+ sparse_part = []
+ for part_id, part_layout in enumerate(part_layouts):
+ for part_obj_id, part_slice in enumerate(part_layout):
+ part_x_sparse_tensor = SparseTensor(
+ coords=x_0[part_id].coords[part_slice],
+ feats=x_0[part_id].feats[part_slice],
+ )
+ sparse_part.append(part_x_sparse_tensor)
+ reps = self.decode_latent(sparse_cat(sparse_part).cuda())
+ else:
+ reps = self.decode_latent(x_0.cuda())
+
+ # Build camera parameters for multiple viewpoints
+ yaws = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
+
+ # fix the angle
+ yaws_offset = np.pi / 4
+ yaws = [y + yaws_offset for y in yaws]
+ pitch = [np.pi / 4 for _ in range(4)]
+
+ exts = []
+ ints = []
+ for yaw, pitch in zip(yaws, pitch):
+ # Calculate camera position based on spherical coordinates
+ orig = torch.tensor([
+ np.sin(yaw) * np.cos(pitch),
+ np.cos(yaw) * np.cos(pitch),
+ np.sin(pitch),
+ ]).float().cuda() * 2
+ fov = torch.deg2rad(torch.tensor(40)).cuda()
+ extrinsics = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intrinsics = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ exts.append(extrinsics)
+ ints.append(intrinsics)
+
+ # Render images for each representation
+ renderer = get_renderer(reps[0])
+ images = []
+ for representation in reps:
+ image = torch.zeros(3, 1024, 1024).cuda()
+ tile = [2, 2]
+ for j, (ext, intr) in enumerate(zip(exts, ints)):
+ res = renderer.render(representation, ext, intr)
+ # Place each view in a grid position
+ image[:, 512 * (j // tile[1]):512 * (j // tile[1] + 1), 512 * (j % tile[1]):512 * (j % tile[1] + 1)] = res['color']
+ images.append(image)
+ images = torch.stack(images)
+
+ return images
+
+
+class SLat(SLatVisMixin, StandardDatasetBase):
+ """
+ Structured latent dataset class.
+ Handles loading and processing of structured latent representations.
+
+ Args:
+ roots (str): path to the dataset
+ latent_model (str): name of the latent model
+ min_aesthetic_score (float): minimum aesthetic score
+ max_num_voxels (int): maximum number of voxels
+ normalization (dict): normalization stats
+ pretrained_slat_dec (str): name of the pretrained slat decoder
+ slat_dec_path (str): path to the slat decoder, if given, will override the pretrained_slat_dec
+ slat_dec_ckpt (str): name of the slat decoder checkpoint
+ """
+ def __init__(self,
+ roots: str,
+ *,
+ data_root: str,
+ train_mesh_list: str,
+ val_mesh_list: str,
+ aug_bbox: Optional[str] = None, # 0 2
+ noise_mask_score: float = 4.0,
+ latent_model: str,
+ min_aesthetic_score: float = 5.0,
+ max_num_voxels: int = 32768,
+ normalization: Optional[dict] = None,
+ pretrained_slat_dec: str = 'JeffreyXiang/TRELLIS-image-large/ckpts/slat_dec_gs_swin8_B_64l8gs32_fp16',
+ slat_dec_path: Optional[str] = None,
+ slat_dec_ckpt: Optional[str] = None,
+ ):
+ """
+ Initialize the structured latent dataset.
+ """
+ self.normalization = normalization
+ self.latent_model = latent_model
+ self.min_aesthetic_score = min_aesthetic_score
+ self.max_num_voxels = max_num_voxels
+ self.value_range = (0, 1)
+
+ super().__init__(
+ roots,
+ pretrained_slat_dec=pretrained_slat_dec,
+ slat_dec_path=slat_dec_path,
+ slat_dec_ckpt=slat_dec_ckpt,
+ )
+
+ # Set up normalization parameters if provided
+ if self.normalization is not None:
+ self.mean = torch.tensor(self.normalization['mean']).reshape(1, -1)
+ self.std = torch.tensor(self.normalization['std']).reshape(1, -1)
+
+ self.data_root = data_root
+ self.mesh_list = []
+ self.loads = []
+ with open(train_mesh_list, 'r') as f:
+ lines = f.readlines()
+ for line in lines:
+ uuid, voxel_num = line.strip().split(' ')
+ voxel_num = int(voxel_num)
+ if voxel_num > self.max_num_voxels:
+ continue
+ self.mesh_list.append(uuid)
+ self.loads.append(voxel_num)
+ # print(self.loads)
+ # exit(0)
+ if aug_bbox is not None:
+ aug_bbox_min, aug_bbox_max = aug_bbox.split(' ')
+ self.aug_bbox_range = (int(aug_bbox_min), int(aug_bbox_max))
+ else:
+ self.aug_bbox_range = None
+ self.noise_mask_score = noise_mask_score
+
+
+ def __len__(self):
+ """Return the total number of instances in the dataset"""
+ return len(self.mesh_list)
+
+
+ def __getitem__(self, index) -> Dict[str, Any]:
+ """
+ Get an item from the dataset by index.
+
+ Includes error handling - if fetching an instance fails, returns a random instance.
+
+ Args:
+ index: Index of the item to retrieve
+
+ Returns:
+ Dict[str, Any]: Dictionary containing the instance data
+ """
+ try:
+ uuid = self.mesh_list[index]
+ # print(f"uuid to find: {uuid}")
+ return self.get_instance(uuid)
+ except Exception as e:
+ print(e)
+ # On error, return a random instance instead
+ return self.__getitem__(np.random.randint(0, len(self)))
+
+ try:
+ root, instance = self.instances[index]
+ return self.get_whole_bbox_info(root, instance)
+ except Exception as e:
+ print(e)
+ raise RuntimeError(
+ f"Failed to get instance {index} from dataset. And the length of dataset is {len(self)}")
+ # On error, return a random instance instead
+ return self.__getitem__(np.random.randint(0, len(self)))
+
+ def coords_to_ids(self, coords, max_val=64):
+ return coords[:, 0] * max_val**2 + coords[:, 1] * max_val + coords[:, 2]
+
+
+ def get_instance(self, uuid):
+ """
+ Process all parts and whole model data and combine them into a single output.
+ Returns a dictionary with coordinates, features, part names, and part layouts.
+ """
+
+ data = np.load(os.path.join(self.data_root, uuid[:2], uuid, 'all_latent.npz'))
+ all_coords = data['coords'].astype(np.int32)
+ all_feats = data['feats'].astype(np.float32)
+ offsets = data['offsets'].astype(np.int32)
+ all_coords_wnoise = []
+ all_feats_wnoise = []
+ part_layouts = []
+ start_idx = 0
+ for i in range(len(offsets) - 1):
+ if i == 0:
+ overall_coords = all_coords[offsets[i]:offsets[i+1]]
+ overall_feats = all_feats[offsets[i]:offsets[i+1]]
+ overall_ids = self.coords_to_ids(overall_coords)
+ part_layouts.append(slice(start_idx, start_idx + overall_coords.shape[0]))
+ start_idx += overall_coords.shape[0]
+ else:
+ part_coords = all_coords[offsets[i]:offsets[i+1]]
+ part_feats = all_feats[offsets[i]:offsets[i+1]]
+ part_bbox_min = part_coords.min(axis=0)
+ part_bbox_max = part_coords.max(axis=0)
+ if self.aug_bbox_range is not None:
+ aug_bbox_min = np.random.randint(self.aug_bbox_range[0], self.aug_bbox_range[1] + 1, size=3)
+ part_bbox_min = part_bbox_min - aug_bbox_min
+ part_bbox_min = np.clip(part_bbox_min, 0, 63)
+ aug_bbox_max = np.random.randint(self.aug_bbox_range[0], self.aug_bbox_range[1] + 1, size=3)
+ part_bbox_max = part_bbox_max + aug_bbox_max
+ part_bbox_max = np.clip(part_bbox_max, 0, 63)
+
+ bbox_mask = np.all((overall_coords >= part_bbox_min) & (overall_coords <= part_bbox_max), axis=1)
+ part_ids = self.coords_to_ids(part_coords)
+ part_in_overall = np.isin(overall_ids, part_ids)
+ noise_mask = np.logical_and(bbox_mask, np.logical_not(part_in_overall))
+ noise_coords = overall_coords[noise_mask]
+ noise_feats = overall_feats[noise_mask]
+ noise_feats = np.concatenate((noise_feats, np.full((noise_feats.shape[0], 1), -self.noise_mask_score)), axis=1)
+ part_feats = np.concatenate((part_feats, np.full((part_feats.shape[0], 1), self.noise_mask_score)), axis=1)
+
+ part_coords = np.concatenate((part_coords, noise_coords), axis=0)
+ part_feats = np.concatenate((part_feats, noise_feats), axis=0)
+
+ part_layouts.append(slice(start_idx, start_idx + part_coords.shape[0]))
+ start_idx += part_coords.shape[0]
+
+ part_coords = torch.from_numpy(part_coords)
+ part_feats = torch.from_numpy(part_feats)
+ all_coords_wnoise.append(part_coords)
+ all_feats_wnoise.append(part_feats)
+
+ # add overall coords and feats
+ overall_feats = np.concatenate((overall_feats, np.full((overall_feats.shape[0], 1), self.noise_mask_score)), axis=1)
+ overall_coords = torch.from_numpy(overall_coords)
+ overall_feats = torch.from_numpy(overall_feats)
+ all_coords_wnoise.insert(0, overall_coords)
+ all_feats_wnoise.insert(0, overall_feats)
+
+ # Concatenate all coordinates and features
+ combined_coords = torch.cat(all_coords_wnoise, dim=0).int()
+ combined_feats = torch.cat(all_feats_wnoise, dim=0).float()
+
+ # Apply normalization if needed
+ if self.normalization is not None:
+ combined_feats = (combined_feats - self.mean) / self.std
+
+ return {
+ 'coords': combined_coords,
+ 'feats': combined_feats,
+ 'part_layouts': part_layouts, # Includes slices for parts and whole model
+ }
+
+ @staticmethod
+ def collate_fn(batch, split_size=None):
+ """
+ Collate function for creating batches from individual samples.
+ Handles sparse tensor construction and layout information.
+
+ Args:
+ batch: List of data samples to be collated
+ split_size: Optional parameter to split large batches based on voxel count
+
+ Returns:
+ Collated batch or list of smaller batches if split_size is provided
+ """
+ # Determine grouping strategy based on whether split_size is specified
+ if split_size is None:
+ # If no split_size, use all samples in a single group
+ # like [0, 1, 2, 3]
+ group_idx = [list(range(len(batch)))]
+ else:
+ # Create balanced groups based on voxel counts to avoid memory issues
+ # This distributes samples across groups to balance computational load
+ group_idx = load_balanced_group_indices([b['coords'].shape[0] for b in batch], split_size)
+
+ packs = []
+ for group in group_idx:
+ # Process each group of samples
+ sub_batch = [batch[i] for i in group]
+ pack = {}
+ pack['part_layouts'] = [b['part_layouts'] for b in sub_batch]
+
+ # Initialize containers for coordinates, features and layout information
+ coords = []
+ feats = []
+ layout = []
+ start = 0
+
+ # Process each sample in the current group
+ for i, b in enumerate(sub_batch):
+ # Add batch index as first dimension to coordinates
+ coords.append(torch.cat( # concatenate the batch index and coordinates along the last dimension
+ [torch.full(
+ (b['coords'].shape[0], 1),
+ i, # the tensor is filled with the batch index "i".
+ dtype=torch.int32),
+ b['coords']]
+ , dim=-1))
+ feats.append(b['feats'])
+
+ layout.append(slice(start, start + b['coords'].shape[0]))
+ start += b['coords'].shape[0]
+
+ # Concatenate all coordinates and features along the first dimension
+ coords = torch.cat(coords)
+ feats = torch.cat(feats)
+
+ # Create a single sparse tensor containing all samples in this group
+ pack['x_0'] = SparseTensor(
+ coords=coords,
+ feats=feats,
+ )
+
+ # Set the shape of the sparse tensor
+ pack['x_0']._shape = torch.Size([len(group), *sub_batch[0]['feats'].shape[1:]])
+ # Register layout information in the sparse tensor's spatial cache
+ pack['x_0'].register_spatial_cache('layout', layout)
+
+ # Process any additional data fields present in the samples
+ keys = [k for k in sub_batch[0].keys() if k not in ['coords', 'feats', 'part_layouts']]
+ for k in keys:
+ if isinstance(sub_batch[0][k], torch.Tensor):
+ pack[k] = torch.stack([b[k] for b in sub_batch])
+ elif isinstance(sub_batch[0][k], list):
+ pack[k] = sum([b[k] for b in sub_batch], [])
+ else:
+ pack[k] = [b[k] for b in sub_batch]
+
+ # Add the processed group to the list of packs
+ packs.append(pack)
+
+ # Return a single pack if no splitting was requested, otherwise return all packs
+ if split_size is None:
+ return packs[0]
+ return packs
+
+class TextConditionedSLat(TextConditionedMixin, SLat):
+ """
+ Text conditioned structured latent dataset.
+ Extends the base SLat class with text conditioning capabilities.
+ """
+ pass
+
+
+class ImageConditionedSLat(ImageConditionedMixin, SLat):
+ """
+ Image conditioned structured latent dataset.
+ Extends the base SLat class with image conditioning capabilities.
+ """
+ pass
diff --git a/OmniPart/training/models/__init__.py b/OmniPart/training/models/__init__.py
new file mode 100644
index 0000000..ac2bf54
--- /dev/null
+++ b/OmniPart/training/models/__init__.py
@@ -0,0 +1,141 @@
+import importlib
+
+__attributes = {
+ 'SparseStructureEncoder': 'sparse_structure_vae',
+ 'SparseStructureDecoder': 'sparse_structure_vae',
+
+ 'SparseStructureFlowModel': 'sparse_structure_flow',
+
+ 'SLatEncoder': 'structured_latent_vae',
+ 'SLatGaussianDecoder': 'structured_latent_vae',
+ 'SLatRadianceFieldDecoder': 'structured_latent_vae',
+ 'SLatMeshDecoder': 'structured_latent_vae',
+ 'ElasticSLatEncoder': 'structured_latent_vae',
+ 'ElasticSLatGaussianDecoder': 'structured_latent_vae',
+ 'ElasticSLatRadianceFieldDecoder': 'structured_latent_vae',
+ 'ElasticSLatMeshDecoder': 'structured_latent_vae',
+
+ 'SLatFlowModel': 'structured_latent_flow',
+ 'ElasticSLatFlowModel': 'structured_latent_flow',
+ 'SLatFlowModelWOPE': 'structured_latent_flow_wo_partpe',
+ 'ElasticSLatFlowModelWOPE': 'structured_latent_flow_wo_partpe',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+def from_pretrained(path: str, **kwargs):
+ """
+ Load a model from a pretrained checkpoint.
+
+ Args:
+ path: The path to the checkpoint. Can be either local path or a Hugging Face model name.
+ NOTE: config file and model file should take the name f'{path}.json' and f'{path}.safetensors' respectively.
+ **kwargs: Additional arguments for the model constructor.
+ """
+ import os
+ import json
+ from safetensors.torch import load_file
+ is_local = os.path.exists(f"{path}.json") and os.path.exists(f"{path}.safetensors")
+
+ if is_local:
+ config_file = f"{path}.json"
+ model_file = f"{path}.safetensors"
+ else:
+ from huggingface_hub import hf_hub_download
+ path_parts = path.split('/')
+ repo_id = f'{path_parts[0]}/{path_parts[1]}'
+ model_name = '/'.join(path_parts[2:])
+ config_file = hf_hub_download(repo_id, f"{model_name}.json")
+ model_file = hf_hub_download(repo_id, f"{model_name}.safetensors")
+
+ with open(config_file, 'r') as f:
+ config = json.load(f)
+ model = __getattr__(config['name'])(**config['args'], **kwargs)
+
+ # Load state dict
+ state_dict = load_file(model_file)
+ model_state_dict = model.state_dict()
+
+ import torch
+ # Handle missing keys with specific initialization methods
+ missing_keys = [k for k in model_state_dict.keys() if k not in state_dict]
+ if missing_keys:
+ print(f"Initializing missing keys in state_dict ({len(missing_keys)} keys):")
+ for k in missing_keys:
+ print(f"shape of {k}: {model_state_dict[k].shape}")
+ # Apply specific initializations based on parameter name
+ if k == "layer_pe.weight":
+ state_dict[k] = torch.normal(mean=0.0, std=0.02, size=model_state_dict[k].shape,
+ device=model_state_dict[k].device,
+ dtype=model_state_dict[k].dtype)
+ print(f" - {k}: initialized with normal distribution (mean=0.0, std=0.02)")
+ elif k in ["layer_pe_proj.weight", "layer_pe_proj.bias",
+ "group_emb_proj.weight", "group_emb_proj.bias"]:
+ state_dict[k] = torch.zeros_like(model_state_dict[k])
+ print(f" - {k}: initialized with zeros")
+ elif k == "group_embedding.weight":
+ state_dict[k] = torch.normal(mean=0.0, std=0.02, size=model_state_dict[k].shape,
+ device=model_state_dict[k].device,
+ dtype=model_state_dict[k].dtype)
+ print(f" - {k}: initialized with normal distribution (mean=0.0, std=0.02)")
+ # Use default initialization patterns for other parameters
+ elif k.endswith('.weight'):
+ state_dict[k] = torch.zeros_like(model_state_dict[k])
+ print(f" - {k}: initialized with zeros")
+ elif k.endswith('.bias'):
+ state_dict[k] = torch.ones_like(model_state_dict[k])
+ print(f" - {k}: initialized with ones")
+ else:
+ state_dict[k] = model_state_dict[k].clone()
+ print(f" - {k}: initialized with default values")
+
+ # Load state dict with strict=False to allow missing keys
+ model.load_state_dict(state_dict, strict=False)
+
+ return model
+
+# For Pylance
+if __name__ == '__main__':
+ from .sparse_structure_vae import (
+ SparseStructureEncoder,
+ SparseStructureDecoder,
+ )
+
+ from .sparse_structure_flow import SparseStructureFlowModel
+
+ from .structured_latent_vae import (
+ SLatEncoder,
+ SLatGaussianDecoder,
+ SLatRadianceFieldDecoder,
+ SLatMeshDecoder,
+ ElasticSLatEncoder,
+ ElasticSLatGaussianDecoder,
+ ElasticSLatRadianceFieldDecoder,
+ ElasticSLatMeshDecoder,
+ )
+
+ from .structured_latent_flow import (
+ SLatFlowModel,
+ ElasticSLatFlowModel,
+ )
+
+ from .structured_latent_flow_wo_partpe import (
+ SLatFlowModelWOPE,
+ ElasticSLatFlowModelWOPE,
+ )
diff --git a/OmniPart/training/models/sparse_elastic_mixin.py b/OmniPart/training/models/sparse_elastic_mixin.py
new file mode 100644
index 0000000..a750fde
--- /dev/null
+++ b/OmniPart/training/models/sparse_elastic_mixin.py
@@ -0,0 +1,61 @@
+from contextlib import contextmanager
+from typing import *
+import math
+from ..modules import sparse as sp
+from ..utils.elastic_utils import ElasticModuleMixin
+
+
+class SparseTransformerElasticMixin(ElasticModuleMixin):
+ """
+ A mixin class for sparse transformers that provides elastic memory management capabilities.
+ Extends the base ElasticModuleMixin with sparse tensor-specific functionality.
+ """
+
+ def _get_input_size(self, x: sp.SparseTensor, *args, **kwargs):
+ """
+ Determines the input size from a sparse tensor.
+
+ Args:
+ x: A SparseTensor input
+ *args, **kwargs: Additional arguments (unused)
+
+ Returns:
+ The size of the feature dimension of the sparse tensor
+ """
+ return x.feats.shape[0]
+
+ @contextmanager
+ def with_mem_ratio(self, mem_ratio=1.0):
+ """
+ Context manager that temporarily adjusts memory usage by enabling gradient checkpointing
+ for a portion of the transformer blocks based on the specified memory ratio.
+
+ Args:
+ mem_ratio: A value between 0 and 1 indicating the desired memory ratio.
+ 1.0 means use all available memory (no checkpointing).
+ Lower values enable more checkpointing to reduce memory usage.
+
+ Yields:
+ The exact memory ratio that could be achieved with the block granularity.
+ """
+ if mem_ratio == 1.0:
+ # No memory optimization needed if ratio is 1.0
+ yield 1.0
+ return
+
+ # Calculate how many blocks should use checkpointing
+ num_blocks = len(self.blocks)
+ num_checkpoint_blocks = min(math.ceil((1 - mem_ratio) * num_blocks) + 1, num_blocks)
+
+ # Calculate the actual memory ratio based on the number of checkpointed blocks
+ exact_mem_ratio = 1 - (num_checkpoint_blocks - 1) / num_blocks
+
+ # Enable checkpointing for the calculated number of blocks
+ for i in range(num_blocks):
+ self.blocks[i].use_checkpoint = i < num_checkpoint_blocks
+
+ yield exact_mem_ratio
+
+ # Restore all blocks to not use checkpointing after context exit
+ for i in range(num_blocks):
+ self.blocks[i].use_checkpoint = False
diff --git a/OmniPart/training/models/sparse_structure_flow.py b/OmniPart/training/models/sparse_structure_flow.py
new file mode 100644
index 0000000..9270250
--- /dev/null
+++ b/OmniPart/training/models/sparse_structure_flow.py
@@ -0,0 +1,287 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..modules.utils import convert_module_to_f16, convert_module_to_f32
+from ..modules.transformer import AbsolutePositionEmbedder, ModulatedTransformerCrossBlock
+from ..modules.spatial import patchify, unpatchify
+
+
+class TimestepEmbedder(nn.Module):
+ """
+ Embeds scalar timesteps into vector representations.
+ This is crucial for diffusion models where the model needs to know
+ which noise level (timestep) it's currently operating at.
+ """
+ def __init__(self, hidden_size, frequency_embedding_size=256):
+ """
+ Initialize the timestep embedder.
+
+ Args:
+ hidden_size: Dimension of the output embeddings
+ frequency_embedding_size: Dimension of the intermediate frequency embeddings
+ """
+ super().__init__()
+ self.mlp = nn.Sequential(
+ nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+ nn.SiLU(),
+ nn.Linear(hidden_size, hidden_size, bias=True),
+ )
+ self.frequency_embedding_size = frequency_embedding_size
+
+ @staticmethod
+ def timestep_embedding(t, dim, max_period=10000):
+ """
+ Create sinusoidal timestep embeddings similar to positional encodings in transformers.
+
+ Args:
+ t: a 1-D Tensor of N indices, one per batch element.
+ These may be fractional.
+ dim: the dimension of the output.
+ max_period: controls the minimum frequency of the embeddings.
+
+ Returns:
+ an (N, D) Tensor of positional embeddings.
+ """
+ # Implementation based on OpenAI's GLIDE repository
+ half = dim // 2
+ freqs = torch.exp(
+ -np.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+ ).to(device=t.device)
+ args = t[:, None].float() * freqs[None]
+ embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+ if dim % 2:
+ embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+ return embedding
+
+ def forward(self, t):
+ """
+ Embed timesteps into vectors.
+
+ Args:
+ t: Timesteps to embed [batch_size]
+
+ Returns:
+ Embedded timesteps [batch_size, hidden_size]
+ """
+ t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+ t_emb = self.mlp(t_freq)
+ return t_emb
+
+
+class SparseStructureFlowModel(nn.Module):
+ """
+ A transformer-based model for processing 3D data with conditional inputs.
+ The model patchifies 3D volumes, processes them with transformer blocks,
+ and then reconstructs the 3D volume at the output.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ cond_channels: int,
+ out_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ patch_size: int = 2,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ share_mod: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ ):
+ """
+ Initialize the Sparse Structure Flow model.
+
+ Args:
+ resolution: Input resolution (assumes cubic inputs of shape [resolution, resolution, resolution])
+ in_channels: Number of input channels
+ model_channels: Number of model's internal channels
+ cond_channels: Number of channels in conditional input
+ out_channels: Number of output channels
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (defaults to model_channels // num_head_channels)
+ num_head_channels: Number of channels per attention head
+ mlp_ratio: Ratio for MLP hidden dimension relative to model_channels
+ patch_size: Size of patches for patchifying the input
+ pe_mode: Type of positional encoding ("ape" for absolute, "rope" for rotary)
+ use_fp16: Whether to use FP16 precision for most operations
+ use_checkpoint: Whether to use gradient checkpointing to save memory
+ share_mod: Whether to share modulation layers across blocks
+ qk_rms_norm: Whether to use RMS normalization for query and key in self-attention
+ qk_rms_norm_cross: Whether to use RMS normalization for query and key in cross-attention
+ """
+ super().__init__()
+ self.resolution = resolution
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.cond_channels = cond_channels
+ self.out_channels = out_channels
+ self.num_blocks = num_blocks
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.patch_size = patch_size
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.qk_rms_norm = qk_rms_norm
+ self.qk_rms_norm_cross = qk_rms_norm_cross
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Timestep embedding network
+ self.t_embedder = TimestepEmbedder(model_channels)
+
+ # Optional shared modulation for all blocks
+ if share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(model_channels, 6 * model_channels, bias=True)
+ )
+
+ # Set up positional encoding
+ if pe_mode == "ape":
+ pos_embedder = AbsolutePositionEmbedder(model_channels, 3)
+ # Create a grid of 3D coordinates for each patch position
+ coords = torch.meshgrid(*[torch.arange(res, device=self.device) for res in [resolution // patch_size] * 3], indexing='ij')
+ coords = torch.stack(coords, dim=-1).reshape(-1, 3)
+ pos_emb = pos_embedder(coords)
+ self.register_buffer("pos_emb", pos_emb)
+
+ # Input projection layer
+ self.input_layer = nn.Linear(in_channels * patch_size**3, model_channels)
+
+ # Transformer blocks with cross-attention for conditioning
+ self.blocks = nn.ModuleList([
+ ModulatedTransformerCrossBlock(
+ model_channels,
+ cond_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode='full',
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ share_mod=share_mod,
+ qk_rms_norm=self.qk_rms_norm,
+ qk_rms_norm_cross=self.qk_rms_norm_cross,
+ )
+ for _ in range(num_blocks)
+ ])
+
+ # Output projection layer
+ self.out_layer = nn.Linear(model_channels, out_channels * patch_size**3)
+
+ # Initialize model weights
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the transformer blocks of the model to float16 for improved efficiency.
+ """
+ self.blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the transformer blocks of the model back to float32 (e.g., for inference).
+ """
+ self.blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model using carefully chosen initialization schemes.
+ """
+ # Initialize transformer layers with Xavier uniform initialization
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ # Initialize timestep embedding MLP with normal distribution
+ nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+ nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+ # Zero-out adaLN modulation layers to ensure stable training initially
+ if self.share_mod:
+ nn.init.constant_(self.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(self.adaLN_modulation[-1].bias, 0)
+ else:
+ for block in self.blocks:
+ nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+ # Zero-out output layers to ensure initial predictions are near zero
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def forward(self, x: torch.Tensor, t: torch.Tensor, cond: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass of the model.
+
+ Args:
+ x: Input tensor of shape [batch_size, in_channels, resolution, resolution, resolution]
+ t: Timestep tensor of shape [batch_size]
+ cond: Conditional input tensor
+
+ Returns:
+ Output tensor of shape [batch_size, out_channels, resolution, resolution, resolution]
+ """
+ # Validate input shape
+ assert [*x.shape] == [x.shape[0], self.in_channels, *[self.resolution] * 3], \
+ f"Input shape mismatch, got {x.shape}, expected {[x.shape[0], self.in_channels, *[self.resolution] * 3]}"
+
+ # Patchify the input volume and reshape for transformer processing
+ h = patchify(x, self.patch_size)
+ h = h.view(*h.shape[:2], -1).permute(0, 2, 1).contiguous() # [B, num_patches, patch_dim]
+
+ # Project to model dimension
+ h = self.input_layer(h)
+
+ # Add positional embeddings
+ h = h + self.pos_emb[None]
+
+ # Get timestep embeddings
+ t_emb = self.t_embedder(t)
+ if self.share_mod:
+ t_emb = self.adaLN_modulation(t_emb)
+
+ # Convert to appropriate dtype for computation
+ t_emb = t_emb.type(self.dtype)
+ h = h.type(self.dtype)
+ cond = cond.type(self.dtype)
+ # print("transfer cond")
+ # print("*" * 20)
+ # print(cond.shape) # torch.Size([4, 4122, 1024])
+ # Process through transformer blocks
+ for block in self.blocks:
+ h = block(h, t_emb, cond)
+
+ # print("transferred ")
+
+ # Convert back to original dtype
+ h = h.type(x.dtype)
+
+ # Final normalization and projection
+ h = F.layer_norm(h, h.shape[-1:])
+ h = self.out_layer(h)
+
+ # Reshape and unpatchify to get final 3D output
+ h = h.permute(0, 2, 1).view(h.shape[0], h.shape[2], *[self.resolution // self.patch_size] * 3)
+ h = unpatchify(h, self.patch_size).contiguous()
+
+ return h
diff --git a/OmniPart/training/models/sparse_structure_vae.py b/OmniPart/training/models/sparse_structure_vae.py
new file mode 100644
index 0000000..7cd408b
--- /dev/null
+++ b/OmniPart/training/models/sparse_structure_vae.py
@@ -0,0 +1,432 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ..modules.norm import GroupNorm32, ChannelLayerNorm32
+from ..modules.spatial import pixel_shuffle_3d
+from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+
+
+def norm_layer(norm_type: str, *args, **kwargs) -> nn.Module:
+ """
+ Return a normalization layer based on the specified type.
+
+ Args:
+ norm_type: Either "group" for GroupNorm or "layer" for LayerNorm
+ *args, **kwargs: Arguments passed to the normalization layer
+
+ Returns:
+ An instance of the requested normalization layer
+ """
+ if norm_type == "group":
+ return GroupNorm32(32, *args, **kwargs)
+ elif norm_type == "layer":
+ return ChannelLayerNorm32(*args, **kwargs)
+ else:
+ raise ValueError(f"Invalid norm type {norm_type}")
+
+
+class ResBlock3d(nn.Module):
+ """
+ 3D Residual Block with two convolutions and a skip connection.
+
+ The block applies normalization, activation, and convolution twice,
+ with a skip connection from the input to the output.
+ """
+ def __init__(
+ self,
+ channels: int,
+ out_channels: Optional[int] = None,
+ norm_type: Literal["group", "layer"] = "layer",
+ ):
+ """
+ Initialize a 3D ResBlock.
+
+ Args:
+ channels: Number of input channels
+ out_channels: Number of output channels (defaults to input channels)
+ norm_type: Type of normalization to use
+ """
+ super().__init__()
+ self.channels = channels
+ self.out_channels = out_channels or channels
+
+ # First normalization and convolution
+ self.norm1 = norm_layer(norm_type, channels)
+ self.norm2 = norm_layer(norm_type, self.out_channels)
+ self.conv1 = nn.Conv3d(channels, self.out_channels, 3, padding=1)
+ # Second convolution is initialized with zeros for stable training
+ self.conv2 = zero_module(nn.Conv3d(self.out_channels, self.out_channels, 3, padding=1))
+ # Skip connection: identity if channels match, otherwise 1x1 conv
+ self.skip_connection = nn.Conv3d(channels, self.out_channels, 1) if channels != self.out_channels else nn.Identity()
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the ResBlock.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Output tensor after residual computation
+ """
+ h = self.norm1(x)
+ h = F.silu(h)
+ h = self.conv1(h)
+ h = self.norm2(h)
+ h = F.silu(h)
+ h = self.conv2(h)
+ h = h + self.skip_connection(x) # Residual connection
+ return h
+
+
+class DownsampleBlock3d(nn.Module):
+ """
+ 3D downsampling block to reduce spatial dimensions by a factor of 2.
+
+ Supports downsampling via strided convolution or average pooling.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ mode: Literal["conv", "avgpool"] = "conv",
+ ):
+ """
+ Initialize a 3D downsampling block.
+
+ Args:
+ in_channels: Number of input channels
+ out_channels: Number of output channels
+ mode: Downsampling method ("conv" or "avgpool")
+ """
+ assert mode in ["conv", "avgpool"], f"Invalid mode {mode}"
+
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ if mode == "conv":
+ self.conv = nn.Conv3d(in_channels, out_channels, 2, stride=2)
+ elif mode == "avgpool":
+ assert in_channels == out_channels, "Pooling mode requires in_channels to be equal to out_channels"
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the downsampling block.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Downsampled tensor
+ """
+ if hasattr(self, "conv"):
+ return self.conv(x)
+ else:
+ return F.avg_pool3d(x, 2)
+
+
+class UpsampleBlock3d(nn.Module):
+ """
+ 3D upsampling block to increase spatial dimensions by a factor of 2.
+
+ Supports upsampling via transposed convolution or nearest-neighbor interpolation.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ mode: Literal["conv", "nearest"] = "conv",
+ ):
+ """
+ Initialize a 3D upsampling block.
+
+ Args:
+ in_channels: Number of input channels
+ out_channels: Number of output channels
+ mode: Upsampling method ("conv" or "nearest")
+ """
+ assert mode in ["conv", "nearest"], f"Invalid mode {mode}"
+
+ super().__init__()
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+
+ if mode == "conv":
+ # For pixel shuffle upsampling, we need 8x channels (2³ = 8)
+ self.conv = nn.Conv3d(in_channels, out_channels*8, 3, padding=1)
+ elif mode == "nearest":
+ assert in_channels == out_channels, "Nearest mode requires in_channels to be equal to out_channels"
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass for the upsampling block.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Upsampled tensor
+ """
+ if hasattr(self, "conv"):
+ x = self.conv(x)
+ return pixel_shuffle_3d(x, 2) # 3D pixel shuffle for upsampling
+ else:
+ return F.interpolate(x, scale_factor=2, mode="nearest")
+
+
+class SparseStructureEncoder(nn.Module):
+ """
+ Encoder for Sparse Structure (\mathcal{E}_S in the paper Sec. 3.3).
+
+ Takes a 3D volume as input and encodes it into a latent distribution (mean and logvar).
+ Can sample from this distribution to get a latent representation.
+
+ Args:
+ in_channels (int): Channels of the input.
+ latent_channels (int): Channels of the latent representation.
+ num_res_blocks (int): Number of residual blocks at each resolution.
+ channels (List[int]): Channels of the encoder blocks.
+ num_res_blocks_middle (int): Number of residual blocks in the middle.
+ norm_type (Literal["group", "layer"]): Type of normalization layer.
+ use_fp16 (bool): Whether to use FP16.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ latent_channels: int,
+ num_res_blocks: int,
+ channels: List[int],
+ num_res_blocks_middle: int = 2,
+ norm_type: Literal["group", "layer"] = "layer",
+ use_fp16: bool = False,
+ ):
+ """
+ Initialize the encoder for sparse structure.
+ """
+ super().__init__()
+ self.in_channels = in_channels
+ self.latent_channels = latent_channels
+ self.num_res_blocks = num_res_blocks
+ self.channels = channels
+ self.num_res_blocks_middle = num_res_blocks_middle
+ self.norm_type = norm_type
+ self.use_fp16 = use_fp16
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Initial projection from input to feature space
+ self.input_layer = nn.Conv3d(in_channels, channels[0], 3, padding=1)
+
+ # Encoder blocks with progressive downsampling
+ self.blocks = nn.ModuleList([])
+ for i, ch in enumerate(channels):
+ # Add residual blocks at the current resolution
+ self.blocks.extend([
+ ResBlock3d(ch, ch)
+ for _ in range(num_res_blocks)
+ ])
+ # Add downsampling block if not at the final resolution
+ if i < len(channels) - 1:
+ self.blocks.append(
+ DownsampleBlock3d(ch, channels[i+1])
+ )
+
+ # Middle blocks at the lowest resolution
+ self.middle_block = nn.Sequential(*[
+ ResBlock3d(channels[-1], channels[-1])
+ for _ in range(num_res_blocks_middle)
+ ])
+
+ # Output layer produces both mean and logvar for the latent distribution
+ self.out_layer = nn.Sequential(
+ norm_layer(norm_type, channels[-1]),
+ nn.SiLU(),
+ nn.Conv3d(channels[-1], latent_channels*2, 3, padding=1)
+ )
+
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16.
+ """
+ self.use_fp16 = True
+ self.dtype = torch.float16
+ self.blocks.apply(convert_module_to_f16)
+ self.middle_block.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model to float32.
+ """
+ self.use_fp16 = False
+ self.dtype = torch.float32
+ self.blocks.apply(convert_module_to_f32)
+ self.middle_block.apply(convert_module_to_f32)
+
+ def forward(self, x: torch.Tensor, sample_posterior: bool = False, return_raw: bool = False) -> torch.Tensor:
+ """
+ Forward pass through the encoder.
+
+ Args:
+ x: Input tensor of shape [B, C, D, H, W]
+ sample_posterior: Whether to sample from the posterior distribution or just return mean
+ return_raw: Whether to return the raw outputs (z, mean, logvar) instead of just z
+
+ Returns:
+ Either the latent representation or a tuple of (z, mean, logvar) if return_raw=True
+ """
+ h = self.input_layer(x)
+ h = h.type(self.dtype) # Convert to FP16 if needed
+
+ # Process through encoder blocks
+ for block in self.blocks:
+ h = block(h)
+ h = self.middle_block(h)
+
+ h = h.type(x.dtype) # Convert back to input dtype
+ h = self.out_layer(h)
+
+ # Split output into mean and log variance
+ mean, logvar = h.chunk(2, dim=1)
+
+ # Sample from the posterior if requested
+ if sample_posterior:
+ std = torch.exp(0.5 * logvar)
+ z = mean + std * torch.randn_like(std) # Reparameterization trick
+ else:
+ z = mean
+
+ if return_raw:
+ return z, mean, logvar
+ return z
+
+
+class SparseStructureDecoder(nn.Module):
+ """
+ Decoder for Sparse Structure (\mathcal{D}_S in the paper Sec. 3.3).
+
+ Takes a latent representation and decodes it back to a 3D volume.
+ Uses a symmetric architecture to the encoder with upsampling instead of downsampling.
+
+ Args:
+ out_channels (int): Channels of the output.
+ latent_channels (int): Channels of the latent representation.
+ num_res_blocks (int): Number of residual blocks at each resolution.
+ channels (List[int]): Channels of the decoder blocks.
+ num_res_blocks_middle (int): Number of residual blocks in the middle.
+ norm_type (Literal["group", "layer"]): Type of normalization layer.
+ use_fp16 (bool): Whether to use FP16.
+ """
+ def __init__(
+ self,
+ out_channels: int,
+ latent_channels: int,
+ num_res_blocks: int,
+ channels: List[int],
+ num_res_blocks_middle: int = 2,
+ norm_type: Literal["group", "layer"] = "layer",
+ use_fp16: bool = False,
+ ):
+ """
+ Initialize the decoder for sparse structure.
+ """
+ super().__init__()
+ self.out_channels = out_channels
+ self.latent_channels = latent_channels
+ self.num_res_blocks = num_res_blocks
+ self.channels = channels
+ self.num_res_blocks_middle = num_res_blocks_middle
+ self.norm_type = norm_type
+ self.use_fp16 = use_fp16
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Initial projection from latent space to feature space
+ self.input_layer = nn.Conv3d(latent_channels, channels[0], 3, padding=1)
+
+ # Middle blocks at the lowest resolution
+ self.middle_block = nn.Sequential(*[
+ ResBlock3d(channels[0], channels[0])
+ for _ in range(num_res_blocks_middle)
+ ])
+
+ # Decoder blocks with progressive upsampling
+ self.blocks = nn.ModuleList([])
+ for i, ch in enumerate(channels):
+ # Add residual blocks at the current resolution
+ self.blocks.extend([
+ ResBlock3d(ch, ch)
+ for _ in range(num_res_blocks)
+ ])
+ # Add upsampling block if not at the final resolution
+ if i < len(channels) - 1:
+ self.blocks.append(
+ UpsampleBlock3d(ch, channels[i+1])
+ )
+
+ # Final output layer to generate the desired output channels
+ self.out_layer = nn.Sequential(
+ norm_layer(norm_type, channels[-1]),
+ nn.SiLU(),
+ nn.Conv3d(channels[-1], out_channels, 3, padding=1)
+ )
+
+ if use_fp16:
+ self.convert_to_fp16()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16.
+ """
+ self.use_fp16 = True
+ self.dtype = torch.float16
+ self.blocks.apply(convert_module_to_f16)
+ self.middle_block.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model to float32.
+ """
+ self.use_fp16 = False
+ self.dtype = torch.float32
+ self.blocks.apply(convert_module_to_f32)
+ self.middle_block.apply(convert_module_to_f32)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Latent representation tensor of shape [B, C, D, H, W]
+
+ Returns:
+ Reconstructed output tensor
+ """
+ h = self.input_layer(x)
+
+ h = h.type(self.dtype) # Convert to FP16 if needed
+
+ h = self.middle_block(h)
+ # Process through decoder blocks
+ for block in self.blocks:
+ h = block(h)
+
+ h = h.type(x.dtype) # Convert back to input dtype
+ h = self.out_layer(h)
+ return h
diff --git a/OmniPart/training/models/structured_latent_flow.py b/OmniPart/training/models/structured_latent_flow.py
new file mode 100644
index 0000000..41294a7
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_flow.py
@@ -0,0 +1,478 @@
+from typing import *
+from einops import rearrange
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+from ..modules.transformer import AbsolutePositionEmbedder
+from ..modules.norm import LayerNorm32
+from ..modules import sparse as sp
+from ..modules.sparse.transformer import ModulatedSparseTransformerCrossBlock
+from .sparse_structure_flow import TimestepEmbedder
+from .sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SparseResBlock3d(nn.Module):
+ """
+ 3D Sparse Residual Block with time embedding conditioning.
+
+ This block performs normalization, convolution operations on sparse tensors,
+ and incorporates time embeddings via adaptive layer normalization.
+ Supports optional up/downsampling.
+ """
+ def __init__(
+ self,
+ channels: int,
+ emb_channels: int,
+ out_channels: Optional[int] = None,
+ downsample: bool = False,
+ upsample: bool = False,
+ ):
+ super().__init__()
+ self.channels = channels
+ self.emb_channels = emb_channels
+ self.out_channels = out_channels or channels
+ self.downsample = downsample
+ self.upsample = upsample
+
+ assert not (downsample and upsample), "Cannot downsample and upsample at the same time"
+
+ # First normalization and convolution
+ self.norm1 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6)
+ self.norm2 = LayerNorm32(self.out_channels, elementwise_affine=False, eps=1e-6)
+ self.conv1 = sp.SparseConv3d(channels, self.out_channels, 3)
+
+ # Second convolution initialized to zero for stable training
+ self.conv2 = zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3))
+
+ # Time embedding projection for adaptive layer norm
+ self.emb_layers = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(emb_channels, 2 * self.out_channels, bias=True),
+ )
+
+ # Skip connection with linear projection if channel dimensions change
+ self.skip_connection = sp.SparseLinear(channels, self.out_channels) if channels != self.out_channels else nn.Identity()
+
+ # Optional up/downsampling
+ self.updown = None
+ if self.downsample:
+ self.updown = sp.SparseDownsample(2)
+ elif self.upsample:
+ self.updown = sp.SparseUpsample(2)
+
+ def _updown(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """Apply up/downsampling if configured"""
+ if self.updown is not None:
+ x = self.updown(x)
+ return x
+
+ def forward(self, x: sp.SparseTensor, emb: torch.Tensor) -> sp.SparseTensor:
+ """
+ Forward pass of the residual block.
+
+ Args:
+ x: Input sparse tensor
+ emb: Time embedding tensor
+
+ Returns:
+ Processed sparse tensor
+ """
+ # print(f"number of points in the input: {x.coords.shape[0]}")
+ # Project embedding to scale and shift factors
+ emb_out = self.emb_layers(emb).type(x.dtype)
+ scale, shift = torch.chunk(emb_out, 2, dim=1)
+
+ # Apply up/downsampling if needed
+ x = self._updown(x)
+
+ # Main processing path
+ h = x.replace(self.norm1(x.feats))
+ h = h.replace(F.silu(h.feats))
+ h = self.conv1(h)
+ # Apply adaptive layer norm using scale and shift from time embedding
+ h = h.replace(self.norm2(h.feats)) * (1 + scale) + shift
+ h = h.replace(F.silu(h.feats))
+ h = self.conv2(h)
+
+ # Residual connection
+ h = h + self.skip_connection(x)
+ # print(f"number of points in the output: {h.coords.shape[0]}")
+
+ return h
+
+
+class SLatFlowModel(nn.Module):
+ """
+ Structured Latent Flow Model for 3D generative modeling.
+
+ This model combines sparse convolutions with transformer blocks and
+ supports conditional generation. It uses a U-Net-like architecture with
+ skip connections and has optional mixed precision support.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ cond_channels: int,
+ out_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ patch_size: int = 2,
+ num_io_res_blocks: int = 2,
+ io_block_channels: List[int] = None,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ use_skip_connection: bool = True,
+ share_mod: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ ):
+ super().__init__()
+ self.resolution = resolution
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.cond_channels = cond_channels
+ self.out_channels = out_channels
+ self.num_blocks = num_blocks
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.patch_size = patch_size
+ self.num_io_res_blocks = num_io_res_blocks
+ self.io_block_channels = io_block_channels
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.use_skip_connection = use_skip_connection
+ self.share_mod = share_mod
+ self.qk_rms_norm = qk_rms_norm
+ self.qk_rms_norm_cross = qk_rms_norm_cross
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Validate configurations
+ if self.io_block_channels is not None:
+ assert int(np.log2(patch_size)) == np.log2(patch_size), "Patch size must be a power of 2"
+ assert np.log2(patch_size) == len(io_block_channels), "Number of IO ResBlocks must match the number of stages"
+
+ # Time step embedder
+ self.t_embedder = TimestepEmbedder(model_channels)
+
+ # Shared modulation for all transformer blocks if enabled
+ if share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(model_channels, 6 * model_channels, bias=True)
+ )
+
+ self.part_max_size = 50
+
+ # Positional embedding for transformer blocks
+ if pe_mode == "ape":
+ self.pos_embedder = AbsolutePositionEmbedder(model_channels)
+ self.layer_pe = nn.Embedding(self.part_max_size + 1, model_channels) # +1 for overall object
+
+ self.layer_pe_proj = nn.Linear(model_channels, model_channels)
+
+ # Mask embedding
+ self.dinov2_hidden_size = 1024
+ self.group_emb_dim = 128
+
+ self.group_embedding = nn.Embedding(self.part_max_size + 1, self.group_emb_dim) # +1 for background
+
+ self.group_emb_proj = nn.Linear(self.group_emb_dim, self.dinov2_hidden_size)
+
+ # Input projection layer
+ self.input_layer = sp.SparseLinear(in_channels, model_channels if io_block_channels is None else io_block_channels[0])
+
+ # Input processing blocks (downsampling path)
+ self.input_blocks = nn.ModuleList([])
+ # print(f"io_block_channels: {io_block_channels}") # io_block_channels: [128]
+ # print(f"model_channels: {model_channels}") # model_channels: 1024
+
+ if io_block_channels is not None:
+ for chs, next_chs in zip(io_block_channels, io_block_channels[1:] + [model_channels]):
+ # Add regular residual blocks at current resolution
+ self.input_blocks.extend([
+ SparseResBlock3d(
+ chs,
+ model_channels,
+ out_channels=chs,
+ )
+ for _ in range(num_io_res_blocks-1)
+ ])
+ # Add downsampling block at the end of each resolution level
+ self.input_blocks.append(
+ SparseResBlock3d(
+ chs,
+ model_channels,
+ out_channels=next_chs,
+ downsample=True,
+ )
+ )
+
+ # Core transformer blocks
+ self.blocks = nn.ModuleList([
+ ModulatedSparseTransformerCrossBlock(
+ model_channels,
+ cond_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode='full',
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ share_mod=self.share_mod,
+ qk_rms_norm=self.qk_rms_norm,
+ qk_rms_norm_cross=self.qk_rms_norm_cross,
+ )
+ for _ in range(num_blocks)
+ ])
+
+ # Output processing blocks (upsampling path)
+ self.out_blocks = nn.ModuleList([])
+ if io_block_channels is not None:
+ for chs, prev_chs in zip(reversed(io_block_channels), [model_channels] + list(reversed(io_block_channels[1:]))):
+ # Add upsampling block at the beginning of each resolution level
+ self.out_blocks.append(
+ SparseResBlock3d(
+ prev_chs * 2 if self.use_skip_connection else prev_chs,
+ model_channels,
+ out_channels=chs,
+ upsample=True,
+ )
+ )
+ # Add regular residual blocks at current resolution
+ self.out_blocks.extend([
+ SparseResBlock3d(
+ chs * 2 if self.use_skip_connection else chs,
+ model_channels,
+ out_channels=chs,
+ )
+ for _ in range(num_io_res_blocks-1)
+ ])
+
+ # Final output projection
+ self.out_layer = sp.SparseLinear(model_channels if io_block_channels is None else io_block_channels[0], out_channels)
+
+ # Initialize model weights
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+ # else:
+ # self.convert_to_fp32()
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 for mixed precision training.
+ """
+ self.input_blocks.apply(convert_module_to_f16)
+ self.blocks.apply(convert_module_to_f16)
+ self.out_blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32.
+ """
+ self.input_blocks.apply(convert_module_to_f32)
+ self.blocks.apply(convert_module_to_f32)
+ self.out_blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights with specialized initialization for different components.
+ """
+ # Initialize transformer layers with Xavier uniform initialization
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ # Initialize timestep embedding MLP with normal distribution
+ nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+ nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+ # Zero-out adaLN modulation layers for stable training
+ if self.share_mod:
+ nn.init.constant_(self.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(self.adaLN_modulation[-1].bias, 0)
+ else:
+ for block in self.blocks:
+ nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+ nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+ # Zero-out output layers for stable training
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ # part embedding initialization
+ nn.init.zeros_(self.layer_pe_proj.weight)
+ nn.init.zeros_(self.layer_pe_proj.bias)
+
+ # Initialize layer positional embeddings
+ self.layer_pe.weight.data.normal_(mean=0.0,std=0.02)
+
+ # Initialize group embedding
+ nn.init.zeros_(self.group_emb_proj.weight)
+ nn.init.zeros_(self.group_emb_proj.bias)
+
+ self.group_embedding.weight.data.normal_(mean=0.0, std=0.02)
+
+ def forward(self, x: sp.SparseTensor, t: torch.Tensor, cond: torch.Tensor, **kwargs) -> sp.SparseTensor:
+ """
+ Forward pass of the Structured Latent Flow model.
+
+ Args:
+ x: Input sparse tensor
+ t: Timestep embedding inputs
+ cond: Conditional input for cross-attention
+ **kwargs: Additional arguments, including part_layouts if available
+
+ Returns:
+ Output sparse tensor
+ """
+
+ input_dtype = x.dtype
+
+ masks = kwargs['ordered_mask_dino'] # [b, h, w]
+
+ # Ensure masks are always long type regardless of source
+ masks = masks.long() # Explicitly convert to long type for embedding
+ masks = rearrange(masks, 'b h w -> b (h w)') # [b, h*w]
+ masks_emb = self.group_embedding(masks) # [b, h*w, 128]
+ masks_emb = self.group_emb_proj(masks_emb) # [b, h*w, 1024]
+ group_emb = torch.zeros((cond.shape[0], cond.shape[1], masks_emb.shape[2]), device=cond.device, dtype=cond.dtype)
+ group_emb[:, :masks_emb.shape[1], :] = masks_emb
+ cond = cond + group_emb
+ cond = cond.type(self.dtype)
+
+ # Store original batch IDs for later restoration
+ original_batch_ids = x.coords[:, 0].clone()
+
+ # Create new batch IDs to represent individual parts (instead of batches)
+ new_batch_ids = torch.zeros_like(original_batch_ids)
+
+ # Assign unique IDs to each part across all batches
+ part_layouts = kwargs['part_layouts']
+ part_id = 0
+ len_before = 0
+ batch_last_partid = []
+ for batch_idx, part_layout in enumerate(part_layouts):
+ for layout_idx, layout in enumerate(part_layout):
+ adjusted_layout = slice(layout.start + len_before, layout.stop + len_before, layout.step)
+ new_batch_ids[adjusted_layout] = part_id
+ part_id += 1
+
+ batch_last_partid.append(part_id)
+ len_before += part_layout[-1].stop
+ # Update coordinates with part-wise batch IDs
+ # x = x.replace(feats=x.feats, coords=torch.cat([new_batch_ids.view(-1, 1), x.coords[:, 1:]], dim=1))
+
+ # Project input to model dimensions and convert to target dtype
+ x = self.input_layer(x).type(self.dtype)
+
+ x = sp.SparseTensor(
+ feats = x.feats,
+ coords = torch.cat([new_batch_ids.view(-1, 1), x.coords[:, 1:]], dim=1),)
+
+ # Process timestep embedding and condition input
+ t_emb = self.t_embedder(t)
+ if self.share_mod:
+ t_emb = self.adaLN_modulation(t_emb)
+ t_emb = t_emb.type(self.dtype)
+ t_emb_updown = []
+ for batch_idx, part_layout in enumerate(part_layouts):
+ t_emb_updown_batch = t_emb[batch_idx:batch_idx+1].repeat(len(part_layout), 1)
+ t_emb_updown.append(t_emb_updown_batch)
+ t_emb_updown = torch.cat(t_emb_updown, dim=0).type(self.dtype)
+
+ # Store features for skip connections
+ skips = []
+
+ # Downsampling path through input blocks
+ for block in self.input_blocks:
+ x = block(x, t_emb_updown)
+ skips.append(x.feats)
+
+ # Store part-wise batch IDs before transformer processing
+ part_wise_batch_ids = x.coords[:, 0].clone()
+
+ # Convert to batch-wise IDs for transformer blocks
+ new_transformer_batch_ids = torch.zeros_like(part_wise_batch_ids)
+ part_ids_in_each_object = torch.zeros_like(part_wise_batch_ids)
+ start_reform = 0
+ last_part_id = 0
+ for part_id in batch_last_partid:
+ mask = (part_wise_batch_ids >= last_part_id) & (part_wise_batch_ids < part_id)
+ new_transformer_batch_ids[mask] = start_reform
+ part_ids_in_each_object[mask] = part_wise_batch_ids[mask] - last_part_id
+ last_part_id = part_id
+ start_reform += 1
+
+ # Update coordinates with batch-wise IDs for transformer processing
+ # h = h.replace(feats=h.feats, coords=torch.cat([new_transformer_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+ h = sp.SparseTensor(
+ feats = x.feats,
+ coords = torch.cat([new_transformer_batch_ids.view(-1, 1), x.coords[:, 1:]], dim=1))
+
+ # Add positional embeddings for transformer blocks
+ if self.pe_mode == "ape":
+ # Add absolute positional embeddings to spatial coordinates
+ h = h + self.pos_embedder(h.coords[:, 1:]).type(self.dtype)
+ # Part-with PE; overall is 0
+ part_pe = self.layer_pe(part_ids_in_each_object)
+ part_pe = self.layer_pe_proj(part_pe)
+ h = h + part_pe.type(self.dtype)
+
+ else:
+ raise NotImplementedError
+
+
+ # Process with transformer blocks
+ for block in self.blocks:
+ h = block(h, t_emb, cond)
+
+ # Restore part-wise batch IDs for upsampling
+ h = x.replace(feats=h.feats, coords=torch.cat([part_wise_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+
+ # Upsampling path with output blocks and skip connections
+ for block, skip in zip(self.out_blocks, reversed(skips)):
+ if self.use_skip_connection:
+ h = block(h.replace(torch.cat([h.feats, skip], dim=1)), t_emb_updown)
+ else:
+ h = block(h, t_emb_updown)
+
+ # Final normalization and output projection
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ h = self.out_layer(h.type(input_dtype))
+
+ # Restore original batch IDs
+ # h = h.replace(feats=h.feats, coords=torch.cat([original_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+ h = sp.SparseTensor(
+ feats = h.feats,
+ coords = torch.cat([original_batch_ids.view(-1, 1), h.coords[:, 1:]], dim=1))
+
+ return h
+
+
+class ElasticSLatFlowModel(SparseTransformerElasticMixin, SLatFlowModel):
+ """
+ Structured Latent Flow Model with elastic memory management.
+
+ This class extends SLatFlowModel with memory-efficient operations,
+ allowing training with limited VRAM by dynamically managing memory
+ allocation for sparse tensors.
+ """
+ pass
\ No newline at end of file
diff --git a/OmniPart/training/models/structured_latent_vae/__init__.py b/OmniPart/training/models/structured_latent_vae/__init__.py
new file mode 100644
index 0000000..4e2ac35
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/__init__.py
@@ -0,0 +1,4 @@
+from .encoder import SLatEncoder, ElasticSLatEncoder
+from .decoder_gs import SLatGaussianDecoder, ElasticSLatGaussianDecoder
+from .decoder_rf import SLatRadianceFieldDecoder, ElasticSLatRadianceFieldDecoder
+from .decoder_mesh import SLatMeshDecoder, ElasticSLatMeshDecoder
diff --git a/OmniPart/training/models/structured_latent_vae/base.py b/OmniPart/training/models/structured_latent_vae/base.py
new file mode 100644
index 0000000..0844e0b
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/base.py
@@ -0,0 +1,173 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ...modules.utils import convert_module_to_f16, convert_module_to_f32
+from ...modules import sparse as sp
+from ...modules.transformer import AbsolutePositionEmbedder
+from ...modules.sparse.transformer import SparseTransformerBlock
+
+
+def block_attn_config(self):
+ """
+ Return the attention configuration for each transformer block.
+
+ Generates configurations for each block based on the specified attention mode:
+ - shift_window: Uses serialized attention with shifting window patterns
+ - shift_sequence: Uses serialized attention with sequence shifts
+ - shift_order: Uses serialized attention with different serialization orders
+ - full: Uses standard full attention (non-sparse)
+ - swin: Uses Swin Transformer-style windowed attention
+
+ Yields:
+ Tuple containing attention mode and its parameters
+ """
+ for i in range(self.num_blocks):
+ if self.attn_mode == "shift_window":
+ yield "serialized", self.window_size, 0, (16 * (i % 2),) * 3, sp.SerializeMode.Z_ORDER
+ elif self.attn_mode == "shift_sequence":
+ yield "serialized", self.window_size, self.window_size // 2 * (i % 2), (0, 0, 0), sp.SerializeMode.Z_ORDER
+ elif self.attn_mode == "shift_order":
+ yield "serialized", self.window_size, 0, (0, 0, 0), sp.SerializeModes[i % 4]
+ elif self.attn_mode == "full":
+ yield "full", None, None, None, None
+ elif self.attn_mode == "swin":
+ yield "windowed", self.window_size, None, self.window_size // 2 * (i % 2), None
+
+
+class SparseTransformerBase(nn.Module):
+ """
+ Sparse Transformer without output layers.
+ Serve as the base class for encoder and decoder.
+
+ Implements a transformer architecture that can work with sparse data structures,
+ supporting various attention mechanisms and positional encodings.
+ """
+ def __init__(
+ self,
+ in_channels: int,
+ model_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ """
+ Initialize the sparse transformer base model.
+
+ Args:
+ in_channels: Number of input channels
+ model_channels: Hidden dimension size
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (calculated from head_channels if None)
+ num_head_channels: Number of channels per attention head
+ mlp_ratio: Ratio for MLP hidden dimension
+ attn_mode: Attention mechanism type
+ window_size: Size of attention window for windowed modes
+ pe_mode: Positional encoding mode (absolute or rotary)
+ use_fp16: Whether to use half precision
+ use_checkpoint: Whether to use gradient checkpointing
+ qk_rms_norm: Whether to use RMS normalization for query and key
+ """
+ super().__init__()
+ self.in_channels = in_channels
+ self.model_channels = model_channels
+ self.num_blocks = num_blocks
+ self.window_size = window_size
+ self.num_heads = num_heads or model_channels // num_head_channels
+ self.mlp_ratio = mlp_ratio
+ self.attn_mode = attn_mode
+ self.pe_mode = pe_mode
+ self.use_fp16 = use_fp16
+ self.use_checkpoint = use_checkpoint
+ self.qk_rms_norm = qk_rms_norm
+ self.dtype = torch.float16 if use_fp16 else torch.float32
+
+ # Create positional embedder if using absolute positional encoding
+ if pe_mode == "ape":
+ self.pos_embedder = AbsolutePositionEmbedder(model_channels)
+
+ # Input projection layer
+ self.input_layer = sp.SparseLinear(in_channels, model_channels)
+
+ # Build transformer blocks with configurations from block_attn_config
+ self.blocks = nn.ModuleList([
+ SparseTransformerBlock(
+ model_channels,
+ num_heads=self.num_heads,
+ mlp_ratio=self.mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ use_checkpoint=self.use_checkpoint,
+ use_rope=(pe_mode == "rope"),
+ qk_rms_norm=self.qk_rms_norm,
+ )
+ for attn_mode, window_size, shift_sequence, shift_window, serialize_mode in block_attn_config(self)
+ ])
+
+ @property
+ def device(self) -> torch.device:
+ """
+ Return the device of the model.
+ """
+ return next(self.parameters()).device
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 precision.
+ Used for mixed precision training.
+ """
+ self.blocks.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32 precision.
+ Used after mixed precision training or inference.
+ """
+ self.blocks.apply(convert_module_to_f32)
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model using Xavier uniform initialization.
+ This helps with training stability and convergence.
+ """
+ def _basic_init(module):
+ if isinstance(module, nn.Linear):
+ torch.nn.init.xavier_uniform_(module.weight)
+ if module.bias is not None:
+ nn.init.constant_(module.bias, 0)
+ self.apply(_basic_init)
+
+ def forward(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """
+ Forward pass through the sparse transformer.
+
+ Args:
+ x: Input sparse tensor
+
+ Returns:
+ Processed sparse tensor after passing through all transformer blocks
+ """
+ # Project input to model dimension
+ h = self.input_layer(x)
+
+ # Add positional embeddings if using absolute positional encoding
+ if self.pe_mode == "ape":
+ h = h + self.pos_embedder(x.coords[:, 1:])
+
+ # Convert to target precision
+ h = h.type(self.dtype)
+
+ # Pass through transformer blocks sequentially
+ for block in self.blocks:
+ h = block(h)
+
+ return h
diff --git a/OmniPart/training/models/structured_latent_vae/decoder_gs.py b/OmniPart/training/models/structured_latent_vae/decoder_gs.py
new file mode 100644
index 0000000..4834c03
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/decoder_gs.py
@@ -0,0 +1,170 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ...modules import sparse as sp
+from ...utils.random_utils import hammersley_sequence
+from .base import SparseTransformerBase
+from ...representations import Gaussian
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatGaussianDecoder(SparseTransformerBase):
+ """
+ Sparse Transformer-based decoder that converts latent codes to 3D Gaussian representations.
+
+ This decoder processes sparse tensors and outputs parameters for Gaussian primitives
+ that can be rendered in 3D space, including positions, features, scaling, rotation,
+ and opacity.
+ """
+ def __init__(
+ self,
+ resolution: int, # The resolution of the 3D grid
+ model_channels: int, # Number of channels in the transformer layers
+ latent_channels: int, # Number of channels in the input latent code
+ num_blocks: int, # Number of transformer blocks
+ num_heads: Optional[int] = None, # Number of attention heads
+ num_head_channels: Optional[int] = 64, # Channels per attention head
+ mlp_ratio: float = 4, # Ratio for MLP size in transformer blocks
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", # Attention mechanism
+ window_size: int = 8, # Size of attention windows for windowed attention
+ pe_mode: Literal["ape", "rope"] = "ape", # Positional encoding mode
+ use_fp16: bool = False, # Whether to use half-precision
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for attention
+ representation_config: dict = None, # Configuration for the Gaussian representation
+ ):
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+ self._calc_layout() # Calculate output tensor layout
+ self.out_layer = sp.SparseLinear(model_channels, self.out_channels) # Final projection layer
+ self._build_perturbation() # Build position perturbation for better initialization
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights, with special handling for output layers.
+ Zero-initializes the output layer for stability.
+ """
+ super().initialize_weights()
+ # Zero-out output layers:
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def _build_perturbation(self) -> None:
+ """
+ Build position perturbation for Gaussian means.
+ Uses Hammersley sequence for quasi-random uniform distribution of points,
+ then transforms to match the desired Gaussian spatial distribution.
+ """
+ perturbation = [hammersley_sequence(3, i, self.rep_config['num_gaussians']) for i in range(self.rep_config['num_gaussians'])]
+ perturbation = torch.tensor(perturbation).float() * 2 - 1 # Scale to [-1, 1]
+ perturbation = perturbation / self.rep_config['voxel_size'] # Scale by voxel size
+ perturbation = torch.atanh(perturbation).to(self.device) # Apply inverse tanh for better gradient flow
+ self.register_buffer('offset_perturbation', perturbation) # Register as buffer (not a parameter)
+
+ def _calc_layout(self) -> None:
+ """
+ Calculate the layout of the output tensor.
+ Defines the shape and size of each Gaussian parameter group (position, features, scaling, rotation, opacity)
+ and their positions in the output tensor.
+ """
+ self.layout = {
+ '_xyz' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_features_dc' : {'shape': (self.rep_config['num_gaussians'], 1, 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_scaling' : {'shape': (self.rep_config['num_gaussians'], 3), 'size': self.rep_config['num_gaussians'] * 3},
+ '_rotation' : {'shape': (self.rep_config['num_gaussians'], 4), 'size': self.rep_config['num_gaussians'] * 4},
+ '_opacity' : {'shape': (self.rep_config['num_gaussians'], 1), 'size': self.rep_config['num_gaussians']},
+ }
+ # Calculate ranges for each parameter group in the flattened output tensor
+ start = 0
+ for k, v in self.layout.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.out_channels = start # Total number of output channels
+
+ def to_representation(self, x: sp.SparseTensor) -> List[Gaussian]:
+ """
+ Convert a batch of network outputs to 3D Gaussian representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of Gaussian representations, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ # Create a new Gaussian representation object with proper configuration
+ representation = Gaussian(
+ sh_degree=0, # No spherical harmonics, just using DC term
+ aabb=[-0.5, -0.5, -0.5, 1.0, 1.0, 1.0], # Axis-aligned bounding box
+ mininum_kernel_size = self.rep_config['3d_filter_kernel_size'],
+ scaling_bias = self.rep_config['scaling_bias'],
+ opacity_bias = self.rep_config['opacity_bias'],
+ scaling_activation = self.rep_config['scaling_activation']
+ )
+ # Get base positions from sparse tensor coordinates
+ xyz = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution
+
+ # Process each parameter group
+ for k, v in self.layout.items():
+ if k == '_xyz':
+ # Handle positions with special perturbation logic
+ offset = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape'])
+ offset = offset * self.rep_config['lr'][k] # Apply learning rate scale
+ if self.rep_config['perturb_offset']:
+ offset = offset + self.offset_perturbation # Add perturbation
+ # Transform offsets through tanh and scale appropriately
+ offset = torch.tanh(offset) / self.resolution * 0.5 * self.rep_config['voxel_size']
+ _xyz = xyz.unsqueeze(1) + offset
+ setattr(representation, k, _xyz.flatten(0, 1))
+ else:
+ # Handle other parameters (features, scaling, rotation, opacity)
+ feats = x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']).flatten(0, 1)
+ feats = feats * self.rep_config['lr'][k] # Apply parameter-specific learning rate
+ setattr(representation, k, feats)
+ ret.append(representation)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[Gaussian]:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Input sparse tensor containing latent codes
+
+ Returns:
+ List of Gaussian representations ready for rendering
+ """
+ h = super().forward(x) # Process through transformer blocks
+ h = h.type(x.dtype) # Ensure consistent dtype
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:])) # Apply layer normalization
+ h = self.out_layer(h) # Project to final output dimensions
+ return self.to_representation(h) # Convert to Gaussian representations
+
+
+class ElasticSLatGaussianDecoder(SparseTransformerElasticMixin, SparseTransformerBase):
+ """
+ Slat VAE Gaussian decoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocations
+ and using efficient sparse operations.
+ """
+ pass
diff --git a/OmniPart/training/models/structured_latent_vae/decoder_mesh.py b/OmniPart/training/models/structured_latent_vae/decoder_mesh.py
new file mode 100644
index 0000000..71547b8
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/decoder_mesh.py
@@ -0,0 +1,209 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ...modules.utils import zero_module, convert_module_to_f16, convert_module_to_f32
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ...representations import MeshExtractResult
+from ...representations.mesh import SparseFeatures2Mesh
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SparseSubdivideBlock3d(nn.Module):
+ """
+ A 3D subdivide block that can subdivide the sparse tensor.
+
+ This block increases the resolution of sparse tensors by a factor of 2,
+ and optionally changes the number of channels.
+
+ Args:
+ channels: channels in the inputs and outputs.
+ resolution: the current resolution of the sparse tensor.
+ out_channels: if specified, the number of output channels.
+ num_groups: the number of groups for the group norm.
+ """
+ def __init__(
+ self,
+ channels: int,
+ resolution: int,
+ out_channels: Optional[int] = None,
+ num_groups: int = 32
+ ):
+ super().__init__()
+ self.channels = channels
+ self.resolution = resolution
+ self.out_resolution = resolution * 2
+ self.out_channels = out_channels or channels
+
+ # Normalization and activation before subdivision
+ self.act_layers = nn.Sequential(
+ sp.SparseGroupNorm32(num_groups, channels),
+ sp.SparseSiLU()
+ )
+
+ # Subdivision operator that doubles the resolution
+ self.sub = sp.SparseSubdivide()
+
+ # Post-subdivision processing with residual connection
+ self.out_layers = nn.Sequential(
+ sp.SparseConv3d(channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}"),
+ sp.SparseGroupNorm32(num_groups, self.out_channels),
+ sp.SparseSiLU(),
+ zero_module(sp.SparseConv3d(self.out_channels, self.out_channels, 3, indice_key=f"res_{self.out_resolution}")),
+ )
+
+ # Skip connection that handles potential channel dimension changes
+ if self.out_channels == channels:
+ self.skip_connection = nn.Identity()
+ else:
+ self.skip_connection = sp.SparseConv3d(channels, self.out_channels, 1, indice_key=f"res_{self.out_resolution}")
+
+ def forward(self, x: sp.SparseTensor) -> sp.SparseTensor:
+ """
+ Apply the block to a Tensor, conditioned on a timestep embedding.
+
+ Args:
+ x: an [N x C x ...] Tensor of features.
+ Returns:
+ an [N x C x ...] Tensor of outputs with doubled resolution.
+ """
+ h = self.act_layers(x)
+ h = self.sub(h) # Double the resolution
+ x = self.sub(x) # Also subdivide the input for skip connection
+ h = self.out_layers(h)
+ h = h + self.skip_connection(x) # Add skip connection
+ return h
+
+
+class SLatMeshDecoder(SparseTransformerBase):
+ """
+ Structured Latent Mesh Decoder that transforms latent codes into 3D meshes.
+
+ Uses sparse transformers followed by upsampling blocks to generate high-resolution
+ features that are then converted to meshes.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ model_channels: int,
+ latent_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin",
+ window_size: int = 8,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ representation_config: dict = None,
+ ):
+ # Initialize the transformer backbone
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+
+ # Mesh extractor to convert features to mesh representation
+ self.mesh_extractor = SparseFeatures2Mesh(res=self.resolution*4, use_color=self.rep_config.get('use_color', False))
+ self.out_channels = self.mesh_extractor.feats_channels
+
+ # Upsampling blocks that progressively increase resolution
+ self.upsample = nn.ModuleList([
+ SparseSubdivideBlock3d(
+ channels=model_channels,
+ resolution=resolution,
+ out_channels=model_channels // 4
+ ),
+ SparseSubdivideBlock3d(
+ channels=model_channels // 4,
+ resolution=resolution * 2,
+ out_channels=model_channels // 8
+ )
+ ])
+
+ # Final layer to map features to mesh attributes
+ self.out_layer = sp.SparseLinear(model_channels // 8, self.out_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """Initialize model weights, with special handling for output layers."""
+ super().initialize_weights()
+ # Zero-out output layers for stable training
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def convert_to_fp16(self) -> None:
+ """
+ Convert the torso of the model to float16 for memory efficiency.
+ """
+ super().convert_to_fp16()
+ self.upsample.apply(convert_module_to_f16)
+
+ def convert_to_fp32(self) -> None:
+ """
+ Convert the torso of the model back to float32 for precision.
+ """
+ super().convert_to_fp32()
+ self.upsample.apply(convert_module_to_f32)
+
+ def to_representation(self, x: sp.SparseTensor) -> List[MeshExtractResult]:
+ """
+ Convert a batch of network outputs to 3D mesh representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of mesh representation results, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ mesh = self.mesh_extractor(x[i], training=self.training)
+ ret.append(mesh)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[MeshExtractResult]:
+ """
+ Process latent codes through the decoder and extract meshes.
+
+ Args:
+ x: Input sparse tensor of latent codes
+
+ Returns:
+ List of extracted mesh representations
+ """
+ h = super().forward(x) # Process through transformer blocks
+ for block in self.upsample:
+ h = block(h) # Progressively increase resolution
+ h = h.type(x.dtype)
+ h = self.out_layer(h) # Final projection to mesh features
+ return self.to_representation(h) # Convert features to meshes
+
+
+class ElasticSLatMeshDecoder(SparseTransformerElasticMixin, SLatMeshDecoder):
+ """
+ Structured Latent Mesh Decoder with elastic memory management.
+
+ This variant uses elastic sparse tensor operations to reduce memory usage
+ during training, making it suitable for environments with limited VRAM.
+ """
+ pass
diff --git a/OmniPart/training/models/structured_latent_vae/decoder_rf.py b/OmniPart/training/models/structured_latent_vae/decoder_rf.py
new file mode 100644
index 0000000..9fe309c
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/decoder_rf.py
@@ -0,0 +1,149 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ...representations import Strivec
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatRadianceFieldDecoder(SparseTransformerBase):
+ """
+ A sparse transformer-based decoder for converting latent codes to radiance field representations.
+ This decoder processes sparse tensors through transformer blocks and outputs parameters for Strivec representation.
+ """
+ def __init__(
+ self,
+ resolution: int, # Resolution of the output 3D grid
+ model_channels: int, # Number of channels in the model's hidden layers
+ latent_channels: int, # Number of channels in the latent code
+ num_blocks: int, # Number of transformer blocks
+ num_heads: Optional[int] = None, # Number of attention heads
+ num_head_channels: Optional[int] = 64, # Channels per attention head
+ mlp_ratio: float = 4, # Ratio for MLP hidden dimension
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin", # Attention mode
+ window_size: int = 8, # Size of local attention window
+ pe_mode: Literal["ape", "rope"] = "ape", # Positional encoding mode
+ use_fp16: bool = False, # Whether to use half precision
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing
+ qk_rms_norm: bool = False, # Whether to normalize query and key
+ representation_config: dict = None, # Configuration for output representation
+ ):
+ # Initialize the base sparse transformer
+ super().__init__(
+ in_channels=latent_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ self.rep_config = representation_config
+ self._calc_layout() # Calculate the output layout
+ # Final layer to project features to the output representation
+ self.out_layer = sp.SparseLinear(model_channels, self.out_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize the weights of the model.
+ Zero-initializes the output layer for better training stability.
+ """
+ super().initialize_weights()
+ # Zero-out output layers for better training stability
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def _calc_layout(self) -> None:
+ """
+ Calculate the output tensor layout for the Strivec representation.
+ Defines the shapes and sizes of different components and their positions in the output tensor.
+ """
+ self.layout = {
+ 'trivec': {'shape': (self.rep_config['rank'], 3, self.rep_config['dim']), 'size': self.rep_config['rank'] * 3 * self.rep_config['dim']},
+ 'density': {'shape': (self.rep_config['rank'],), 'size': self.rep_config['rank']},
+ 'features_dc': {'shape': (self.rep_config['rank'], 1, 3), 'size': self.rep_config['rank'] * 3},
+ }
+ # Calculate the range (start, end) indices for each component in the output tensor
+ start = 0
+ for k, v in self.layout.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.out_channels = start
+
+ def to_representation(self, x: sp.SparseTensor) -> List[Strivec]:
+ """
+ Convert a batch of network outputs to 3D representations.
+
+ Args:
+ x: The [N x * x C] sparse tensor output by the network.
+
+ Returns:
+ list of Strivec representations, one per batch item
+ """
+ ret = []
+ for i in range(x.shape[0]):
+ # Create a new Strivec representation
+ representation = Strivec(
+ sh_degree=0,
+ resolution=self.resolution,
+ aabb=[-0.5, -0.5, -0.5, 1, 1, 1], # Axis-aligned bounding box
+ rank=self.rep_config['rank'],
+ dim=self.rep_config['dim'],
+ device='cuda',
+ )
+ representation.density_shift = 0.0
+ # Set position from sparse coordinates (normalized to [0,1])
+ representation.position = (x.coords[x.layout[i]][:, 1:].float() + 0.5) / self.resolution
+ # Set depth (octree level) based on resolution
+ representation.depth = torch.full((representation.position.shape[0], 1), int(np.log2(self.resolution)), dtype=torch.uint8, device='cuda')
+
+ # Extract each component from the output features according to the layout
+ for k, v in self.layout.items():
+ setattr(representation, k, x.feats[x.layout[i]][:, v['range'][0]:v['range'][1]].reshape(-1, *v['shape']))
+
+ # Add 1 to trivec for stability (prevent zero vectors)
+ representation.trivec = representation.trivec + 1
+ ret.append(representation)
+ return ret
+
+ def forward(self, x: sp.SparseTensor) -> List[Strivec]:
+ """
+ Forward pass through the decoder.
+
+ Args:
+ x: Input sparse tensor containing latent codes
+
+ Returns:
+ List of Strivec representations
+ """
+ # Pass through transformer backbone
+ h = super().forward(x)
+ h = h.type(x.dtype)
+ # Layer normalization on feature dimension
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ # Final projection to output features
+ h = self.out_layer(h)
+ # Convert network output to Strivec representations
+ return self.to_representation(h)
+
+
+class ElasticSLatRadianceFieldDecoder(SparseTransformerElasticMixin, SLatRadianceFieldDecoder):
+ """
+ Slat VAE Radiance Field Decoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocation
+ and performing operations in chunks when needed.
+ """
+ pass
diff --git a/OmniPart/training/models/structured_latent_vae/encoder.py b/OmniPart/training/models/structured_latent_vae/encoder.py
new file mode 100644
index 0000000..6393aad
--- /dev/null
+++ b/OmniPart/training/models/structured_latent_vae/encoder.py
@@ -0,0 +1,128 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ...modules import sparse as sp
+from .base import SparseTransformerBase
+from ..sparse_elastic_mixin import SparseTransformerElasticMixin
+
+
+class SLatEncoder(SparseTransformerBase):
+ """
+ Sparse Latent Variable Encoder that uses transformer architecture to encode
+ sparse data into a latent distribution.
+ """
+ def __init__(
+ self,
+ resolution: int,
+ in_channels: int,
+ model_channels: int,
+ latent_channels: int,
+ num_blocks: int,
+ num_heads: Optional[int] = None,
+ num_head_channels: Optional[int] = 64,
+ mlp_ratio: float = 4,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "swin",
+ window_size: int = 8,
+ pe_mode: Literal["ape", "rope"] = "ape",
+ use_fp16: bool = False,
+ use_checkpoint: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ """
+ Initialize the Sparse Latent Encoder.
+
+ Args:
+ resolution: Input data resolution
+ in_channels: Number of input feature channels
+ model_channels: Number of internal model feature channels
+ latent_channels: Dimension of the latent space
+ num_blocks: Number of transformer blocks
+ num_heads: Number of attention heads (optional)
+ num_head_channels: Channels per attention head if num_heads is None
+ mlp_ratio: Expansion ratio for MLP in transformer blocks
+ attn_mode: Type of attention mechanism to use
+ window_size: Size of attention windows if using windowed attention
+ pe_mode: Positional encoding mode (absolute or relative)
+ use_fp16: Whether to use half-precision floating point
+ use_checkpoint: Whether to use gradient checkpointing
+ qk_rms_norm: Whether to apply RMS normalization to query and key
+ """
+ super().__init__(
+ in_channels=in_channels,
+ model_channels=model_channels,
+ num_blocks=num_blocks,
+ num_heads=num_heads,
+ num_head_channels=num_head_channels,
+ mlp_ratio=mlp_ratio,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ pe_mode=pe_mode,
+ use_fp16=use_fp16,
+ use_checkpoint=use_checkpoint,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.resolution = resolution
+ # Output layer projects to twice the latent dimension (for mean and logvar)
+ self.out_layer = sp.SparseLinear(model_channels, 2 * latent_channels)
+
+ self.initialize_weights()
+ if use_fp16:
+ self.convert_to_fp16()
+
+ def initialize_weights(self) -> None:
+ """
+ Initialize model weights with special handling for output layer.
+ The output layer weights are initialized to zero to stabilize training.
+ """
+ super().initialize_weights()
+ # Zero-out output layers for better training stability
+ nn.init.constant_(self.out_layer.weight, 0)
+ nn.init.constant_(self.out_layer.bias, 0)
+
+ def forward(self, x: sp.SparseTensor, sample_posterior=True, return_raw=False):
+ """
+ Forward pass through the encoder.
+
+ Args:
+ x: Input sparse tensor
+ sample_posterior: Whether to sample from posterior or return mean
+ return_raw: Whether to return mean and logvar in addition to samples
+
+ Returns:
+ If return_raw is True:
+ - sampled latent variables, mean, and logvar
+ Otherwise:
+ - sampled latent variables only
+ """
+ # Process through transformer blocks
+ h = super().forward(x)
+ h = h.type(x.dtype)
+ # Apply layer normalization to features
+ h = h.replace(F.layer_norm(h.feats, h.feats.shape[-1:]))
+ h = self.out_layer(h)
+
+ # Split output into mean and logvar components
+ mean, logvar = h.feats.chunk(2, dim=-1)
+ if sample_posterior:
+ # Reparameterization trick: z = mean + std * epsilon
+ std = torch.exp(0.5 * logvar)
+ z = mean + std * torch.randn_like(std)
+ else:
+ # Use mean directly without sampling
+ z = mean
+ z = h.replace(z)
+
+ if return_raw:
+ return z, mean, logvar
+ else:
+ return z
+
+
+class ElasticSLatEncoder(SparseTransformerElasticMixin, SLatEncoder):
+ """
+ SLat VAE encoder with elastic memory management.
+ Used for training with low VRAM by dynamically managing memory allocation
+ and performing operations with reduced memory footprint.
+ """
+ pass
diff --git a/OmniPart/training/modules/attention/__init__.py b/OmniPart/training/modules/attention/__init__.py
new file mode 100644
index 0000000..f452320
--- /dev/null
+++ b/OmniPart/training/modules/attention/__init__.py
@@ -0,0 +1,36 @@
+from typing import *
+
+BACKEND = 'flash_attn'
+DEBUG = False
+
+def __from_env():
+ import os
+
+ global BACKEND
+ global DEBUG
+
+ env_attn_backend = os.environ.get('ATTN_BACKEND')
+ env_sttn_debug = os.environ.get('ATTN_DEBUG')
+
+ if env_attn_backend is not None and env_attn_backend in ['xformers', 'flash_attn', 'sdpa', 'naive']:
+ BACKEND = env_attn_backend
+ if env_sttn_debug is not None:
+ DEBUG = env_sttn_debug == '1'
+
+ print(f"[ATTENTION] Using backend: {BACKEND}")
+
+
+__from_env()
+
+
+def set_backend(backend: Literal['xformers', 'flash_attn']):
+ global BACKEND
+ BACKEND = backend
+
+def set_debug(debug: bool):
+ global DEBUG
+ DEBUG = debug
+
+
+from .full_attn import *
+from .modules import *
diff --git a/OmniPart/training/modules/attention/full_attn.py b/OmniPart/training/modules/attention/full_attn.py
new file mode 100644
index 0000000..32d4752
--- /dev/null
+++ b/OmniPart/training/modules/attention/full_attn.py
@@ -0,0 +1,190 @@
+from typing import *
+import torch
+import math
+from . import DEBUG, BACKEND # Import configuration variables
+
+# Select the appropriate attention backend based on configuration
+if BACKEND == 'xformers':
+ import xformers.ops as xops
+elif BACKEND == 'flash_attn':
+ import flash_attn
+elif BACKEND == 'sdpa':
+ from torch.nn.functional import scaled_dot_product_attention as sdpa
+elif BACKEND == 'naive':
+ pass # Will use the naive implementation defined below
+else:
+ raise ValueError(f"Unknown attention backend: {BACKEND}")
+
+
+__all__ = [
+ 'scaled_dot_product_attention', # Only expose this main function
+]
+
+
+def _naive_sdpa(q, k, v):
+ """
+ Naive implementation of scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): Query tensor
+ k (torch.Tensor): Key tensor
+ v (torch.Tensor): Value tensor
+
+ Returns:
+ torch.Tensor: Output attention tensor
+
+ Note:
+ This implementation follows the standard attention formula:
+ Attention(Q,K,V) = softmax(QK^T/sqrt(d_k))V
+ """
+ q = q.permute(0, 2, 1, 3) # [N, H, L, C] - Reshape for batched matrix multiplication
+ k = k.permute(0, 2, 1, 3) # [N, H, L, C]
+ v = v.permute(0, 2, 1, 3) # [N, H, L, C]
+ scale_factor = 1 / math.sqrt(q.size(-1)) # Scale factor to prevent softmax saturation
+ attn_weight = q @ k.transpose(-2, -1) * scale_factor # Compute scaled dot product
+ attn_weight = torch.softmax(attn_weight, dim=-1) # Apply softmax to get attention weights
+ out = attn_weight @ v # Apply attention weights to values
+ out = out.permute(0, 2, 1, 3) # [N, L, H, C] - Restore original dimension order
+ return out
+
+
+@overload
+def scaled_dot_product_attention(qkv: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ qkv (torch.Tensor): A [N, L, 3, H, C] tensor containing Qs, Ks, and Vs.
+ """
+ ...
+
+@overload
+def scaled_dot_product_attention(q: torch.Tensor, kv: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, C] tensor containing Qs.
+ kv (torch.Tensor): A [N, L, 2, H, C] tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def scaled_dot_product_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, Ci] tensor containing Qs.
+ k (torch.Tensor): A [N, L, H, Ci] tensor containing Ks.
+ v (torch.Tensor): A [N, L, H, Co] tensor containing Vs.
+
+ Note:
+ k and v are assumed to have the same coordinate map.
+ """
+ ...
+
+def scaled_dot_product_attention(*args, **kwargs):
+ """
+ Unified interface for scaled dot product attention with multiple calling patterns.
+
+ Supports three calling patterns:
+ 1. Single combined QKV tensor: scaled_dot_product_attention(qkv)
+ 2. Separate Q and combined KV: scaled_dot_product_attention(q, kv)
+ 3. Separate Q, K, V tensors: scaled_dot_product_attention(q, k, v)
+
+ The function automatically selects the appropriate backend implementation
+ based on the BACKEND configuration.
+ """
+ # Define expected argument names for each calling pattern
+ arg_names_dict = {
+ 1: ['qkv'],
+ 2: ['q', 'kv'],
+ 3: ['q', 'k', 'v']
+ }
+ num_all_args = len(args) + len(kwargs)
+ assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3"
+ for key in arg_names_dict[num_all_args][len(args):]:
+ assert key in kwargs, f"Missing argument {key}"
+
+ # Handle case 1: Single combined QKV tensor
+ if num_all_args == 1:
+ qkv = args[0] if len(args) > 0 else kwargs['qkv']
+ assert len(qkv.shape) == 5 and qkv.shape[2] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, L, 3, H, C]"
+ device = qkv.device
+
+ # Handle case 2: Separate Q and combined KV tensors
+ elif num_all_args == 2:
+ # print("handle case 2")
+ q = args[0] if len(args) > 0 else kwargs['q']
+ kv = args[1] if len(args) > 1 else kwargs['kv']
+ assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}"
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]"
+ assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]"
+ device = q.device
+
+ # Handle case 3: Separate Q, K, V tensors
+ elif num_all_args == 3:
+ # print("handle case 3")
+ q = args[0] if len(args) > 0 else kwargs['q']
+ k = args[1] if len(args) > 1 else kwargs['k']
+ v = args[2] if len(args) > 2 else kwargs['v']
+ assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}"
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]"
+ assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]"
+ assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]"
+ device = q.device
+
+ # print("no problem")
+ # Use xformers backend
+ if BACKEND == 'xformers':
+ if num_all_args == 1:
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor into separate Q, K, V
+ elif num_all_args == 2:
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ out = xops.memory_efficient_attention(q, k, v)
+
+ # Use Flash Attention backend
+ elif BACKEND == 'flash_attn':
+ # print("flash_attn")
+ if num_all_args == 1:
+ # print("case 1")
+ out = flash_attn.flash_attn_qkvpacked_func(qkv) # Use packed QKV format
+ elif num_all_args == 2:
+ # print("case 2")
+ out = flash_attn.flash_attn_kvpacked_func(q, kv) # Use packed KV format with separate Q
+ elif num_all_args == 3:
+ # print("case 3")
+ out = flash_attn.flash_attn_func(q, k, v) # Use fully separate Q, K, V
+
+ # Use PyTorch's native scaled dot product attention
+ elif BACKEND == 'sdpa':
+ # print("sdpa")
+ if num_all_args == 1:
+ # print("case 1")
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor
+ elif num_all_args == 2:
+ # print("case 2")
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ # PyTorch's SDPA expects tensors in format [N, H, L, C]
+ q = q.permute(0, 2, 1, 3) # [N, H, L, C]
+ k = k.permute(0, 2, 1, 3) # [N, H, L, C]
+ v = v.permute(0, 2, 1, 3) # [N, H, L, C]
+ out = sdpa(q, k, v) # [N, H, L, C]
+ out = out.permute(0, 2, 1, 3) # Convert back to [N, L, H, C]
+
+ # Use naive implementation
+ elif BACKEND == 'naive':
+ # print("naive")
+ if num_all_args == 1:
+ # print("case 1")
+ q, k, v = qkv.unbind(dim=2) # Split combined tensor
+ elif num_all_args == 2:
+ # print("case 2")
+ k, v = kv.unbind(dim=2) # Split combined KV tensor
+ out = _naive_sdpa(q, k, v) # Call the naive implementation
+
+ else:
+ raise ValueError(f"Unknown attention module: {BACKEND}")
+ # print("no problem")
+ return out
diff --git a/OmniPart/training/modules/attention/modules.py b/OmniPart/training/modules/attention/modules.py
new file mode 100644
index 0000000..72aa2f2
--- /dev/null
+++ b/OmniPart/training/modules/attention/modules.py
@@ -0,0 +1,249 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .full_attn import scaled_dot_product_attention
+
+
+class MultiHeadRMSNorm(nn.Module):
+ """
+ Multi-head RMS normalization layer that applies per-head normalization.
+ This helps stabilize attention computations by normalizing query and key vectors.
+
+ Args:
+ dim (int): The dimensionality of each head
+ heads (int): Number of attention heads
+ """
+ def __init__(self, dim: int, heads: int):
+ super().__init__()
+ self.scale = dim ** 0.5
+ self.gamma = nn.Parameter(torch.ones(heads, dim))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Apply RMS normalization along the last dimension.
+
+ Args:
+ x (torch.Tensor): Input tensor of shape [..., dim]
+
+ Returns:
+ torch.Tensor: Normalized tensor with the same shape
+ """
+ return (F.normalize(x.float(), dim = -1) * self.gamma * self.scale).to(x.dtype)
+
+
+class RotaryPositionEmbedder(nn.Module):
+ """
+ Implements Rotary Position Embedding (RoPE), which encodes position information
+ into the query and key tensors through a rotation-based approach.
+
+ Args:
+ hidden_size (int): Size of the hidden dimension
+ in_channels (int): Number of input channels, defaults to 3
+ """
+ def __init__(self, hidden_size: int, in_channels: int = 3):
+ super().__init__()
+ assert hidden_size % 2 == 0, "Hidden size must be divisible by 2"
+ self.hidden_size = hidden_size
+ self.in_channels = in_channels
+ self.freq_dim = hidden_size // in_channels // 2
+ # Calculate frequency bands on a log scale
+ self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim
+ self.freqs = 1.0 / (10000 ** self.freqs)
+
+ def _get_phases(self, indices: torch.Tensor) -> torch.Tensor:
+ """
+ Compute phase shifts based on position indices.
+
+ Args:
+ indices (torch.Tensor): Position indices
+
+ Returns:
+ torch.Tensor: Complex tensor containing phase information
+ """
+ self.freqs = self.freqs.to(indices.device)
+ phases = torch.outer(indices, self.freqs)
+ phases = torch.polar(torch.ones_like(phases), phases)
+ return phases
+
+ def _rotary_embedding(self, x: torch.Tensor, phases: torch.Tensor) -> torch.Tensor:
+ """
+ Apply rotary embeddings to the input tensor.
+
+ Args:
+ x (torch.Tensor): Input tensor
+ phases (torch.Tensor): Phase tensor from _get_phases
+
+ Returns:
+ torch.Tensor: Tensor with rotary embeddings applied
+ """
+ x_complex = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2))
+ x_rotated = x_complex * phases
+ x_embed = torch.view_as_real(x_rotated).reshape(*x_rotated.shape[:-1], -1).to(x.dtype)
+ return x_embed
+
+ def forward(self, q: torch.Tensor, k: torch.Tensor, indices: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Apply rotary position embeddings to query and key tensors.
+
+ Args:
+ q (torch.Tensor): [..., N, D] tensor of queries
+ k (torch.Tensor): [..., N, D] tensor of keys
+ indices (torch.Tensor): [..., N, C] tensor of spatial positions. If None,
+ sequential indices will be used.
+
+ Returns:
+ Tuple[torch.Tensor, torch.Tensor]: Position-encoded query and key tensors
+ """
+ if indices is None:
+ indices = torch.arange(q.shape[-2], device=q.device)
+ if len(q.shape) > 2:
+ indices = indices.unsqueeze(0).expand(q.shape[:-2] + (-1,))
+
+ phases = self._get_phases(indices.reshape(-1)).reshape(*indices.shape[:-1], -1)
+ if phases.shape[1] < self.hidden_size // 2:
+ phases = torch.cat([phases, torch.polar(
+ torch.ones(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device),
+ torch.zeros(*phases.shape[:-1], self.hidden_size // 2 - phases.shape[1], device=phases.device)
+ )], dim=-1)
+ q_embed = self._rotary_embedding(q, phases)
+ k_embed = self._rotary_embedding(k, phases)
+ return q_embed, k_embed
+
+
+class MultiHeadAttention(nn.Module):
+ """
+ Flexible multi-head attention implementation supporting both self-attention
+ and cross-attention with various optimizations.
+
+ Args:
+ channels (int): Number of input/output channels
+ num_heads (int): Number of attention heads
+ ctx_channels (Optional[int]): Number of context channels for cross-attention
+ type (str): Type of attention, either "self" or "cross"
+ attn_mode (str): Attention computation mode, either "full" or "windowed"
+ window_size (Optional[int]): Size of attention window if windowed mode is used
+ shift_window (Optional[Tuple[int, int, int]]): Shift amount for windowed attention
+ qkv_bias (bool): Whether to include bias in QKV projections
+ use_rope (bool): Whether to use rotary position embeddings
+ qk_rms_norm (bool): Whether to apply RMS normalization to Q and K
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ ctx_channels: Optional[int]=None,
+ type: Literal["self", "cross"] = "self",
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ qkv_bias: bool = True,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ super().__init__()
+ assert channels % num_heads == 0
+ assert type in ["self", "cross"], f"Invalid attention type: {type}"
+ assert attn_mode in ["full", "windowed"], f"Invalid attention mode: {attn_mode}"
+ assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention"
+
+ if attn_mode == "windowed":
+ raise NotImplementedError("Windowed attention is not yet implemented")
+
+ self.channels = channels
+ self.head_dim = channels // num_heads
+ self.ctx_channels = ctx_channels if ctx_channels is not None else channels
+ self.num_heads = num_heads
+ self._type = type
+ self.attn_mode = attn_mode
+ self.window_size = window_size
+ self.shift_window = shift_window
+ self.use_rope = use_rope
+ self.qk_rms_norm = qk_rms_norm
+
+ # Initialize projection layers based on attention type
+ if self._type == "self":
+ # For self-attention, create a single QKV projection
+ self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias)
+ else:
+ # For cross-attention, create separate projections for query and key-value
+ self.to_q = nn.Linear(channels, channels, bias=qkv_bias)
+ self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias)
+
+ # Optional RMS normalization for stabilizing attention
+ if self.qk_rms_norm:
+ self.q_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads)
+ self.k_rms_norm = MultiHeadRMSNorm(self.head_dim, num_heads)
+
+ # Output projection
+ self.to_out = nn.Linear(channels, channels)
+
+ # Optional rotary position embeddings
+ if use_rope:
+ self.rope = RotaryPositionEmbedder(channels)
+
+ def forward(self, x: torch.Tensor, context: Optional[torch.Tensor] = None, indices: Optional[torch.Tensor] = None) -> torch.Tensor:
+ """
+ Apply multi-head attention to the input tensor.
+
+ Args:
+ x (torch.Tensor): Input tensor of shape [B, L, C]
+ context (Optional[torch.Tensor]): Context tensor for cross-attention
+ indices (Optional[torch.Tensor]): Position indices for rotary embeddings
+
+ Returns:
+ torch.Tensor: Output tensor of shape [B, L, C]
+ """
+ B, L, C = x.shape
+ if self._type == "self":
+ # Self-attention path
+ qkv = self.to_qkv(x)
+ qkv = qkv.reshape(B, L, 3, self.num_heads, -1)
+ if self.use_rope:
+ # Apply rotary position embeddings if enabled
+ q, k, v = qkv.unbind(dim=2)
+ q, k = self.rope(q, k, indices)
+ qkv = torch.stack([q, k, v], dim=2)
+ if self.attn_mode == "full":
+ if self.qk_rms_norm:
+ # Apply RMS normalization to queries and keys if enabled
+ q, k, v = qkv.unbind(dim=2)
+ q = self.q_rms_norm(q)
+ k = self.k_rms_norm(k)
+ h = scaled_dot_product_attention(q, k, v)
+ else:
+ # Standard attention with combined QKV tensor
+ h = scaled_dot_product_attention(qkv)
+ elif self.attn_mode == "windowed":
+ raise NotImplementedError("Windowed attention is not yet implemented")
+ else:
+
+ # Cross-attention path
+ Lkv = context.shape[1]
+ q = self.to_q(x)
+ # print(f"context shape: {context.shape}")
+ kv = self.to_kv(context)
+ # print("reshape kv")
+ q = q.reshape(B, L, self.num_heads, -1)
+ kv = kv.reshape(B, Lkv, 2, self.num_heads, -1)
+ # print("unbind kv")
+ if self.qk_rms_norm:
+ # print("qk_rms_norm")
+ # Apply RMS normalization to queries and keys if enabled
+ q = self.q_rms_norm(q)
+ k, v = kv.unbind(dim=2)
+ # print("unbind kv2")
+ k = self.k_rms_norm(k)
+ # print("unbind kv3")
+ h = scaled_dot_product_attention(q, k, v)
+ # print("unbind kv4")
+ else:
+ # Standard cross-attention
+ # print("unbind kv2")
+ # print(kv.shape)
+ h = scaled_dot_product_attention(q, kv)
+ # print("unbind kv3")
+ # Reshape and project back to the original dimension
+ h = h.reshape(B, L, -1)
+ h = self.to_out(h)
+ return h
diff --git a/OmniPart/training/modules/norm.py b/OmniPart/training/modules/norm.py
new file mode 100644
index 0000000..0903572
--- /dev/null
+++ b/OmniPart/training/modules/norm.py
@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+
+
+class LayerNorm32(nn.LayerNorm):
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return super().forward(x.float()).type(x.dtype)
+
+
+class GroupNorm32(nn.GroupNorm):
+ """
+ A GroupNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return super().forward(x.float()).type(x.dtype)
+
+
+class ChannelLayerNorm32(LayerNorm32):
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ DIM = x.dim()
+ x = x.permute(0, *range(2, DIM), 1).contiguous()
+ x = super().forward(x)
+ x = x.permute(0, DIM-1, *range(1, DIM-1)).contiguous()
+ return x
+
\ No newline at end of file
diff --git a/OmniPart/training/modules/sparse/__init__.py b/OmniPart/training/modules/sparse/__init__.py
new file mode 100644
index 0000000..726756c
--- /dev/null
+++ b/OmniPart/training/modules/sparse/__init__.py
@@ -0,0 +1,102 @@
+from typing import *
+
+BACKEND = 'spconv'
+DEBUG = False
+ATTN = 'flash_attn'
+
+def __from_env():
+ import os
+
+ global BACKEND
+ global DEBUG
+ global ATTN
+
+ env_sparse_backend = os.environ.get('SPARSE_BACKEND')
+ env_sparse_debug = os.environ.get('SPARSE_DEBUG')
+ env_sparse_attn = os.environ.get('SPARSE_ATTN_BACKEND')
+ if env_sparse_attn is None:
+ env_sparse_attn = os.environ.get('ATTN_BACKEND')
+
+ if env_sparse_backend is not None and env_sparse_backend in ['spconv', 'torchsparse']:
+ BACKEND = env_sparse_backend
+ if env_sparse_debug is not None:
+ DEBUG = env_sparse_debug == '1'
+ if env_sparse_attn is not None and env_sparse_attn in ['xformers', 'flash_attn']:
+ ATTN = env_sparse_attn
+
+ print(f"[SPARSE] Backend: {BACKEND}, Attention: {ATTN}")
+
+
+__from_env()
+
+
+def set_backend(backend: Literal['spconv', 'torchsparse']):
+ global BACKEND
+ BACKEND = backend
+
+def set_debug(debug: bool):
+ global DEBUG
+ DEBUG = debug
+
+def set_attn(attn: Literal['xformers', 'flash_attn']):
+ global ATTN
+ ATTN = attn
+
+
+import importlib
+
+__attributes = {
+ 'SparseTensor': 'basic',
+ 'sparse_batch_broadcast': 'basic',
+ 'sparse_batch_op': 'basic',
+ 'sparse_cat': 'basic',
+ 'sparse_unbind': 'basic',
+ 'SparseGroupNorm': 'norm',
+ 'SparseLayerNorm': 'norm',
+ 'SparseGroupNorm32': 'norm',
+ 'SparseLayerNorm32': 'norm',
+ 'SparseReLU': 'nonlinearity',
+ 'SparseSiLU': 'nonlinearity',
+ 'SparseGELU': 'nonlinearity',
+ 'SparseActivation': 'nonlinearity',
+ 'SparseLinear': 'linear',
+ 'sparse_scaled_dot_product_attention': 'attention',
+ 'SerializeMode': 'attention',
+ 'sparse_serialized_scaled_dot_product_self_attention': 'attention',
+ 'sparse_windowed_scaled_dot_product_self_attention': 'attention',
+ 'SparseMultiHeadAttention': 'attention',
+ 'SparseConv3d': 'conv',
+ 'SparseInverseConv3d': 'conv',
+ 'SparseDownsample': 'spatial',
+ 'SparseUpsample': 'spatial',
+ 'SparseSubdivide' : 'spatial'
+}
+
+__submodules = ['transformer']
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .basic import *
+ from .norm import *
+ from .nonlinearity import *
+ from .linear import *
+ from .attention import *
+ from .conv import *
+ from .spatial import *
+ import transformer
diff --git a/OmniPart/training/modules/sparse/attention/__init__.py b/OmniPart/training/modules/sparse/attention/__init__.py
new file mode 100644
index 0000000..32b3c2c
--- /dev/null
+++ b/OmniPart/training/modules/sparse/attention/__init__.py
@@ -0,0 +1,4 @@
+from .full_attn import *
+from .serialized_attn import *
+from .windowed_attn import *
+from .modules import *
diff --git a/OmniPart/training/modules/sparse/attention/full_attn.py b/OmniPart/training/modules/sparse/attention/full_attn.py
new file mode 100644
index 0000000..e9e27ae
--- /dev/null
+++ b/OmniPart/training/modules/sparse/attention/full_attn.py
@@ -0,0 +1,215 @@
+from typing import *
+import torch
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_scaled_dot_product_attention',
+]
+
+
+@overload
+def sparse_scaled_dot_product_attention(qkv: SparseTensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): A [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, kv: Union[SparseTensor, torch.Tensor]) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, C] sparse tensor containing Qs.
+ kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor or a [N, L, 2, H, C] dense tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: torch.Tensor, kv: SparseTensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, L, H, C] dense tensor containing Qs.
+ kv (SparseTensor or torch.Tensor): A [N, *, 2, H, C] sparse tensor containing Ks and Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, k: SparseTensor, v: SparseTensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs.
+ k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks.
+ v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs.
+
+ Note:
+ k and v are assumed to have the same coordinate map.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: SparseTensor, k: torch.Tensor, v: torch.Tensor) -> SparseTensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (SparseTensor): A [N, *, H, Ci] sparse tensor containing Qs.
+ k (torch.Tensor): A [N, L, H, Ci] dense tensor containing Ks.
+ v (torch.Tensor): A [N, L, H, Co] dense tensor containing Vs.
+ """
+ ...
+
+@overload
+def sparse_scaled_dot_product_attention(q: torch.Tensor, k: SparseTensor, v: SparseTensor) -> torch.Tensor:
+ """
+ Apply scaled dot product attention to a sparse tensor.
+
+ Args:
+ q (torch.Tensor): A [N, L, H, Ci] dense tensor containing Qs.
+ k (SparseTensor): A [N, *, H, Ci] sparse tensor containing Ks.
+ v (SparseTensor): A [N, *, H, Co] sparse tensor containing Vs.
+ """
+ ...
+
+def sparse_scaled_dot_product_attention(*args, **kwargs):
+ arg_names_dict = {
+ 1: ['qkv'],
+ 2: ['q', 'kv'],
+ 3: ['q', 'k', 'v']
+ }
+ num_all_args = len(args) + len(kwargs)
+ assert num_all_args in arg_names_dict, f"Invalid number of arguments, got {num_all_args}, expected 1, 2, or 3"
+ for key in arg_names_dict[num_all_args][len(args):]:
+ assert key in kwargs, f"Missing argument {key}"
+
+ if num_all_args == 1:
+ qkv = args[0] if len(args) > 0 else kwargs['qkv']
+ assert isinstance(qkv, SparseTensor), f"qkv must be a SparseTensor, got {type(qkv)}"
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+ device = qkv.device
+
+ s = qkv
+ q_seqlen = [qkv.layout[i].stop - qkv.layout[i].start for i in range(qkv.shape[0])]
+ kv_seqlen = q_seqlen
+ qkv = qkv.feats # [T, 3, H, C]
+
+ elif num_all_args == 2:
+ q = args[0] if len(args) > 0 else kwargs['q']
+ kv = args[1] if len(args) > 1 else kwargs['kv']
+ assert isinstance(q, SparseTensor) and isinstance(kv, (SparseTensor, torch.Tensor)) or \
+ isinstance(q, torch.Tensor) and isinstance(kv, SparseTensor), \
+ f"Invalid types, got {type(q)} and {type(kv)}"
+ assert q.shape[0] == kv.shape[0], f"Batch size mismatch, got {q.shape[0]} and {kv.shape[0]}"
+ device = q.device
+
+ if isinstance(q, SparseTensor):
+ assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, C]"
+ s = q
+ q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])]
+ q = q.feats # [T_Q, H, C]
+ else:
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, C]"
+ s = None
+ N, L, H, C = q.shape
+ q_seqlen = [L] * N
+ q = q.reshape(N * L, H, C) # [T_Q, H, C]
+
+ if isinstance(kv, SparseTensor):
+ assert len(kv.shape) == 4 and kv.shape[1] == 2, f"Invalid shape for kv, got {kv.shape}, expected [N, *, 2, H, C]"
+ kv_seqlen = [kv.layout[i].stop - kv.layout[i].start for i in range(kv.shape[0])]
+ kv = kv.feats # [T_KV, 2, H, C]
+ else:
+ assert len(kv.shape) == 5, f"Invalid shape for kv, got {kv.shape}, expected [N, L, 2, H, C]"
+ N, L, _, H, C = kv.shape
+ kv_seqlen = [L] * N
+ kv = kv.reshape(N * L, 2, H, C) # [T_KV, 2, H, C]
+
+ elif num_all_args == 3:
+ q = args[0] if len(args) > 0 else kwargs['q']
+ k = args[1] if len(args) > 1 else kwargs['k']
+ v = args[2] if len(args) > 2 else kwargs['v']
+ assert isinstance(q, SparseTensor) and isinstance(k, (SparseTensor, torch.Tensor)) and type(k) == type(v) or \
+ isinstance(q, torch.Tensor) and isinstance(k, SparseTensor) and isinstance(v, SparseTensor), \
+ f"Invalid types, got {type(q)}, {type(k)}, and {type(v)}"
+ assert q.shape[0] == k.shape[0] == v.shape[0], f"Batch size mismatch, got {q.shape[0]}, {k.shape[0]}, and {v.shape[0]}"
+ device = q.device
+
+ if isinstance(q, SparseTensor):
+ assert len(q.shape) == 3, f"Invalid shape for q, got {q.shape}, expected [N, *, H, Ci]"
+ s = q
+ q_seqlen = [q.layout[i].stop - q.layout[i].start for i in range(q.shape[0])]
+ q = q.feats # [T_Q, H, Ci]
+ else:
+ assert len(q.shape) == 4, f"Invalid shape for q, got {q.shape}, expected [N, L, H, Ci]"
+ s = None
+ N, L, H, CI = q.shape
+ q_seqlen = [L] * N
+ q = q.reshape(N * L, H, CI) # [T_Q, H, Ci]
+
+ if isinstance(k, SparseTensor):
+ assert len(k.shape) == 3, f"Invalid shape for k, got {k.shape}, expected [N, *, H, Ci]"
+ assert len(v.shape) == 3, f"Invalid shape for v, got {v.shape}, expected [N, *, H, Co]"
+ kv_seqlen = [k.layout[i].stop - k.layout[i].start for i in range(k.shape[0])]
+ k = k.feats # [T_KV, H, Ci]
+ v = v.feats # [T_KV, H, Co]
+ else:
+ assert len(k.shape) == 4, f"Invalid shape for k, got {k.shape}, expected [N, L, H, Ci]"
+ assert len(v.shape) == 4, f"Invalid shape for v, got {v.shape}, expected [N, L, H, Co]"
+ N, L, H, CI, CO = *k.shape, v.shape[-1]
+ kv_seqlen = [L] * N
+ k = k.reshape(N * L, H, CI) # [T_KV, H, Ci]
+ v = v.reshape(N * L, H, CO) # [T_KV, H, Co]
+
+ if DEBUG:
+ if s is not None:
+ for i in range(s.shape[0]):
+ assert (s.coords[s.layout[i]] == i).all(), f"SparseScaledDotProductSelfAttention: batch index mismatch"
+ if num_all_args in [2, 3]:
+ assert q.shape[:2] == [1, sum(q_seqlen)], f"SparseScaledDotProductSelfAttention: q shape mismatch"
+ if num_all_args == 3:
+ assert k.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: k shape mismatch"
+ assert v.shape[:2] == [1, sum(kv_seqlen)], f"SparseScaledDotProductSelfAttention: v shape mismatch"
+
+ if ATTN == 'xformers':
+ if num_all_args == 1:
+ q, k, v = qkv.unbind(dim=1)
+ elif num_all_args == 2:
+ k, v = kv.unbind(dim=1)
+ q = q.unsqueeze(0)
+ k = k.unsqueeze(0)
+ v = v.unsqueeze(0)
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(q_seqlen, kv_seqlen)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0]
+ elif ATTN == 'flash_attn':
+ cu_seqlens_q = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(q_seqlen), dim=0)]).int().to(device)
+ if num_all_args in [2, 3]:
+ cu_seqlens_kv = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(kv_seqlen), dim=0)]).int().to(device)
+ if num_all_args == 1:
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv, cu_seqlens_q, max(q_seqlen))
+ elif num_all_args == 2:
+ out = flash_attn.flash_attn_varlen_kvpacked_func(q, kv, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen))
+ elif num_all_args == 3:
+ out = flash_attn.flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max(q_seqlen), max(kv_seqlen))
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+ if s is not None:
+ return s.replace(out)
+ else:
+ return out.reshape(N, L, H, -1)
diff --git a/OmniPart/training/modules/sparse/attention/modules.py b/OmniPart/training/modules/sparse/attention/modules.py
new file mode 100644
index 0000000..5d2fe78
--- /dev/null
+++ b/OmniPart/training/modules/sparse/attention/modules.py
@@ -0,0 +1,139 @@
+from typing import *
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .. import SparseTensor
+from .full_attn import sparse_scaled_dot_product_attention
+from .serialized_attn import SerializeMode, sparse_serialized_scaled_dot_product_self_attention
+from .windowed_attn import sparse_windowed_scaled_dot_product_self_attention
+from ...attention import RotaryPositionEmbedder
+
+
+class SparseMultiHeadRMSNorm(nn.Module):
+ def __init__(self, dim: int, heads: int):
+ super().__init__()
+ self.scale = dim ** 0.5
+ self.gamma = nn.Parameter(torch.ones(heads, dim))
+
+ def forward(self, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]:
+ x_type = x.dtype
+ x = x.float()
+ if isinstance(x, SparseTensor):
+ x = x.replace(F.normalize(x.feats, dim=-1))
+ else:
+ x = F.normalize(x, dim=-1)
+ return (x * self.gamma * self.scale).to(x_type)
+
+
+class SparseMultiHeadAttention(nn.Module):
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ ctx_channels: Optional[int] = None,
+ type: Literal["self", "cross"] = "self",
+ attn_mode: Literal["full", "serialized", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ qkv_bias: bool = True,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ ):
+ super().__init__()
+ assert channels % num_heads == 0
+ assert type in ["self", "cross"], f"Invalid attention type: {type}"
+ assert attn_mode in ["full", "serialized", "windowed"], f"Invalid attention mode: {attn_mode}"
+ assert type == "self" or attn_mode == "full", "Cross-attention only supports full attention"
+ assert type == "self" or use_rope is False, "Rotary position embeddings only supported for self-attention"
+ self.channels = channels
+ self.ctx_channels = ctx_channels if ctx_channels is not None else channels
+ self.num_heads = num_heads
+ self._type = type
+ self.attn_mode = attn_mode
+ self.window_size = window_size
+ self.shift_sequence = shift_sequence
+ self.shift_window = shift_window
+ self.serialize_mode = serialize_mode
+ self.use_rope = use_rope
+ self.qk_rms_norm = qk_rms_norm
+
+ if self._type == "self":
+ self.to_qkv = nn.Linear(channels, channels * 3, bias=qkv_bias)
+ else:
+ self.to_q = nn.Linear(channels, channels, bias=qkv_bias)
+ self.to_kv = nn.Linear(self.ctx_channels, channels * 2, bias=qkv_bias)
+
+ if self.qk_rms_norm:
+ self.q_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads)
+ self.k_rms_norm = SparseMultiHeadRMSNorm(channels // num_heads, num_heads)
+
+ self.to_out = nn.Linear(channels, channels)
+
+ if use_rope:
+ self.rope = RotaryPositionEmbedder(channels)
+
+ @staticmethod
+ def _linear(module: nn.Linear, x: Union[SparseTensor, torch.Tensor]) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ return x.replace(module(x.feats))
+ else:
+ return module(x)
+
+ @staticmethod
+ def _reshape_chs(x: Union[SparseTensor, torch.Tensor], shape: Tuple[int, ...]) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ return x.reshape(*shape)
+ else:
+ return x.reshape(*x.shape[:2], *shape)
+
+ def _fused_pre(self, x: Union[SparseTensor, torch.Tensor], num_fused: int) -> Union[SparseTensor, torch.Tensor]:
+ if isinstance(x, SparseTensor):
+ x_feats = x.feats.unsqueeze(0)
+ else:
+ x_feats = x
+ x_feats = x_feats.reshape(*x_feats.shape[:2], num_fused, self.num_heads, -1)
+ return x.replace(x_feats.squeeze(0)) if isinstance(x, SparseTensor) else x_feats
+
+ def _rope(self, qkv: SparseTensor) -> SparseTensor:
+ q, k, v = qkv.feats.unbind(dim=1) # [T, H, C]
+ q, k = self.rope(q, k, qkv.coords[:, 1:])
+ qkv = qkv.replace(torch.stack([q, k, v], dim=1))
+ return qkv
+
+ def forward(self, x: Union[SparseTensor, torch.Tensor], context: Optional[Union[SparseTensor, torch.Tensor]] = None) -> Union[SparseTensor, torch.Tensor]:
+ if self._type == "self":
+ qkv = self._linear(self.to_qkv, x)
+ qkv = self._fused_pre(qkv, num_fused=3)
+ if self.use_rope:
+ qkv = self._rope(qkv)
+ if self.qk_rms_norm:
+ q, k, v = qkv.unbind(dim=1)
+ q = self.q_rms_norm(q)
+ k = self.k_rms_norm(k)
+ qkv = qkv.replace(torch.stack([q.feats, k.feats, v.feats], dim=1))
+ if self.attn_mode == "full":
+ h = sparse_scaled_dot_product_attention(qkv)
+ elif self.attn_mode == "serialized":
+ h = sparse_serialized_scaled_dot_product_self_attention(
+ qkv, self.window_size, serialize_mode=self.serialize_mode, shift_sequence=self.shift_sequence, shift_window=self.shift_window
+ )
+ elif self.attn_mode == "windowed":
+ h = sparse_windowed_scaled_dot_product_self_attention(
+ qkv, self.window_size, shift_window=self.shift_window
+ )
+ else:
+ q = self._linear(self.to_q, x)
+ q = self._reshape_chs(q, (self.num_heads, -1))
+ kv = self._linear(self.to_kv, context)
+ kv = self._fused_pre(kv, num_fused=2)
+ if self.qk_rms_norm:
+ q = self.q_rms_norm(q)
+ k, v = kv.unbind(dim=1)
+ k = self.k_rms_norm(k)
+ kv = kv.replace(torch.stack([k.feats, v.feats], dim=1))
+ h = sparse_scaled_dot_product_attention(q, kv)
+ h = self._reshape_chs(h, (-1,))
+ h = self._linear(self.to_out, h)
+ return h
diff --git a/OmniPart/training/modules/sparse/attention/serialized_attn.py b/OmniPart/training/modules/sparse/attention/serialized_attn.py
new file mode 100644
index 0000000..5950b75
--- /dev/null
+++ b/OmniPart/training/modules/sparse/attention/serialized_attn.py
@@ -0,0 +1,193 @@
+from typing import *
+from enum import Enum
+import torch
+import math
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_serialized_scaled_dot_product_self_attention',
+]
+
+
+class SerializeMode(Enum):
+ Z_ORDER = 0
+ Z_ORDER_TRANSPOSED = 1
+ HILBERT = 2
+ HILBERT_TRANSPOSED = 3
+
+
+SerializeModes = [
+ SerializeMode.Z_ORDER,
+ SerializeMode.Z_ORDER_TRANSPOSED,
+ SerializeMode.HILBERT,
+ SerializeMode.HILBERT_TRANSPOSED
+]
+
+
+def calc_serialization(
+ tensor: SparseTensor,
+ window_size: int,
+ serialize_mode: SerializeMode = SerializeMode.Z_ORDER,
+ shift_sequence: int = 0,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> Tuple[torch.Tensor, torch.Tensor, List[int]]:
+ """
+ Calculate serialization and partitioning for a set of coordinates.
+
+ Args:
+ tensor (SparseTensor): The input tensor.
+ window_size (int): The window size to use.
+ serialize_mode (SerializeMode): The serialization mode to use.
+ shift_sequence (int): The shift of serialized sequence.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+
+ Returns:
+ (torch.Tensor, torch.Tensor): Forwards and backwards indices.
+ """
+ fwd_indices = []
+ bwd_indices = []
+ seq_lens = []
+ seq_batch_indices = []
+ offsets = [0]
+
+ if 'vox2seq' not in globals():
+ import vox2seq
+
+ # Serialize the input
+ serialize_coords = tensor.coords[:, 1:].clone()
+ serialize_coords += torch.tensor(shift_window, dtype=torch.int32, device=tensor.device).reshape(1, 3)
+ if serialize_mode == SerializeMode.Z_ORDER:
+ code = vox2seq.encode(serialize_coords, mode='z_order', permute=[0, 1, 2])
+ elif serialize_mode == SerializeMode.Z_ORDER_TRANSPOSED:
+ code = vox2seq.encode(serialize_coords, mode='z_order', permute=[1, 0, 2])
+ elif serialize_mode == SerializeMode.HILBERT:
+ code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[0, 1, 2])
+ elif serialize_mode == SerializeMode.HILBERT_TRANSPOSED:
+ code = vox2seq.encode(serialize_coords, mode='hilbert', permute=[1, 0, 2])
+ else:
+ raise ValueError(f"Unknown serialize mode: {serialize_mode}")
+
+ for bi, s in enumerate(tensor.layout):
+ num_points = s.stop - s.start
+ num_windows = (num_points + window_size - 1) // window_size
+ valid_window_size = num_points / num_windows
+ to_ordered = torch.argsort(code[s.start:s.stop])
+ if num_windows == 1:
+ fwd_indices.append(to_ordered)
+ bwd_indices.append(torch.zeros_like(to_ordered).scatter_(0, to_ordered, torch.arange(num_points, device=tensor.device)))
+ fwd_indices[-1] += s.start
+ bwd_indices[-1] += offsets[-1]
+ seq_lens.append(num_points)
+ seq_batch_indices.append(bi)
+ offsets.append(offsets[-1] + seq_lens[-1])
+ else:
+ # Partition the input
+ offset = 0
+ mids = [(i + 0.5) * valid_window_size + shift_sequence for i in range(num_windows)]
+ split = [math.floor(i * valid_window_size + shift_sequence) for i in range(num_windows + 1)]
+ bwd_index = torch.zeros((num_points,), dtype=torch.int64, device=tensor.device)
+ for i in range(num_windows):
+ mid = mids[i]
+ valid_start = split[i]
+ valid_end = split[i + 1]
+ padded_start = math.floor(mid - 0.5 * window_size)
+ padded_end = padded_start + window_size
+ fwd_indices.append(to_ordered[torch.arange(padded_start, padded_end, device=tensor.device) % num_points])
+ offset += valid_start - padded_start
+ bwd_index.scatter_(0, fwd_indices[-1][valid_start-padded_start:valid_end-padded_start], torch.arange(offset, offset + valid_end - valid_start, device=tensor.device))
+ offset += padded_end - valid_start
+ fwd_indices[-1] += s.start
+ seq_lens.extend([window_size] * num_windows)
+ seq_batch_indices.extend([bi] * num_windows)
+ bwd_indices.append(bwd_index + offsets[-1])
+ offsets.append(offsets[-1] + num_windows * window_size)
+
+ fwd_indices = torch.cat(fwd_indices)
+ bwd_indices = torch.cat(bwd_indices)
+
+ return fwd_indices, bwd_indices, seq_lens, seq_batch_indices
+
+
+def sparse_serialized_scaled_dot_product_self_attention(
+ qkv: SparseTensor,
+ window_size: int,
+ serialize_mode: SerializeMode = SerializeMode.Z_ORDER,
+ shift_sequence: int = 0,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> SparseTensor:
+ """
+ Apply serialized scaled dot product self attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ window_size (int): The window size to use.
+ serialize_mode (SerializeMode): The serialization mode to use.
+ shift_sequence (int): The shift of serialized sequence.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+ shift (int): The shift to use.
+ """
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+
+ serialization_spatial_cache_name = f'serialization_{serialize_mode}_{window_size}_{shift_sequence}_{shift_window}'
+ serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name)
+ if serialization_spatial_cache is None:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_serialization(qkv, window_size, serialize_mode, shift_sequence, shift_window)
+ qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices))
+ else:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache
+
+ M = fwd_indices.shape[0]
+ T = qkv.feats.shape[0]
+ H = qkv.feats.shape[2]
+ C = qkv.feats.shape[3]
+
+ qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C]
+
+ if DEBUG:
+ start = 0
+ qkv_coords = qkv.coords[fwd_indices]
+ for i in range(len(seq_lens)):
+ assert (qkv_coords[start:start+seq_lens[i], 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch"
+ start += seq_lens[i]
+
+ if all([seq_len == window_size for seq_len in seq_lens]):
+ B = len(seq_lens)
+ N = window_size
+ qkv_feats = qkv_feats.reshape(B, N, 3, H, C)
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C]
+ out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C]
+ elif ATTN == 'flash_attn':
+ out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C]
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+ out = out.reshape(B * N, H, C) # [M, H, C]
+ else:
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=1) # [M, H, C]
+ q = q.unsqueeze(0) # [1, M, H, C]
+ k = k.unsqueeze(0) # [1, M, H, C]
+ v = v.unsqueeze(0) # [1, M, H, C]
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C]
+ elif ATTN == 'flash_attn':
+ cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \
+ .to(qkv.device).int()
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C]
+
+ out = out[bwd_indices] # [T, H, C]
+
+ if DEBUG:
+ qkv_coords = qkv_coords[bwd_indices]
+ assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch"
+
+ return qkv.replace(out)
diff --git a/OmniPart/training/modules/sparse/attention/windowed_attn.py b/OmniPart/training/modules/sparse/attention/windowed_attn.py
new file mode 100644
index 0000000..cd642c5
--- /dev/null
+++ b/OmniPart/training/modules/sparse/attention/windowed_attn.py
@@ -0,0 +1,135 @@
+from typing import *
+import torch
+import math
+from .. import SparseTensor
+from .. import DEBUG, ATTN
+
+if ATTN == 'xformers':
+ import xformers.ops as xops
+elif ATTN == 'flash_attn':
+ import flash_attn
+else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+
+
+__all__ = [
+ 'sparse_windowed_scaled_dot_product_self_attention',
+]
+
+
+def calc_window_partition(
+ tensor: SparseTensor,
+ window_size: Union[int, Tuple[int, ...]],
+ shift_window: Union[int, Tuple[int, ...]] = 0
+) -> Tuple[torch.Tensor, torch.Tensor, List[int], List[int]]:
+ """
+ Calculate serialization and partitioning for a set of coordinates.
+
+ Args:
+ tensor (SparseTensor): The input tensor.
+ window_size (int): The window size to use.
+ shift_window (Tuple[int, ...]): The shift of serialized coordinates.
+
+ Returns:
+ (torch.Tensor): Forwards indices.
+ (torch.Tensor): Backwards indices.
+ (List[int]): Sequence lengths.
+ (List[int]): Sequence batch indices.
+ """
+ DIM = tensor.coords.shape[1] - 1
+ shift_window = (shift_window,) * DIM if isinstance(shift_window, int) else shift_window
+ window_size = (window_size,) * DIM if isinstance(window_size, int) else window_size
+ shifted_coords = tensor.coords.clone().detach()
+ shifted_coords[:, 1:] += torch.tensor(shift_window, device=tensor.device, dtype=torch.int32).unsqueeze(0)
+
+ MAX_COORDS = shifted_coords[:, 1:].max(dim=0).values.tolist()
+ NUM_WINDOWS = [math.ceil((mc + 1) / ws) for mc, ws in zip(MAX_COORDS, window_size)]
+ OFFSET = torch.cumprod(torch.tensor([1] + NUM_WINDOWS[::-1]), dim=0).tolist()[::-1]
+
+ shifted_coords[:, 1:] //= torch.tensor(window_size, device=tensor.device, dtype=torch.int32).unsqueeze(0)
+ shifted_indices = (shifted_coords * torch.tensor(OFFSET, device=tensor.device, dtype=torch.int32).unsqueeze(0)).sum(dim=1)
+ fwd_indices = torch.argsort(shifted_indices)
+ bwd_indices = torch.empty_like(fwd_indices)
+ bwd_indices[fwd_indices] = torch.arange(fwd_indices.shape[0], device=tensor.device)
+ seq_lens = torch.bincount(shifted_indices)
+ seq_batch_indices = torch.arange(seq_lens.shape[0], device=tensor.device, dtype=torch.int32) // OFFSET[0]
+ mask = seq_lens != 0
+ seq_lens = seq_lens[mask].tolist()
+ seq_batch_indices = seq_batch_indices[mask].tolist()
+
+ return fwd_indices, bwd_indices, seq_lens, seq_batch_indices
+
+
+def sparse_windowed_scaled_dot_product_self_attention(
+ qkv: SparseTensor,
+ window_size: int,
+ shift_window: Tuple[int, int, int] = (0, 0, 0)
+) -> SparseTensor:
+ """
+ Apply windowed scaled dot product self attention to a sparse tensor.
+
+ Args:
+ qkv (SparseTensor): [N, *, 3, H, C] sparse tensor containing Qs, Ks, and Vs.
+ window_size (int): The window size to use.
+ shift_window (Tuple[int, int, int]): The shift of serialized coordinates.
+ shift (int): The shift to use.
+ """
+ assert len(qkv.shape) == 4 and qkv.shape[1] == 3, f"Invalid shape for qkv, got {qkv.shape}, expected [N, *, 3, H, C]"
+
+ serialization_spatial_cache_name = f'window_partition_{window_size}_{shift_window}'
+ serialization_spatial_cache = qkv.get_spatial_cache(serialization_spatial_cache_name)
+ if serialization_spatial_cache is None:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = calc_window_partition(qkv, window_size, shift_window)
+ qkv.register_spatial_cache(serialization_spatial_cache_name, (fwd_indices, bwd_indices, seq_lens, seq_batch_indices))
+ else:
+ fwd_indices, bwd_indices, seq_lens, seq_batch_indices = serialization_spatial_cache
+
+ M = fwd_indices.shape[0]
+ T = qkv.feats.shape[0]
+ H = qkv.feats.shape[2]
+ C = qkv.feats.shape[3]
+
+ qkv_feats = qkv.feats[fwd_indices] # [M, 3, H, C]
+
+ if DEBUG:
+ start = 0
+ qkv_coords = qkv.coords[fwd_indices]
+ for i in range(len(seq_lens)):
+ seq_coords = qkv_coords[start:start+seq_lens[i]]
+ assert (seq_coords[:, 0] == seq_batch_indices[i]).all(), f"SparseWindowedScaledDotProductSelfAttention: batch index mismatch"
+ assert (seq_coords[:, 1:].max(dim=0).values - seq_coords[:, 1:].min(dim=0).values < window_size).all(), \
+ f"SparseWindowedScaledDotProductSelfAttention: window size exceeded"
+ start += seq_lens[i]
+
+ if all([seq_len == window_size for seq_len in seq_lens]):
+ B = len(seq_lens)
+ N = window_size
+ qkv_feats = qkv_feats.reshape(B, N, 3, H, C)
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=2) # [B, N, H, C]
+ out = xops.memory_efficient_attention(q, k, v) # [B, N, H, C]
+ elif ATTN == 'flash_attn':
+ out = flash_attn.flash_attn_qkvpacked_func(qkv_feats) # [B, N, H, C]
+ else:
+ raise ValueError(f"Unknown attention module: {ATTN}")
+ out = out.reshape(B * N, H, C) # [M, H, C]
+ else:
+ if ATTN == 'xformers':
+ q, k, v = qkv_feats.unbind(dim=1) # [M, H, C]
+ q = q.unsqueeze(0) # [1, M, H, C]
+ k = k.unsqueeze(0) # [1, M, H, C]
+ v = v.unsqueeze(0) # [1, M, H, C]
+ mask = xops.fmha.BlockDiagonalMask.from_seqlens(seq_lens)
+ out = xops.memory_efficient_attention(q, k, v, mask)[0] # [M, H, C]
+ elif ATTN == 'flash_attn':
+ cu_seqlens = torch.cat([torch.tensor([0]), torch.cumsum(torch.tensor(seq_lens), dim=0)], dim=0) \
+ .to(qkv.device).int()
+ out = flash_attn.flash_attn_varlen_qkvpacked_func(qkv_feats, cu_seqlens, max(seq_lens)) # [M, H, C]
+
+ out = out[bwd_indices] # [T, H, C]
+
+ if DEBUG:
+ qkv_coords = qkv_coords[bwd_indices]
+ assert torch.equal(qkv_coords, qkv.coords), "SparseWindowedScaledDotProductSelfAttention: coordinate mismatch"
+
+ return qkv.replace(out)
diff --git a/OmniPart/training/modules/sparse/basic.py b/OmniPart/training/modules/sparse/basic.py
new file mode 100644
index 0000000..f856b8a
--- /dev/null
+++ b/OmniPart/training/modules/sparse/basic.py
@@ -0,0 +1,691 @@
+"""
+Sparse Tensor Implementation for TRELLIS
+----------------------------------------
+
+This file implements a unified sparse tensor interface that supports multiple backends (torchsparse and spconv).
+Sparse tensors are efficient representations of tensors where most values are zero, storing only non-zero values
+and their coordinates. This is particularly useful for 3D point clouds and voxel grids in computer vision and
+robotics applications where data is naturally sparse.
+
+The main components of this file are:
+- SparseTensor: Core class providing a unified API over different sparse tensor backends
+- Utility functions for sparse tensor operations (concatenation, unbinding, broadcasting, etc.)
+- Backend-agnostic arithmetic operations for sparse tensors
+
+The implementation abstracts away backend-specific details to allow seamless switching between
+torchsparse and spconv while maintaining a consistent interface.
+"""
+
+from typing import *
+import torch
+import torch.nn as nn
+from . import BACKEND, DEBUG
+SparseTensorData = None # Lazy import
+
+
+__all__ = [
+ 'SparseTensor',
+ 'sparse_batch_broadcast',
+ 'sparse_batch_op',
+ 'sparse_cat',
+ 'sparse_unbind',
+]
+
+
+class SparseTensor:
+ """
+ Sparse tensor with support for both torchsparse and spconv backends.
+
+ Parameters:
+ - feats (torch.Tensor): Features of the sparse tensor.
+ - coords (torch.Tensor): Coordinates of the sparse tensor.
+ - shape (torch.Size): Shape of the sparse tensor.
+ - layout (List[slice]): Layout of the sparse tensor for each batch
+ - data (SparseTensorData): Sparse tensor data used for convolusion
+
+ NOTE:
+ - Data corresponding to a same batch should be contiguous.
+ - Coords should be in [0, 1023]
+ """
+ @overload
+ def __init__(self, feats: torch.Tensor, coords: torch.Tensor, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ...
+
+ @overload
+ def __init__(self, data, shape: Optional[torch.Size] = None, layout: Optional[List[slice]] = None, **kwargs): ...
+
+ def __init__(self, *args, **kwargs):
+ # Lazy import of sparse tensor backend to avoid circular imports and improve startup time
+ global SparseTensorData
+ if SparseTensorData is None:
+ import importlib
+ if BACKEND == 'torchsparse':
+ SparseTensorData = importlib.import_module('torchsparse').SparseTensor
+ elif BACKEND == 'spconv':
+ SparseTensorData = importlib.import_module('spconv.pytorch').SparseConvTensor
+
+ # print(SparseTensorData)
+ # exit(0)
+
+ # Determine initialization method based on arguments (method 0: from tensors, method 1: from existing data)
+ method_id = 0
+ if len(args) != 0:
+ method_id = 0 if isinstance(args[0], torch.Tensor) else 1
+ else:
+ method_id = 1 if 'data' in kwargs else 0
+
+ self.old_index = None # Placeholder for old indices, if needed
+
+ if method_id == 0:
+ # Initialize from feature and coordinate tensors
+ feats, coords, shape, layout = args + (None,) * (4 - len(args))
+ if 'feats' in kwargs:
+ feats = kwargs['feats']
+ del kwargs['feats']
+ if 'coords' in kwargs:
+ coords = kwargs['coords']
+ del kwargs['coords']
+ if 'shape' in kwargs:
+ shape = kwargs['shape']
+ del kwargs['shape']
+ if 'layout' in kwargs:
+ layout = kwargs['layout']
+ del kwargs['layout']
+
+ if shape is None:
+ shape = self.__cal_shape(feats, coords)
+ if layout is None:
+ layout = self.__cal_layout(coords, shape[0])
+
+ # Create backend-specific tensor representation
+ if BACKEND == 'torchsparse':
+ self.data = SparseTensorData(feats, coords, **kwargs)
+ elif BACKEND == 'spconv':
+ spatial_shape = list(coords.max(0)[0] + 1)[1:]
+ self.data = SparseTensorData(feats.reshape(feats.shape[0], -1), coords, spatial_shape, shape[0], **kwargs)
+ self.data._features = feats
+ elif method_id == 1:
+ # Initialize from existing sparse tensor data
+ data, shape, layout = args + (None,) * (3 - len(args))
+ if 'data' in kwargs:
+ data = kwargs['data']
+ del kwargs['data']
+ if 'shape' in kwargs:
+ shape = kwargs['shape']
+ del kwargs['shape']
+ if 'layout' in kwargs:
+ layout = kwargs['layout']
+ del kwargs['layout']
+
+ self.data = data
+ if shape is None:
+ shape = self.__cal_shape(self.feats, self.coords)
+ if layout is None:
+ layout = self.__cal_layout(self.coords, shape[0])
+
+ # Store metadata
+ self._shape = shape
+ self._layout = layout
+ self._scale = kwargs.get('scale', (1, 1, 1))
+ self._spatial_cache = kwargs.get('spatial_cache', {})
+
+ # Validate tensor properties in debug mode
+ if DEBUG:
+ try:
+ assert self.feats.shape[0] == self.coords.shape[0], f"Invalid feats shape: {self.feats.shape}, coords shape: {self.coords.shape}"
+ assert self.shape == self.__cal_shape(self.feats, self.coords), f"Invalid shape: {self.shape}"
+ assert self.layout == self.__cal_layout(self.coords, self.shape[0]), f"Invalid layout: {self.layout}"
+ for i in range(self.shape[0]):
+ assert torch.all(self.coords[self.layout[i], 0] == i), f"The data of batch {i} is not contiguous"
+ except Exception as e:
+ print('Debugging information:')
+ print(f"- Shape: {self.shape}")
+ print(f"- Layout: {self.layout}")
+ print(f"- Scale: {self._scale}")
+ print(f"- Coords: {self.coords}")
+ raise e
+
+ def __cal_shape(self, feats, coords):
+ """
+ Calculate the shape of the sparse tensor from features and coordinates.
+
+ This method determines the overall shape of the sparse tensor by examining:
+ - The batch dimension (from max coordinate value in first column + 1)
+ - The feature dimensions (from the feature tensor shape)
+
+ Args:
+ feats (torch.Tensor): Feature tensor of shape (N, C1, C2, ...)
+ coords (torch.Tensor): Coordinate tensor of shape (N, D+1) where
+ first column contains batch indices
+
+ Returns:
+ torch.Size: Shape of the sparse tensor as (batch_size, C1, C2, ...)
+ """
+ shape = []
+ # First dimension is the batch size (max batch index + 1)
+ shape.append(coords[:, 0].max().item() + 1)
+ # Remaining dimensions match the feature tensor's dimensions
+ shape.extend([*feats.shape[1:]])
+ return torch.Size(shape)
+
+ def __cal_layout(self, coords, batch_size):
+ """
+ Calculate the layout of each batch in the sparse tensor.
+
+ This method computes slice objects to efficiently index into specific batches
+ within the coordinate and feature tensors. It assumes that coordinates are
+ sorted by batch index (first column).
+
+ Algorithm:
+ 1. Count how many elements belong to each batch using bincount
+ 2. Calculate cumulative sums to find ending offsets for each batch
+ 3. Create slice objects representing the range of indices for each batch
+
+ Args:
+ coords (torch.Tensor): Coordinate tensor with first column as batch indices
+ batch_size (int): Number of batches in the sparse tensor
+
+ Returns:
+ List[slice]: List of slice objects where layout[i] indexes all elements
+ belonging to batch i
+ """
+ # Count number of points in each batch
+ seq_len = torch.bincount(coords[:, 0], minlength=batch_size)
+ # Calculate ending position of each batch
+ offset = torch.cumsum(seq_len, dim=0)
+ # Create slices for each batch from (end_prev_batch, end_current_batch)
+ layout = [slice((offset[i] - seq_len[i]).item(), offset[i].item()) for i in range(batch_size)]
+ return layout
+
+ @property
+ def shape(self) -> torch.Size:
+ """Return the shape of the sparse tensor"""
+ return self._shape
+
+ def dim(self) -> int:
+ """Return the number of dimensions of the sparse tensor"""
+ return len(self.shape)
+
+ @property
+ def layout(self) -> List[slice]:
+ """Return the layout of each batch in the sparse tensor"""
+ return self._layout
+
+ @property
+ def feats(self) -> torch.Tensor:
+ """Return the features tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ return self.data.F
+ elif BACKEND == 'spconv':
+ return self.data.features
+
+ @feats.setter
+ def feats(self, value: torch.Tensor):
+ """Set the features tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ self.data.F = value
+ elif BACKEND == 'spconv':
+ self.data.features = value
+
+ @property
+ def coords(self) -> torch.Tensor:
+ """Return the coordinates tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ return self.data.C
+ elif BACKEND == 'spconv':
+ return self.data.indices
+
+ @coords.setter
+ def coords(self, value: torch.Tensor):
+ """Set the coordinates tensor with backend-specific access"""
+ if BACKEND == 'torchsparse':
+ self.data.C = value
+ elif BACKEND == 'spconv':
+ self.data.indices = value
+
+ @property
+ def dtype(self):
+ """Return the data type of the sparse tensor's features"""
+ return self.feats.dtype
+
+ @property
+ def device(self):
+ """Return the device of the sparse tensor's features"""
+ return self.feats.device
+
+ @overload
+ def to(self, dtype: torch.dtype) -> 'SparseTensor': ...
+
+ @overload
+ def to(self, device: Optional[Union[str, torch.device]] = None, dtype: Optional[torch.dtype] = None) -> 'SparseTensor': ...
+
+ def to(self, *args, **kwargs) -> 'SparseTensor':
+ """
+ Move the sparse tensor to the specified device and/or change its data type.
+ Mimics the PyTorch tensor.to() method.
+ """
+ device = None
+ dtype = None
+ if len(args) == 2:
+ device, dtype = args
+ elif len(args) == 1:
+ if isinstance(args[0], torch.dtype):
+ dtype = args[0]
+ else:
+ device = args[0]
+ if 'dtype' in kwargs:
+ assert dtype is None, "to() received multiple values for argument 'dtype'"
+ dtype = kwargs['dtype']
+ if 'device' in kwargs:
+ assert device is None, "to() received multiple values for argument 'device'"
+ device = kwargs['device']
+
+ # print(self.feats)
+ # print(self.coords)
+ # print(SparseTensorData)
+ new_feats = self.feats.to(device=device, dtype=dtype)
+ new_coords = self.coords.to(device=device)
+ return self.replace(new_feats, new_coords)
+
+ def type(self, dtype):
+ """Convert the sparse tensor to the specified data type"""
+ new_feats = self.feats.type(dtype)
+ return self.replace(new_feats)
+
+ def cpu(self) -> 'SparseTensor':
+ """Move the sparse tensor to CPU memory"""
+ new_feats = self.feats.cpu()
+ new_coords = self.coords.cpu()
+ return self.replace(new_feats, new_coords)
+
+ def cuda(self) -> 'SparseTensor':
+ """Move the sparse tensor to CUDA memory"""
+ new_feats = self.feats.cuda()
+ new_coords = self.coords.cuda()
+ return self.replace(new_feats, new_coords)
+
+ def half(self) -> 'SparseTensor':
+ """Convert the sparse tensor to half precision"""
+ new_feats = self.feats.half()
+ return self.replace(new_feats)
+
+ def float(self) -> 'SparseTensor':
+ """Convert the sparse tensor to single precision"""
+ new_feats = self.feats.float()
+ return self.replace(new_feats)
+
+ def detach(self) -> 'SparseTensor':
+ """Detach the sparse tensor from the computation graph"""
+ new_coords = self.coords.detach()
+ new_feats = self.feats.detach()
+ return self.replace(new_feats, new_coords)
+
+ def dense(self) -> torch.Tensor:
+ """Convert the sparse tensor to a dense tensor representation"""
+ if BACKEND == 'torchsparse':
+ return self.data.dense()
+ elif BACKEND == 'spconv':
+ return self.data.dense()
+
+ def reshape(self, *shape) -> 'SparseTensor':
+ """Reshape the feature dimensions of the sparse tensor"""
+ new_feats = self.feats.reshape(self.feats.shape[0], *shape)
+ return self.replace(new_feats)
+
+ def unbind(self, dim: int) -> List['SparseTensor']:
+ """Unbind the sparse tensor along the specified dimension"""
+ return sparse_unbind(self, dim)
+
+ def replace(self, feats: torch.Tensor, coords: Optional[torch.Tensor] = None) -> 'SparseTensor':
+ """
+ Create a new sparse tensor with the specified features and optionally new coordinates.
+ Preserves other properties like stride, spatial range, and caches.
+ """
+ new_shape = [self.shape[0]]
+ new_shape.extend(feats.shape[1:])
+ if BACKEND == 'torchsparse':
+ new_data = SparseTensorData(
+ feats=feats,
+ coords=self.data.coords if coords is None else coords,
+ stride=self.data.stride,
+ spatial_range=self.data.spatial_range,
+ )
+ new_data._caches = self.data._caches
+ elif BACKEND == 'spconv':
+ new_data = SparseTensorData(
+ self.data.features.reshape(self.data.features.shape[0], -1),
+ self.data.indices,
+ self.data.spatial_shape,
+ self.data.batch_size,
+ self.data.grid,
+ self.data.voxel_num,
+ self.data.indice_dict
+ )
+ new_data._features = feats
+ new_data.benchmark = self.data.benchmark
+ new_data.benchmark_record = self.data.benchmark_record
+ new_data.thrust_allocator = self.data.thrust_allocator
+ new_data._timer = self.data._timer
+ new_data.force_algo = self.data.force_algo
+ new_data.int8_scale = self.data.int8_scale
+ if coords is not None:
+ new_data.indices = coords
+ new_tensor = SparseTensor(new_data, shape=torch.Size(new_shape), layout=self.layout, scale=self._scale, spatial_cache=self._spatial_cache)
+ return new_tensor
+
+ @staticmethod
+ def full(aabb, dim, value, dtype=torch.float32, device=None) -> 'SparseTensor':
+ """
+ Create a sparse tensor with uniform values within an axis-aligned bounding box.
+
+ Args:
+ aabb: [x_min, y_min, z_min, x_max, y_max, z_max] defining the bounding box
+ dim: (batch_size, feature_dim) tuple defining tensor dimensions
+ value: Value to fill the tensor with
+ dtype: Data type for features
+ device: Device to create the tensor on
+ """
+ N, C = dim
+ x = torch.arange(aabb[0], aabb[3] + 1)
+ y = torch.arange(aabb[1], aabb[4] + 1)
+ z = torch.arange(aabb[2], aabb[5] + 1)
+ coords = torch.stack(torch.meshgrid(x, y, z, indexing='ij'), dim=-1).reshape(-1, 3)
+ coords = torch.cat([
+ torch.arange(N).view(-1, 1).repeat(1, coords.shape[0]).view(-1, 1),
+ coords.repeat(N, 1),
+ ], dim=1).to(dtype=torch.int32, device=device)
+ feats = torch.full((coords.shape[0], C), value, dtype=dtype, device=device)
+ return SparseTensor(feats=feats, coords=coords)
+
+ def __merge_sparse_cache(self, other: 'SparseTensor') -> dict:
+ """Merge the spatial caches of two sparse tensors"""
+ new_cache = {}
+ for k in set(list(self._spatial_cache.keys()) + list(other._spatial_cache.keys())):
+ if k in self._spatial_cache:
+ new_cache[k] = self._spatial_cache[k]
+ if k in other._spatial_cache:
+ if k not in new_cache:
+ new_cache[k] = other._spatial_cache[k]
+ else:
+ new_cache[k].update(other._spatial_cache[k])
+ return new_cache
+
+ def __neg__(self) -> 'SparseTensor':
+ """Negate the sparse tensor's values"""
+ return self.replace(-self.feats)
+
+ def __elemwise__(self, other: Union[torch.Tensor, 'SparseTensor'], op: callable) -> 'SparseTensor':
+ """
+ Apply an elementwise operation between this sparse tensor and another tensor.
+ Handles broadcasting when necessary.
+ """
+ if isinstance(other, torch.Tensor):
+ try:
+ other = torch.broadcast_to(other, self.shape)
+ other = sparse_batch_broadcast(self, other)
+ except:
+ pass
+ if isinstance(other, SparseTensor):
+ other = other.feats
+ new_feats = op(self.feats, other)
+ new_tensor = self.replace(new_feats)
+ if isinstance(other, SparseTensor):
+ new_tensor._spatial_cache = self.__merge_sparse_cache(other)
+ return new_tensor
+
+ def __add__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Add a tensor or value to this sparse tensor"""
+ return self.__elemwise__(other, torch.add)
+
+ def __radd__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Add this sparse tensor to a tensor or value (reversed)"""
+ return self.__elemwise__(other, torch.add)
+
+ def __sub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Subtract a tensor or value from this sparse tensor"""
+ return self.__elemwise__(other, torch.sub)
+
+ def __rsub__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Subtract this sparse tensor from a tensor or value (reversed)"""
+ return self.__elemwise__(other, lambda x, y: torch.sub(y, x))
+
+ def __mul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Multiply this sparse tensor by a tensor or value"""
+ return self.__elemwise__(other, torch.mul)
+
+ def __rmul__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Multiply a tensor or value by this sparse tensor (reversed)"""
+ return self.__elemwise__(other, torch.mul)
+
+ def __truediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Divide this sparse tensor by a tensor or value"""
+ return self.__elemwise__(other, torch.div)
+
+ def __rtruediv__(self, other: Union[torch.Tensor, 'SparseTensor', float]) -> 'SparseTensor':
+ """Divide a tensor or value by this sparse tensor (reversed)"""
+ return self.__elemwise__(other, lambda x, y: torch.div(y, x))
+
+ def __getitem__(self, idx):
+ """
+ Extract a batch or subset of batches from the sparse tensor.
+ Support for integer, slice, and tensor indexing.
+ """
+ if isinstance(idx, int):
+ idx = [idx]
+ elif isinstance(idx, slice):
+ idx = range(*idx.indices(self.shape[0]))
+ elif isinstance(idx, torch.Tensor):
+ if idx.dtype == torch.bool:
+ assert idx.shape == (self.shape[0],), f"Invalid index shape: {idx.shape}"
+ idx = idx.nonzero().squeeze(1)
+ elif idx.dtype in [torch.int32, torch.int64]:
+ assert len(idx.shape) == 1, f"Invalid index shape: {idx.shape}"
+ else:
+ raise ValueError(f"Unknown index type: {idx.dtype}")
+ else:
+ raise ValueError(f"Unknown index type: {type(idx)}")
+
+ coords = []
+ feats = []
+ old_index_list = []
+ for new_idx, old_idx in enumerate(idx):
+ coords.append(self.coords[self.layout[old_idx]].clone())
+ # print(f"slice: old index{old_idx}, new index: {new_idx}")
+ old_index_list.append(old_idx)
+ coords[-1][:, 0] = new_idx
+ feats.append(self.feats[self.layout[old_idx]])
+ coords = torch.cat(coords, dim=0).contiguous()
+ feats = torch.cat(feats, dim=0).contiguous()
+ self.old_index = old_index_list
+ return SparseTensor(feats=feats, coords=coords)
+
+ # def get_item_preserve_batch(self, idx):
+ # """
+ # Extract a batch or subset of batches from the sparse tensor without renumbering batch indices.
+ # Unlike __getitem__, this method preserves the original batch IDs in the coords tensor.
+
+ # Args:
+ # idx: Integer, slice, torch.Tensor, or tuple specifying which batch(es) to extract.
+ # When a tuple is provided, it's used for direct slicing of the underlying data.
+
+ # Returns:
+ # SparseTensor: A new sparse tensor with the selected batches and original batch IDs
+ # """
+ # if isinstance(idx, tuple):
+ # # Direct slice-based indexing
+ # coords_slice = self.coords[idx]
+ # feats_slice = self.feats[idx]
+ # return SparseTensor(feats=feats_slice, coords=coords_slice)
+
+ # if isinstance(idx, int):
+ # idx = [idx]
+ # elif isinstance(idx, slice):
+ # idx = range(*idx.indices(self.shape[0]))
+ # elif isinstance(idx, torch.Tensor):
+ # if idx.dtype == torch.bool:
+ # assert idx.shape == (self.shape[0],), f"Invalid index shape: {idx.shape}"
+ # idx = idx.nonzero().squeeze(1)
+ # elif idx.dtype in [torch.int32, torch.int64]:
+ # assert len(idx.shape) == 1, f"Invalid index shape: {idx.shape}"
+ # else:
+ # raise ValueError(f"Unknown index type: {idx.dtype}")
+ # else:
+ # raise ValueError(f"Unknown index type: {type(idx)}")
+
+ # coords = []
+ # feats = []
+ # for old_idx in idx:
+ # coords.append(self.coords[self.layout[old_idx]].clone())
+ # # Keep original batch ID (don't modify coords[:, 0])
+ # feats.append(self.feats[self.layout[old_idx]])
+
+ # coords = torch.cat(coords, dim=0).contiguous()
+ # feats = torch.cat(feats, dim=0).contiguous()
+
+ # # Create new SparseTensor with preserved batch IDs
+ # return SparseTensor(feats=feats, coords=coords)
+
+
+ def register_spatial_cache(self, key, value) -> None:
+ """
+ Register a spatial cache.
+ The spatial cache can be any thing you want to cache.
+ The registery and retrieval of the cache is based on current scale.
+ """
+ scale_key = str(self._scale)
+ if scale_key not in self._spatial_cache:
+ self._spatial_cache[scale_key] = {}
+ self._spatial_cache[scale_key][key] = value
+
+ def get_spatial_cache(self, key=None):
+ """
+ Get a spatial cache.
+ If key is None, return all caches for the current scale.
+ Otherwise, return the cache associated with the specified key.
+ """
+ scale_key = str(self._scale)
+ cur_scale_cache = self._spatial_cache.get(scale_key, {})
+ if key is None:
+ return cur_scale_cache
+ return cur_scale_cache.get(key, None)
+
+
+def sparse_batch_broadcast(input: SparseTensor, other: torch.Tensor) -> torch.Tensor:
+ """
+ Broadcast a tensor to a sparse tensor along the batch dimension.
+
+ Args:
+ input (SparseTensor): Sparse tensor to broadcast to
+ other (torch.Tensor): Tensor to broadcast
+
+ Returns:
+ torch.Tensor: Broadcasted tensor matching the sparse tensor's layout
+ """
+ coords, feats = input.coords, input.feats
+ broadcasted = torch.zeros_like(feats)
+ for k in range(input.shape[0]):
+ broadcasted[input.layout[k]] = other[k]
+ return broadcasted
+
+
+def sparse_batch_op(input: SparseTensor, other: torch.Tensor, op: callable = torch.add) -> SparseTensor:
+ """
+ Broadcast a 1D tensor to a sparse tensor along the batch dimension then perform an operation.
+
+ Args:
+ input (SparseTensor): Sparse tensor to operate on
+ other (torch.Tensor): 1D tensor to broadcast
+ op (callable): Operation to perform after broadcasting. Defaults to torch.add.
+
+ Returns:
+ SparseTensor: Result of the operation
+ """
+ return input.replace(op(input.feats, sparse_batch_broadcast(input, other)))
+
+def sparse_cat(inputs: List[SparseTensor], dim: int = 0) -> SparseTensor:
+ """
+ Concatenate a list of sparse tensors along a specified dimension.
+
+ This function handles two types of concatenation:
+ 1. Batch concatenation (dim=0): Combines multiple sparse tensors by stacking their batches,
+ adjusting batch indices to maintain proper batch ordering.
+ 2. Feature concatenation (dim>0): Combines features while maintaining the same coordinate structure,
+ useful for concatenating different feature channels for the same spatial locations.
+
+ Args:
+ inputs (List[SparseTensor]): List of sparse tensors to concatenate. All tensors must have
+ compatible shapes for the requested concatenation dimension.
+ dim (int): Dimension along which to concatenate.
+ - If 0, batches are concatenated (increasing batch indices)
+ - If >0, features are concatenated (same coordinates, more features)
+
+ Returns:
+ SparseTensor: A new sparse tensor with concatenated data
+ """
+ if dim == 0:
+ # Concatenate batches - requires adjusting batch indices in coordinates
+ start = 0
+ coords = []
+
+ # Process each input sparse tensor
+ for input in inputs:
+ # Create a copy of coordinates to avoid modifying the original
+ current_coords = input.coords.clone()
+
+ # print("current coords", current_coords[:, 0])
+
+ # Adjust batch indices (first column of coordinates) to maintain proper batch ordering
+ # Each tensor's batch indices are offset by the sum of previous tensors' batch sizes
+ current_coords[:, 0] += start
+
+ # print("current coords", current_coords[:, 0])
+ # Add to coordinate list and update the batch counter
+ coords.append(current_coords)
+
+ # print("shape of input", input.shape)
+
+ start += input.shape[0]
+
+ # print("start number", start)
+
+ # Concatenate all adjusted coordinates into a single tensor
+ coords = torch.cat(coords, dim=0)
+
+ # Concatenate feature values in the same order as coordinates
+ feats = torch.cat([input.feats for input in inputs], dim=0)
+
+ # Create a new sparse tensor with combined coordinates and features
+ output = SparseTensor(
+ coords=coords,
+ feats=feats,
+ )
+ else:
+ # Concatenate features only - coordinates remain unchanged
+ # This works when all input tensors share the same coordinate structure
+ # but have different feature dimensions to combine
+
+ # Combine features along the specified dimension
+ feats = torch.cat([input.feats for input in inputs], dim=dim)
+
+ # Create new sparse tensor using the first input's coordinates
+ # but with the concatenated features
+ output = inputs[0].replace(feats)
+
+ return output
+
+
+def sparse_unbind(input: SparseTensor, dim: int) -> List[SparseTensor]:
+ """
+ Unbind a sparse tensor along a dimension.
+
+ Args:
+ input (SparseTensor): Sparse tensor to unbind
+ dim (int): Dimension to unbind
+
+ Returns:
+ List[SparseTensor]: List of sparse tensors, each representing a slice along the dimension
+ """
+ if dim == 0:
+ return [input[i] for i in range(input.shape[0])]
+ else:
+ feats = input.feats.unbind(dim)
+ return [input.replace(f) for f in feats]
diff --git a/OmniPart/training/modules/sparse/conv/__init__.py b/OmniPart/training/modules/sparse/conv/__init__.py
new file mode 100644
index 0000000..340a871
--- /dev/null
+++ b/OmniPart/training/modules/sparse/conv/__init__.py
@@ -0,0 +1,21 @@
+from .. import BACKEND
+
+
+SPCONV_ALGO = 'auto' # 'auto', 'implicit_gemm', 'native'
+
+def __from_env():
+ import os
+
+ global SPCONV_ALGO
+ env_spconv_algo = os.environ.get('SPCONV_ALGO')
+ if env_spconv_algo is not None and env_spconv_algo in ['auto', 'implicit_gemm', 'native']:
+ SPCONV_ALGO = env_spconv_algo
+ print(f"[SPARSE][CONV] spconv algo: {SPCONV_ALGO}")
+
+
+__from_env()
+
+if BACKEND == 'torchsparse':
+ from .conv_torchsparse import *
+elif BACKEND == 'spconv':
+ from .conv_spconv import *
diff --git a/OmniPart/training/modules/sparse/conv/conv_spconv.py b/OmniPart/training/modules/sparse/conv/conv_spconv.py
new file mode 100644
index 0000000..524bcd4
--- /dev/null
+++ b/OmniPart/training/modules/sparse/conv/conv_spconv.py
@@ -0,0 +1,80 @@
+import torch
+import torch.nn as nn
+from .. import SparseTensor
+from .. import DEBUG
+from . import SPCONV_ALGO
+
+class SparseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, padding=None, bias=True, indice_key=None):
+ super(SparseConv3d, self).__init__()
+ if 'spconv' not in globals():
+ import spconv.pytorch as spconv
+ algo = None
+ if SPCONV_ALGO == 'native':
+ algo = spconv.ConvAlgo.Native
+ elif SPCONV_ALGO == 'implicit_gemm':
+ algo = spconv.ConvAlgo.MaskImplicitGemm
+ if stride == 1 and (padding is None):
+ self.conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, dilation=dilation, bias=bias, indice_key=indice_key, algo=algo)
+ else:
+ self.conv = spconv.SparseConv3d(in_channels, out_channels, kernel_size, stride=stride, dilation=dilation, padding=padding, bias=bias, indice_key=indice_key, algo=algo)
+ self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride)
+ self.padding = padding
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ spatial_changed = any(s != 1 for s in self.stride) or (self.padding is not None)
+ new_data = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ new_layout = None if spatial_changed else x.layout
+
+ if spatial_changed and (x.shape[0] != 1):
+ # spconv was non-1 stride will break the contiguous of the output tensor, sort by the coords
+ fwd = new_data.indices[:, 0].argsort()
+ bwd = torch.zeros_like(fwd).scatter_(0, fwd, torch.arange(fwd.shape[0], device=fwd.device))
+ sorted_feats = new_data.features[fwd]
+ sorted_coords = new_data.indices[fwd]
+ unsorted_data = new_data
+ new_data = spconv.SparseConvTensor(sorted_feats, sorted_coords, unsorted_data.spatial_shape, unsorted_data.batch_size) # type: ignore
+
+ out = SparseTensor(
+ new_data, shape=torch.Size(new_shape), layout=new_layout,
+ scale=tuple([s * stride for s, stride in zip(x._scale, self.stride)]),
+ spatial_cache=x._spatial_cache,
+ )
+
+ if spatial_changed and (x.shape[0] != 1):
+ out.register_spatial_cache(f'conv_{self.stride}_unsorted_data', unsorted_data)
+ out.register_spatial_cache(f'conv_{self.stride}_sort_bwd', bwd)
+
+ return out
+
+
+class SparseInverseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseInverseConv3d, self).__init__()
+ if 'spconv' not in globals():
+ import spconv.pytorch as spconv
+ self.conv = spconv.SparseInverseConv3d(in_channels, out_channels, kernel_size, bias=bias, indice_key=indice_key)
+ self.stride = tuple(stride) if isinstance(stride, (list, tuple)) else (stride, stride, stride)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ spatial_changed = any(s != 1 for s in self.stride)
+ if spatial_changed:
+ # recover the original spconv order
+ data = x.get_spatial_cache(f'conv_{self.stride}_unsorted_data')
+ bwd = x.get_spatial_cache(f'conv_{self.stride}_sort_bwd')
+ data = data.replace_feature(x.feats[bwd])
+ if DEBUG:
+ assert torch.equal(data.indices, x.coords[bwd]), 'Recover the original order failed'
+ else:
+ data = x.data
+
+ new_data = self.conv(data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ new_layout = None if spatial_changed else x.layout
+ out = SparseTensor(
+ new_data, shape=torch.Size(new_shape), layout=new_layout,
+ scale=tuple([s // stride for s, stride in zip(x._scale, self.stride)]),
+ spatial_cache=x._spatial_cache,
+ )
+ return out
diff --git a/OmniPart/training/modules/sparse/conv/conv_torchsparse.py b/OmniPart/training/modules/sparse/conv/conv_torchsparse.py
new file mode 100644
index 0000000..1d61258
--- /dev/null
+++ b/OmniPart/training/modules/sparse/conv/conv_torchsparse.py
@@ -0,0 +1,38 @@
+import torch
+import torch.nn as nn
+from .. import SparseTensor
+
+
+class SparseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseConv3d, self).__init__()
+ if 'torchsparse' not in globals():
+ import torchsparse
+ self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ out = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None)
+ out._spatial_cache = x._spatial_cache
+ out._scale = tuple([s * stride for s, stride in zip(x._scale, self.conv.stride)])
+ return out
+
+
+class SparseInverseConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, bias=True, indice_key=None):
+ super(SparseInverseConv3d, self).__init__()
+ if 'torchsparse' not in globals():
+ import torchsparse
+ self.conv = torchsparse.nn.Conv3d(in_channels, out_channels, kernel_size, stride, 0, dilation, bias, transposed=True)
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ out = self.conv(x.data)
+ new_shape = [x.shape[0], self.conv.out_channels]
+ out = SparseTensor(out, shape=torch.Size(new_shape), layout=x.layout if all(s == 1 for s in self.conv.stride) else None)
+ out._spatial_cache = x._spatial_cache
+ out._scale = tuple([s // stride for s, stride in zip(x._scale, self.conv.stride)])
+ return out
+
+
+
diff --git a/OmniPart/training/modules/sparse/linear.py b/OmniPart/training/modules/sparse/linear.py
new file mode 100644
index 0000000..a854e77
--- /dev/null
+++ b/OmniPart/training/modules/sparse/linear.py
@@ -0,0 +1,15 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseLinear'
+]
+
+
+class SparseLinear(nn.Linear):
+ def __init__(self, in_features, out_features, bias=True):
+ super(SparseLinear, self).__init__(in_features, out_features, bias)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
diff --git a/OmniPart/training/modules/sparse/nonlinearity.py b/OmniPart/training/modules/sparse/nonlinearity.py
new file mode 100644
index 0000000..f200098
--- /dev/null
+++ b/OmniPart/training/modules/sparse/nonlinearity.py
@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseReLU',
+ 'SparseSiLU',
+ 'SparseGELU',
+ 'SparseActivation'
+]
+
+
+class SparseReLU(nn.ReLU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseSiLU(nn.SiLU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseGELU(nn.GELU):
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(super().forward(input.feats))
+
+
+class SparseActivation(nn.Module):
+ def __init__(self, activation: nn.Module):
+ super().__init__()
+ self.activation = activation
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ return input.replace(self.activation(input.feats))
+
diff --git a/OmniPart/training/modules/sparse/norm.py b/OmniPart/training/modules/sparse/norm.py
new file mode 100644
index 0000000..6b38a36
--- /dev/null
+++ b/OmniPart/training/modules/sparse/norm.py
@@ -0,0 +1,58 @@
+import torch
+import torch.nn as nn
+from . import SparseTensor
+from . import DEBUG
+
+__all__ = [
+ 'SparseGroupNorm',
+ 'SparseLayerNorm',
+ 'SparseGroupNorm32',
+ 'SparseLayerNorm32',
+]
+
+
+class SparseGroupNorm(nn.GroupNorm):
+ def __init__(self, num_groups, num_channels, eps=1e-5, affine=True):
+ super(SparseGroupNorm, self).__init__(num_groups, num_channels, eps, affine)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ nfeats = torch.zeros_like(input.feats)
+ for k in range(input.shape[0]):
+ if DEBUG:
+ assert (input.coords[input.layout[k], 0] == k).all(), f"SparseGroupNorm: batch index mismatch"
+ bfeats = input.feats[input.layout[k]]
+ bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1)
+ bfeats = super().forward(bfeats)
+ bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0)
+ nfeats[input.layout[k]] = bfeats
+ return input.replace(nfeats)
+
+
+class SparseLayerNorm(nn.LayerNorm):
+ def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True):
+ super(SparseLayerNorm, self).__init__(normalized_shape, eps, elementwise_affine)
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ nfeats = torch.zeros_like(input.feats)
+ for k in range(input.shape[0]):
+ bfeats = input.feats[input.layout[k]]
+ bfeats = bfeats.permute(1, 0).reshape(1, input.shape[1], -1)
+ bfeats = super().forward(bfeats)
+ bfeats = bfeats.reshape(input.shape[1], -1).permute(1, 0)
+ nfeats[input.layout[k]] = bfeats
+ return input.replace(nfeats)
+
+
+class SparseGroupNorm32(SparseGroupNorm):
+ """
+ A GroupNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return super().forward(x.float()).type(x.dtype)
+
+class SparseLayerNorm32(SparseLayerNorm):
+ """
+ A LayerNorm layer that converts to float32 before the forward pass.
+ """
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return super().forward(x.float()).type(x.dtype)
diff --git a/OmniPart/training/modules/sparse/spatial.py b/OmniPart/training/modules/sparse/spatial.py
new file mode 100644
index 0000000..ad71214
--- /dev/null
+++ b/OmniPart/training/modules/sparse/spatial.py
@@ -0,0 +1,110 @@
+from typing import *
+import torch
+import torch.nn as nn
+from . import SparseTensor
+
+__all__ = [
+ 'SparseDownsample',
+ 'SparseUpsample',
+ 'SparseSubdivide'
+]
+
+
+class SparseDownsample(nn.Module):
+ """
+ Downsample a sparse tensor by a factor of `factor`.
+ Implemented as average pooling.
+ """
+ def __init__(self, factor: Union[int, Tuple[int, ...], List[int]]):
+ super(SparseDownsample, self).__init__()
+ self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM
+ assert DIM == len(factor), 'Input coordinates must have the same dimension as the downsample factor.'
+
+ coord = list(input.coords.unbind(dim=-1))
+ for i, f in enumerate(factor):
+ coord[i+1] = coord[i+1] // f
+
+ MAX = [coord[i+1].max().item() + 1 for i in range(DIM)]
+ OFFSET = torch.cumprod(torch.tensor(MAX[::-1]), 0).tolist()[::-1] + [1]
+ code = sum([c * o for c, o in zip(coord, OFFSET)])
+ code, idx = code.unique(return_inverse=True)
+
+ new_feats = torch.scatter_reduce(
+ torch.zeros(code.shape[0], input.feats.shape[1], device=input.feats.device, dtype=input.feats.dtype),
+ dim=0,
+ index=idx.unsqueeze(1).expand(-1, input.feats.shape[1]),
+ src=input.feats,
+ reduce='mean'
+ )
+ new_coords = torch.stack(
+ [code // OFFSET[0]] +
+ [(code // OFFSET[i+1]) % MAX[i] for i in range(DIM)],
+ dim=-1
+ )
+ out = SparseTensor(new_feats, new_coords, input.shape,)
+ out._scale = tuple([s // f for s, f in zip(input._scale, factor)])
+ out._spatial_cache = input._spatial_cache
+
+ out.register_spatial_cache(f'upsample_{factor}_coords', input.coords)
+ out.register_spatial_cache(f'upsample_{factor}_layout', input.layout)
+ out.register_spatial_cache(f'upsample_{factor}_idx', idx)
+
+ return out
+
+
+class SparseUpsample(nn.Module):
+ """
+ Upsample a sparse tensor by a factor of `factor`.
+ Implemented as nearest neighbor interpolation.
+ """
+ def __init__(self, factor: Union[int, Tuple[int, int, int], List[int]]):
+ super(SparseUpsample, self).__init__()
+ self.factor = tuple(factor) if isinstance(factor, (list, tuple)) else factor
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ factor = self.factor if isinstance(self.factor, tuple) else (self.factor,) * DIM
+ assert DIM == len(factor), 'Input coordinates must have the same dimension as the upsample factor.'
+
+ new_coords = input.get_spatial_cache(f'upsample_{factor}_coords')
+ new_layout = input.get_spatial_cache(f'upsample_{factor}_layout')
+ idx = input.get_spatial_cache(f'upsample_{factor}_idx')
+ if any([x is None for x in [new_coords, new_layout, idx]]):
+ raise ValueError('Upsample cache not found. SparseUpsample must be paired with SparseDownsample.')
+ new_feats = input.feats[idx]
+ out = SparseTensor(new_feats, new_coords, input.shape, new_layout)
+ out._scale = tuple([s * f for s, f in zip(input._scale, factor)])
+ out._spatial_cache = input._spatial_cache
+ return out
+
+class SparseSubdivide(nn.Module):
+ """
+ Upsample a sparse tensor by a factor of `factor`.
+ Implemented as nearest neighbor interpolation.
+ """
+ def __init__(self):
+ super(SparseSubdivide, self).__init__()
+
+ def forward(self, input: SparseTensor) -> SparseTensor:
+ DIM = input.coords.shape[-1] - 1
+ # upsample scale=2^DIM
+ n_cube = torch.ones([2] * DIM, device=input.device, dtype=torch.int)
+ n_coords = torch.nonzero(n_cube)
+ n_coords = torch.cat([torch.zeros_like(n_coords[:, :1]), n_coords], dim=-1)
+ factor = n_coords.shape[0]
+ assert factor == 2 ** DIM
+ # print(n_coords.shape)
+ new_coords = input.coords.clone()
+ new_coords[:, 1:] *= 2
+ new_coords = new_coords.unsqueeze(1) + n_coords.unsqueeze(0).to(new_coords.dtype)
+
+ new_feats = input.feats.unsqueeze(1).expand(input.feats.shape[0], factor, *input.feats.shape[1:])
+ out = SparseTensor(new_feats.flatten(0, 1), new_coords.flatten(0, 1), input.shape)
+ out._scale = input._scale * 2
+ out._spatial_cache = input._spatial_cache
+ return out
+
diff --git a/OmniPart/training/modules/sparse/transformer/__init__.py b/OmniPart/training/modules/sparse/transformer/__init__.py
new file mode 100644
index 0000000..b08b0d4
--- /dev/null
+++ b/OmniPart/training/modules/sparse/transformer/__init__.py
@@ -0,0 +1,2 @@
+from .blocks import *
+from .modulated import *
\ No newline at end of file
diff --git a/OmniPart/training/modules/sparse/transformer/blocks.py b/OmniPart/training/modules/sparse/transformer/blocks.py
new file mode 100644
index 0000000..9d037a4
--- /dev/null
+++ b/OmniPart/training/modules/sparse/transformer/blocks.py
@@ -0,0 +1,151 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..basic import SparseTensor
+from ..linear import SparseLinear
+from ..nonlinearity import SparseGELU
+from ..attention import SparseMultiHeadAttention, SerializeMode
+from ...norm import LayerNorm32
+
+
+class SparseFeedForwardNet(nn.Module):
+ def __init__(self, channels: int, mlp_ratio: float = 4.0):
+ super().__init__()
+ self.mlp = nn.Sequential(
+ SparseLinear(channels, int(channels * mlp_ratio)),
+ SparseGELU(approximate="tanh"),
+ SparseLinear(int(channels * mlp_ratio), channels),
+ )
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ return self.mlp(x)
+
+
+class SparseTransformerBlock(nn.Module):
+ """
+ Sparse Transformer block (MSA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: SparseTensor) -> SparseTensor:
+ h = x.replace(self.norm1(x.feats))
+ h = self.attn(h)
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False)
+ else:
+ return self._forward(x)
+
+
+class SparseTransformerCrossBlock(nn.Module):
+ """
+ Sparse Transformer cross-attention block (MSA + MCA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.self_attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = SparseMultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor):
+ h = x.replace(self.norm1(x.feats))
+ h = self.self_attn(h)
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = x.replace(self.norm3(x.feats))
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, context: torch.Tensor):
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False)
+ else:
+ return self._forward(x, context)
diff --git a/OmniPart/training/modules/sparse/transformer/modulated.py b/OmniPart/training/modules/sparse/transformer/modulated.py
new file mode 100644
index 0000000..4a84165
--- /dev/null
+++ b/OmniPart/training/modules/sparse/transformer/modulated.py
@@ -0,0 +1,166 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..basic import SparseTensor
+from ..attention import SparseMultiHeadAttention, SerializeMode
+from ...norm import LayerNorm32
+from .blocks import SparseFeedForwardNet
+
+
+class ModulatedSparseTransformerBlock(nn.Module):
+ """
+ Sparse Transformer block (MSA + FFN) with adaptive layer norm conditioning.
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ share_mod: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True)
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor:
+ if self.share_mod:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+ h = x.replace(self.norm1(x.feats))
+ h = h * (1 + scale_msa) + shift_msa
+ h = self.attn(h)
+ h = h * gate_msa
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = h * (1 + scale_mlp) + shift_mlp
+ h = self.mlp(h)
+ h = h * gate_mlp
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, mod: torch.Tensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False)
+ else:
+ return self._forward(x, mod)
+
+
+class ModulatedSparseTransformerCrossBlock(nn.Module):
+ """
+ Sparse Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning.
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "shift_window", "shift_sequence", "shift_order", "swin"] = "full",
+ window_size: Optional[int] = None,
+ shift_sequence: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ serialize_mode: Optional[SerializeMode] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ share_mod: bool = False,
+
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.self_attn = SparseMultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_sequence=shift_sequence,
+ shift_window=shift_window,
+ serialize_mode=serialize_mode,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = SparseMultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = SparseFeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True)
+ )
+
+ def _forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor:
+ if self.share_mod:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+ h = x.replace(self.norm1(x.feats))
+ h = h * (1 + scale_msa) + shift_msa
+ h = self.self_attn(h)
+ h = h * gate_msa
+ x = x + h
+ h = x.replace(self.norm2(x.feats))
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = x.replace(self.norm3(x.feats))
+ h = h * (1 + scale_mlp) + shift_mlp
+ h = self.mlp(h)
+ h = h * gate_mlp
+ x = x + h
+ return x
+
+ def forward(self, x: SparseTensor, mod: torch.Tensor, context: torch.Tensor) -> SparseTensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False)
+ else:
+ return self._forward(x, mod, context)
diff --git a/OmniPart/training/modules/spatial.py b/OmniPart/training/modules/spatial.py
new file mode 100644
index 0000000..79e268d
--- /dev/null
+++ b/OmniPart/training/modules/spatial.py
@@ -0,0 +1,48 @@
+import torch
+
+
+def pixel_shuffle_3d(x: torch.Tensor, scale_factor: int) -> torch.Tensor:
+ """
+ 3D pixel shuffle.
+ """
+ B, C, H, W, D = x.shape
+ C_ = C // scale_factor**3
+ x = x.reshape(B, C_, scale_factor, scale_factor, scale_factor, H, W, D)
+ x = x.permute(0, 1, 5, 2, 6, 3, 7, 4)
+ x = x.reshape(B, C_, H*scale_factor, W*scale_factor, D*scale_factor)
+ return x
+
+
+def patchify(x: torch.Tensor, patch_size: int):
+ """
+ Patchify a tensor.
+
+ Args:
+ x (torch.Tensor): (N, C, *spatial) tensor
+ patch_size (int): Patch size
+ """
+ DIM = x.dim() - 2
+ for d in range(2, DIM + 2):
+ assert x.shape[d] % patch_size == 0, f"Dimension {d} of input tensor must be divisible by patch size, got {x.shape[d]} and {patch_size}"
+
+ x = x.reshape(*x.shape[:2], *sum([[x.shape[d] // patch_size, patch_size] for d in range(2, DIM + 2)], []))
+ x = x.permute(0, 1, *([2 * i + 3 for i in range(DIM)] + [2 * i + 2 for i in range(DIM)]))
+ x = x.reshape(x.shape[0], x.shape[1] * (patch_size ** DIM), *(x.shape[-DIM:]))
+ return x
+
+
+def unpatchify(x: torch.Tensor, patch_size: int):
+ """
+ Unpatchify a tensor.
+
+ Args:
+ x (torch.Tensor): (N, C, *spatial) tensor
+ patch_size (int): Patch size
+ """
+ DIM = x.dim() - 2
+ assert x.shape[1] % (patch_size ** DIM) == 0, f"Second dimension of input tensor must be divisible by patch size to unpatchify, got {x.shape[1]} and {patch_size ** DIM}"
+
+ x = x.reshape(x.shape[0], x.shape[1] // (patch_size ** DIM), *([patch_size] * DIM), *(x.shape[-DIM:]))
+ x = x.permute(0, 1, *(sum([[2 + DIM + i, 2 + i] for i in range(DIM)], [])))
+ x = x.reshape(x.shape[0], x.shape[1], *[x.shape[2 + 2 * i] * patch_size for i in range(DIM)])
+ return x
diff --git a/OmniPart/training/modules/transformer/__init__.py b/OmniPart/training/modules/transformer/__init__.py
new file mode 100644
index 0000000..b08b0d4
--- /dev/null
+++ b/OmniPart/training/modules/transformer/__init__.py
@@ -0,0 +1,2 @@
+from .blocks import *
+from .modulated import *
\ No newline at end of file
diff --git a/OmniPart/training/modules/transformer/blocks.py b/OmniPart/training/modules/transformer/blocks.py
new file mode 100644
index 0000000..c37eb7e
--- /dev/null
+++ b/OmniPart/training/modules/transformer/blocks.py
@@ -0,0 +1,182 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..attention import MultiHeadAttention
+from ..norm import LayerNorm32
+
+
+class AbsolutePositionEmbedder(nn.Module):
+ """
+ Embeds spatial positions into vector representations.
+ """
+ def __init__(self, channels: int, in_channels: int = 3):
+ super().__init__()
+ self.channels = channels
+ self.in_channels = in_channels
+ self.freq_dim = channels // in_channels // 2
+ self.freqs = torch.arange(self.freq_dim, dtype=torch.float32) / self.freq_dim
+ self.freqs = 1.0 / (10000 ** self.freqs)
+
+ def _sin_cos_embedding(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Create sinusoidal position embeddings.
+
+ Args:
+ x: a 1-D Tensor of N indices
+
+ Returns:
+ an (N, D) Tensor of positional embeddings.
+ """
+ self.freqs = self.freqs.to(x.device)
+ out = torch.outer(x, self.freqs)
+ out = torch.cat([torch.sin(out), torch.cos(out)], dim=-1)
+ return out
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ """
+ Args:
+ x (torch.Tensor): (N, D) tensor of spatial positions
+ """
+ N, D = x.shape
+ assert D == self.in_channels, "Input dimension must match number of input channels"
+ embed = self._sin_cos_embedding(x.reshape(-1))
+ embed = embed.reshape(N, -1)
+ if embed.shape[1] < self.channels:
+ embed = torch.cat([embed, torch.zeros(N, self.channels - embed.shape[1], device=embed.device)], dim=-1)
+ return embed
+
+
+class FeedForwardNet(nn.Module):
+ def __init__(self, channels: int, mlp_ratio: float = 4.0):
+ super().__init__()
+ self.mlp = nn.Sequential(
+ nn.Linear(channels, int(channels * mlp_ratio)),
+ nn.GELU(approximate="tanh"),
+ nn.Linear(int(channels * mlp_ratio), channels),
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ return self.mlp(x)
+
+
+class TransformerBlock(nn.Module):
+ """
+ Transformer block (MSA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[int] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: torch.Tensor) -> torch.Tensor:
+ h = self.norm1(x)
+ h = self.attn(h)
+ x = x + h
+ h = self.norm2(x)
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, use_reentrant=False)
+ else:
+ return self._forward(x)
+
+
+class TransformerCrossBlock(nn.Module):
+ """
+ Transformer cross-attention block (MSA + MCA + FFN).
+ """
+ def __init__(
+ self,
+ channels: int,
+ ctx_channels: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ attn_mode: Literal["full", "windowed"] = "full",
+ window_size: Optional[int] = None,
+ shift_window: Optional[Tuple[int, int, int]] = None,
+ use_checkpoint: bool = False,
+ use_rope: bool = False,
+ qk_rms_norm: bool = False,
+ qk_rms_norm_cross: bool = False,
+ qkv_bias: bool = True,
+ ln_affine: bool = False,
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.norm1 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.norm3 = LayerNorm32(channels, elementwise_affine=ln_affine, eps=1e-6)
+ self.self_attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+ self.cross_attn = MultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full",
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ def _forward(self, x: torch.Tensor, context: torch.Tensor):
+ h = self.norm1(x)
+ h = self.self_attn(h)
+ x = x + h
+ h = self.norm2(x)
+ h = self.cross_attn(h, context)
+ x = x + h
+ h = self.norm3(x)
+ h = self.mlp(h)
+ x = x + h
+ return x
+
+ def forward(self, x: torch.Tensor, context: torch.Tensor):
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, context, use_reentrant=False)
+ else:
+ return self._forward(x, context)
+
\ No newline at end of file
diff --git a/OmniPart/training/modules/transformer/modulated.py b/OmniPart/training/modules/transformer/modulated.py
new file mode 100644
index 0000000..a470615
--- /dev/null
+++ b/OmniPart/training/modules/transformer/modulated.py
@@ -0,0 +1,240 @@
+from typing import *
+import torch
+import torch.nn as nn
+from ..attention import MultiHeadAttention
+from ..norm import LayerNorm32
+from .blocks import FeedForwardNet
+
+
+class ModulatedTransformerBlock(nn.Module):
+ """
+ Transformer block (MSA + FFN) with adaptive layer norm conditioning.
+
+ This block combines multi-head self-attention with a feed-forward network,
+ and uses adaptive layer normalization to condition the processing on external information.
+ """
+ def __init__(
+ self,
+ channels: int, # Number of input/output channels
+ num_heads: int, # Number of attention heads
+ mlp_ratio: float = 4.0, # Ratio determining MLP hidden dimension size
+ attn_mode: Literal["full", "windowed"] = "full", # Attention computation mode
+ window_size: Optional[int] = None, # Size of attention window if using windowed attention
+ shift_window: Optional[Tuple[int, int, int]] = None, # Parameters for shifted window attention
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing to save memory
+ use_rope: bool = False, # Whether to use Rotary Position Embedding
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for query and key
+ qkv_bias: bool = True, # Whether to use bias in QKV projection
+ share_mod: bool = False, # Whether to share modulation parameters externally
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+
+ # Layer normalization without affine parameters (will be modulated)
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+ self.norm2 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6)
+
+ # Multi-head self-attention layer
+ self.attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+
+ # Feed-forward network
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ # Modulation network to generate adaptive parameters if not shared
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True) # 6 channels: shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp
+ )
+
+ def _forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor:
+ """
+ Internal forward function for the modulated transformer block.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ # Split modulation vector into shift, scale, and gate parameters for MSA and FFN
+ if self.share_mod:
+ # Use externally provided modulation parameters
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ # Generate modulation parameters from the conditioning vector
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+
+ # Apply modulated self-attention
+ h = self.norm1(x) # Normalize
+ h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) # Apply modulation
+ h = self.attn(h) # Self-attention
+ h = h * gate_msa.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ # Apply modulated feed-forward network
+ h = self.norm2(x) # Normalize
+ h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) # Apply modulation
+ h = self.mlp(h) # Feed-forward
+ h = h * gate_mlp.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ return x
+
+ def forward(self, x: torch.Tensor, mod: torch.Tensor) -> torch.Tensor:
+ """
+ Forward pass with optional gradient checkpointing to save memory.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, use_reentrant=False)
+ else:
+ return self._forward(x, mod)
+
+
+class ModulatedTransformerCrossBlock(nn.Module):
+ """
+ Transformer cross-attention block (MSA + MCA + FFN) with adaptive layer norm conditioning.
+
+ This block extends the standard transformer block with an additional cross-attention
+ layer, allowing it to attend to a separate context input.
+ """
+ def __init__(
+ self,
+ channels: int, # Number of input/output channels
+ ctx_channels: int, # Number of context channels
+ num_heads: int, # Number of attention heads
+ mlp_ratio: float = 4.0, # Ratio determining MLP hidden dimension size
+ attn_mode: Literal["full", "windowed"] = "full", # Attention computation mode
+ window_size: Optional[int] = None, # Size of attention window if using windowed attention
+ shift_window: Optional[Tuple[int, int, int]] = None, # Parameters for shifted window attention
+ use_checkpoint: bool = False, # Whether to use gradient checkpointing to save memory
+ use_rope: bool = False, # Whether to use Rotary Position Embedding
+ qk_rms_norm: bool = False, # Whether to use RMS normalization for query and key in self-attention
+ qk_rms_norm_cross: bool = False, # Whether to use RMS normalization for query and key in cross-attention
+ qkv_bias: bool = True, # Whether to use bias in QKV projection
+ share_mod: bool = False, # Whether to share modulation parameters externally
+ ):
+ super().__init__()
+ self.use_checkpoint = use_checkpoint
+ self.share_mod = share_mod
+
+ # Layer normalizations
+ self.norm1 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) # For self-attention, will be modulated
+ self.norm2 = LayerNorm32(channels, elementwise_affine=True, eps=1e-6) # For cross-attention, standard normalization
+ self.norm3 = LayerNorm32(channels, elementwise_affine=False, eps=1e-6) # For FFN, will be modulated
+
+ # Self-attention layer
+ self.self_attn = MultiHeadAttention(
+ channels,
+ num_heads=num_heads,
+ type="self",
+ attn_mode=attn_mode,
+ window_size=window_size,
+ shift_window=shift_window,
+ qkv_bias=qkv_bias,
+ use_rope=use_rope,
+ qk_rms_norm=qk_rms_norm,
+ )
+
+ # Cross-attention layer
+ self.cross_attn = MultiHeadAttention(
+ channels,
+ ctx_channels=ctx_channels,
+ num_heads=num_heads,
+ type="cross",
+ attn_mode="full", # Cross-attention always uses full attention
+ qkv_bias=qkv_bias,
+ qk_rms_norm=qk_rms_norm_cross,
+ )
+
+ # Feed-forward network
+ self.mlp = FeedForwardNet(
+ channels,
+ mlp_ratio=mlp_ratio,
+ )
+
+ # Modulation network to generate adaptive parameters if not shared
+ if not share_mod:
+ self.adaLN_modulation = nn.Sequential(
+ nn.SiLU(),
+ nn.Linear(channels, 6 * channels, bias=True) # 6 channels: shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp
+ )
+
+ def _forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor):
+ """
+ Internal forward function for the modulated transformer cross-attention block.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+ context: Context tensor for cross-attention [batch, context_len, ctx_channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ # Split modulation vector into shift, scale, and gate parameters for MSA and FFN
+ if self.share_mod:
+ # Use externally provided modulation parameters
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = mod.chunk(6, dim=1)
+ else:
+ # Generate modulation parameters from the conditioning vector
+ shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(mod).chunk(6, dim=1)
+
+ # Apply modulated self-attention
+ h = self.norm1(x) # Normalize
+ h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) # Apply modulation
+ h = self.self_attn(h) # Self-attention
+ h = h * gate_msa.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ # Apply cross-attention (not modulated)
+ h = self.norm2(x) # Normalize
+ h = self.cross_attn(h, context) # Cross-attention with context
+ x = x + h # Residual connection
+
+ # Apply modulated feed-forward network
+ h = self.norm3(x) # Normalize
+ h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) # Apply modulation
+ h = self.mlp(h) # Feed-forward
+ h = h * gate_mlp.unsqueeze(1) # Apply gate
+ x = x + h # Residual connection
+
+ return x
+
+ def forward(self, x: torch.Tensor, mod: torch.Tensor, context: torch.Tensor):
+ """
+ Forward pass with optional gradient checkpointing to save memory.
+
+ Args:
+ x: Input tensor [batch, seq_len, channels]
+ mod: Modulation tensor [batch, channels]
+ context: Context tensor for cross-attention [batch, context_len, ctx_channels]
+
+ Returns:
+ Processed tensor with same shape as input
+ """
+ if self.use_checkpoint:
+ return torch.utils.checkpoint.checkpoint(self._forward, x, mod, context, use_reentrant=False)
+ else:
+ return self._forward(x, mod, context)
\ No newline at end of file
diff --git a/OmniPart/training/modules/utils.py b/OmniPart/training/modules/utils.py
new file mode 100644
index 0000000..f0afb1b
--- /dev/null
+++ b/OmniPart/training/modules/utils.py
@@ -0,0 +1,54 @@
+import torch.nn as nn
+from ..modules import sparse as sp
+
+FP16_MODULES = (
+ nn.Conv1d,
+ nn.Conv2d,
+ nn.Conv3d,
+ nn.ConvTranspose1d,
+ nn.ConvTranspose2d,
+ nn.ConvTranspose3d,
+ nn.Linear,
+ sp.SparseConv3d,
+ sp.SparseInverseConv3d,
+ sp.SparseLinear,
+)
+
+def convert_module_to_f16(l):
+ """
+ Convert primitive modules to float16.
+ """
+ if isinstance(l, FP16_MODULES):
+ for p in l.parameters():
+ p.data = p.data.half()
+
+
+def convert_module_to_f32(l):
+ """
+ Convert primitive modules to float32, undoing convert_module_to_f16().
+ """
+ if isinstance(l, FP16_MODULES):
+ for p in l.parameters():
+ p.data = p.data.float()
+
+
+def zero_module(module):
+ """
+ Zero out the parameters of a module and return it.
+ """
+ for p in module.parameters():
+ p.detach().zero_()
+ return module
+
+
+def scale_module(module, scale):
+ """
+ Scale the parameters of a module and return it.
+ """
+ for p in module.parameters():
+ p.detach().mul_(scale)
+ return module
+
+
+def modulate(x, shift, scale):
+ return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
diff --git a/OmniPart/training/pipelines/__init__.py b/OmniPart/training/pipelines/__init__.py
new file mode 100644
index 0000000..0ab84bc
--- /dev/null
+++ b/OmniPart/training/pipelines/__init__.py
@@ -0,0 +1,26 @@
+from . import samplers
+# from .trellis_image_to_3d import TrellisImageTo3DPipeline
+from .trellis_text_to_3d import TrellisTextTo3DPipeline
+from .trellis_image_to_parts import TrellisImageTo3DPipeline
+
+
+def from_pretrained(path: str):
+ """
+ Load a pipeline from a model folder or a Hugging Face model hub.
+
+ Args:
+ path: The path to the model. Can be either local path or a Hugging Face model name.
+ """
+ import os
+ import json
+ is_local = os.path.exists(f"{path}/pipeline.json")
+
+ if is_local:
+ config_file = f"{path}/pipeline.json"
+ else:
+ from huggingface_hub import hf_hub_download
+ config_file = hf_hub_download(path, "pipeline.json")
+
+ with open(config_file, 'r') as f:
+ config = json.load(f)
+ return globals()[config['name']].from_pretrained(path)
diff --git a/OmniPart/training/pipelines/base.py b/OmniPart/training/pipelines/base.py
new file mode 100644
index 0000000..01c71d6
--- /dev/null
+++ b/OmniPart/training/pipelines/base.py
@@ -0,0 +1,121 @@
+from typing import *
+import torch
+import torch.nn as nn
+from .. import models
+from ..utils.transfer_st_pt import convert_pt_to_safetensors, save_json
+
+class Pipeline:
+ """
+ A base class for pipelines.
+ """
+ def __init__(
+ self,
+ models: Dict[str, nn.Module] = None,
+ ):
+ if models is None:
+ return
+ self.models = models
+ for model in self.models.values():
+ model.eval()
+
+ def finetune_from_pretrained(self, model_name:str, path: str):
+ """
+ Load a finetuned part model.
+ """
+ import os
+ import json
+ from safetensors.torch import load_file
+
+ # Convert to safetensors format if necessary
+ st_path_name = convert_pt_to_safetensors(path)
+ save_json(model_name, st_path_name)
+
+ print(f"Loading model {model_name} from {st_path_name}")
+
+ try:
+ # Load the config file
+ config_file = f"{st_path_name}.json"
+ if os.path.exists(config_file):
+ with open(config_file, 'r') as f:
+ config = json.load(f)
+
+ # Special handling for certain models that need channel adjustment
+ if model_name == "slat_flow_model":
+ # Override in_channels and out_channels specifically for finetuning
+ config['args']['in_channels'] = 9
+ config['args']['out_channels'] = 9
+ print(f"Overriding channels for finetuning {model_name}: in_channels=9, out_channels=9")
+
+ # Create the model with the adjusted config
+ model = models.__getattr__(config['name'])(**config['args'])
+
+ # Load the model weights
+ model_file = f"{st_path_name}.safetensors"
+ state_dict = load_file(model_file)
+
+ # Load with strict=False to allow parameter shape mismatches
+ model.load_state_dict(state_dict, strict=False)
+ self.models[model_name] = model
+ else:
+ # Fallback to standard loading
+ self.models[model_name] = models.from_pretrained(f"{st_path_name}")
+
+ except Exception as e:
+ print(f"Error loading model: {str(e)}")
+ raise RuntimeError(f"Model {model_name} not found in {st_path_name}")
+
+ def finetune_from_pretrained_list(self, model_name_paths: List[Tuple[str, str]]):
+ """
+ Load a finetuned part model.
+ """
+ for model_name, path in model_name_paths:
+ self.finetune_from_pretrained(model_name, path)
+
+ @staticmethod
+ def from_pretrained(path: str) -> "Pipeline":
+ """
+ Load a pretrained model.
+ """
+ import os
+ import json
+ is_local = os.path.exists(f"{path}/pipeline.json")
+
+ if is_local:
+ config_file = f"{path}/pipeline.json"
+ else:
+ from huggingface_hub import hf_hub_download
+ config_file = hf_hub_download(path, "pipeline.json")
+
+ with open(config_file, 'r') as f:
+ args = json.load(f)['args']
+
+ _models = {}
+ for k, v in args['models'].items():
+ try:
+ _models[k] = models.from_pretrained(f"{path}/{v}")
+ except:
+ _models[k] = models.from_pretrained(v)
+
+ new_pipeline = Pipeline(_models)
+ new_pipeline._pretrained_args = args
+ return new_pipeline
+
+ @property
+ def device(self) -> torch.device:
+ for model in self.models.values():
+ if hasattr(model, 'device'):
+ return model.device
+ for model in self.models.values():
+ if hasattr(model, 'parameters'):
+ return next(model.parameters()).device
+ raise RuntimeError("No device found.")
+
+ def to(self, device: torch.device) -> None:
+ for model in self.models.values():
+ model.to(device)
+
+ def cuda(self) -> None:
+ self.to(torch.device("cuda"))
+
+ def cpu(self) -> None:
+ self.to(torch.device("cpu"))
diff --git a/OmniPart/training/pipelines/samplers/__init__.py b/OmniPart/training/pipelines/samplers/__init__.py
new file mode 100644
index 0000000..54d412f
--- /dev/null
+++ b/OmniPart/training/pipelines/samplers/__init__.py
@@ -0,0 +1,2 @@
+from .base import Sampler
+from .flow_euler import FlowEulerSampler, FlowEulerCfgSampler, FlowEulerGuidanceIntervalSampler
\ No newline at end of file
diff --git a/OmniPart/training/pipelines/samplers/base.py b/OmniPart/training/pipelines/samplers/base.py
new file mode 100644
index 0000000..1966ce7
--- /dev/null
+++ b/OmniPart/training/pipelines/samplers/base.py
@@ -0,0 +1,20 @@
+from typing import *
+from abc import ABC, abstractmethod
+
+
+class Sampler(ABC):
+ """
+ A base class for samplers.
+ """
+
+ @abstractmethod
+ def sample(
+ self,
+ model,
+ **kwargs
+ ):
+ """
+ Sample from a model.
+ """
+ pass
+
\ No newline at end of file
diff --git a/OmniPart/training/pipelines/samplers/classifier_free_guidance_mixin.py b/OmniPart/training/pipelines/samplers/classifier_free_guidance_mixin.py
new file mode 100644
index 0000000..c9600c1
--- /dev/null
+++ b/OmniPart/training/pipelines/samplers/classifier_free_guidance_mixin.py
@@ -0,0 +1,16 @@
+from typing import *
+import torch
+
+
+class ClassifierFreeGuidanceSamplerMixin:
+ """
+ A mixin class for samplers that apply classifier-free guidance.
+ """
+
+ def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, **kwargs):
+ # kwargs['if_use_mask'] = True
+ pred = super()._inference_model(model, x_t, t, cond, **kwargs)
+ # kwargs['if_use_mask'] = False
+ kwargs['ordered_mask_dino'] = torch.zeros_like(kwargs['ordered_mask_dino'])
+ neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs)
+ return (1 + cfg_strength) * pred - cfg_strength * neg_pred
diff --git a/OmniPart/training/pipelines/samplers/flow_euler.py b/OmniPart/training/pipelines/samplers/flow_euler.py
new file mode 100644
index 0000000..d4ca3b7
--- /dev/null
+++ b/OmniPart/training/pipelines/samplers/flow_euler.py
@@ -0,0 +1,296 @@
+"""
+Flow Euler Samplers for Generative Models
+
+This file implements samplers for flow-matching generative models using the Euler integration method.
+It contains three main sampler classes:
+1. FlowEulerSampler: Base implementation of Euler sampling for flow-matching models
+2. FlowEulerCfgSampler: Adds classifier-free guidance to the Euler sampler
+3. FlowEulerGuidanceIntervalSampler: Enhances the sampler with both classifier-free guidance and guidance intervals
+
+Flow-matching models define continuous paths from noise to data, and these samplers implement
+ODE solvers (specifically Euler method) to follow these paths and generate samples.
+"""
+
+from typing import *
+import torch
+import numpy as np
+from tqdm import tqdm
+from easydict import EasyDict as edict
+from .base import Sampler
+from .classifier_free_guidance_mixin import ClassifierFreeGuidanceSamplerMixin
+from .guidance_interval_mixin import GuidanceIntervalSamplerMixin
+
+
+class FlowEulerSampler(Sampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling.
+
+ Args:
+ sigma_min: The minimum scale of noise in flow.
+ """
+ def __init__(
+ self,
+ sigma_min: float,
+ ):
+ # sigma_min controls the minimum noise level in the flow
+ self.sigma_min = sigma_min
+
+ def _eps_to_xstart(self, x_t, t, eps):
+ """
+ Convert noise prediction (epsilon) to predicted clean data (x_0).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ eps: Predicted noise
+
+ Returns:
+ Predicted clean data x_0
+ """
+ assert x_t.shape == eps.shape
+ return (x_t - (self.sigma_min + (1 - self.sigma_min) * t) * eps) / (1 - t)
+
+ def _xstart_to_eps(self, x_t, t, x_0):
+ """
+ Convert predicted clean data (x_0) to noise prediction (epsilon).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ x_0: Predicted clean data
+
+ Returns:
+ Implied noise prediction epsilon
+ """
+ assert x_t.shape == x_0.shape
+ return (x_t - (1 - t) * x_0) / (self.sigma_min + (1 - self.sigma_min) * t)
+
+ def _v_to_xstart_eps(self, x_t, t, v):
+ """
+ Convert velocity prediction (v) to predicted clean data (x_0) and noise (epsilon).
+
+ Args:
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ v: Predicted velocity
+
+ Returns:
+ Tuple of (x_0, epsilon) derived from velocity
+ """
+ assert x_t.shape == v.shape
+ eps = (1 - t) * v + x_t
+ x_0 = (1 - self.sigma_min) * x_t - (self.sigma_min + (1 - self.sigma_min) * t) * v
+ return x_0, eps
+
+ def _inference_model(self, model, x_t, t, cond=None, **kwargs):
+ """
+ Run inference with the model.
+
+ Args:
+ model: The flow model
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep (will be scaled by 1000)
+ cond: Conditional information
+ kwargs: Additional arguments for model
+
+ Returns:
+ Model's predicted velocity
+ """
+ # Scale timestep by 1000 for model input
+ t = torch.tensor([1000 * t] * x_t.shape[0], device=x_t.device, dtype=torch.float32)
+ # Broadcast single condition to match batch size if needed
+ # print(f"cond shape: {cond.shape}")
+ if cond is not None and cond.shape[0] == 1 and x_t.shape[0] > 1:
+ cond = cond.repeat(x_t.shape[0], *([1] * (len(cond.shape) - 1)))
+ # print(f"cond shape after repeat: {cond.shape}")
+ return model(x_t, t, cond, **kwargs)
+
+ def _get_model_prediction(self, model, x_t, t, cond=None, **kwargs):
+ """
+ Get model predictions and convert to various formats.
+
+ Args:
+ model: The flow model
+ x_t: Current noisy tensor at timestep t
+ t: Current timestep
+ cond: Conditional information
+ kwargs: Additional arguments for model
+
+ Returns:
+ Tuple of (x_0, epsilon, velocity) predictions
+ """
+ pred_v = self._inference_model(model, x_t, t, cond, **kwargs)
+ pred_x_0, pred_eps = self._v_to_xstart_eps(x_t=x_t, t=t, v=pred_v)
+ return pred_x_0, pred_eps, pred_v
+
+ @torch.no_grad()
+ def sample_once(
+ self,
+ model,
+ x_t,
+ t: float,
+ t_prev: float,
+ cond: Optional[Any] = None,
+ **kwargs
+ ):
+ """
+ Sample x_{t-1} from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ x_t: The [N x C x ...] tensor of noisy inputs at time t.
+ t: The current timestep.
+ t_prev: The previous timestep.
+ cond: conditional information.
+ **kwargs: Additional arguments for model inference.
+
+ Returns:
+ a dict containing the following
+ - 'pred_x_prev': x_{t-1}.
+ - 'pred_x_0': a prediction of x_0.
+ """
+ # Get model predictions
+ pred_x_0, pred_eps, pred_v = self._get_model_prediction(model, x_t, t, cond, **kwargs)
+ # Euler step: x_{t-1} = x_t - (t - t_prev) * v_t
+ pred_x_prev = x_t - (t - t_prev) * pred_v
+ return edict({"pred_x_prev": pred_x_prev, "pred_x_0": pred_x_0})
+
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond: Optional[Any] = None,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ sample = noise
+ # Create a linearly spaced timestep sequence from 1 to 0
+ t_seq = np.linspace(1, 0, steps + 1)
+ # Apply rescaling to timesteps if needed
+ t_seq = rescale_t * t_seq / (1 + (rescale_t - 1) * t_seq)
+ # Create pairs of consecutive timesteps
+ t_pairs = list((t_seq[i], t_seq[i + 1]) for i in range(steps))
+
+ # Initialize return dictionary
+ ret = edict({"samples": None, "pred_x_t": [], "pred_x_0": []})
+ # print(f"shape of cond: {cond.shape}") # shape of cond: torch.Size([4, 1374, 1024])
+ # Perform Euler sampling steps
+ for t, t_prev in tqdm(t_pairs, desc="Sampling", disable=not verbose):
+ out = self.sample_once(model, sample, t, t_prev, cond, **kwargs)
+ sample = out.pred_x_prev
+ ret.pred_x_t.append(out.pred_x_prev)
+ ret.pred_x_0.append(out.pred_x_0)
+
+ ret.samples = sample
+ return ret
+
+
+class FlowEulerCfgSampler(ClassifierFreeGuidanceSamplerMixin, FlowEulerSampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling with classifier-free guidance.
+
+ This class adds classifier-free guidance to the Euler sampler, enabling conditional
+ generation with guidance strength control.
+ """
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond,
+ neg_cond,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ cfg_strength: float = 3.0,
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ neg_cond: negative conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ cfg_strength: The strength of classifier-free guidance.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ # Call the parent sample method with CFG parameters
+ return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, **kwargs)
+
+
+class FlowEulerGuidanceIntervalSampler(GuidanceIntervalSamplerMixin, FlowEulerSampler):
+ """
+ Generate samples from a flow-matching model using Euler sampling with classifier-free guidance and interval.
+
+ This class extends the Euler sampler with both classifier-free guidance and the ability
+ to specify timestep intervals where guidance is applied.
+ """
+ @torch.no_grad()
+ def sample(
+ self,
+ model,
+ noise,
+ cond,
+ neg_cond,
+ steps: int = 50,
+ rescale_t: float = 1.0,
+ cfg_strength: float = 3.0,
+ cfg_interval: Tuple[float, float] = (0.0, 1.0),
+ verbose: bool = True,
+ **kwargs
+ ):
+ """
+ Generate samples from the model using Euler method.
+
+ Args:
+ model: The model to sample from.
+ noise: The initial noise tensor.
+ cond: conditional information.
+ neg_cond: negative conditional information.
+ steps: The number of steps to sample.
+ rescale_t: The rescale factor for t.
+ cfg_strength: The strength of classifier-free guidance.
+ cfg_interval: The interval for classifier-free guidance.
+ verbose: If True, show a progress bar.
+ **kwargs: Additional arguments for model_inference.
+
+ Returns:
+ a dict containing the following
+ - 'samples': the model samples.
+ - 'pred_x_t': a list of prediction of x_t.
+ - 'pred_x_0': a list of prediction of x_0.
+ """
+ # Call the parent sample method with CFG and interval parameters
+ return super().sample(model, noise, cond, steps, rescale_t, verbose, neg_cond=neg_cond, cfg_strength=cfg_strength, cfg_interval=cfg_interval, **kwargs)
diff --git a/OmniPart/training/pipelines/samplers/guidance_interval_mixin.py b/OmniPart/training/pipelines/samplers/guidance_interval_mixin.py
new file mode 100644
index 0000000..78a955c
--- /dev/null
+++ b/OmniPart/training/pipelines/samplers/guidance_interval_mixin.py
@@ -0,0 +1,17 @@
+from typing import *
+import torch
+
+
+class GuidanceIntervalSamplerMixin:
+ """
+ A mixin class for samplers that apply classifier-free guidance with interval.
+ """
+
+ def _inference_model(self, model, x_t, t, cond, neg_cond, cfg_strength, cfg_interval, **kwargs):
+ if cfg_interval[0] <= t <= cfg_interval[1]:
+ pred = super()._inference_model(model, x_t, t, cond, **kwargs)
+ kwargs['ordered_mask_dino'] = torch.zeros_like(kwargs['ordered_mask_dino'])
+ neg_pred = super()._inference_model(model, x_t, t, neg_cond, **kwargs)
+ return (1 + cfg_strength) * pred - cfg_strength * neg_pred
+ else:
+ return super()._inference_model(model, x_t, t, cond, **kwargs)
diff --git a/OmniPart/training/renderers/__init__.py b/OmniPart/training/renderers/__init__.py
new file mode 100644
index 0000000..0339355
--- /dev/null
+++ b/OmniPart/training/renderers/__init__.py
@@ -0,0 +1,31 @@
+import importlib
+
+__attributes = {
+ 'OctreeRenderer': 'octree_renderer',
+ 'GaussianRenderer': 'gaussian_render',
+ 'MeshRenderer': 'mesh_renderer',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .octree_renderer import OctreeRenderer
+ from .gaussian_render import GaussianRenderer
+ from .mesh_renderer import MeshRenderer
\ No newline at end of file
diff --git a/OmniPart/training/renderers/gaussian_render.py b/OmniPart/training/renderers/gaussian_render.py
new file mode 100644
index 0000000..bfc164d
--- /dev/null
+++ b/OmniPart/training/renderers/gaussian_render.py
@@ -0,0 +1,307 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact george.drettakis@inria.fr
+#
+
+import torch
+import math
+from easydict import EasyDict as edict
+import numpy as np
+from ..representations.gaussian import Gaussian
+from .sh_utils import eval_sh
+import torch.nn.functional as F
+from easydict import EasyDict as edict
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ Convert OpenCV-style camera intrinsics matrix to OpenGL perspective projection matrix.
+
+ This function transforms a standard 3x3 camera intrinsics matrix into a 4x4 perspective
+ projection matrix compatible with OpenGL rendering pipeline. The resulting matrix
+ properly handles the coordinate system differences between computer vision and
+ computer graphics conventions.
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix containing focal lengths
+ and principal point coordinates
+ near (float): Distance to the near clipping plane (must be positive)
+ far (float): Distance to the far clipping plane (must be greater than near)
+
+ Returns:
+ torch.Tensor: [4, 4] OpenGL perspective projection matrix for rendering
+ """
+
+ # Extract focal lengths and principal point from intrinsics matrix
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1] # Focal lengths in x and y directions
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2] # Principal point coordinates
+
+ # Initialize empty 4x4 projection matrix
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+
+ # Fill in the projection matrix components
+ ret[0, 0] = 2 * fx # Scale for x axis based on horizontal focal length
+ ret[1, 1] = 2 * fy # Scale for y axis based on vertical focal length
+ ret[0, 2] = 2 * cx - 1 # X offset based on principal point (OpenCV to OpenGL conversion)
+ ret[1, 2] = - 2 * cy + 1 # Y offset based on principal point (with flipped Y axis)
+ ret[2, 2] = far / (far - near) # Handle depth mapping to clip space
+ ret[2, 3] = near * far / (near - far) # Term for perspective division in clip space
+ ret[3, 2] = 1. # Enable perspective division
+
+ return ret
+
+def render(viewpoint_camera, pc : Gaussian, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None):
+ """
+ Render the scene using 3D Gaussians.
+
+ This function performs the rasterization of 3D Gaussian points into a 2D image from a given viewpoint.
+
+ Args:
+ viewpoint_camera: Camera parameters including position, view transform, and projection
+ pc (Gaussian): Point cloud represented as 3D Gaussians
+ pipe: Pipeline configuration parameters
+ bg_color (torch.Tensor): Background color tensor (must be on GPU)
+ scaling_modifier (float): Scale modifier for the Gaussian splats
+ override_color (torch.Tensor, optional): Custom colors to override computed SH-based colors
+
+ Returns:
+ edict: Dictionary containing rendered image, viewspace points, visibility filter, and radii information
+ """
+ # Lazy import of the rasterization module to avoid circular dependencies
+ # or to improve startup performance when not needed immediately
+ if 'GaussianRasterizer' not in globals():
+ from diff_gaussian_rasterization import GaussianRasterizer, GaussianRasterizationSettings
+
+ # Create zero tensor for screen space points
+ # This tensor will hold gradients of the 2D (screen-space) means for optimization
+ screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0
+ try:
+ screenspace_points.retain_grad()
+ except:
+ pass
+
+ # Calculate camera frustum parameters from the field of view
+ tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
+ tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
+
+ # Get kernel size from the pipeline configuration
+ kernel_size = pipe.kernel_size
+
+ # Initialize subpixel offset for all pixels (used for anti-aliasing)
+ subpixel_offset = torch.zeros((int(viewpoint_camera.image_height), int(viewpoint_camera.image_width), 2),
+ dtype=torch.float32, device="cuda")
+
+ # Configure the Gaussian rasterization settings with all necessary parameters
+ raster_settings = GaussianRasterizationSettings(
+ image_height=int(viewpoint_camera.image_height),
+ image_width=int(viewpoint_camera.image_width),
+ tanfovx=tanfovx,
+ tanfovy=tanfovy,
+ kernel_size=kernel_size,
+ subpixel_offset=subpixel_offset,
+ bg=bg_color,
+ scale_modifier=scaling_modifier,
+ viewmatrix=viewpoint_camera.world_view_transform,
+ projmatrix=viewpoint_camera.full_proj_transform,
+ sh_degree=pc.active_sh_degree,
+ campos=viewpoint_camera.camera_center,
+ prefiltered=False,
+ debug=pipe.debug
+ )
+
+ # Create the rasterizer with the configured settings
+ rasterizer = GaussianRasterizer(raster_settings=raster_settings)
+
+ # Get the Gaussian 3D positions and opacities
+ means3D = pc.get_xyz
+ means2D = screenspace_points
+ opacity = pc.get_opacity
+
+ # Handle covariance computation options
+ # Either use precomputed 3D covariance or let the rasterizer compute it from scales and rotations
+ scales = None
+ rotations = None
+ cov3D_precomp = None
+ if pipe.compute_cov3D_python:
+ # Compute 3D covariances in Python before rasterization
+ cov3D_precomp = pc.get_covariance(scaling_modifier)
+ else:
+ # Let the rasterizer compute covariances from scale and rotation
+ scales = pc.get_scaling
+ rotations = pc.get_rotation
+
+ # Handle color computation options
+ # Either use override colors, precomputed colors from SHs, or let the rasterizer compute colors from SHs
+ shs = None
+ colors_precomp = None
+ if override_color is None:
+ if pipe.convert_SHs_python:
+ # Convert spherical harmonics to RGB colors in Python
+ shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2)
+ # Calculate the view direction from Gaussian center to camera
+ dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1))
+ dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True)
+ # Evaluate spherical harmonics to get RGB colors
+ sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
+ # Apply offset and clamp to ensure valid color values
+ colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
+ else:
+ # Let the rasterizer convert SHs to colors
+ shs = pc.get_features
+ else:
+ # Use provided override colors
+ colors_precomp = override_color
+
+ # Perform the rasterization to generate the final rendered image
+ # This projects the 3D Gaussians to 2D and blends them according to their opacities
+ rendered_image, radii = rasterizer(
+ means3D = means3D,
+ means2D = means2D,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ opacities = opacity,
+ scales = scales,
+ rotations = rotations,
+ cov3D_precomp = cov3D_precomp
+ )
+
+ # Return the rendering results in a dictionary
+ # radii > 0 creates a filter for visible Gaussians (those not frustum-culled)
+ return edict({"render": rendered_image,
+ "viewspace_points": screenspace_points,
+ "visibility_filter" : radii > 0,
+ "radii": radii})
+
+class GaussianRenderer:
+ """
+ A renderer for Gaussian Splatting that converts 3D Gaussian primitives into 2D images.
+
+ This renderer projects 3D Gaussian splats onto a 2D image plane using the provided
+ camera parameters, handling the rasterization process through an optimized backend.
+
+ Args:
+ rendering_options (dict): Configuration options for rendering including resolution,
+ depth range, background color, and supersampling level.
+ """
+
+ def __init__(self, rendering_options={}) -> None:
+ # Initialize default pipeline parameters
+ self.pipe = edict({
+ "kernel_size": 0.1, # Size of the Gaussian kernel for rasterization
+ "convert_SHs_python": False, # Whether to convert Spherical Harmonics to colors in Python
+ "compute_cov3D_python": False, # Whether to compute 3D covariance matrices in Python
+ "scale_modifier": 1.0, # Global scaling factor for all Gaussians
+ "debug": False # Enable/disable debug mode
+ })
+
+ # Initialize default rendering options
+ self.rendering_options = edict({
+ "resolution": None, # Output image resolution (width and height)
+ "near": None, # Near clipping plane distance
+ "far": None, # Far clipping plane distance
+ "ssaa": 1, # Super-sampling anti-aliasing factor (1 = disabled)
+ "bg_color": 'random', # Background color ('random' or specific color)
+ })
+
+ # Update with user-provided options
+ self.rendering_options.update(rendering_options)
+
+ # Initialize background color (will be set during rendering)
+ self.bg_color = None
+
+ def render(
+ self,
+ gausssian: Gaussian,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ colors_overwrite: torch.Tensor = None
+ ) -> edict:
+ """
+ Render the 3D Gaussian representation from a given camera viewpoint.
+
+ This method projects the 3D Gaussians onto a 2D image plane using the provided camera parameters,
+ handling the full rendering pipeline including projection, rasterization, and optional supersampling.
+
+ Args:
+ gaussian: The Gaussian representation containing positions, features, and other attributes
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics matrix defining camera position and orientation
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics matrix with focal lengths and principal point
+ colors_overwrite (torch.Tensor): Optional (N, 3) tensor to override Gaussian colors
+
+ Returns:
+ edict containing:
+ color (torch.Tensor): (3, H, W) rendered color image
+ """
+ # Extract rendering parameters from options
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"] # Super-sampling anti-aliasing factor
+
+ # Set background color based on rendering options
+ if self.rendering_options["bg_color"] == 'random':
+ # Randomly choose either black or white background
+ self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda")
+ if np.random.rand() < 0.5:
+ self.bg_color += 1
+ else:
+ # Use specified background color
+ self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda")
+
+ # Prepare camera parameters for the renderer
+ view = extrinsics # World-to-camera transform
+
+ # Convert OpenCV intrinsics to OpenGL projection matrix
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+
+ # Extract camera center from extrinsics (inverse of view matrix)
+ camera = torch.inverse(view)[:3, 3]
+
+ # Calculate field of view from focal lengths
+ focalx = intrinsics[0, 0]
+ focaly = intrinsics[1, 1]
+ fovx = 2 * torch.atan(0.5 / focalx) # Horizontal FoV in radians
+ fovy = 2 * torch.atan(0.5 / focaly) # Vertical FoV in radians
+
+ # Build complete camera parameter dictionary
+ camera_dict = edict({
+ "image_height": resolution * ssaa, # Apply supersampling if enabled
+ "image_width": resolution * ssaa,
+ "FoVx": fovx,
+ "FoVy": fovy,
+ "znear": near,
+ "zfar": far,
+ "world_view_transform": view.T.contiguous(), # Transpose for OpenGL convention
+ "projection_matrix": perspective.T.contiguous(),
+ "full_proj_transform": (perspective @ view).T.contiguous(), # Combined projection and view
+ "camera_center": camera
+ })
+
+ # Perform the actual rendering using the 3D Gaussian rasterizer
+ render_ret = render(camera_dict, gausssian, self.pipe, self.bg_color,
+ override_color=colors_overwrite, scaling_modifier=self.pipe.scale_modifier)
+
+ # Handle supersampling by downsampling the high-resolution render to the target resolution
+ if ssaa > 1:
+ # Use bilinear interpolation with antialiasing to downsample the image
+ render_ret.render = F.interpolate(render_ret.render[None],
+ size=(resolution, resolution),
+ mode='bilinear',
+ align_corners=False,
+ antialias=True).squeeze()
+
+ # Return the final rendered color image
+ ret = edict({
+ 'color': render_ret['render']
+ })
+ return ret
diff --git a/OmniPart/training/renderers/mesh_renderer.py b/OmniPart/training/renderers/mesh_renderer.py
new file mode 100644
index 0000000..b504fa4
--- /dev/null
+++ b/OmniPart/training/renderers/mesh_renderer.py
@@ -0,0 +1,133 @@
+import torch
+import nvdiffrast.torch as dr
+from easydict import EasyDict as edict
+from ..representations.mesh import MeshExtractResult
+import torch.nn.functional as F
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ OpenCV intrinsics to OpenGL perspective matrix
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix
+ near (float): near plane to clip
+ far (float): far plane to clip
+ Returns:
+ (torch.Tensor): [4, 4] OpenGL perspective matrix
+ """
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1]
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2]
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+ ret[0, 0] = 2 * fx
+ ret[1, 1] = 2 * fy
+ ret[0, 2] = 2 * cx - 1
+ ret[1, 2] = - 2 * cy + 1
+ ret[2, 2] = far / (far - near)
+ ret[2, 3] = near * far / (near - far)
+ ret[3, 2] = 1.
+ return ret
+
+
+class MeshRenderer:
+ """
+ Renderer for the Mesh representation.
+
+ Args:
+ rendering_options (dict): Rendering options.
+ glctx (nvdiffrast.torch.RasterizeGLContext): RasterizeGLContext object for CUDA/OpenGL interop.
+ """
+ def __init__(self, rendering_options={}, device='cuda'):
+ self.rendering_options = edict({
+ "resolution": None,
+ "near": None,
+ "far": None,
+ "ssaa": 1
+ })
+ self.rendering_options.update(rendering_options)
+ self.glctx = dr.RasterizeCudaContext(device=device)
+ self.device=device
+
+ def render(
+ self,
+ mesh : MeshExtractResult,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ return_types = ["mask", "normal", "depth"]
+ ) -> edict:
+ """
+ Render the mesh.
+
+ Args:
+ mesh : meshmodel
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics
+ return_types (list): list of return types, can be "mask", "depth", "normal_map", "normal", "color"
+
+ Returns:
+ edict based on return_types containing:
+ color (torch.Tensor): [3, H, W] rendered color image
+ depth (torch.Tensor): [H, W] rendered depth image
+ normal (torch.Tensor): [3, H, W] rendered normal image
+ normal_map (torch.Tensor): [3, H, W] rendered normal map image
+ mask (torch.Tensor): [H, W] rendered mask image
+ """
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"]
+
+ if mesh.vertices.shape[0] == 0 or mesh.faces.shape[0] == 0:
+ default_img = torch.zeros((1, resolution, resolution, 3), dtype=torch.float32, device=self.device)
+ ret_dict = {k : default_img if k in ['normal', 'normal_map', 'color'] else default_img[..., :1] for k in return_types}
+ return ret_dict
+
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+
+ RT = extrinsics.unsqueeze(0)
+ full_proj = (perspective @ extrinsics).unsqueeze(0)
+
+ vertices = mesh.vertices.unsqueeze(0)
+
+ vertices_homo = torch.cat([vertices, torch.ones_like(vertices[..., :1])], dim=-1)
+ vertices_camera = torch.bmm(vertices_homo, RT.transpose(-1, -2))
+ vertices_clip = torch.bmm(vertices_homo, full_proj.transpose(-1, -2))
+ faces_int = mesh.faces.int()
+ rast, _ = dr.rasterize(
+ self.glctx, vertices_clip, faces_int, (resolution * ssaa, resolution * ssaa))
+
+ out_dict = edict()
+ for type in return_types:
+ img = None
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int)
+ elif type == "depth":
+ img = dr.interpolate(vertices_camera[..., 2:3].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ elif type == "normal" :
+ img = dr.interpolate(
+ mesh.face_normal.reshape(1, -1, 3), rast,
+ torch.arange(mesh.faces.shape[0] * 3, device=self.device, dtype=torch.int).reshape(-1, 3)
+ )[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ # normalize norm pictures
+ img = (img + 1) / 2
+ elif type == "normal_map" :
+ img = dr.interpolate(mesh.vertex_attrs[:, 3:].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+ elif type == "color" :
+ img = dr.interpolate(mesh.vertex_attrs[:, :3].contiguous(), rast, faces_int)[0]
+ img = dr.antialias(img, rast, vertices_clip, faces_int)
+
+ if ssaa > 1:
+ img = F.interpolate(img.permute(0, 3, 1, 2), (resolution, resolution), mode='bilinear', align_corners=False, antialias=True)
+ img = img.squeeze()
+ else:
+ img = img.permute(0, 3, 1, 2).squeeze()
+ out_dict[type] = img
+
+ return out_dict
diff --git a/OmniPart/training/renderers/octree_renderer.py b/OmniPart/training/renderers/octree_renderer.py
new file mode 100644
index 0000000..136069c
--- /dev/null
+++ b/OmniPart/training/renderers/octree_renderer.py
@@ -0,0 +1,300 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+import math
+import cv2
+from scipy.stats import qmc
+from easydict import EasyDict as edict
+from ..representations.octree import DfsOctree
+
+
+def intrinsics_to_projection(
+ intrinsics: torch.Tensor,
+ near: float,
+ far: float,
+ ) -> torch.Tensor:
+ """
+ OpenCV intrinsics to OpenGL perspective matrix
+
+ Args:
+ intrinsics (torch.Tensor): [3, 3] OpenCV intrinsics matrix
+ near (float): near plane to clip
+ far (float): far plane to clip
+ Returns:
+ (torch.Tensor): [4, 4] OpenGL perspective matrix
+ """
+ fx, fy = intrinsics[0, 0], intrinsics[1, 1]
+ cx, cy = intrinsics[0, 2], intrinsics[1, 2]
+ ret = torch.zeros((4, 4), dtype=intrinsics.dtype, device=intrinsics.device)
+ ret[0, 0] = 2 * fx
+ ret[1, 1] = 2 * fy
+ ret[0, 2] = 2 * cx - 1
+ ret[1, 2] = - 2 * cy + 1
+ ret[2, 2] = far / (far - near)
+ ret[2, 3] = near * far / (near - far)
+ ret[3, 2] = 1.
+ return ret
+
+
+def render(viewpoint_camera, octree : DfsOctree, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, used_rank = None, colors_overwrite = None, aux=None, halton_sampler=None):
+ """
+ Render the scene.
+
+ Background tensor (bg_color) must be on GPU!
+ """
+ # lazy import
+ if 'OctreeTrivecRasterizer' not in globals():
+ from diffoctreerast import OctreeVoxelRasterizer, OctreeGaussianRasterizer, OctreeTrivecRasterizer, OctreeDecoupolyRasterizer
+
+ # Set up rasterization configuration
+ tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
+ tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
+
+ raster_settings = edict(
+ image_height=int(viewpoint_camera.image_height),
+ image_width=int(viewpoint_camera.image_width),
+ tanfovx=tanfovx,
+ tanfovy=tanfovy,
+ bg=bg_color,
+ scale_modifier=scaling_modifier,
+ viewmatrix=viewpoint_camera.world_view_transform,
+ projmatrix=viewpoint_camera.full_proj_transform,
+ sh_degree=octree.active_sh_degree,
+ campos=viewpoint_camera.camera_center,
+ with_distloss=pipe.with_distloss,
+ jitter=pipe.jitter,
+ debug=pipe.debug,
+ )
+
+ positions = octree.get_xyz
+ if octree.primitive == "voxel":
+ densities = octree.get_density
+ elif octree.primitive == "gaussian":
+ opacities = octree.get_opacity
+ elif octree.primitive == "trivec":
+ trivecs = octree.get_trivec
+ densities = octree.get_density
+ raster_settings.density_shift = octree.density_shift
+ elif octree.primitive == "decoupoly":
+ decoupolys_V, decoupolys_g = octree.get_decoupoly
+ densities = octree.get_density
+ raster_settings.density_shift = octree.density_shift
+ else:
+ raise ValueError(f"Unknown primitive {octree.primitive}")
+ depths = octree.get_depth
+
+ # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors
+ # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer.
+ colors_precomp = None
+ shs = octree.get_features
+ if octree.primitive in ["voxel", "gaussian"] and colors_overwrite is not None:
+ colors_precomp = colors_overwrite
+ shs = None
+
+ ret = edict()
+
+ if octree.primitive == "voxel":
+ renderer = OctreeVoxelRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha, distloss = renderer(
+ positions = positions,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ ret['distloss'] = distloss
+ elif octree.primitive == "gaussian":
+ renderer = OctreeGaussianRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha = renderer(
+ positions = positions,
+ opacities = opacities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ elif octree.primitive == "trivec":
+ raster_settings.used_rank = used_rank if used_rank is not None else trivecs.shape[1]
+ renderer = OctreeTrivecRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha, percent_depth = renderer(
+ positions = positions,
+ trivecs = trivecs,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ colors_overwrite = colors_overwrite,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ halton_sampler = halton_sampler,
+ )
+ ret['percent_depth'] = percent_depth
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+ elif octree.primitive == "decoupoly":
+ raster_settings.used_rank = used_rank if used_rank is not None else decoupolys_V.shape[1]
+ renderer = OctreeDecoupolyRasterizer(raster_settings=raster_settings)
+ rgb, depth, alpha = renderer(
+ positions = positions,
+ decoupolys_V = decoupolys_V,
+ decoupolys_g = decoupolys_g,
+ densities = densities,
+ shs = shs,
+ colors_precomp = colors_precomp,
+ depths = depths,
+ aabb = octree.aabb,
+ aux = aux,
+ )
+ ret['rgb'] = rgb
+ ret['depth'] = depth
+ ret['alpha'] = alpha
+
+ return ret
+
+
+class OctreeRenderer:
+ """
+ Renderer for the Voxel representation.
+
+ Args:
+ rendering_options (dict): Rendering options.
+ """
+
+ def __init__(self, rendering_options={}) -> None:
+ try:
+ import diffoctreerast
+ except ImportError:
+ print("\033[93m[WARNING] diffoctreerast is not installed. The renderer will be disabled.\033[0m")
+ self.unsupported = True
+ else:
+ self.unsupported = False
+
+ self.pipe = edict({
+ "with_distloss": False,
+ "with_aux": False,
+ "scale_modifier": 1.0,
+ "used_rank": None,
+ "jitter": False,
+ "debug": False,
+ })
+ self.rendering_options = edict({
+ "resolution": None,
+ "near": None,
+ "far": None,
+ "ssaa": 1,
+ "bg_color": 'random',
+ })
+ self.halton_sampler = qmc.Halton(2, scramble=False)
+ self.rendering_options.update(rendering_options)
+ self.bg_color = None
+
+ def render(
+ self,
+ octree: DfsOctree,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ colors_overwrite: torch.Tensor = None,
+ ) -> edict:
+ """
+ Render the octree.
+
+ Args:
+ octree (Octree): octree
+ extrinsics (torch.Tensor): (4, 4) camera extrinsics
+ intrinsics (torch.Tensor): (3, 3) camera intrinsics
+ colors_overwrite (torch.Tensor): (N, 3) override color
+
+ Returns:
+ edict containing:
+ color (torch.Tensor): (3, H, W) rendered color
+ depth (torch.Tensor): (H, W) rendered depth
+ alpha (torch.Tensor): (H, W) rendered alpha
+ distloss (Optional[torch.Tensor]): (H, W) rendered distance loss
+ percent_depth (Optional[torch.Tensor]): (H, W) rendered percent depth
+ aux (Optional[edict]): auxiliary tensors
+ """
+ resolution = self.rendering_options["resolution"]
+ near = self.rendering_options["near"]
+ far = self.rendering_options["far"]
+ ssaa = self.rendering_options["ssaa"]
+
+ if self.unsupported:
+ image = np.zeros((512, 512, 3), dtype=np.uint8)
+ text_bbox = cv2.getTextSize("Unsupported", cv2.FONT_HERSHEY_SIMPLEX, 2, 3)[0]
+ origin = (512 - text_bbox[0]) // 2, (512 - text_bbox[1]) // 2
+ image = cv2.putText(image, "Unsupported", origin, cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 3, cv2.LINE_AA)
+ return {
+ 'color': torch.tensor(image, dtype=torch.float32).permute(2, 0, 1) / 255,
+ }
+
+ if self.rendering_options["bg_color"] == 'random':
+ self.bg_color = torch.zeros(3, dtype=torch.float32, device="cuda")
+ if np.random.rand() < 0.5:
+ self.bg_color += 1
+ else:
+ self.bg_color = torch.tensor(self.rendering_options["bg_color"], dtype=torch.float32, device="cuda")
+
+ if self.pipe["with_aux"]:
+ aux = {
+ 'grad_color2': torch.zeros((octree.num_leaf_nodes, 3), dtype=torch.float32, requires_grad=True, device="cuda") + 0,
+ 'contributions': torch.zeros((octree.num_leaf_nodes, 1), dtype=torch.float32, requires_grad=True, device="cuda") + 0,
+ }
+ for k in aux.keys():
+ aux[k].requires_grad_()
+ aux[k].retain_grad()
+ else:
+ aux = None
+
+ view = extrinsics
+ perspective = intrinsics_to_projection(intrinsics, near, far)
+ camera = torch.inverse(view)[:3, 3]
+ focalx = intrinsics[0, 0]
+ focaly = intrinsics[1, 1]
+ fovx = 2 * torch.atan(0.5 / focalx)
+ fovy = 2 * torch.atan(0.5 / focaly)
+
+ camera_dict = edict({
+ "image_height": resolution * ssaa,
+ "image_width": resolution * ssaa,
+ "FoVx": fovx,
+ "FoVy": fovy,
+ "znear": near,
+ "zfar": far,
+ "world_view_transform": view.T.contiguous(),
+ "projection_matrix": perspective.T.contiguous(),
+ "full_proj_transform": (perspective @ view).T.contiguous(),
+ "camera_center": camera
+ })
+
+ # Render
+ render_ret = render(camera_dict, octree, self.pipe, self.bg_color, aux=aux, colors_overwrite=colors_overwrite, scaling_modifier=self.pipe.scale_modifier, used_rank=self.pipe.used_rank, halton_sampler=self.halton_sampler)
+
+ if ssaa > 1:
+ render_ret.rgb = F.interpolate(render_ret.rgb[None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ render_ret.depth = F.interpolate(render_ret.depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ render_ret.alpha = F.interpolate(render_ret.alpha[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+ if hasattr(render_ret, 'percent_depth'):
+ render_ret.percent_depth = F.interpolate(render_ret.percent_depth[None, None], size=(resolution, resolution), mode='bilinear', align_corners=False, antialias=True).squeeze()
+
+ ret = edict({
+ 'color': render_ret.rgb,
+ 'depth': render_ret.depth,
+ 'alpha': render_ret.alpha,
+ })
+ if self.pipe["with_distloss"] and 'distloss' in render_ret:
+ ret['distloss'] = render_ret.distloss
+ if self.pipe["with_aux"]:
+ ret['aux'] = aux
+ if hasattr(render_ret, 'percent_depth'):
+ ret['percent_depth'] = render_ret.percent_depth
+ return ret
diff --git a/OmniPart/training/renderers/sh_utils.py b/OmniPart/training/renderers/sh_utils.py
new file mode 100644
index 0000000..bbca7d1
--- /dev/null
+++ b/OmniPart/training/renderers/sh_utils.py
@@ -0,0 +1,118 @@
+# Copyright 2021 The PlenOctree Authors.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+import torch
+
+C0 = 0.28209479177387814
+C1 = 0.4886025119029199
+C2 = [
+ 1.0925484305920792,
+ -1.0925484305920792,
+ 0.31539156525252005,
+ -1.0925484305920792,
+ 0.5462742152960396
+]
+C3 = [
+ -0.5900435899266435,
+ 2.890611442640554,
+ -0.4570457994644658,
+ 0.3731763325901154,
+ -0.4570457994644658,
+ 1.445305721320277,
+ -0.5900435899266435
+]
+C4 = [
+ 2.5033429417967046,
+ -1.7701307697799304,
+ 0.9461746957575601,
+ -0.6690465435572892,
+ 0.10578554691520431,
+ -0.6690465435572892,
+ 0.47308734787878004,
+ -1.7701307697799304,
+ 0.6258357354491761,
+]
+
+
+def eval_sh(deg, sh, dirs):
+ """
+ Evaluate spherical harmonics at unit directions
+ using hardcoded SH polynomials.
+ Works with torch/np/jnp.
+ ... Can be 0 or more batch dimensions.
+ Args:
+ deg: int SH deg. Currently, 0-3 supported
+ sh: jnp.ndarray SH coeffs [..., C, (deg + 1) ** 2]
+ dirs: jnp.ndarray unit directions [..., 3]
+ Returns:
+ [..., C]
+ """
+ assert deg <= 4 and deg >= 0
+ coeff = (deg + 1) ** 2
+ assert sh.shape[-1] >= coeff
+
+ result = C0 * sh[..., 0]
+ if deg > 0:
+ x, y, z = dirs[..., 0:1], dirs[..., 1:2], dirs[..., 2:3]
+ result = (result -
+ C1 * y * sh[..., 1] +
+ C1 * z * sh[..., 2] -
+ C1 * x * sh[..., 3])
+
+ if deg > 1:
+ xx, yy, zz = x * x, y * y, z * z
+ xy, yz, xz = x * y, y * z, x * z
+ result = (result +
+ C2[0] * xy * sh[..., 4] +
+ C2[1] * yz * sh[..., 5] +
+ C2[2] * (2.0 * zz - xx - yy) * sh[..., 6] +
+ C2[3] * xz * sh[..., 7] +
+ C2[4] * (xx - yy) * sh[..., 8])
+
+ if deg > 2:
+ result = (result +
+ C3[0] * y * (3 * xx - yy) * sh[..., 9] +
+ C3[1] * xy * z * sh[..., 10] +
+ C3[2] * y * (4 * zz - xx - yy)* sh[..., 11] +
+ C3[3] * z * (2 * zz - 3 * xx - 3 * yy) * sh[..., 12] +
+ C3[4] * x * (4 * zz - xx - yy) * sh[..., 13] +
+ C3[5] * z * (xx - yy) * sh[..., 14] +
+ C3[6] * x * (xx - 3 * yy) * sh[..., 15])
+
+ if deg > 3:
+ result = (result + C4[0] * xy * (xx - yy) * sh[..., 16] +
+ C4[1] * yz * (3 * xx - yy) * sh[..., 17] +
+ C4[2] * xy * (7 * zz - 1) * sh[..., 18] +
+ C4[3] * yz * (7 * zz - 3) * sh[..., 19] +
+ C4[4] * (zz * (35 * zz - 30) + 3) * sh[..., 20] +
+ C4[5] * xz * (7 * zz - 3) * sh[..., 21] +
+ C4[6] * (xx - yy) * (7 * zz - 1) * sh[..., 22] +
+ C4[7] * xz * (xx - 3 * yy) * sh[..., 23] +
+ C4[8] * (xx * (xx - 3 * yy) - yy * (3 * xx - yy)) * sh[..., 24])
+ return result
+
+def RGB2SH(rgb):
+ return (rgb - 0.5) / C0
+
+def SH2RGB(sh):
+ return sh * C0 + 0.5
\ No newline at end of file
diff --git a/OmniPart/training/representations/__init__.py b/OmniPart/training/representations/__init__.py
new file mode 100644
index 0000000..549ffdb
--- /dev/null
+++ b/OmniPart/training/representations/__init__.py
@@ -0,0 +1,4 @@
+from .radiance_field import Strivec
+from .octree import DfsOctree as Octree
+from .gaussian import Gaussian
+from .mesh import MeshExtractResult
diff --git a/OmniPart/training/representations/gaussian/__init__.py b/OmniPart/training/representations/gaussian/__init__.py
new file mode 100644
index 0000000..e3de6e1
--- /dev/null
+++ b/OmniPart/training/representations/gaussian/__init__.py
@@ -0,0 +1 @@
+from .gaussian_model import Gaussian
\ No newline at end of file
diff --git a/OmniPart/training/representations/gaussian/gaussian_model.py b/OmniPart/training/representations/gaussian/gaussian_model.py
new file mode 100644
index 0000000..54ba16f
--- /dev/null
+++ b/OmniPart/training/representations/gaussian/gaussian_model.py
@@ -0,0 +1,209 @@
+import torch
+import numpy as np
+from plyfile import PlyData, PlyElement
+from .general_utils import inverse_sigmoid, strip_symmetric, build_scaling_rotation
+import utils3d
+
+
+class Gaussian:
+ def __init__(
+ self,
+ aabb : list,
+ sh_degree : int = 0,
+ mininum_kernel_size : float = 0.0,
+ scaling_bias : float = 0.01,
+ opacity_bias : float = 0.1,
+ scaling_activation : str = "exp",
+ device='cuda'
+ ):
+ self.init_params = {
+ 'aabb': aabb,
+ 'sh_degree': sh_degree,
+ 'mininum_kernel_size': mininum_kernel_size,
+ 'scaling_bias': scaling_bias,
+ 'opacity_bias': opacity_bias,
+ 'scaling_activation': scaling_activation,
+ }
+
+ self.sh_degree = sh_degree
+ self.active_sh_degree = sh_degree
+ self.mininum_kernel_size = mininum_kernel_size
+ self.scaling_bias = scaling_bias
+ self.opacity_bias = opacity_bias
+ self.scaling_activation_type = scaling_activation
+ self.device = device
+ self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device)
+ self.setup_functions()
+
+ self._xyz = None
+ self._features_dc = None
+ self._features_rest = None
+ self._scaling = None
+ self._rotation = None
+ self._opacity = None
+
+ def setup_functions(self):
+ def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation):
+ L = build_scaling_rotation(scaling_modifier * scaling, rotation)
+ actual_covariance = L @ L.transpose(1, 2)
+ symm = strip_symmetric(actual_covariance)
+ return symm
+
+ if self.scaling_activation_type == "exp":
+ self.scaling_activation = torch.exp
+ self.inverse_scaling_activation = torch.log
+ elif self.scaling_activation_type == "softplus":
+ self.scaling_activation = torch.nn.functional.softplus
+ self.inverse_scaling_activation = lambda x: x + torch.log(-torch.expm1(-x))
+
+ self.covariance_activation = build_covariance_from_scaling_rotation
+
+ self.opacity_activation = torch.sigmoid
+ self.inverse_opacity_activation = inverse_sigmoid
+
+ self.rotation_activation = torch.nn.functional.normalize
+
+ self.scale_bias = self.inverse_scaling_activation(torch.tensor(self.scaling_bias)).cuda()
+ self.rots_bias = torch.zeros((4)).cuda()
+ self.rots_bias[0] = 1
+ self.opacity_bias = self.inverse_opacity_activation(torch.tensor(self.opacity_bias)).cuda()
+
+ @property
+ def get_scaling(self):
+ scales = self.scaling_activation(self._scaling + self.scale_bias)
+ scales = torch.square(scales) + self.mininum_kernel_size ** 2
+ scales = torch.sqrt(scales)
+ return scales
+
+ @property
+ def get_rotation(self):
+ return self.rotation_activation(self._rotation + self.rots_bias[None, :])
+
+ @property
+ def get_xyz(self):
+ return self._xyz * self.aabb[None, 3:] + self.aabb[None, :3]
+
+ @property
+ def get_features(self):
+ return torch.cat((self._features_dc, self._features_rest), dim=2) if self._features_rest is not None else self._features_dc
+
+ @property
+ def get_opacity(self):
+ return self.opacity_activation(self._opacity + self.opacity_bias)
+
+ def get_covariance(self, scaling_modifier = 1):
+ return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation + self.rots_bias[None, :])
+
+ def from_scaling(self, scales):
+ scales = torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2)
+ self._scaling = self.inverse_scaling_activation(scales) - self.scale_bias
+
+ def from_rotation(self, rots):
+ self._rotation = rots - self.rots_bias[None, :]
+
+ def from_xyz(self, xyz):
+ self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:]
+
+ def from_features(self, features):
+ self._features_dc = features
+
+ def from_opacity(self, opacities):
+ self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias
+
+ def construct_list_of_attributes(self):
+ l = ['x', 'y', 'z', 'nx', 'ny', 'nz']
+ # All channels except the 3 DC
+ for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]):
+ l.append('f_dc_{}'.format(i))
+ l.append('opacity')
+ for i in range(self._scaling.shape[1]):
+ l.append('scale_{}'.format(i))
+ for i in range(self._rotation.shape[1]):
+ l.append('rot_{}'.format(i))
+ return l
+
+ def save_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]):
+ xyz = self.get_xyz.detach().cpu().numpy()
+ normals = np.zeros_like(xyz)
+ f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
+ opacities = inverse_sigmoid(self.get_opacity).detach().cpu().numpy()
+ scale = torch.log(self.get_scaling).detach().cpu().numpy()
+ rotation = (self._rotation + self.rots_bias[None, :]).detach().cpu().numpy()
+
+ if transform is not None:
+ transform = np.array(transform)
+ xyz = np.matmul(xyz, transform.T)
+ rotation = utils3d.numpy.quaternion_to_matrix(rotation)
+ rotation = np.matmul(transform, rotation)
+ rotation = utils3d.numpy.matrix_to_quaternion(rotation)
+
+ dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()]
+
+ elements = np.empty(xyz.shape[0], dtype=dtype_full)
+ attributes = np.concatenate((xyz, normals, f_dc, opacities, scale, rotation), axis=1)
+ elements[:] = list(map(tuple, attributes))
+ el = PlyElement.describe(elements, 'vertex')
+ PlyData([el]).write(path)
+
+ def load_ply(self, path, transform=[[1, 0, 0], [0, 0, -1], [0, 1, 0]]):
+ plydata = PlyData.read(path)
+
+ xyz = np.stack((np.asarray(plydata.elements[0]["x"]),
+ np.asarray(plydata.elements[0]["y"]),
+ np.asarray(plydata.elements[0]["z"])), axis=1)
+ opacities = np.asarray(plydata.elements[0]["opacity"])[..., np.newaxis]
+
+ features_dc = np.zeros((xyz.shape[0], 3, 1))
+ features_dc[:, 0, 0] = np.asarray(plydata.elements[0]["f_dc_0"])
+ features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"])
+ features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"])
+
+ if self.sh_degree > 0:
+ extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")]
+ extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1]))
+ assert len(extra_f_names)==3*(self.sh_degree + 1) ** 2 - 3
+ features_extra = np.zeros((xyz.shape[0], len(extra_f_names)))
+ for idx, attr_name in enumerate(extra_f_names):
+ features_extra[:, idx] = np.asarray(plydata.elements[0][attr_name])
+ # Reshape (P,F*SH_coeffs) to (P, F, SH_coeffs except DC)
+ features_extra = features_extra.reshape((features_extra.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1))
+
+ scale_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("scale_")]
+ scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1]))
+ scales = np.zeros((xyz.shape[0], len(scale_names)))
+ for idx, attr_name in enumerate(scale_names):
+ scales[:, idx] = np.asarray(plydata.elements[0][attr_name])
+
+ rot_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("rot")]
+ rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1]))
+ rots = np.zeros((xyz.shape[0], len(rot_names)))
+ for idx, attr_name in enumerate(rot_names):
+ rots[:, idx] = np.asarray(plydata.elements[0][attr_name])
+
+ if transform is not None:
+ transform = np.array(transform)
+ xyz = np.matmul(xyz, transform)
+ rotation = utils3d.numpy.quaternion_to_matrix(rotation)
+ rotation = np.matmul(rotation, transform)
+ rotation = utils3d.numpy.matrix_to_quaternion(rotation)
+
+ # convert to actual gaussian attributes
+ xyz = torch.tensor(xyz, dtype=torch.float, device=self.device)
+ features_dc = torch.tensor(features_dc, dtype=torch.float, device=self.device).transpose(1, 2).contiguous()
+ if self.sh_degree > 0:
+ features_extra = torch.tensor(features_extra, dtype=torch.float, device=self.device).transpose(1, 2).contiguous()
+ opacities = torch.sigmoid(torch.tensor(opacities, dtype=torch.float, device=self.device))
+ scales = torch.exp(torch.tensor(scales, dtype=torch.float, device=self.device))
+ rots = torch.tensor(rots, dtype=torch.float, device=self.device)
+
+ # convert to _hidden attributes
+ self._xyz = (xyz - self.aabb[None, :3]) / self.aabb[None, 3:]
+ self._features_dc = features_dc
+ if self.sh_degree > 0:
+ self._features_rest = features_extra
+ else:
+ self._features_rest = None
+ self._opacity = self.inverse_opacity_activation(opacities) - self.opacity_bias
+ self._scaling = self.inverse_scaling_activation(torch.sqrt(torch.square(scales) - self.mininum_kernel_size ** 2)) - self.scale_bias
+ self._rotation = rots - self.rots_bias[None, :]
+
\ No newline at end of file
diff --git a/OmniPart/training/representations/gaussian/general_utils.py b/OmniPart/training/representations/gaussian/general_utils.py
new file mode 100644
index 0000000..541c082
--- /dev/null
+++ b/OmniPart/training/representations/gaussian/general_utils.py
@@ -0,0 +1,133 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact george.drettakis@inria.fr
+#
+
+import torch
+import sys
+from datetime import datetime
+import numpy as np
+import random
+
+def inverse_sigmoid(x):
+ return torch.log(x/(1-x))
+
+def PILtoTorch(pil_image, resolution):
+ resized_image_PIL = pil_image.resize(resolution)
+ resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0
+ if len(resized_image.shape) == 3:
+ return resized_image.permute(2, 0, 1)
+ else:
+ return resized_image.unsqueeze(dim=-1).permute(2, 0, 1)
+
+def get_expon_lr_func(
+ lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000
+):
+ """
+ Copied from Plenoxels
+
+ Continuous learning rate decay function. Adapted from JaxNeRF
+ The returned rate is lr_init when step=0 and lr_final when step=max_steps, and
+ is log-linearly interpolated elsewhere (equivalent to exponential decay).
+ If lr_delay_steps>0 then the learning rate will be scaled by some smooth
+ function of lr_delay_mult, such that the initial learning rate is
+ lr_init*lr_delay_mult at the beginning of optimization but will be eased back
+ to the normal learning rate when steps>lr_delay_steps.
+ :param conf: config subtree 'lr' or similar
+ :param max_steps: int, the number of steps during optimization.
+ :return HoF which takes step as input
+ """
+
+ def helper(step):
+ if step < 0 or (lr_init == 0.0 and lr_final == 0.0):
+ # Disable this parameter
+ return 0.0
+ if lr_delay_steps > 0:
+ # A kind of reverse cosine decay.
+ delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(
+ 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)
+ )
+ else:
+ delay_rate = 1.0
+ t = np.clip(step / max_steps, 0, 1)
+ log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t)
+ return delay_rate * log_lerp
+
+ return helper
+
+def strip_lowerdiag(L):
+ uncertainty = torch.zeros((L.shape[0], 6), dtype=torch.float, device="cuda")
+
+ uncertainty[:, 0] = L[:, 0, 0]
+ uncertainty[:, 1] = L[:, 0, 1]
+ uncertainty[:, 2] = L[:, 0, 2]
+ uncertainty[:, 3] = L[:, 1, 1]
+ uncertainty[:, 4] = L[:, 1, 2]
+ uncertainty[:, 5] = L[:, 2, 2]
+ return uncertainty
+
+def strip_symmetric(sym):
+ return strip_lowerdiag(sym)
+
+def build_rotation(r):
+ norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3])
+
+ q = r / norm[:, None]
+
+ R = torch.zeros((q.size(0), 3, 3), device='cuda')
+
+ r = q[:, 0]
+ x = q[:, 1]
+ y = q[:, 2]
+ z = q[:, 3]
+
+ R[:, 0, 0] = 1 - 2 * (y*y + z*z)
+ R[:, 0, 1] = 2 * (x*y - r*z)
+ R[:, 0, 2] = 2 * (x*z + r*y)
+ R[:, 1, 0] = 2 * (x*y + r*z)
+ R[:, 1, 1] = 1 - 2 * (x*x + z*z)
+ R[:, 1, 2] = 2 * (y*z - r*x)
+ R[:, 2, 0] = 2 * (x*z - r*y)
+ R[:, 2, 1] = 2 * (y*z + r*x)
+ R[:, 2, 2] = 1 - 2 * (x*x + y*y)
+ return R
+
+def build_scaling_rotation(s, r):
+ L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device="cuda")
+ R = build_rotation(r)
+
+ L[:,0,0] = s[:,0]
+ L[:,1,1] = s[:,1]
+ L[:,2,2] = s[:,2]
+
+ L = R @ L
+ return L
+
+def safe_state(silent):
+ old_f = sys.stdout
+ class F:
+ def __init__(self, silent):
+ self.silent = silent
+
+ def write(self, x):
+ if not self.silent:
+ if x.endswith("\n"):
+ old_f.write(x.replace("\n", " [{}]\n".format(str(datetime.now().strftime("%d/%m %H:%M:%S")))))
+ else:
+ old_f.write(x)
+
+ def flush(self):
+ old_f.flush()
+
+ sys.stdout = F(silent)
+
+ random.seed(0)
+ np.random.seed(0)
+ torch.manual_seed(0)
+ torch.cuda.set_device(torch.device("cuda:0"))
diff --git a/OmniPart/training/representations/mesh/__init__.py b/OmniPart/training/representations/mesh/__init__.py
new file mode 100644
index 0000000..38cf35c
--- /dev/null
+++ b/OmniPart/training/representations/mesh/__init__.py
@@ -0,0 +1 @@
+from .cube2mesh import SparseFeatures2Mesh, MeshExtractResult
diff --git a/OmniPart/training/representations/mesh/cube2mesh.py b/OmniPart/training/representations/mesh/cube2mesh.py
new file mode 100644
index 0000000..44e8776
--- /dev/null
+++ b/OmniPart/training/representations/mesh/cube2mesh.py
@@ -0,0 +1,143 @@
+import torch
+from ...modules.sparse import SparseTensor
+from easydict import EasyDict as edict
+from .utils_cube import *
+from .flexicubes.flexicubes import FlexiCubes
+
+
+class MeshExtractResult:
+ def __init__(self,
+ vertices,
+ faces,
+ vertex_attrs=None,
+ res=64
+ ):
+ self.vertices = vertices
+ self.faces = faces.long()
+ self.vertex_attrs = vertex_attrs
+ self.face_normal = self.comput_face_normals(vertices, faces)
+ self.res = res
+ self.success = (vertices.shape[0] != 0 and faces.shape[0] != 0)
+
+ # training only
+ self.tsdf_v = None
+ self.tsdf_s = None
+ self.reg_loss = None
+
+ def comput_face_normals(self, verts, faces):
+ i0 = faces[..., 0].long()
+ i1 = faces[..., 1].long()
+ i2 = faces[..., 2].long()
+
+ v0 = verts[i0, :]
+ v1 = verts[i1, :]
+ v2 = verts[i2, :]
+ face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1)
+ face_normals = torch.nn.functional.normalize(face_normals, dim=1)
+ # print(face_normals.min(), face_normals.max(), face_normals.shape)
+ return face_normals[:, None, :].repeat(1, 3, 1)
+
+ def comput_v_normals(self, verts, faces):
+ i0 = faces[..., 0].long()
+ i1 = faces[..., 1].long()
+ i2 = faces[..., 2].long()
+
+ v0 = verts[i0, :]
+ v1 = verts[i1, :]
+ v2 = verts[i2, :]
+ face_normals = torch.cross(v1 - v0, v2 - v0, dim=-1)
+ v_normals = torch.zeros_like(verts)
+ v_normals.scatter_add_(0, i0[..., None].repeat(1, 3), face_normals)
+ v_normals.scatter_add_(0, i1[..., None].repeat(1, 3), face_normals)
+ v_normals.scatter_add_(0, i2[..., None].repeat(1, 3), face_normals)
+
+ v_normals = torch.nn.functional.normalize(v_normals, dim=1)
+ return v_normals
+
+
+class SparseFeatures2Mesh:
+ def __init__(self, device="cuda", res=64, use_color=True):
+ '''
+ a model to generate a mesh from sparse features structures using flexicube
+ '''
+ super().__init__()
+ self.device=device
+ self.res = res
+ self.mesh_extractor = FlexiCubes(device=device)
+ self.sdf_bias = -1.0 / res
+ verts, cube = construct_dense_grid(self.res, self.device)
+ self.reg_c = cube.to(self.device)
+ self.reg_v = verts.to(self.device)
+ self.use_color = use_color
+ self._calc_layout()
+
+ def _calc_layout(self):
+ LAYOUTS = {
+ 'sdf': {'shape': (8, 1), 'size': 8},
+ 'deform': {'shape': (8, 3), 'size': 8 * 3},
+ 'weights': {'shape': (21,), 'size': 21}
+ }
+ if self.use_color:
+ '''
+ 6 channel color including normal map
+ '''
+ LAYOUTS['color'] = {'shape': (8, 6,), 'size': 8 * 6}
+ self.layouts = edict(LAYOUTS)
+ start = 0
+ for k, v in self.layouts.items():
+ v['range'] = (start, start + v['size'])
+ start += v['size']
+ self.feats_channels = start
+
+ def get_layout(self, feats : torch.Tensor, name : str):
+ if name not in self.layouts:
+ return None
+ return feats[:, self.layouts[name]['range'][0]:self.layouts[name]['range'][1]].reshape(-1, *self.layouts[name]['shape'])
+
+ def __call__(self, cubefeats : SparseTensor, training=False):
+ """
+ Generates a mesh based on the specified sparse voxel structures.
+ Args:
+ cube_attrs [Nx21] : Sparse Tensor attrs about cube weights
+ verts_attrs [Nx10] : [0:1] SDF [1:4] deform [4:7] color [7:10] normal
+ Returns:
+ return the success tag and ni you loss,
+ """
+ # add sdf bias to verts_attrs
+ coords = cubefeats.coords[:, 1:]
+ feats = cubefeats.feats
+
+ sdf, deform, color, weights = [self.get_layout(feats, name) for name in ['sdf', 'deform', 'color', 'weights']]
+ sdf += self.sdf_bias
+ v_attrs = [sdf, deform, color] if self.use_color else [sdf, deform]
+ v_pos, v_attrs, reg_loss = sparse_cube2verts(coords, torch.cat(v_attrs, dim=-1), training=training)
+ v_attrs_d = get_dense_attrs(v_pos, v_attrs, res=self.res+1, sdf_init=True)
+ weights_d = get_dense_attrs(coords, weights, res=self.res, sdf_init=False)
+ if self.use_color:
+ sdf_d, deform_d, colors_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4], v_attrs_d[..., 4:]
+ else:
+ sdf_d, deform_d = v_attrs_d[..., 0], v_attrs_d[..., 1:4]
+ colors_d = None
+
+ x_nx3 = get_defomed_verts(self.reg_v, deform_d, self.res)
+
+ vertices, faces, L_dev, colors = self.mesh_extractor(
+ voxelgrid_vertices=x_nx3,
+ scalar_field=sdf_d,
+ cube_idx=self.reg_c,
+ resolution=self.res,
+ beta=weights_d[:, :12],
+ alpha=weights_d[:, 12:20],
+ gamma_f=weights_d[:, 20],
+ voxelgrid_colors=colors_d,
+ training=training)
+
+ mesh = MeshExtractResult(vertices=vertices, faces=faces, vertex_attrs=colors, res=self.res)
+ if training:
+ if mesh.success:
+ reg_loss += L_dev.mean() * 0.5
+ reg_loss += (weights[:,:20]).abs().mean() * 0.2
+ mesh.reg_loss = reg_loss
+ mesh.tsdf_v = get_defomed_verts(v_pos, v_attrs[:, 1:4], self.res)
+ mesh.tsdf_s = v_attrs[:, 0]
+ return mesh
diff --git a/OmniPart/training/representations/mesh/flexicubes/LICENSE.txt b/OmniPart/training/representations/mesh/flexicubes/LICENSE.txt
new file mode 100644
index 0000000..40e8f76
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/LICENSE.txt
@@ -0,0 +1,90 @@
+Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+
+NVIDIA Source Code License for FlexiCubes
+
+
+=======================================================================
+
+1. Definitions
+
+“Licensor” means any person or entity that distributes its Work.
+
+“Work” means (a) the original work of authorship made available under
+this license, which may include software, documentation, or other files,
+and (b) any additions to or derivative works thereof that are made
+available under this license.
+
+The terms “reproduce,” “reproduction,” “derivative works,” and
+“distribution” have the meaning as provided under U.S. copyright law;
+provided, however, that 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.
+
+Works are “made available” under this license by including in or with
+the Work either (a) a copyright notice referencing the applicability of
+this license to the Work, or (b) a copy of this license.
+
+2. License Grant
+
+ 2.1 Copyright Grant. Subject to the terms and conditions of this license,
+ each Licensor grants to you a perpetual, worldwide, non-exclusive,
+ royalty-free, copyright license to use, reproduce, prepare derivative
+ works of, publicly display, publicly perform, sublicense and distribute
+ its Work and any resulting derivative works in any form.
+
+3. Limitations
+
+ 3.1 Redistribution. You may reproduce or distribute the Work only if
+ (a) you do so under this license, (b) you include a complete copy of
+ this license with your distribution, and (c) you retain without
+ modification any copyright, patent, trademark, or attribution notices
+ that are present in the Work.
+
+ 3.2 Derivative Works. You may specify that additional or different terms
+ apply to the use, reproduction, and distribution of your derivative
+ works of the Work (“Your Terms”) only if (a) Your Terms provide that the
+ use limitation in Section 3.3 applies to your derivative works, and (b)
+ you identify the specific derivative works that are subject to Your Terms.
+ Notwithstanding Your Terms, this license (including the redistribution
+ requirements in Section 3.1) will continue to apply to the Work itself.
+
+ 3.3 Use Limitation. The Work and any derivative works thereof only may be
+ used or intended for use non-commercially. Notwithstanding the foregoing,
+ NVIDIA Corporation and its affiliates may use the Work and any derivative
+ works commercially. As used herein, “non-commercially” means for research
+ or evaluation purposes only.
+
+ 3.4 Patent Claims. If you bring or threaten to bring a patent claim against
+ any Licensor (including any claim, cross-claim or counterclaim in a lawsuit)
+ to enforce any patents that you allege are infringed by any Work, then your
+ rights under this license from such Licensor (including the grant in
+ Section 2.1) will terminate immediately.
+
+ 3.5 Trademarks. This license does not grant any rights to use any Licensor’s
+ or its affiliates’ names, logos, or trademarks, except as necessary to
+ reproduce the notices described in this license.
+
+ 3.6 Termination. If you violate any term of this license, then your rights
+ under this license (including the grant in Section 2.1) will terminate
+ immediately.
+
+4. Disclaimer of Warranty.
+
+THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT.
+YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE.
+
+5. Limitation of Liability.
+
+EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY,
+WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY
+LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE,
+THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF
+GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR
+MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+=======================================================================
\ No newline at end of file
diff --git a/OmniPart/training/representations/mesh/flexicubes/README.md b/OmniPart/training/representations/mesh/flexicubes/README.md
new file mode 100644
index 0000000..8f8b460
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/README.md
@@ -0,0 +1,110 @@
+## Flexible Isosurface Extraction for Gradient-Based Mesh Optimization (FlexiCubes)
Official PyTorch implementation
+
+![Teaser image]()
+
+FlexiCubes is a high-quality isosurface representation specifically designed for gradient-based mesh optimization with respect to geometric, visual, or even physical objectives. For more details, please refer to our [paper](https://arxiv.org/abs/2308.05371) and [project page](https://research.nvidia.com/labs/toronto-ai/flexicubes/).
+
+## Highlights
+* [Getting started](https://github.com/nv-tlabs/FlexiCubes#getting-started)
+* [Basic workflow](https://github.com/nv-tlabs/FlexiCubes#example-usage)
+* [nvdiffrec: image-based reconstruction example](https://github.com/NVlabs/nvdiffrec#news)
+* [GET3D: generative AI example](https://github.com/nv-tlabs/GET3D#employing-flexicubes)
+* [Bibtex](https://github.com/nv-tlabs/FlexiCubes#citation)
+
+## Getting Started
+
+The core functions of FlexiCubes are now in [Kaolin](https://github.com/NVIDIAGameWorks/kaolin/) starting from v0.15.0. See installation instructions [here](https://kaolin.readthedocs.io/en/latest/notes/installation.html) and API documentations [here](https://kaolin.readthedocs.io/en/latest/modules/kaolin.non_commercial.html#kaolin.non_commercial.FlexiCubes)
+
+The original code of the paper is still visible in `flexicube.py`.
+
+## Example Usage
+
+### Gradient-Based Mesh Optimization
+We provide examples demonstrating how to use FlexiCubes for reconstructing unknown meshes through gradient-based optimization. Specifically, starting from randomly initialized SDF, we optimize the shape towards the reference mesh by minimizing their geometric difference, measured by multiview mask and depth losses. This workflow is a simplified version of `nvdiffrec` with code largely borrowed from the [nvdiffrec GitHub](https://github.com/NVlabs/nvdiffrec). We use the same pipeline to conduct the analysis in Section 3 and the main experiments described in Section 5 of our paper. We provide a detailed tutorial in `examples/optimization.ipynb`, along with an optimization script in `examples/optimize.py` which accepts command-line arguments.
+
+
+To run the examples, it is suggested to install the Conda environment as detailed below:
+```sh
+conda create -n flexicubes python=3.9
+conda activate flexicubes
+conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 -c pytorch
+pip install imageio trimesh tqdm matplotlib torch_scatter ninja
+pip install git+https://github.com/NVlabs/nvdiffrast/
+pip install kaolin==0.15.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-1.12.0_cu113.html
+```
+
+Then download the dataset collected by [Myles et al.](https://vcg.isti.cnr.it/Publications/2014/MPZ14/) as follows. We include one shape in 'examples/data/inputmodels/block.obj' if you want to test without downloading the full dataset.
+
+```sh
+cd examples
+python download_data.py
+```
+
+After downloading the data, run shape optimization with the following example command:
+```sh
+python optimize.py --ref_mesh data/inputmodels/block.obj --out_dir out/block
+```
+You can find visualization and output meshes in the `out/block`. Below, we show the initial and final shapes during optimization, with the reference shape on the right.
+
+
+
+
+
+
+To further demonstrate the flexibility of our FlexiCubes representation, which can accommodates both reconstruction objectives and regularizers defined on the extracted mesh, you can add a developability regularizer (proposed by [Stein et al.](https://www.cs.cmu.edu/~kmcrane/Projects/DiscreteDevelopable/)) to the previous reconstruction pipeline to encourage fabricability from panels:
+```sh
+python optimize.py --ref_mesh data/inputmodels/david.obj --out_dir out/david_dev --develop_reg True --iter=1250
+```
+
+### Extract mesh from known signed distance field
+While not its designated use case, our function can extract a mesh from a known Signed Distance Field (SDF) without optimization. Please refer to the tutorial found in `examples/extraction.ipynb` for details.
+
+## Tips for using FlexiCubes
+### Regularization losses:
+We commonly use three regularizers in our mesh optimization pipelines, referenced in lines `L104-L106` in `examples/optimize.py`. The weights of these regularizers should be scaled according to the your application objectives. Initially, it is suggested to employ low weights because strong regularization can hinder convergence. You can incrementally increase the weights if you notice artifacts appearing in the optimized meshes. Specifically:
+
+* The loss function at `L104` helps to remove floaters in areas of the shape that are not supervised by the application objective, such as internal faces when using image supervision only.
+* The L_dev loss at `L105` can be increased if you observe artifacts in flat areas, as illustrated in the image below.
+* Generally, the L1 regularizer on flexible weights at `L106` does not have a significant impact during the optimization of a single shape. However, we found it to be effective in stabilizing training in generative pipelines such as GET3D.
+
+
+### Resolution of voxel grid vs. tetrahedral grid:
+If you are switching from our previous work, DMTet, it's important to note the difference in grid resolution when compared to FlexiCubes. In both implementations, the resolution is defined by the edge length: a grid resolution of `n` means the grid edge length is 1/n for both the voxel and tetrahedral grids. However, a tetrahedral grid with a resolution of `n` contains only `(n/2+1)³` grid vertices, in contrast to the `(n+1)³` vertices in a voxel grid. Consequently, if you are switching from DMTet to FlexiCubes while maintaining the same resolution, you will notice not only a denser output mesh but also a substantial increase in computational cost. To align the triangle count in the output meshes more closely, we recommend adopting a 4:5 resolution ratio between the voxel grid and the tetrahedral grid. For instance, in our paper, `64³` FlexiCubes generate approximately the same number of triangles as `80³` DMTet.
+
+## Applications
+FlexiCubes is now integrated into NVIDIA applications as a drop-in replacement for DMTet. You can visit their GitHub pages to see how FlexiCubes is used in advanced photogrammetry and 3D generative pipelines.
+
+[Extracting Triangular 3D Models, Materials, and Lighting From Images (nvdiffrec)](https://github.com/NVlabs/nvdiffrec#news)
+
+[GET3D: A Generative Model of High Quality 3D Textured Shapes Learned from Images](https://github.com/nv-tlabs/GET3D#employing-flexicubes)
+
+
+
+## License
+Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+This work is made available under the [Nvidia Source Code License](LICENSE.txt).
+
+For business inquiries, please visit our website and submit the form: [NVIDIA Research Licensing](https://www.nvidia.com/en-us/research/inquiries/).
+
+## Citation
+```bibtex
+@article{shen2023flexicubes,
+author = {Shen, Tianchang and Munkberg, Jacob and Hasselgren, Jon and Yin, Kangxue and Wang, Zian
+ and Chen, Wenzheng and Gojcic, Zan and Fidler, Sanja and Sharp, Nicholas and Gao, Jun},
+title = {Flexible Isosurface Extraction for Gradient-Based Mesh Optimization},
+year = {2023},
+issue_date = {August 2023},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+volume = {42},
+number = {4},
+issn = {0730-0301},
+url = {https://doi.org/10.1145/3592430},
+doi = {10.1145/3592430},
+journal = {ACM Trans. Graph.},
+month = {jul},
+articleno = {37},
+numpages = {16}
+}
+```
diff --git a/OmniPart/training/representations/mesh/flexicubes/examples/download_data.py b/OmniPart/training/representations/mesh/flexicubes/examples/download_data.py
new file mode 100644
index 0000000..3d0ea2d
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/examples/download_data.py
@@ -0,0 +1,41 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import requests
+from zipfile import ZipFile
+from tqdm import tqdm
+import os
+
+def download_file(url, output_path):
+ response = requests.get(url, stream=True)
+ response.raise_for_status()
+ total_size_in_bytes = int(response.headers.get('content-length', 0))
+ block_size = 1024 #1 Kibibyte
+ progress_bar = tqdm(total=total_size_in_bytes, unit='iB', unit_scale=True)
+
+ with open(output_path, 'wb') as file:
+ for data in response.iter_content(block_size):
+ progress_bar.update(len(data))
+ file.write(data)
+ progress_bar.close()
+ if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:
+ raise Exception("ERROR, something went wrong")
+
+
+url = "https://vcg.isti.cnr.it/Publications/2014/MPZ14/inputmodels.zip"
+zip_file_path = './data/inputmodels.zip'
+
+os.makedirs('./data', exist_ok=True)
+
+download_file(url, zip_file_path)
+
+with ZipFile(zip_file_path, 'r') as zip_ref:
+ zip_ref.extractall('./data')
+
+os.remove(zip_file_path)
+
+print("Download and extraction complete.")
diff --git a/OmniPart/training/representations/mesh/flexicubes/examples/loss.py b/OmniPart/training/representations/mesh/flexicubes/examples/loss.py
new file mode 100644
index 0000000..ba507f0
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/examples/loss.py
@@ -0,0 +1,95 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import torch
+import torch_scatter
+
+###############################################################################
+# Pytorch implementation of the developability regularizer introduced in paper
+# "Developability of Triangle Meshes" by Stein et al.
+###############################################################################
+def mesh_developable_reg(mesh):
+
+ verts = mesh.vertices
+ tris = mesh.faces
+
+ device = verts.device
+ V = verts.shape[0]
+ F = tris.shape[0]
+
+ POS_EPS = 1e-6
+ REL_EPS = 1e-6
+
+ def normalize(vecs):
+ return vecs / (torch.linalg.norm(vecs, dim=-1, keepdim=True) + POS_EPS)
+
+ tri_pos = verts[tris]
+
+ vert_normal_covariance_sum = torch.zeros((V, 9), device=device)
+ vert_area = torch.zeros(V, device=device)
+ vert_degree = torch.zeros(V, dtype=torch.int32, device=device)
+
+ for iC in range(3): # loop over three corners of each triangle
+
+ # gather tri verts
+ pRoot = tri_pos[:, iC, :]
+ pA = tri_pos[:, (iC + 1) % 3, :]
+ pB = tri_pos[:, (iC + 2) % 3, :]
+
+ # compute the corner angle & normal
+ vA = pA - pRoot
+ vAn = normalize(vA)
+ vB = pB - pRoot
+ vBn = normalize(vB)
+ area_normal = torch.linalg.cross(vA, vB, dim=-1)
+ face_area = 0.5 * torch.linalg.norm(area_normal, dim=-1)
+ normal = normalize(area_normal)
+ corner_angle = torch.acos(torch.clamp(torch.sum(vAn * vBn, dim=-1), min=-1., max=1.))
+
+ # add up the contribution to the covariance matrix
+ outer = normal[:, :, None] @ normal[:, None, :]
+ contrib = corner_angle[:, None] * outer.reshape(-1, 9)
+
+ # scatter the result to the appropriate matrices
+ vert_normal_covariance_sum = torch_scatter.scatter_add(src=contrib,
+ index=tris[:, iC],
+ dim=-2,
+ out=vert_normal_covariance_sum)
+
+ vert_area = torch_scatter.scatter_add(src=face_area / 3.,
+ index=tris[:, iC],
+ dim=-1,
+ out=vert_area)
+
+ vert_degree = torch_scatter.scatter_add(src=torch.ones(F, dtype=torch.int32, device=device),
+ index=tris[:, iC],
+ dim=-1,
+ out=vert_degree)
+
+ # The energy is the smallest eigenvalue of the outer-product matrix
+ vert_normal_covariance_sum = vert_normal_covariance_sum.reshape(
+ -1, 3, 3) # reshape to a batch of matrices
+ vert_normal_covariance_sum = vert_normal_covariance_sum + torch.eye(
+ 3, device=device)[None, :, :] * REL_EPS
+
+ min_eigvals = torch.min(torch.linalg.eigvals(vert_normal_covariance_sum).abs(), dim=-1).values
+
+ # Mask out degree-3 vertices
+ vert_area = torch.where(vert_degree == 3, torch.tensor(0, dtype=vert_area.dtype,device=vert_area.device), vert_area)
+
+ # Adjust the vertex area weighting so it is unit-less, and 1 on average
+ vert_area = vert_area * (V / torch.sum(vert_area, dim=-1, keepdim=True))
+
+ return vert_area * min_eigvals
+
+def sdf_reg_loss(sdf, all_edges):
+ sdf_f1x6x2 = sdf[all_edges.reshape(-1)].reshape(-1,2)
+ mask = torch.sign(sdf_f1x6x2[...,0]) != torch.sign(sdf_f1x6x2[...,1])
+ sdf_f1x6x2 = sdf_f1x6x2[mask]
+ sdf_diff = torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,0], (sdf_f1x6x2[...,1] > 0).float()) + \
+ torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,1], (sdf_f1x6x2[...,0] > 0).float())
+ return sdf_diff
\ No newline at end of file
diff --git a/OmniPart/training/representations/mesh/flexicubes/examples/optimize.py b/OmniPart/training/representations/mesh/flexicubes/examples/optimize.py
new file mode 100644
index 0000000..332fa2c
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/examples/optimize.py
@@ -0,0 +1,150 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import argparse
+import numpy as np
+import torch
+import nvdiffrast.torch as dr
+import trimesh
+import os
+from util import *
+import render
+import loss
+import imageio
+
+import sys
+sys.path.append('..')
+from flexicubes import FlexiCubes
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def lr_schedule(iter):
+ return max(0.0, 10**(-(iter)*0.0002)) # Exponential falloff from [1.0, 0.1] over 5k epochs.
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(description='flexicubes optimization')
+ parser.add_argument('-o', '--out_dir', type=str, default=None)
+ parser.add_argument('-rm', '--ref_mesh', type=str)
+
+ parser.add_argument('-i', '--iter', type=int, default=1000)
+ parser.add_argument('-b', '--batch', type=int, default=8)
+ parser.add_argument('-r', '--train_res', nargs=2, type=int, default=[2048, 2048])
+ parser.add_argument('-lr', '--learning_rate', type=float, default=0.01)
+ parser.add_argument('--voxel_grid_res', type=int, default=64)
+
+ parser.add_argument('--sdf_loss', type=bool, default=True)
+ parser.add_argument('--develop_reg', type=bool, default=False)
+ parser.add_argument('--sdf_regularizer', type=float, default=0.2)
+
+ parser.add_argument('-dr', '--display_res', nargs=2, type=int, default=[512, 512])
+ parser.add_argument('-si', '--save_interval', type=int, default=20)
+ FLAGS = parser.parse_args()
+ device = 'cuda'
+
+ os.makedirs(FLAGS.out_dir, exist_ok=True)
+ glctx = dr.RasterizeGLContext()
+
+ # Load GT mesh
+ gt_mesh = load_mesh(FLAGS.ref_mesh, device)
+ gt_mesh.auto_normals() # compute face normals for visualization
+
+ # ==============================================================================================
+ # Create and initialize FlexiCubes
+ # ==============================================================================================
+ fc = FlexiCubes(device)
+ x_nx3, cube_fx8 = fc.construct_voxel_grid(FLAGS.voxel_grid_res)
+ x_nx3 *= 2 # scale up the grid so that it's larger than the target object
+
+ sdf = torch.rand_like(x_nx3[:,0]) - 0.1 # randomly init SDF
+ sdf = torch.nn.Parameter(sdf.clone().detach(), requires_grad=True)
+ # set per-cube learnable weights to zeros
+ weight = torch.zeros((cube_fx8.shape[0], 21), dtype=torch.float, device='cuda')
+ weight = torch.nn.Parameter(weight.clone().detach(), requires_grad=True)
+ deform = torch.nn.Parameter(torch.zeros_like(x_nx3), requires_grad=True)
+
+ # Retrieve all the edges of the voxel grid; these edges will be utilized to
+ # compute the regularization loss in subsequent steps of the process.
+ all_edges = cube_fx8[:, fc.cube_edges].reshape(-1, 2)
+ grid_edges = torch.unique(all_edges, dim=0)
+
+ # ==============================================================================================
+ # Setup optimizer
+ # ==============================================================================================
+ optimizer = torch.optim.Adam([sdf, weight,deform], lr=FLAGS.learning_rate)
+ scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda x: lr_schedule(x))
+
+ # ==============================================================================================
+ # Train loop
+ # ==============================================================================================
+ for it in range(FLAGS.iter):
+ optimizer.zero_grad()
+ # sample random camera poses
+ mv, mvp = render.get_random_camera_batch(FLAGS.batch, iter_res=FLAGS.train_res, device=device, use_kaolin=False)
+ # render gt mesh
+ target = render.render_mesh_paper(gt_mesh, mv, mvp, FLAGS.train_res)
+ # extract and render FlexiCubes mesh
+ grid_verts = x_nx3 + (2-1e-8) / (FLAGS.voxel_grid_res * 2) * torch.tanh(deform)
+ vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20],
+ gamma_f=weight[:,20], training=True)
+ flexicubes_mesh = Mesh(vertices, faces)
+ buffers = render.render_mesh_paper(flexicubes_mesh, mv, mvp, FLAGS.train_res)
+
+ # evaluate reconstruction loss
+ mask_loss = (buffers['mask'] - target['mask']).abs().mean()
+ depth_loss = (((((buffers['depth'] - (target['depth']))* target['mask'])**2).sum(-1)+1e-8)).sqrt().mean() * 10
+
+ t_iter = it / FLAGS.iter
+ sdf_weight = FLAGS.sdf_regularizer - (FLAGS.sdf_regularizer - FLAGS.sdf_regularizer/20)*min(1.0, 4.0 * t_iter)
+ reg_loss = loss.sdf_reg_loss(sdf, grid_edges).mean() * sdf_weight # Loss to eliminate internal floaters that are not visible
+ reg_loss += L_dev.mean() * 0.5
+ reg_loss += (weight[:,:20]).abs().mean() * 0.1
+ total_loss = mask_loss + depth_loss + reg_loss
+
+ if FLAGS.sdf_loss: # optionally add SDF loss to eliminate internal structures
+ with torch.no_grad():
+ pts = sample_random_points(1000, gt_mesh)
+ gt_sdf = compute_sdf(pts, gt_mesh.vertices, gt_mesh.faces)
+ pred_sdf = compute_sdf(pts, flexicubes_mesh.vertices, flexicubes_mesh.faces)
+ total_loss += torch.nn.functional.mse_loss(pred_sdf, gt_sdf) * 2e3
+
+ # optionally add developability regularizer, as described in paper section 5.2
+ if FLAGS.develop_reg:
+ reg_weight = max(0, t_iter - 0.8) * 5
+ if reg_weight > 0: # only applied after shape converges
+ reg_loss = loss.mesh_developable_reg(flexicubes_mesh).mean() * 10
+ reg_loss += (deform).abs().mean()
+ reg_loss += (weight[:,:20]).abs().mean()
+ total_loss = mask_loss + depth_loss + reg_loss
+
+ total_loss.backward()
+ optimizer.step()
+ scheduler.step()
+
+ if (it % FLAGS.save_interval == 0 or it == (FLAGS.iter-1)): # save normal image for visualization
+ with torch.no_grad():
+ # extract mesh with training=False
+ vertices, faces, L_dev = fc(grid_verts, sdf, cube_fx8, FLAGS.voxel_grid_res, beta_fx12=weight[:,:12], alpha_fx8=weight[:,12:20],
+ gamma_f=weight[:,20], training=False)
+ flexicubes_mesh = Mesh(vertices, faces)
+
+ flexicubes_mesh.auto_normals() # compute face normals for visualization
+ mv, mvp = render.get_rotate_camera(it//FLAGS.save_interval, iter_res=FLAGS.display_res, device=device,use_kaolin=False)
+ val_buffers = render.render_mesh_paper(flexicubes_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True)
+ val_image = ((val_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8)
+
+ gt_buffers = render.render_mesh_paper(gt_mesh, mv.unsqueeze(0), mvp.unsqueeze(0), FLAGS.display_res, return_types=["normal"], white_bg=True)
+ gt_image = ((gt_buffers["normal"][0].detach().cpu().numpy()+1)/2*255).astype(np.uint8)
+ imageio.imwrite(os.path.join(FLAGS.out_dir, '{:04d}.png'.format(it)), np.concatenate([val_image, gt_image], 1))
+ print(f"Optimization Step [{it}/{FLAGS.iter}], Loss: {total_loss.item():.4f}")
+
+ # ==============================================================================================
+ # Save ouput
+ # ==============================================================================================
+ mesh_np = trimesh.Trimesh(vertices = vertices.detach().cpu().numpy(), faces=faces.detach().cpu().numpy(), process=False)
+ mesh_np.export(os.path.join(FLAGS.out_dir, 'output_mesh.obj'))
\ No newline at end of file
diff --git a/OmniPart/training/representations/mesh/flexicubes/examples/render.py b/OmniPart/training/representations/mesh/flexicubes/examples/render.py
new file mode 100644
index 0000000..034f961
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/examples/render.py
@@ -0,0 +1,267 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import numpy as np
+import copy
+import math
+from ipywidgets import interactive, HBox, VBox, FloatLogSlider, IntSlider
+
+import torch
+import nvdiffrast.torch as dr
+import kaolin as kal
+import util
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def get_random_camera_batch(batch_size, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True):
+ if use_kaolin:
+ camera_pos = torch.stack(kal.ops.coords.spherical2cartesian(
+ *kal.ops.random.sample_spherical_coords((batch_size,), azimuth_low=0., azimuth_high=math.pi * 2,
+ elevation_low=-math.pi / 2., elevation_high=math.pi / 2., device='cuda'),
+ cam_radius
+ ), dim=-1)
+ return kal.render.camera.Camera.from_args(
+ eye=camera_pos + torch.rand((batch_size, 1), device='cuda') * 0.5 - 0.25,
+ at=torch.zeros(batch_size, 3),
+ up=torch.tensor([[0., 1., 0.]]),
+ fov=fovy,
+ near=cam_near_far[0], far=cam_near_far[1],
+ height=iter_res[0], width=iter_res[1],
+ device='cuda'
+ )
+ else:
+ def get_random_camera():
+ proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1])
+ mv = util.translate(0, 0, -cam_radius) @ util.random_rotation_translation(0.25)
+ mvp = proj_mtx @ mv
+ return mv, mvp
+ mv_batch = []
+ mvp_batch = []
+ for i in range(batch_size):
+ mv, mvp = get_random_camera()
+ mv_batch.append(mv)
+ mvp_batch.append(mvp)
+ return torch.stack(mv_batch).to(device), torch.stack(mvp_batch).to(device)
+
+def get_rotate_camera(itr, fovy = np.deg2rad(45), iter_res=[512,512], cam_near_far=[0.1, 1000.0], cam_radius=3.0, device="cuda", use_kaolin=True):
+ if use_kaolin:
+ ang = (itr / 10) * np.pi * 2
+ camera_pos = torch.stack(kal.ops.coords.spherical2cartesian(torch.tensor(ang), torch.tensor(0.4), -torch.tensor(cam_radius)))
+ return kal.render.camera.Camera.from_args(
+ eye=camera_pos,
+ at=torch.zeros(3),
+ up=torch.tensor([0., 1., 0.]),
+ fov=fovy,
+ near=cam_near_far[0], far=cam_near_far[1],
+ height=iter_res[0], width=iter_res[1],
+ device='cuda'
+ )
+ else:
+ proj_mtx = util.perspective(fovy, iter_res[1] / iter_res[0], cam_near_far[0], cam_near_far[1])
+
+ # Smooth rotation for display.
+ ang = (itr / 10) * np.pi * 2
+ mv = util.translate(0, 0, -cam_radius) @ (util.rotate_x(-0.4) @ util.rotate_y(ang))
+ mvp = proj_mtx @ mv
+ return mv.to(device), mvp.to(device)
+
+glctx = dr.RasterizeGLContext()
+def render_mesh(mesh, camera, iter_res, return_types = ["mask", "depth"], white_bg=False, wireframe_thickness=0.4):
+ vertices_camera = camera.extrinsics.transform(mesh.vertices)
+ face_vertices_camera = kal.ops.mesh.index_vertices_by_faces(
+ vertices_camera, mesh.faces
+ )
+
+ # Projection: nvdiffrast take clip coordinates as input to apply barycentric perspective correction.
+ # Using `camera.intrinsics.transform(vertices_camera) would return the normalized device coordinates.
+ proj = camera.projection_matrix().unsqueeze(1)
+ proj[:, :, 1, 1] = -proj[:, :, 1, 1]
+ homogeneous_vecs = kal.render.camera.up_to_homogeneous(
+ vertices_camera
+ )
+ vertices_clip = (proj @ homogeneous_vecs.unsqueeze(-1)).squeeze(-1)
+ faces_int = mesh.faces.int()
+
+ rast, _ = dr.rasterize(
+ glctx, vertices_clip, faces_int, iter_res)
+
+ out_dict = {}
+ for type in return_types:
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, vertices_clip, faces_int)
+ elif type == "depth":
+ img = dr.interpolate(homogeneous_vecs, rast, faces_int)[0]
+ elif type == "wireframe":
+ img = torch.logical_or(
+ torch.logical_or(rast[..., 0] < wireframe_thickness, rast[..., 1] < wireframe_thickness),
+ (rast[..., 0] + rast[..., 1]) > (1. - wireframe_thickness)
+ ).unsqueeze(-1)
+ elif type == "normals" :
+ img = dr.interpolate(
+ mesh.face_normals.reshape(len(mesh), -1, 3), rast,
+ torch.arange(mesh.faces.shape[0] * 3, device='cuda', dtype=torch.int).reshape(-1, 3)
+ )[0]
+ if white_bg:
+ bg = torch.ones_like(img)
+ alpha = (rast[..., -1:] > 0).float()
+ img = torch.lerp(bg, img, alpha)
+ out_dict[type] = img
+
+
+ return out_dict
+
+def render_mesh_paper(mesh, mv, mvp, iter_res, return_types = ["mask", "depth"], white_bg=False):
+ '''
+ The rendering function used to produce the results in the paper.
+ '''
+ v_pos_clip = util.xfm_points(mesh.vertices.unsqueeze(0), mvp) # Rotate it to camera coordinates
+ rast, db = dr.rasterize(
+ dr.RasterizeGLContext(), v_pos_clip, mesh.faces.int(), iter_res)
+
+ out_dict = {}
+ for type in return_types:
+ if type == "mask" :
+ img = dr.antialias((rast[..., -1:] > 0).float(), rast, v_pos_clip, mesh.faces.int())
+ elif type == "depth":
+ v_pos_cam = util.xfm_points(mesh.vertices.unsqueeze(0), mv)
+ img, _ = util.interpolate(v_pos_cam, rast, mesh.faces.int())
+ elif type == "normal" :
+ normal_indices = (torch.arange(0, mesh.nrm.shape[0], dtype=torch.int64, device='cuda')[:, None]).repeat(1, 3)
+ img, _ = util.interpolate(mesh.nrm.unsqueeze(0).contiguous(), rast, normal_indices.int())
+ elif type == "vertex_normal":
+ img, _ = util.interpolate(mesh.v_nrm.unsqueeze(0).contiguous(), rast, mesh.faces.int())
+ img = dr.antialias((img + 1) * 0.5, rast, v_pos_clip, mesh.faces.int())
+ if white_bg:
+ bg = torch.ones_like(img)
+ alpha = (rast[..., -1:] > 0).float()
+ img = torch.lerp(bg, img, alpha)
+ out_dict[type] = img
+ return out_dict
+
+class SplitVisualizer():
+ def __init__(self, lh_mesh, rh_mesh, height, width):
+ self.lh_mesh = lh_mesh
+ self.rh_mesh = rh_mesh
+ self.height = height
+ self.width = width
+ self.wireframe_thickness = 0.4
+
+
+ def render(self, camera):
+ lh_outputs = render_mesh(
+ self.lh_mesh, camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+ rh_outputs = render_mesh(
+ self.rh_mesh, camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+ outputs = {
+ k: torch.cat(
+ [lh_outputs[k][0].permute(1, 0, 2), rh_outputs[k][0].permute(1, 0, 2)],
+ dim=0
+ ).permute(1, 0, 2) for k in ["normals", "wireframe"]
+ }
+ return {
+ 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8),
+ 'normals': outputs['normals']
+ }
+
+ def show(self, init_camera):
+ visualizer = kal.visualize.IpyTurntableVisualizer(
+ self.height, self.width * 2, copy.deepcopy(init_camera), self.render,
+ max_fps=24, world_up_axis=1)
+
+ def slider_callback(new_wireframe_thickness):
+ """ipywidgets sliders callback"""
+ with visualizer.out: # This is in case of bug
+ self.wireframe_thickness = new_wireframe_thickness
+ # this is how we request a new update
+ visualizer.render_update()
+
+ wireframe_thickness_slider = FloatLogSlider(
+ value=self.wireframe_thickness,
+ base=10,
+ min=-3,
+ max=-0.4,
+ step=0.1,
+ description='wireframe_thickness',
+ continuous_update=True,
+ readout=True,
+ readout_format='.3f',
+ )
+
+ interactive_slider = interactive(
+ slider_callback,
+ new_wireframe_thickness=wireframe_thickness_slider,
+ )
+
+ full_output = VBox([visualizer.canvas, interactive_slider])
+ display(full_output, visualizer.out)
+
+class TimelineVisualizer():
+ def __init__(self, meshes, height, width):
+ self.meshes = meshes
+ self.height = height
+ self.width = width
+ self.wireframe_thickness = 0.4
+ self.idx = len(meshes) - 1
+
+ def render(self, camera):
+ outputs = render_mesh(
+ self.meshes[self.idx], camera, (self.height, self.width),
+ return_types=["normals", "wireframe"], wireframe_thickness=self.wireframe_thickness
+ )
+
+ return {
+ 'img': (outputs['wireframe'] * ((outputs['normals'] + 1.) / 2.) * 255).to(torch.uint8)[0],
+ 'normals': outputs['normals'][0]
+ }
+
+ def show(self, init_camera):
+ visualizer = kal.visualize.IpyTurntableVisualizer(
+ self.height, self.width, copy.deepcopy(init_camera), self.render,
+ max_fps=24, world_up_axis=1)
+
+ def slider_callback(new_wireframe_thickness, new_idx):
+ """ipywidgets sliders callback"""
+ with visualizer.out: # This is in case of bug
+ self.wireframe_thickness = new_wireframe_thickness
+ self.idx = new_idx
+ # this is how we request a new update
+ visualizer.render_update()
+
+ wireframe_thickness_slider = FloatLogSlider(
+ value=self.wireframe_thickness,
+ base=10,
+ min=-3,
+ max=-0.4,
+ step=0.1,
+ description='wireframe_thickness',
+ continuous_update=True,
+ readout=True,
+ readout_format='.3f',
+ )
+
+ idx_slider = IntSlider(
+ value=self.idx,
+ min=0,
+ max=len(self.meshes) - 1,
+ description='idx',
+ continuous_update=True,
+ readout=True
+ )
+
+ interactive_slider = interactive(
+ slider_callback,
+ new_wireframe_thickness=wireframe_thickness_slider,
+ new_idx=idx_slider
+ )
+ full_output = HBox([visualizer.canvas, interactive_slider])
+ display(full_output, visualizer.out)
diff --git a/OmniPart/training/representations/mesh/flexicubes/examples/util.py b/OmniPart/training/representations/mesh/flexicubes/examples/util.py
new file mode 100644
index 0000000..f39ea1c
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/examples/util.py
@@ -0,0 +1,122 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+import numpy as np
+import torch
+import trimesh
+import kaolin
+import nvdiffrast.torch as dr
+
+###############################################################################
+# Functions adapted from https://github.com/NVlabs/nvdiffrec
+###############################################################################
+
+def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+ return torch.sum(x*y, -1, keepdim=True)
+
+def length(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor:
+ return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN
+
+def safe_normalize(x: torch.Tensor, eps: float =1e-8) -> torch.Tensor:
+ return x / length(x, eps)
+
+def perspective(fovy=0.7854, aspect=1.0, n=0.1, f=1000.0, device=None):
+ y = np.tan(fovy / 2)
+ return torch.tensor([[1/(y*aspect), 0, 0, 0],
+ [ 0, 1/-y, 0, 0],
+ [ 0, 0, -(f+n)/(f-n), -(2*f*n)/(f-n)],
+ [ 0, 0, -1, 0]], dtype=torch.float32, device=device)
+
+def translate(x, y, z, device=None):
+ return torch.tensor([[1, 0, 0, x],
+ [0, 1, 0, y],
+ [0, 0, 1, z],
+ [0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+@torch.no_grad()
+def random_rotation_translation(t, device=None):
+ m = np.random.normal(size=[3, 3])
+ m[1] = np.cross(m[0], m[2])
+ m[2] = np.cross(m[0], m[1])
+ m = m / np.linalg.norm(m, axis=1, keepdims=True)
+ m = np.pad(m, [[0, 1], [0, 1]], mode='constant')
+ m[3, 3] = 1.0
+ m[:3, 3] = np.random.uniform(-t, t, size=[3])
+ return torch.tensor(m, dtype=torch.float32, device=device)
+
+def rotate_x(a, device=None):
+ s, c = np.sin(a), np.cos(a)
+ return torch.tensor([[1, 0, 0, 0],
+ [0, c, s, 0],
+ [0, -s, c, 0],
+ [0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+def rotate_y(a, device=None):
+ s, c = np.sin(a), np.cos(a)
+ return torch.tensor([[ c, 0, s, 0],
+ [ 0, 1, 0, 0],
+ [-s, 0, c, 0],
+ [ 0, 0, 0, 1]], dtype=torch.float32, device=device)
+
+class Mesh:
+ def __init__(self, vertices, faces):
+ self.vertices = vertices
+ self.faces = faces
+
+ def auto_normals(self):
+ v0 = self.vertices[self.faces[:, 0], :]
+ v1 = self.vertices[self.faces[:, 1], :]
+ v2 = self.vertices[self.faces[:, 2], :]
+ nrm = safe_normalize(torch.cross(v1 - v0, v2 - v0))
+ self.nrm = nrm
+
+def load_mesh(path, device):
+ mesh_np = trimesh.load(path)
+ vertices = torch.tensor(mesh_np.vertices, device=device, dtype=torch.float)
+ faces = torch.tensor(mesh_np.faces, device=device, dtype=torch.long)
+
+ # Normalize
+ vmin, vmax = vertices.min(dim=0)[0], vertices.max(dim=0)[0]
+ scale = 1.8 / torch.max(vmax - vmin).item()
+ vertices = vertices - (vmax + vmin) / 2 # Center mesh on origin
+ vertices = vertices * scale # Rescale to [-0.9, 0.9]
+ return Mesh(vertices, faces)
+
+def compute_sdf(points, vertices, faces):
+ face_vertices = kaolin.ops.mesh.index_vertices_by_faces(vertices.clone().unsqueeze(0), faces)
+ distance = kaolin.metrics.trianglemesh.point_to_mesh_distance(points.unsqueeze(0), face_vertices)[0]
+ with torch.no_grad():
+ sign = (kaolin.ops.mesh.check_sign(vertices.unsqueeze(0), faces, points.unsqueeze(0))<1).float() * 2 - 1
+ sdf = (sign*distance).squeeze(0)
+ return sdf
+
+def sample_random_points(n, mesh):
+ pts_random = (torch.rand((n//2,3),device='cuda') - 0.5) * 2
+ pts_surface = kaolin.ops.mesh.sample_points(mesh.vertices.unsqueeze(0), mesh.faces, 500)[0].squeeze(0)
+ pts_surface += torch.randn_like(pts_surface) * 0.05
+ pts = torch.cat([pts_random, pts_surface])
+ return pts
+
+def xfm_points(points, matrix):
+ '''Transform points.
+ Args:
+ points: Tensor containing 3D points with shape [minibatch_size, num_vertices, 3] or [1, num_vertices, 3]
+ matrix: A 4x4 transform matrix with shape [minibatch_size, 4, 4]
+ use_python: Use PyTorch's torch.matmul (for validation)
+ Returns:
+ Transformed points in homogeneous 4D with shape [minibatch_size, num_vertices, 4].
+ '''
+ out = torch.matmul(
+ torch.nn.functional.pad(points, pad=(0, 1), mode='constant', value=1.0), torch.transpose(matrix, 1, 2))
+ if torch.is_anomaly_enabled():
+ assert torch.all(torch.isfinite(out)), "Output of xfm_points contains inf or NaN"
+ return out
+
+def interpolate(attr, rast, attr_idx, rast_db=None):
+ return dr.interpolate(
+ attr, rast, attr_idx, rast_db=rast_db,
+ diff_attrs=None if rast_db is None else 'all')
\ No newline at end of file
diff --git a/OmniPart/training/representations/mesh/flexicubes/flexicubes.py b/OmniPart/training/representations/mesh/flexicubes/flexicubes.py
new file mode 100644
index 0000000..15a5960
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/flexicubes.py
@@ -0,0 +1,384 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+
+import torch
+from .tables import *
+from kaolin.utils.testing import check_tensor
+
+__all__ = [
+ 'FlexiCubes'
+]
+
+
+class FlexiCubes:
+ def __init__(self, device="cuda"):
+
+ self.device = device
+ self.dmc_table = torch.tensor(dmc_table, dtype=torch.long, device=device, requires_grad=False)
+ self.num_vd_table = torch.tensor(num_vd_table,
+ dtype=torch.long, device=device, requires_grad=False)
+ self.check_table = torch.tensor(
+ check_table,
+ dtype=torch.long, device=device, requires_grad=False)
+
+ self.tet_table = torch.tensor(tet_table, dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_1 = torch.tensor([0, 1, 2, 0, 2, 3], dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_2 = torch.tensor([0, 1, 3, 3, 1, 2], dtype=torch.long, device=device, requires_grad=False)
+ self.quad_split_train = torch.tensor(
+ [0, 1, 1, 2, 2, 3, 3, 0], dtype=torch.long, device=device, requires_grad=False)
+
+ self.cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [
+ 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.float, device=device)
+ self.cube_corners_idx = torch.pow(2, torch.arange(8, requires_grad=False))
+ self.cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6,
+ 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, device=device, requires_grad=False)
+
+ self.edge_dir_table = torch.tensor([0, 2, 0, 2, 0, 2, 0, 2, 1, 1, 1, 1],
+ dtype=torch.long, device=device)
+ self.dir_faces_table = torch.tensor([
+ [[5, 4], [3, 2], [4, 5], [2, 3]],
+ [[5, 4], [1, 0], [4, 5], [0, 1]],
+ [[3, 2], [1, 0], [2, 3], [0, 1]]
+ ], dtype=torch.long, device=device)
+ self.adj_pairs = torch.tensor([0, 1, 1, 3, 3, 2, 2, 0], dtype=torch.long, device=device)
+
+ def __call__(self, voxelgrid_vertices, scalar_field, cube_idx, resolution, qef_reg_scale=1e-3,
+ weight_scale=0.99, beta=None, alpha=None, gamma_f=None, voxelgrid_colors=None, training=False):
+ assert torch.is_tensor(voxelgrid_vertices) and \
+ check_tensor(voxelgrid_vertices, (None, 3), throw=False), \
+ "'voxelgrid_vertices' should be a tensor of shape (num_vertices, 3)"
+ num_vertices = voxelgrid_vertices.shape[0]
+ assert torch.is_tensor(scalar_field) and \
+ check_tensor(scalar_field, (num_vertices,), throw=False), \
+ "'scalar_field' should be a tensor of shape (num_vertices,)"
+ assert torch.is_tensor(cube_idx) and \
+ check_tensor(cube_idx, (None, 8), throw=False), \
+ "'cube_idx' should be a tensor of shape (num_cubes, 8)"
+ num_cubes = cube_idx.shape[0]
+ assert beta is None or (
+ torch.is_tensor(beta) and
+ check_tensor(beta, (num_cubes, 12), throw=False)
+ ), "'beta' should be a tensor of shape (num_cubes, 12)"
+ assert alpha is None or (
+ torch.is_tensor(alpha) and
+ check_tensor(alpha, (num_cubes, 8), throw=False)
+ ), "'alpha' should be a tensor of shape (num_cubes, 8)"
+ assert gamma_f is None or (
+ torch.is_tensor(gamma_f) and
+ check_tensor(gamma_f, (num_cubes,), throw=False)
+ ), "'gamma_f' should be a tensor of shape (num_cubes,)"
+
+ surf_cubes, occ_fx8 = self._identify_surf_cubes(scalar_field, cube_idx)
+ if surf_cubes.sum() == 0:
+ return (
+ torch.zeros((0, 3), device=self.device),
+ torch.zeros((0, 3), dtype=torch.long, device=self.device),
+ torch.zeros((0), device=self.device),
+ torch.zeros((0, voxelgrid_colors.shape[-1]), device=self.device) if voxelgrid_colors is not None else None
+ )
+ beta, alpha, gamma_f = self._normalize_weights(
+ beta, alpha, gamma_f, surf_cubes, weight_scale)
+
+ if voxelgrid_colors is not None:
+ voxelgrid_colors = torch.sigmoid(voxelgrid_colors)
+
+ case_ids = self._get_case_id(occ_fx8, surf_cubes, resolution)
+
+ surf_edges, idx_map, edge_counts, surf_edges_mask = self._identify_surf_edges(
+ scalar_field, cube_idx, surf_cubes
+ )
+
+ vd, L_dev, vd_gamma, vd_idx_map, vd_color = self._compute_vd(
+ voxelgrid_vertices, cube_idx[surf_cubes], surf_edges, scalar_field,
+ case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors)
+ vertices, faces, s_edges, edge_indices, vertices_color = self._triangulate(
+ scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map,
+ vd_idx_map, surf_edges_mask, training, vd_color)
+ return vertices, faces, L_dev, vertices_color
+
+ def _compute_reg_loss(self, vd, ue, edge_group_to_vd, vd_num_edges):
+ """
+ Regularizer L_dev as in Equation 8
+ """
+ dist = torch.norm(ue - torch.index_select(input=vd, index=edge_group_to_vd, dim=0), dim=-1)
+ mean_l2 = torch.zeros_like(vd[:, 0])
+ mean_l2 = (mean_l2).index_add_(0, edge_group_to_vd, dist) / vd_num_edges.squeeze(1).float()
+ mad = (dist - torch.index_select(input=mean_l2, index=edge_group_to_vd, dim=0)).abs()
+ return mad
+
+ def _normalize_weights(self, beta, alpha, gamma_f, surf_cubes, weight_scale):
+ """
+ Normalizes the given weights to be non-negative. If input weights are None, it creates and returns a set of weights of ones.
+ """
+ n_cubes = surf_cubes.shape[0]
+
+ if beta is not None:
+ beta = (torch.tanh(beta) * weight_scale + 1)
+ else:
+ beta = torch.ones((n_cubes, 12), dtype=torch.float, device=self.device)
+
+ if alpha is not None:
+ alpha = (torch.tanh(alpha) * weight_scale + 1)
+ else:
+ alpha = torch.ones((n_cubes, 8), dtype=torch.float, device=self.device)
+
+ if gamma_f is not None:
+ gamma_f = torch.sigmoid(gamma_f) * weight_scale + (1 - weight_scale) / 2
+ else:
+ gamma_f = torch.ones((n_cubes), dtype=torch.float, device=self.device)
+
+ return beta[surf_cubes], alpha[surf_cubes], gamma_f[surf_cubes]
+
+ @torch.no_grad()
+ def _get_case_id(self, occ_fx8, surf_cubes, res):
+ """
+ Obtains the ID of topology cases based on cell corner occupancy. This function resolves the
+ ambiguity in the Dual Marching Cubes (DMC) configurations as described in Section 1.3 of the
+ supplementary material. It should be noted that this function assumes a regular grid.
+ """
+ case_ids = (occ_fx8[surf_cubes] * self.cube_corners_idx.to(self.device).unsqueeze(0)).sum(-1)
+
+ problem_config = self.check_table.to(self.device)[case_ids]
+ to_check = problem_config[..., 0] == 1
+ problem_config = problem_config[to_check]
+ if not isinstance(res, (list, tuple)):
+ res = [res, res, res]
+
+ # The 'problematic_configs' only contain configurations for surface cubes. Next, we construct a 3D array,
+ # 'problem_config_full', to store configurations for all cubes (with default config for non-surface cubes).
+ # This allows efficient checking on adjacent cubes.
+ problem_config_full = torch.zeros(list(res) + [5], device=self.device, dtype=torch.long)
+ vol_idx = torch.nonzero(problem_config_full[..., 0] == 0) # N, 3
+ vol_idx_problem = vol_idx[surf_cubes][to_check]
+ problem_config_full[vol_idx_problem[..., 0], vol_idx_problem[..., 1], vol_idx_problem[..., 2]] = problem_config
+ vol_idx_problem_adj = vol_idx_problem + problem_config[..., 1:4]
+
+ within_range = (
+ vol_idx_problem_adj[..., 0] >= 0) & (
+ vol_idx_problem_adj[..., 0] < res[0]) & (
+ vol_idx_problem_adj[..., 1] >= 0) & (
+ vol_idx_problem_adj[..., 1] < res[1]) & (
+ vol_idx_problem_adj[..., 2] >= 0) & (
+ vol_idx_problem_adj[..., 2] < res[2])
+
+ vol_idx_problem = vol_idx_problem[within_range]
+ vol_idx_problem_adj = vol_idx_problem_adj[within_range]
+ problem_config = problem_config[within_range]
+ problem_config_adj = problem_config_full[vol_idx_problem_adj[..., 0],
+ vol_idx_problem_adj[..., 1], vol_idx_problem_adj[..., 2]]
+ # If two cubes with cases C16 and C19 share an ambiguous face, both cases are inverted.
+ to_invert = (problem_config_adj[..., 0] == 1)
+ idx = torch.arange(case_ids.shape[0], device=self.device)[to_check][within_range][to_invert]
+ case_ids.index_put_((idx,), problem_config[to_invert][..., -1])
+ return case_ids
+
+ @torch.no_grad()
+ def _identify_surf_edges(self, scalar_field, cube_idx, surf_cubes):
+ """
+ Identifies grid edges that intersect with the underlying surface by checking for opposite signs. As each edge
+ can be shared by multiple cubes, this function also assigns a unique index to each surface-intersecting edge
+ and marks the cube edges with this index.
+ """
+ occ_n = scalar_field < 0
+ all_edges = cube_idx[surf_cubes][:, self.cube_edges].reshape(-1, 2)
+ unique_edges, _idx_map, counts = torch.unique(all_edges, dim=0, return_inverse=True, return_counts=True)
+
+ unique_edges = unique_edges.long()
+ mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1, 2).sum(-1) == 1
+
+ surf_edges_mask = mask_edges[_idx_map]
+ counts = counts[_idx_map]
+
+ mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device=cube_idx.device) * -1
+ mapping[mask_edges] = torch.arange(mask_edges.sum(), device=cube_idx.device)
+ # Shaped as [number of cubes x 12 edges per cube]. This is later used to map a cube edge to the unique index
+ # for a surface-intersecting edge. Non-surface-intersecting edges are marked with -1.
+ idx_map = mapping[_idx_map]
+ surf_edges = unique_edges[mask_edges]
+ return surf_edges, idx_map, counts, surf_edges_mask
+
+ @torch.no_grad()
+ def _identify_surf_cubes(self, scalar_field, cube_idx):
+ """
+ Identifies grid cubes that intersect with the underlying surface by checking if the signs at
+ all corners are not identical.
+ """
+ occ_n = scalar_field < 0
+ occ_fx8 = occ_n[cube_idx.reshape(-1)].reshape(-1, 8)
+ _occ_sum = torch.sum(occ_fx8, -1)
+ surf_cubes = (_occ_sum > 0) & (_occ_sum < 8)
+ return surf_cubes, occ_fx8
+
+ def _linear_interp(self, edges_weight, edges_x):
+ """
+ Computes the location of zero-crossings on 'edges_x' using linear interpolation with 'edges_weight'.
+ """
+ edge_dim = edges_weight.dim() - 2
+ assert edges_weight.shape[edge_dim] == 2
+ edges_weight = torch.cat([torch.index_select(input=edges_weight, index=torch.tensor(1, device=self.device), dim=edge_dim), -
+ torch.index_select(input=edges_weight, index=torch.tensor(0, device=self.device), dim=edge_dim)]
+ , edge_dim)
+ denominator = edges_weight.sum(edge_dim)
+ ue = (edges_x * edges_weight).sum(edge_dim) / denominator
+ return ue
+
+ def _solve_vd_QEF(self, p_bxnx3, norm_bxnx3, c_bx3, qef_reg_scale):
+ p_bxnx3 = p_bxnx3.reshape(-1, 7, 3)
+ norm_bxnx3 = norm_bxnx3.reshape(-1, 7, 3)
+ c_bx3 = c_bx3.reshape(-1, 3)
+ A = norm_bxnx3
+ B = ((p_bxnx3) * norm_bxnx3).sum(-1, keepdims=True)
+
+ A_reg = (torch.eye(3, device=p_bxnx3.device) * qef_reg_scale).unsqueeze(0).repeat(p_bxnx3.shape[0], 1, 1)
+ B_reg = (qef_reg_scale * c_bx3).unsqueeze(-1)
+ A = torch.cat([A, A_reg], 1)
+ B = torch.cat([B, B_reg], 1)
+ dual_verts = torch.linalg.lstsq(A, B).solution.squeeze(-1)
+ return dual_verts
+
+ def _compute_vd(self, voxelgrid_vertices, surf_cubes_fx8, surf_edges, scalar_field,
+ case_ids, beta, alpha, gamma_f, idx_map, qef_reg_scale, voxelgrid_colors):
+ """
+ Computes the location of dual vertices as described in Section 4.2
+ """
+ alpha_nx12x2 = torch.index_select(input=alpha, index=self.cube_edges, dim=1).reshape(-1, 12, 2)
+ surf_edges_x = torch.index_select(input=voxelgrid_vertices, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 3)
+ surf_edges_s = torch.index_select(input=scalar_field, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, 1)
+ zero_crossing = self._linear_interp(surf_edges_s, surf_edges_x)
+
+ if voxelgrid_colors is not None:
+ C = voxelgrid_colors.shape[-1]
+ surf_edges_c = torch.index_select(input=voxelgrid_colors, index=surf_edges.reshape(-1), dim=0).reshape(-1, 2, C)
+
+ idx_map = idx_map.reshape(-1, 12)
+ num_vd = torch.index_select(input=self.num_vd_table, index=case_ids, dim=0)
+ edge_group, edge_group_to_vd, edge_group_to_cube, vd_num_edges, vd_gamma = [], [], [], [], []
+
+ # if color is not None:
+ # vd_color = []
+
+ total_num_vd = 0
+ vd_idx_map = torch.zeros((case_ids.shape[0], 12), dtype=torch.long, device=self.device, requires_grad=False)
+
+ for num in torch.unique(num_vd):
+ cur_cubes = (num_vd == num) # consider cubes with the same numbers of vd emitted (for batching)
+ curr_num_vd = cur_cubes.sum() * num
+ curr_edge_group = self.dmc_table[case_ids[cur_cubes], :num].reshape(-1, num * 7)
+ curr_edge_group_to_vd = torch.arange(
+ curr_num_vd, device=self.device).unsqueeze(-1).repeat(1, 7) + total_num_vd
+ total_num_vd += curr_num_vd
+ curr_edge_group_to_cube = torch.arange(idx_map.shape[0], device=self.device)[
+ cur_cubes].unsqueeze(-1).repeat(1, num * 7).reshape_as(curr_edge_group)
+
+ curr_mask = (curr_edge_group != -1)
+ edge_group.append(torch.masked_select(curr_edge_group, curr_mask))
+ edge_group_to_vd.append(torch.masked_select(curr_edge_group_to_vd.reshape_as(curr_edge_group), curr_mask))
+ edge_group_to_cube.append(torch.masked_select(curr_edge_group_to_cube, curr_mask))
+ vd_num_edges.append(curr_mask.reshape(-1, 7).sum(-1, keepdims=True))
+ vd_gamma.append(torch.masked_select(gamma_f, cur_cubes).unsqueeze(-1).repeat(1, num).reshape(-1))
+ # if color is not None:
+ # vd_color.append(color[cur_cubes].unsqueeze(1).repeat(1, num, 1).reshape(-1, 3))
+
+ edge_group = torch.cat(edge_group)
+ edge_group_to_vd = torch.cat(edge_group_to_vd)
+ edge_group_to_cube = torch.cat(edge_group_to_cube)
+ vd_num_edges = torch.cat(vd_num_edges)
+ vd_gamma = torch.cat(vd_gamma)
+ # if color is not None:
+ # vd_color = torch.cat(vd_color)
+ # else:
+ # vd_color = None
+
+ vd = torch.zeros((total_num_vd, 3), device=self.device)
+ beta_sum = torch.zeros((total_num_vd, 1), device=self.device)
+
+ idx_group = torch.gather(input=idx_map.reshape(-1), dim=0, index=edge_group_to_cube * 12 + edge_group)
+
+ x_group = torch.index_select(input=surf_edges_x, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 3)
+ s_group = torch.index_select(input=surf_edges_s, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, 1)
+
+
+ zero_crossing_group = torch.index_select(
+ input=zero_crossing, index=idx_group.reshape(-1), dim=0).reshape(-1, 3)
+
+ alpha_group = torch.index_select(input=alpha_nx12x2.reshape(-1, 2), dim=0,
+ index=edge_group_to_cube * 12 + edge_group).reshape(-1, 2, 1)
+ ue_group = self._linear_interp(s_group * alpha_group, x_group)
+
+ beta_group = torch.gather(input=beta.reshape(-1), dim=0,
+ index=edge_group_to_cube * 12 + edge_group).reshape(-1, 1)
+ beta_sum = beta_sum.index_add_(0, index=edge_group_to_vd, source=beta_group)
+ vd = vd.index_add_(0, index=edge_group_to_vd, source=ue_group * beta_group) / beta_sum
+
+ '''
+ interpolate colors use the same method as dual vertices
+ '''
+ if voxelgrid_colors is not None:
+ vd_color = torch.zeros((total_num_vd, C), device=self.device)
+ c_group = torch.index_select(input=surf_edges_c, index=idx_group.reshape(-1), dim=0).reshape(-1, 2, C)
+ uc_group = self._linear_interp(s_group * alpha_group, c_group)
+ vd_color = vd_color.index_add_(0, index=edge_group_to_vd, source=uc_group * beta_group) / beta_sum
+ else:
+ vd_color = None
+
+ L_dev = self._compute_reg_loss(vd, zero_crossing_group, edge_group_to_vd, vd_num_edges)
+
+ v_idx = torch.arange(vd.shape[0], device=self.device) # + total_num_vd
+
+ vd_idx_map = (vd_idx_map.reshape(-1)).scatter(dim=0, index=edge_group_to_cube *
+ 12 + edge_group, src=v_idx[edge_group_to_vd])
+
+ return vd, L_dev, vd_gamma, vd_idx_map, vd_color
+
+ def _triangulate(self, scalar_field, surf_edges, vd, vd_gamma, edge_counts, idx_map, vd_idx_map, surf_edges_mask, training, vd_color):
+ """
+ Connects four neighboring dual vertices to form a quadrilateral. The quadrilaterals are then split into
+ triangles based on the gamma parameter, as described in Section 4.3.
+ """
+ with torch.no_grad():
+ group_mask = (edge_counts == 4) & surf_edges_mask # surface edges shared by 4 cubes.
+ group = idx_map.reshape(-1)[group_mask]
+ vd_idx = vd_idx_map[group_mask]
+ edge_indices, indices = torch.sort(group, stable=True)
+ quad_vd_idx = vd_idx[indices].reshape(-1, 4)
+
+ # Ensure all face directions point towards the positive SDF to maintain consistent winding.
+ s_edges = scalar_field[surf_edges[edge_indices.reshape(-1, 4)[:, 0]].reshape(-1)].reshape(-1, 2)
+ flip_mask = s_edges[:, 0] > 0
+ quad_vd_idx = torch.cat((quad_vd_idx[flip_mask][:, [0, 1, 3, 2]],
+ quad_vd_idx[~flip_mask][:, [2, 3, 1, 0]]))
+
+ quad_gamma = torch.index_select(input=vd_gamma, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4)
+ gamma_02 = quad_gamma[:, 0] * quad_gamma[:, 2]
+ gamma_13 = quad_gamma[:, 1] * quad_gamma[:, 3]
+ if not training:
+ mask = (gamma_02 > gamma_13)
+ faces = torch.zeros((quad_gamma.shape[0], 6), dtype=torch.long, device=quad_vd_idx.device)
+ faces[mask] = quad_vd_idx[mask][:, self.quad_split_1]
+ faces[~mask] = quad_vd_idx[~mask][:, self.quad_split_2]
+ faces = faces.reshape(-1, 3)
+ else:
+ vd_quad = torch.index_select(input=vd, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, 3)
+ vd_02 = (vd_quad[:, 0] + vd_quad[:, 2]) / 2
+ vd_13 = (vd_quad[:, 1] + vd_quad[:, 3]) / 2
+ weight_sum = (gamma_02 + gamma_13) + 1e-8
+ vd_center = (vd_02 * gamma_02.unsqueeze(-1) + vd_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1)
+
+ if vd_color is not None:
+ color_quad = torch.index_select(input=vd_color, index=quad_vd_idx.reshape(-1), dim=0).reshape(-1, 4, vd_color.shape[-1])
+ color_02 = (color_quad[:, 0] + color_quad[:, 2]) / 2
+ color_13 = (color_quad[:, 1] + color_quad[:, 3]) / 2
+ color_center = (color_02 * gamma_02.unsqueeze(-1) + color_13 * gamma_13.unsqueeze(-1)) / weight_sum.unsqueeze(-1)
+ vd_color = torch.cat([vd_color, color_center])
+
+
+ vd_center_idx = torch.arange(vd_center.shape[0], device=self.device) + vd.shape[0]
+ vd = torch.cat([vd, vd_center])
+ faces = quad_vd_idx[:, self.quad_split_train].reshape(-1, 4, 2)
+ faces = torch.cat([faces, vd_center_idx.reshape(-1, 1, 1).repeat(1, 4, 1)], -1).reshape(-1, 3)
+ return vd, faces, s_edges, edge_indices, vd_color
\ No newline at end of file
diff --git a/OmniPart/training/representations/mesh/flexicubes/images/ablate_L_dev.jpg b/OmniPart/training/representations/mesh/flexicubes/images/ablate_L_dev.jpg
new file mode 100644
index 0000000..461bd1c
Binary files /dev/null and b/OmniPart/training/representations/mesh/flexicubes/images/ablate_L_dev.jpg differ
diff --git a/OmniPart/training/representations/mesh/flexicubes/images/block_final.png b/OmniPart/training/representations/mesh/flexicubes/images/block_final.png
new file mode 100644
index 0000000..8b19771
Binary files /dev/null and b/OmniPart/training/representations/mesh/flexicubes/images/block_final.png differ
diff --git a/OmniPart/training/representations/mesh/flexicubes/images/block_init.png b/OmniPart/training/representations/mesh/flexicubes/images/block_init.png
new file mode 100644
index 0000000..3c682b9
Binary files /dev/null and b/OmniPart/training/representations/mesh/flexicubes/images/block_init.png differ
diff --git a/OmniPart/training/representations/mesh/flexicubes/images/teaser_top.png b/OmniPart/training/representations/mesh/flexicubes/images/teaser_top.png
new file mode 100644
index 0000000..719ddc2
Binary files /dev/null and b/OmniPart/training/representations/mesh/flexicubes/images/teaser_top.png differ
diff --git a/OmniPart/training/representations/mesh/flexicubes/tables.py b/OmniPart/training/representations/mesh/flexicubes/tables.py
new file mode 100644
index 0000000..5873e77
--- /dev/null
+++ b/OmniPart/training/representations/mesh/flexicubes/tables.py
@@ -0,0 +1,791 @@
+# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# NVIDIA CORPORATION & AFFILIATES and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION & AFFILIATES is strictly prohibited.
+dmc_table = [
+[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 6, 7, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 5, 6, 8], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 5, 9, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 6, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 7, 8, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [5, 6, 10, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [5, 6, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 9, 10, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [4, 6, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 8, 9, 10, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 6, 7, 8, 10, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 6, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [1, 2, 5, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 6, 9, -1, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 6, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 6, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 6, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 6, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 6, 7, 9], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 6, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 6, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 6, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 6, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 3, 5, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, 6, 7, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 6, 9, 11, -1], [4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 6, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 6, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 6, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 6, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 6, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 6, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 6, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[6, 7, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [5, 7, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [4, 5, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 9, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [4, 7, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 10, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 8, 10, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[8, 9, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 9, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 8, 10, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 10, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 5, 7, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [2, 3, 4, 5, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 9, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 8, 9, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 4, 7, 10], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 8, 9, 10, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 9, 10, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 8, 10, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 10, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 5, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 5, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 5, 7, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 5, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 4, 5, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 5, 8, 9, 11], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [1, 2, 4, 7, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 4, 7, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 4, 7, 8, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 2, 8, 9, 11, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 2, 3, 9, 11, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 2, 8, 11, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[2, 3, 11, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 5, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 5, 7, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 5, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[5, 7, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 5, 8, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 5, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 5, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 5, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 4, 7, 9, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 4, 7, 8, 9, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 4, 7, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[4, 7, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[1, 3, 8, 9, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 1, 9, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[0, 3, 8, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]],
+[[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]]
+]
+num_vd_table = [0, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 2, 2,
+2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 3, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 2,
+1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 2, 3, 2, 2, 1, 1, 1, 1,
+1, 1, 2, 1, 1, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 2, 2, 1, 3, 4, 2,
+2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 2,
+3, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 3, 2, 3, 2, 4, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1,
+2, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1,
+1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2,
+1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
+check_table = [
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 194],
+[1, -1, 0, 0, 193],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 164],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 161],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 152],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 145],
+[1, 0, 0, 1, 144],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 137],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 133],
+[1, 0, 1, 0, 132],
+[1, 1, 0, 0, 131],
+[1, 1, 0, 0, 130],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 100],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 98],
+[0, 0, 0, 0, 0],
+[1, 0, 0, 1, 96],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 88],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 82],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 74],
+[0, 0, 0, 0, 0],
+[1, 0, 1, 0, 72],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 70],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 67],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 65],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 56],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 52],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 44],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 1, 0, 0, 40],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 38],
+[1, 0, -1, 0, 37],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 33],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 28],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 26],
+[1, 0, 0, -1, 25],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, -1, 0, 0, 20],
+[0, 0, 0, 0, 0],
+[1, 0, -1, 0, 18],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 9],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[1, 0, 0, -1, 6],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0]
+]
+tet_table = [
+[-1, -1, -1, -1, -1, -1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, -1],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[0, 4, 0, 4, 4, -1],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[5, 5, 5, 5, 5, 5],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, -1, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, -1, 2, 4, 4, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 4, 4, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 4, 2, 4, 4, 2],
+[0, 4, 0, 4, 4, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 5, 2, 5, 5, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, -1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[4, 1, 1, 4, 4, 1],
+[0, 1, 1, 0, 0, 1],
+[4, 0, 0, 4, 4, 0],
+[2, 2, 2, 2, 2, 2],
+[-1, 1, 1, 4, 4, 1],
+[0, 1, 1, 4, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[5, 1, 1, 5, 5, 1],
+[0, 1, 1, 0, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[8, 8, 8, 8, 8, 8],
+[1, 1, 1, 4, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 4, 4, 1],
+[0, 4, 0, 4, 4, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 5, 5, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[6, 6, 6, 6, 6, 6],
+[6, -1, 0, 6, 0, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 1, 1, 6, 1, 6],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[6, 4, -1, 6, 4, 6],
+[6, 4, 0, 6, 4, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 1, 1, 6, 1, 6],
+[5, 5, 5, 5, 5, 5],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 4, 2, 2, 4, 2],
+[0, 4, 0, 4, 4, 0],
+[2, 0, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[6, 1, 1, 6, -1, 6],
+[6, 1, 1, 6, 0, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 2, 2, 6, 2, 6],
+[4, 1, 1, 4, 4, 1],
+[0, 1, 1, 0, 0, 1],
+[4, 0, 0, 4, 4, 4],
+[2, 2, 2, 2, 2, 2],
+[6, 1, 1, 6, 4, 6],
+[6, 1, 1, 6, 4, 6],
+[6, 0, 0, 6, 0, 6],
+[6, 2, 2, 6, 2, 6],
+[5, 1, 1, 5, 5, 1],
+[0, 1, 1, 0, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[6, 6, 6, 6, 6, 6],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 4, 1],
+[0, 4, 0, 4, 4, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 5, 0, 5, 0, 5],
+[5, 5, 5, 5, 5, 5],
+[5, 5, 5, 5, 5, 5],
+[0, 5, 0, 5, 0, 5],
+[-1, 5, 0, 5, 0, 5],
+[1, 5, 1, 5, 1, 5],
+[4, 5, -1, 5, 4, 5],
+[0, 5, 0, 5, 0, 5],
+[4, 5, 0, 5, 4, 5],
+[1, 5, 1, 5, 1, 5],
+[4, 4, 4, 4, 4, 4],
+[0, 4, 0, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[6, 6, 6, 6, 6, 6],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 5, 2, 5, -1, 5],
+[0, 5, 0, 5, 0, 5],
+[2, 5, 2, 5, 0, 5],
+[1, 5, 1, 5, 1, 5],
+[2, 5, 2, 5, 4, 5],
+[0, 5, 0, 5, 0, 5],
+[2, 5, 2, 5, 4, 5],
+[1, 5, 1, 5, 1, 5],
+[2, 4, 2, 4, 4, 2],
+[0, 4, 0, 4, 4, 4],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 6, 2, 6, 6, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 0, 2, 0, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, 1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[4, 1, 1, 1, 4, 1],
+[0, 1, 1, 1, 0, 1],
+[4, 0, 0, 4, 4, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[1, 1, 1, 1, 4, 1],
+[0, 0, 0, 0, 0, 0],
+[4, 0, 0, 4, 4, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[6, 0, 0, 6, 0, 6],
+[0, 0, 0, 0, 0, 0],
+[6, 6, 6, 6, 6, 6],
+[5, 5, 5, 5, 5, 5],
+[5, 5, 0, 5, 0, 5],
+[5, 5, 0, 5, 0, 5],
+[5, 5, 1, 5, 1, 5],
+[4, 4, 4, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 0, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[4, 4, 4, 4, 4, 4],
+[4, 4, 0, 4, 4, 4],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[8, 8, 8, 8, 8, 8],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 0, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 1, 1, 4, 4, 1],
+[2, 2, 2, 2, 2, 2],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 0, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 4, 2, 4, 4, 2],
+[1, 1, 1, 1, 1, 1],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[2, 2, 2, 2, 2, 2],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[5, 5, 5, 5, 5, 5],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[4, 4, 4, 4, 4, 4],
+[1, 1, 1, 1, 1, 1],
+[0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0],
+[12, 12, 12, 12, 12, 12]
+]
diff --git a/OmniPart/training/representations/mesh/utils_cube.py b/OmniPart/training/representations/mesh/utils_cube.py
new file mode 100644
index 0000000..23913c9
--- /dev/null
+++ b/OmniPart/training/representations/mesh/utils_cube.py
@@ -0,0 +1,61 @@
+import torch
+cube_corners = torch.tensor([[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [
+ 1, 0, 1], [0, 1, 1], [1, 1, 1]], dtype=torch.int)
+cube_neighbor = torch.tensor([[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]])
+cube_edges = torch.tensor([0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6,
+ 2, 0, 3, 1, 7, 5, 6, 4], dtype=torch.long, requires_grad=False)
+
+def construct_dense_grid(res, device='cuda'):
+ '''construct a dense grid based on resolution'''
+ res_v = res + 1
+ vertsid = torch.arange(res_v ** 3, device=device)
+ coordsid = vertsid.reshape(res_v, res_v, res_v)[:res, :res, :res].flatten()
+ cube_corners_bias = (cube_corners[:, 0] * res_v + cube_corners[:, 1]) * res_v + cube_corners[:, 2]
+ cube_fx8 = (coordsid.unsqueeze(1) + cube_corners_bias.unsqueeze(0).to(device))
+ verts = torch.stack([vertsid // (res_v ** 2), (vertsid // res_v) % res_v, vertsid % res_v], dim=1)
+ return verts, cube_fx8
+
+
+def construct_voxel_grid(coords):
+ verts = (cube_corners.unsqueeze(0).to(coords) + coords.unsqueeze(1)).reshape(-1, 3)
+ verts_unique, inverse_indices = torch.unique(verts, dim=0, return_inverse=True)
+ cubes = inverse_indices.reshape(-1, 8)
+ return verts_unique, cubes
+
+
+def cubes_to_verts(num_verts, cubes, value, reduce='mean'):
+ """
+ Args:
+ cubes [Vx8] verts index for each cube
+ value [Vx8xM] value to be scattered
+ Operation:
+ reduced[cubes[i][j]][k] += value[i][k]
+ """
+ M = value.shape[2] # number of channels
+ reduced = torch.zeros(num_verts, M, device=cubes.device)
+ return torch.scatter_reduce(reduced, 0,
+ cubes.unsqueeze(-1).expand(-1, -1, M).flatten(0, 1),
+ value.flatten(0, 1), reduce=reduce, include_self=False)
+
+def sparse_cube2verts(coords, feats, training=True):
+ new_coords, cubes = construct_voxel_grid(coords)
+ new_feats = cubes_to_verts(new_coords.shape[0], cubes, feats)
+ if training:
+ con_loss = torch.mean((feats - new_feats[cubes]) ** 2)
+ else:
+ con_loss = 0.0
+ return new_coords, new_feats, con_loss
+
+
+def get_dense_attrs(coords : torch.Tensor, feats : torch.Tensor, res : int, sdf_init=True):
+ F = feats.shape[-1]
+ dense_attrs = torch.zeros([res] * 3 + [F], device=feats.device)
+ if sdf_init:
+ dense_attrs[..., 0] = 1 # initial outside sdf value
+ dense_attrs[coords[:, 0], coords[:, 1], coords[:, 2], :] = feats
+ return dense_attrs.reshape(-1, F)
+
+
+def get_defomed_verts(v_pos : torch.Tensor, deform : torch.Tensor, res):
+ return v_pos / res - 0.5 + (1 - 1e-8) / (res * 2) * torch.tanh(deform)
+
\ No newline at end of file
diff --git a/OmniPart/training/representations/octree/__init__.py b/OmniPart/training/representations/octree/__init__.py
new file mode 100644
index 0000000..f66a39a
--- /dev/null
+++ b/OmniPart/training/representations/octree/__init__.py
@@ -0,0 +1 @@
+from .octree_dfs import DfsOctree
\ No newline at end of file
diff --git a/OmniPart/training/representations/octree/octree_dfs.py b/OmniPart/training/representations/octree/octree_dfs.py
new file mode 100644
index 0000000..c2bd4dc
--- /dev/null
+++ b/OmniPart/training/representations/octree/octree_dfs.py
@@ -0,0 +1,347 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DfsOctree:
+ """
+ Sparse Voxel Octree (SVO) implementation for PyTorch.
+ Using Depth-First Search (DFS) order to store the octree.
+ DFS order suits rendering and ray tracing.
+
+ The structure and data are separatedly stored.
+ Structure is stored as a continuous array, each element is a 3*32 bits descriptor.
+ |-----------------------------------------|
+ | 0:3 bits | 4:31 bits |
+ | leaf num | unused |
+ |-----------------------------------------|
+ | 0:31 bits |
+ | child ptr |
+ |-----------------------------------------|
+ | 0:31 bits |
+ | data ptr |
+ |-----------------------------------------|
+ Each element represents a non-leaf node in the octree.
+ The valid mask is used to indicate whether the children are valid.
+ The leaf mask is used to indicate whether the children are leaf nodes.
+ The child ptr is used to point to the first non-leaf child. Non-leaf children descriptors are stored continuously from the child ptr.
+ The data ptr is used to point to the data of leaf children. Leaf children data are stored continuously from the data ptr.
+
+ There are also auxiliary arrays to store the additional structural information to facilitate parallel processing.
+ - Position: the position of the octree nodes.
+ - Depth: the depth of the octree nodes.
+
+ Args:
+ depth (int): the depth of the octree.
+ """
+
+ def __init__(
+ self,
+ depth,
+ aabb=[0,0,0,1,1,1],
+ sh_degree=2,
+ primitive='voxel',
+ primitive_config={},
+ device='cuda',
+ ):
+ self.max_depth = depth
+ self.aabb = torch.tensor(aabb, dtype=torch.float32, device=device)
+ self.device = device
+ self.sh_degree = sh_degree
+ self.active_sh_degree = sh_degree
+ self.primitive = primitive
+ self.primitive_config = primitive_config
+
+ self.structure = torch.tensor([[8, 1, 0]], dtype=torch.int32, device=self.device)
+ self.position = torch.zeros((8, 3), dtype=torch.float32, device=self.device)
+ self.depth = torch.zeros((8, 1), dtype=torch.uint8, device=self.device)
+ self.position[:, 0] = torch.tensor([0.25, 0.75, 0.25, 0.75, 0.25, 0.75, 0.25, 0.75], device=self.device)
+ self.position[:, 1] = torch.tensor([0.25, 0.25, 0.75, 0.75, 0.25, 0.25, 0.75, 0.75], device=self.device)
+ self.position[:, 2] = torch.tensor([0.25, 0.25, 0.25, 0.25, 0.75, 0.75, 0.75, 0.75], device=self.device)
+ self.depth[:, 0] = 1
+
+ self.data = ['position', 'depth']
+ self.param_names = []
+
+ if primitive == 'voxel':
+ self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.data += ['features_dc', 'features_ac']
+ self.param_names += ['features_dc', 'features_ac']
+ if not primitive_config.get('solid', False):
+ self.density = torch.zeros((8, 1), dtype=torch.float32, device=self.device)
+ self.data.append('density')
+ self.param_names.append('density')
+ elif primitive == 'gaussian':
+ self.features_dc = torch.zeros((8, 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.opacity = torch.zeros((8, 1), dtype=torch.float32, device=self.device)
+ self.data += ['features_dc', 'features_ac', 'opacity']
+ self.param_names += ['features_dc', 'features_ac', 'opacity']
+ elif primitive == 'trivec':
+ self.trivec = torch.zeros((8, primitive_config['rank'], 3, primitive_config['dim']), dtype=torch.float32, device=self.device)
+ self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device)
+ self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.density_shift = 0
+ self.data += ['trivec', 'density', 'features_dc', 'features_ac']
+ self.param_names += ['trivec', 'density', 'features_dc', 'features_ac']
+ elif primitive == 'decoupoly':
+ self.decoupoly_V = torch.zeros((8, primitive_config['rank'], 3), dtype=torch.float32, device=self.device)
+ self.decoupoly_g = torch.zeros((8, primitive_config['rank'], primitive_config['degree']), dtype=torch.float32, device=self.device)
+ self.density = torch.zeros((8, primitive_config['rank']), dtype=torch.float32, device=self.device)
+ self.features_dc = torch.zeros((8, primitive_config['rank'], 1, 3), dtype=torch.float32, device=self.device)
+ self.features_ac = torch.zeros((8, primitive_config['rank'], (sh_degree+1)**2-1, 3), dtype=torch.float32, device=self.device)
+ self.density_shift = 0
+ self.data += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac']
+ self.param_names += ['decoupoly_V', 'decoupoly_g', 'density', 'features_dc', 'features_ac']
+
+ self.setup_functions()
+
+ def setup_functions(self):
+ self.density_activation = (lambda x: torch.exp(x - 2)) if self.primitive != 'trivec' else (lambda x: x)
+ self.opacity_activation = lambda x: torch.sigmoid(x - 6)
+ self.inverse_opacity_activation = lambda x: torch.log(x / (1 - x)) + 6
+ self.color_activation = lambda x: torch.sigmoid(x)
+
+ @property
+ def num_non_leaf_nodes(self):
+ return self.structure.shape[0]
+
+ @property
+ def num_leaf_nodes(self):
+ return self.depth.shape[0]
+
+ @property
+ def cur_depth(self):
+ return self.depth.max().item()
+
+ @property
+ def occupancy(self):
+ return self.num_leaf_nodes / 8 ** self.cur_depth
+
+ @property
+ def get_xyz(self):
+ return self.position
+
+ @property
+ def get_depth(self):
+ return self.depth
+
+ @property
+ def get_density(self):
+ if self.primitive == 'voxel' and self.primitive_config.get('solid', False):
+ return torch.full((self.position.shape[0], 1), torch.finfo(torch.float32).max, dtype=torch.float32, device=self.device)
+ return self.density_activation(self.density)
+
+ @property
+ def get_opacity(self):
+ return self.opacity_activation(self.density)
+
+ @property
+ def get_trivec(self):
+ return self.trivec
+
+ @property
+ def get_decoupoly(self):
+ return F.normalize(self.decoupoly_V, dim=-1), self.decoupoly_g
+
+ @property
+ def get_color(self):
+ return self.color_activation(self.colors)
+
+ @property
+ def get_features(self):
+ if self.sh_degree == 0:
+ return self.features_dc
+ return torch.cat([self.features_dc, self.features_ac], dim=-2)
+
+ def state_dict(self):
+ ret = {'structure': self.structure, 'position': self.position, 'depth': self.depth, 'sh_degree': self.sh_degree, 'active_sh_degree': self.active_sh_degree, 'primitive_config': self.primitive_config, 'primitive': self.primitive}
+ if hasattr(self, 'density_shift'):
+ ret['density_shift'] = self.density_shift
+ for data in set(self.data + self.param_names):
+ if not isinstance(getattr(self, data), nn.Module):
+ ret[data] = getattr(self, data)
+ else:
+ ret[data] = getattr(self, data).state_dict()
+ return ret
+
+ def load_state_dict(self, state_dict):
+ keys = list(set(self.data + self.param_names + list(state_dict.keys()) + ['structure', 'position', 'depth']))
+ for key in keys:
+ if key not in state_dict:
+ print(f"Warning: key {key} not found in the state_dict.")
+ continue
+ try:
+ if not isinstance(getattr(self, key), nn.Module):
+ setattr(self, key, state_dict[key])
+ else:
+ getattr(self, key).load_state_dict(state_dict[key])
+ except Exception as e:
+ print(e)
+ raise ValueError(f"Error loading key {key}.")
+
+ def gather_from_leaf_children(self, data):
+ """
+ Gather the data from the leaf children.
+
+ Args:
+ data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes.
+ """
+ leaf_cnt = self.structure[:, 0]
+ leaf_cnt_masks = [leaf_cnt == i for i in range(1, 9)]
+ ret = torch.zeros((self.num_non_leaf_nodes,), dtype=data.dtype, device=self.device)
+ for i in range(8):
+ if leaf_cnt_masks[i].sum() == 0:
+ continue
+ start = self.structure[leaf_cnt_masks[i], 2]
+ for j in range(i+1):
+ ret[leaf_cnt_masks[i]] += data[start + j]
+ return ret
+
+ def gather_from_non_leaf_children(self, data):
+ """
+ Gather the data from the non-leaf children.
+
+ Args:
+ data (torch.Tensor): the data to gather. The first dimension should be the number of leaf nodes.
+ """
+ non_leaf_cnt = 8 - self.structure[:, 0]
+ non_leaf_cnt_masks = [non_leaf_cnt == i for i in range(1, 9)]
+ ret = torch.zeros_like(data, device=self.device)
+ for i in range(8):
+ if non_leaf_cnt_masks[i].sum() == 0:
+ continue
+ start = self.structure[non_leaf_cnt_masks[i], 1]
+ for j in range(i+1):
+ ret[non_leaf_cnt_masks[i]] += data[start + j]
+ return ret
+
+ def structure_control(self, mask):
+ """
+ Control the structure of the octree.
+
+ Args:
+ mask (torch.Tensor): the mask to control the structure. 1 for subdivide, -1 for merge, 0 for keep.
+ """
+ # Dont subdivide when the depth is the maximum.
+ mask[self.depth.squeeze() == self.max_depth] = torch.clamp_max(mask[self.depth.squeeze() == self.max_depth], 0)
+ # Dont merge when the depth is the minimum.
+ mask[self.depth.squeeze() == 1] = torch.clamp_min(mask[self.depth.squeeze() == 1], 0)
+
+ # Gather control mask
+ structre_ctrl = self.gather_from_leaf_children(mask)
+ structre_ctrl[structre_ctrl==-8] = -1
+
+ new_leaf_num = self.structure[:, 0].clone()
+ # Modify the leaf num.
+ structre_valid = structre_ctrl >= 0
+ new_leaf_num[structre_valid] -= structre_ctrl[structre_valid] # Add the new nodes.
+ structre_delete = structre_ctrl < 0
+ merged_nodes = self.gather_from_non_leaf_children(structre_delete.int())
+ new_leaf_num += merged_nodes # Delete the merged nodes.
+
+ # Update the structure array to allocate new nodes.
+ mem_offset = torch.zeros((self.num_non_leaf_nodes + 1,), dtype=torch.int32, device=self.device)
+ mem_offset.index_add_(0, self.structure[structre_valid, 1], structre_ctrl[structre_valid]) # Add the new nodes.
+ mem_offset[:-1] -= structre_delete.int() # Delete the merged nodes.
+ new_structre_idx = torch.arange(0, self.num_non_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0)
+ new_structure_length = new_structre_idx[-1].item()
+ new_structre_idx = new_structre_idx[:-1]
+ new_structure = torch.empty((new_structure_length, 3), dtype=torch.int32, device=self.device)
+ new_structure[new_structre_idx[structre_valid], 0] = new_leaf_num[structre_valid]
+
+ # Initialize the new nodes.
+ new_node_mask = torch.ones((new_structure_length,), dtype=torch.bool, device=self.device)
+ new_node_mask[new_structre_idx[structre_valid]] = False
+ new_structure[new_node_mask, 0] = 8 # Initialize to all leaf nodes.
+ new_node_num = new_node_mask.sum().item()
+
+ # Rebuild child ptr.
+ non_leaf_cnt = 8 - new_structure[:, 0]
+ new_child_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), non_leaf_cnt.cumsum(0)[:-1]])
+ new_structure[:, 1] = new_child_ptr + 1
+
+ # Rebuild data ptr with old data.
+ leaf_cnt = torch.zeros((new_structure_length,), dtype=torch.int32, device=self.device)
+ leaf_cnt.index_add_(0, new_structre_idx, self.structure[:, 0])
+ old_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]])
+
+ # Update the data array
+ subdivide_mask = mask == 1
+ merge_mask = mask == -1
+ data_valid = ~(subdivide_mask | merge_mask)
+ mem_offset = torch.zeros((self.num_leaf_nodes + 1,), dtype=torch.int32, device=self.device)
+ mem_offset.index_add_(0, old_data_ptr[new_node_mask], torch.full((new_node_num,), 8, dtype=torch.int32, device=self.device)) # Add data array for new nodes
+ mem_offset[:-1] -= subdivide_mask.int() # Delete data elements for subdivide nodes
+ mem_offset[:-1] -= merge_mask.int() # Delete data elements for merge nodes
+ mem_offset.index_add_(0, self.structure[structre_valid, 2], merged_nodes[structre_valid]) # Add data elements for merge nodes
+ new_data_idx = torch.arange(0, self.num_leaf_nodes + 1, dtype=torch.int32, device=self.device) + mem_offset.cumsum(0)
+ new_data_length = new_data_idx[-1].item()
+ new_data_idx = new_data_idx[:-1]
+ new_data = {data: torch.empty((new_data_length,) + getattr(self, data).shape[1:], dtype=getattr(self, data).dtype, device=self.device) for data in self.data}
+ for data in self.data:
+ new_data[data][new_data_idx[data_valid]] = getattr(self, data)[data_valid]
+
+ # Rebuild data ptr
+ leaf_cnt = new_structure[:, 0]
+ new_data_ptr = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), leaf_cnt.cumsum(0)[:-1]])
+ new_structure[:, 2] = new_data_ptr
+
+ # Initialize the new data array
+ ## For subdivide nodes
+ if subdivide_mask.sum() > 0:
+ subdivide_data_ptr = new_structure[new_node_mask, 2]
+ for data in self.data:
+ for i in range(8):
+ if data == 'position':
+ offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) - 0.5
+ scale = 2 ** (-1.0 - self.depth[subdivide_mask])
+ new_data['position'][subdivide_data_ptr + i] = self.position[subdivide_mask] + offset * scale
+ elif data == 'depth':
+ new_data['depth'][subdivide_data_ptr + i] = self.depth[subdivide_mask] + 1
+ elif data == 'opacity':
+ new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(torch.sqrt(self.opacity_activation(self.opacity[subdivide_mask])))
+ elif data == 'trivec':
+ offset = torch.tensor([i // 4, (i // 2) % 2, i % 2], dtype=torch.float32, device=self.device) * 0.5
+ coord = (torch.linspace(0, 0.5, self.trivec.shape[-1], dtype=torch.float32, device=self.device)[None] + offset[:, None]).reshape(1, 3, self.trivec.shape[-1], 1)
+ axis = torch.linspace(0, 1, 3, dtype=torch.float32, device=self.device).reshape(1, 3, 1, 1).repeat(1, 1, self.trivec.shape[-1], 1)
+ coord = torch.stack([coord, axis], dim=3).reshape(1, 3, self.trivec.shape[-1], 2).expand(self.trivec[subdivide_mask].shape[0], -1, -1, -1) * 2 - 1
+ new_data['trivec'][subdivide_data_ptr + i] = F.grid_sample(self.trivec[subdivide_mask], coord, align_corners=True)
+ else:
+ new_data[data][subdivide_data_ptr + i] = getattr(self, data)[subdivide_mask]
+ ## For merge nodes
+ if merge_mask.sum() > 0:
+ merge_data_ptr = torch.empty((merged_nodes.sum().item(),), dtype=torch.int32, device=self.device)
+ merge_nodes_cumsum = torch.cat([torch.zeros((1,), dtype=torch.int32, device=self.device), merged_nodes.cumsum(0)[:-1]])
+ for i in range(8):
+ merge_data_ptr[merge_nodes_cumsum[merged_nodes > i] + i] = new_structure[new_structre_idx[merged_nodes > i], 2] + i
+ old_merge_data_ptr = self.structure[structre_delete, 2]
+ for data in self.data:
+ if data == 'position':
+ scale = 2 ** (1.0 - self.depth[old_merge_data_ptr])
+ new_data['position'][merge_data_ptr] = ((self.position[old_merge_data_ptr] + 0.5) / scale).floor() * scale + 0.5 * scale - 0.5
+ elif data == 'depth':
+ new_data['depth'][merge_data_ptr] = self.depth[old_merge_data_ptr] - 1
+ elif data == 'opacity':
+ new_data['opacity'][subdivide_data_ptr + i] = self.inverse_opacity_activation(self.opacity_activation(self.opacity[subdivide_mask])**2)
+ elif data == 'trivec':
+ new_data['trivec'][merge_data_ptr] = self.trivec[old_merge_data_ptr]
+ else:
+ new_data[data][merge_data_ptr] = getattr(self, data)[old_merge_data_ptr]
+
+ # Update the structure and data array
+ self.structure = new_structure
+ for data in self.data:
+ setattr(self, data, new_data[data])
+
+ # Save data array control temp variables
+ self.data_rearrange_buffer = {
+ 'subdivide_mask': subdivide_mask,
+ 'merge_mask': merge_mask,
+ 'data_valid': data_valid,
+ 'new_data_idx': new_data_idx,
+ 'new_data_length': new_data_length,
+ 'new_data': new_data
+ }
diff --git a/OmniPart/training/representations/radiance_field/__init__.py b/OmniPart/training/representations/radiance_field/__init__.py
new file mode 100644
index 0000000..b72a1b7
--- /dev/null
+++ b/OmniPart/training/representations/radiance_field/__init__.py
@@ -0,0 +1 @@
+from .strivec import Strivec
\ No newline at end of file
diff --git a/OmniPart/training/representations/radiance_field/strivec.py b/OmniPart/training/representations/radiance_field/strivec.py
new file mode 100644
index 0000000..8fc4b74
--- /dev/null
+++ b/OmniPart/training/representations/radiance_field/strivec.py
@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from ..octree import DfsOctree as Octree
+
+
+class Strivec(Octree):
+ def __init__(
+ self,
+ resolution: int,
+ aabb: list,
+ sh_degree: int = 0,
+ rank: int = 8,
+ dim: int = 8,
+ device: str = "cuda",
+ ):
+ assert np.log2(resolution) % 1 == 0, "Resolution must be a power of 2"
+ self.resolution = resolution
+ depth = int(np.round(np.log2(resolution)))
+ super().__init__(
+ depth=depth,
+ aabb=aabb,
+ sh_degree=sh_degree,
+ primitive="trivec",
+ primitive_config={"rank": rank, "dim": dim},
+ device=device,
+ )
diff --git a/OmniPart/training/trainers/__init__.py b/OmniPart/training/trainers/__init__.py
new file mode 100644
index 0000000..29b54f9
--- /dev/null
+++ b/OmniPart/training/trainers/__init__.py
@@ -0,0 +1,63 @@
+import importlib
+
+__attributes = {
+ 'BasicTrainer': 'basic',
+
+ 'SparseStructureVaeTrainer': 'vae.sparse_structure_vae',
+
+ 'SLatVaeGaussianTrainer': 'vae.structured_latent_vae_gaussian',
+ 'SLatVaeRadianceFieldDecoderTrainer': 'vae.structured_latent_vae_rf_dec',
+ 'SLatVaeMeshDecoderTrainer': 'vae.structured_latent_vae_mesh_dec',
+
+ 'FlowMatchingTrainer': 'flow_matching.flow_matching',
+ 'FlowMatchingCFGTrainer': 'flow_matching.flow_matching',
+ 'TextConditionedFlowMatchingCFGTrainer': 'flow_matching.flow_matching',
+ 'ImageConditionedFlowMatchingCFGTrainer': 'flow_matching.flow_matching',
+
+ 'SparseFlowMatchingTrainer': 'flow_matching.sparse_flow_matching',
+ 'SparseFlowMatchingCFGTrainer': 'flow_matching.sparse_flow_matching',
+ 'TextConditionedSparseFlowMatchingCFGTrainer': 'flow_matching.sparse_flow_matching',
+ 'ImageConditionedSparseFlowMatchingCFGTrainer': 'flow_matching.sparse_flow_matching',
+}
+
+__submodules = []
+
+__all__ = list(__attributes.keys()) + __submodules
+
+def __getattr__(name):
+ if name not in globals():
+ if name in __attributes:
+ module_name = __attributes[name]
+ module = importlib.import_module(f".{module_name}", __name__)
+ globals()[name] = getattr(module, name)
+ elif name in __submodules:
+ module = importlib.import_module(f".{name}", __name__)
+ globals()[name] = module
+ else:
+ raise AttributeError(f"module {__name__} has no attribute {name}")
+ return globals()[name]
+
+
+# For Pylance
+if __name__ == '__main__':
+ from .basic import BasicTrainer
+
+ from .vae.sparse_structure_vae import SparseStructureVaeTrainer
+
+ from .vae.structured_latent_vae_gaussian import SLatVaeGaussianTrainer
+ from .vae.structured_latent_vae_rf_dec import SLatVaeRadianceFieldDecoderTrainer
+ from .vae.structured_latent_vae_mesh_dec import SLatVaeMeshDecoderTrainer
+
+ from .flow_matching.flow_matching import (
+ FlowMatchingTrainer,
+ FlowMatchingCFGTrainer,
+ TextConditionedFlowMatchingCFGTrainer,
+ ImageConditionedFlowMatchingCFGTrainer,
+ )
+
+ from .flow_matching.sparse_flow_matching import (
+ SparseFlowMatchingTrainer,
+ SparseFlowMatchingCFGTrainer,
+ TextConditionedSparseFlowMatchingCFGTrainer,
+ ImageConditionedSparseFlowMatchingCFGTrainer,
+ )
diff --git a/OmniPart/training/trainers/base.py b/OmniPart/training/trainers/base.py
new file mode 100644
index 0000000..976574d
--- /dev/null
+++ b/OmniPart/training/trainers/base.py
@@ -0,0 +1,794 @@
+from abc import abstractmethod
+import os
+import time
+import json
+
+import torch
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+import numpy as np
+
+from torchvision import utils
+from torch.utils.tensorboard import SummaryWriter
+
+from .utils import *
+from ..utils.general_utils import *
+from ..utils.data_utils import recursive_to_device, cycle, ResumableSampler, DuplicatedDataset
+
+import datetime
+
+from tqdm import tqdm
+class Trainer:
+ """
+ Base class for training.
+
+ This abstract class defines the core training loop and utilities
+ that are common across different training tasks. Specific training
+ implementations should inherit from this class and implement the
+ abstract methods.
+ """
+ def __init__(self,
+ models,
+ dataset,
+ *,
+ output_dir,
+ load_dir,
+ step,
+ max_steps,
+ batch_size=None,
+ batch_size_per_gpu=None,
+ batch_split=None,
+ optimizer={},
+ lr_scheduler=None,
+ elastic=None,
+ grad_clip=None,
+ ema_rate=0.9999,
+ fp16_mode='inflat_all',
+ fp16_scale_growth=1e-3,
+ finetune_ckpt=None,
+ log_param_stats=False,
+ prefetch_data=True,
+ i_print=1000,
+ i_log=500,
+ i_sample=10000,
+ i_save=10000,
+ i_ddpcheck=10000,
+ **kwargs
+ ):
+ """
+ Initialize the trainer with models, dataset, and training configuration.
+
+ Args:
+ models: Dictionary of models to train
+ dataset: Dataset to train on
+ output_dir: Directory to save outputs
+ load_dir: Directory to load checkpoints from
+ step: Current training step (for resuming)
+ max_steps: Maximum number of training steps
+ batch_size: Global batch size across all GPUs
+ batch_size_per_gpu: Batch size per GPU (alternative to batch_size)
+ batch_split: Number of microbatches to split each batch into
+ optimizer: Dictionary of optimizer configurations
+ lr_scheduler: Learning rate scheduler configuration
+ elastic: Configuration for elastic training
+ grad_clip: Value for gradient clipping
+ ema_rate: Rate for exponential moving average
+ fp16_mode: Mode for mixed precision training ('inflat_all' or 'amp')
+ fp16_scale_growth: Growth rate for mixed precision scaling
+ finetune_ckpt: Checkpoint path for fine-tuning
+ log_param_stats: Whether to log parameter statistics
+ prefetch_data: Whether to prefetch data to GPU
+ i_print: Interval for printing progress
+ i_log: Interval for logging metrics
+ i_sample: Interval for sampling/visualization
+ i_save: Interval for saving checkpoints
+ i_ddpcheck: Interval for checking DDP consistency
+ """
+ assert batch_size is not None or batch_size_per_gpu is not None, 'Either batch_size or batch_size_per_gpu must be specified.'
+
+ self.models = models
+ self.dataset = dataset
+ self.batch_split = batch_split if batch_split is not None else 1
+ self.max_steps = max_steps
+ self.optimizer_config = optimizer
+ self.lr_scheduler_config = lr_scheduler
+ self.elastic_controller_config = elastic
+ self.grad_clip = grad_clip
+ self.ema_rate = [ema_rate] if isinstance(ema_rate, float) else ema_rate
+ self.fp16_mode = fp16_mode
+ self.fp16_scale_growth = fp16_scale_growth
+ self.log_param_stats = log_param_stats
+ self.prefetch_data = prefetch_data
+ if self.prefetch_data:
+ self._data_prefetched = None
+
+ self.output_dir = output_dir
+ self.i_print = i_print
+ self.i_log = i_log
+ self.i_sample = i_sample
+ self.i_save = i_save
+ self.i_ddpcheck = i_ddpcheck
+
+ # Set up distributed training configuration
+ if dist.is_initialized():
+ # Multi-GPU params
+ self.world_size = dist.get_world_size()
+ self.rank = dist.get_rank()
+ self.local_rank = dist.get_rank() % torch.cuda.device_count()
+ self.is_master = self.rank == 0
+ else:
+ # Single-GPU params
+ self.world_size = 1
+ self.rank = 0
+ self.local_rank = 0
+ self.is_master = True
+
+ # Calculate batch size parameters
+ self.batch_size = batch_size if batch_size_per_gpu is None else batch_size_per_gpu * self.world_size
+ self.batch_size_per_gpu = batch_size_per_gpu if batch_size_per_gpu is not None else batch_size // self.world_size
+ assert self.batch_size % self.world_size == 0, 'Batch size must be divisible by the number of GPUs.'
+ assert self.batch_size_per_gpu % self.batch_split == 0, 'Batch size per GPU must be divisible by batch split.'
+
+ # Initialize models, optimizers, etc.
+ self.init_models_and_more(**kwargs)
+ self.prepare_dataloader(**kwargs)
+
+ # Load checkpoint or initialize from scratch
+ self.step = 0
+ if load_dir is not None and step is not None:
+ # print("load from ...x")
+ self.load(load_dir, step)
+ elif finetune_ckpt is not None:
+ # print("finetune from ...x")
+ self.finetune_from(finetune_ckpt)
+ # print(finetune_ckpt)
+ # print("loading finished......")
+
+ # Set up output directories and tensorboard writer on master process
+ if self.is_master:
+ os.makedirs(os.path.join(self.output_dir, 'ckpts'), exist_ok=True)
+ os.makedirs(os.path.join(self.output_dir, 'samples'), exist_ok=True)
+ self.writer = SummaryWriter(os.path.join(self.output_dir, 'tb_logs'))
+
+ # Check DDP setup for multi-GPU training
+ if self.world_size > 1:
+ self.check_ddp()
+
+ if self.is_master:
+ print('\n\nTrainer initialized.')
+ print(self)
+
+ @property
+ def device(self):
+ """
+ Get the device that the models are on.
+
+ Returns:
+ torch.device: The device of the first model parameter found.
+ """
+ for _, model in self.models.items():
+ if hasattr(model, 'device'):
+ return model.device
+ return next(list(self.models.values())[0].parameters()).device
+
+ @abstractmethod
+ def init_models_and_more(self, **kwargs):
+ """
+ Initialize models and other components like optimizers, schedulers, etc.
+
+ This abstract method must be implemented by subclasses to set up the
+ specific models and related components needed for training.
+ """
+ pass
+
+ def prepare_dataloader(self, **kwargs):
+ """
+ Prepare dataloader for training.
+
+ Sets up the data sampler and dataloader with appropriate batch size,
+ workers, and other configurations for efficient data loading.
+ """
+ print("original dataset size:", len(self.dataset))
+ num_dataset = 128
+ # Wrap your dataset in the DuplicatedDataset if it's too small
+ print(f"Dataset size: {len(self.dataset)}")
+ if len(self.dataset) < num_dataset: # Adjust this threshold as needed
+ from ..utils.data_utils import DuplicatedDataset
+
+ self.dataset = DuplicatedDataset(self.dataset, repeat=num_dataset)
+ print(f"Dataset duplicated to {len(self.dataset)} samples")
+
+ self.data_sampler = ResumableSampler(
+ self.dataset,
+ shuffle=True,
+ )
+ self.dataloader = DataLoader(
+ self.dataset,
+ batch_size=self.batch_size_per_gpu,
+ num_workers=int(np.ceil(os.cpu_count() / torch.cuda.device_count())),
+ pin_memory=True,
+ drop_last=True,
+ persistent_workers=True,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ sampler=self.data_sampler,
+ )
+
+ self.data_iterator = cycle(self.dataloader)
+
+ @abstractmethod
+ def load(self, load_dir, step=0):
+ """
+ Load a checkpoint.
+
+ This method should be implemented to restore the training state
+ from a saved checkpoint.
+
+ Args:
+ load_dir: Directory containing checkpoints
+ step: Specific step to load, or 0 for latest
+
+ Note: Should be called by all processes in distributed training.
+ """
+ pass
+
+ @abstractmethod
+ def save(self):
+ """
+ Save a checkpoint.
+
+ This method should be implemented to save the current training state
+ to a checkpoint file.
+
+ Note: Should be called only by the rank 0 process in distributed training.
+ """
+ pass
+
+ @abstractmethod
+ def finetune_from(self, finetune_ckpt):
+ """
+ Finetune from a checkpoint.
+
+ This method should be implemented to load pre-trained weights
+ for fine-tuning.
+
+ Args:
+ finetune_ckpt: Path to checkpoint for fine-tuning
+
+ Note: Should be called by all processes in distributed training.
+ """
+ pass
+
+ @abstractmethod
+ def run_snapshot(self, num_samples, batch_size=4, verbose=False, **kwargs):
+ """
+ Run a snapshot of the model.
+
+ This method should be implemented to generate samples from the model
+ for visualization.
+
+ Args:
+ num_samples: Number of samples to generate
+ batch_size: Batch size for generation
+ verbose: Whether to print verbose information
+ **kwargs: Additional arguments
+
+ Returns:
+ dict: Dictionary of generated samples
+ """
+ pass
+
+ @torch.no_grad()
+ def visualize_sample(self, sample):
+ """
+ Convert a sample to an image for visualization.
+
+ Args:
+ sample: Data sample to visualize
+
+ Returns:
+ torch.Tensor or dict: Processed sample ready for visualization
+ """
+ if hasattr(self.dataset, 'visualize_sample'):
+ return self.dataset.visualize_sample(sample)
+ else:
+ return sample
+
+ @torch.no_grad()
+ def snapshot_dataset(self, num_samples=4):
+ """
+ Sample images from the dataset for visualization.
+
+ Creates a visualization of dataset samples and saves them to disk.
+
+ Args:
+ num_samples: Number of samples to visualize
+ """
+ # print(f"Starting snapshot_dataset with {num_samples} samples...")
+ # print("Creating dataloader...")
+ dataloader = torch.utils.data.DataLoader(
+ self.dataset,
+ batch_size=num_samples,
+ num_workers=0,
+ shuffle=True,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+ # print("Dataloader created, retrieving batch...")
+ data = next(iter(dataloader))
+ # print("Batch retrieved, moving to device...")
+ data = recursive_to_device(data, self.device)
+ # print("Data moved to device, visualizing sample...")
+ vis = self.visualize_sample(data)
+ # print("Sample visualized, preparing to save images...")
+ if isinstance(vis, dict):
+ save_cfg = [(f'dataset_{k}', v) for k, v in vis.items()]
+ else:
+ save_cfg = [('dataset', vis)]
+ for name, image in save_cfg:
+ # print(f"Saving image {name}...")
+ max_images_per_file = 100
+
+ # Get the number of images in this batch
+ num_images = image.size(0)
+
+ if num_images <= max_images_per_file:
+ # If fewer than max_images_per_file, save them all in one file
+ utils.save_image(
+ image,
+ os.path.join(self.output_dir, 'samples', f'{name}.jpg'),
+ nrow=int(np.sqrt(num_images)),
+ normalize=True,
+ value_range=self.dataset.value_range,
+ )
+ else:
+ # If more than max_images_per_file, split into multiple files
+ num_batches = (num_images + max_images_per_file - 1) // max_images_per_file
+
+ for i in range(num_batches):
+ start_idx = i * max_images_per_file
+ end_idx = min((i + 1) * max_images_per_file, num_images)
+
+ # Extract the current batch of images
+ batch_images = image[start_idx:end_idx]
+ batch_size_actual = batch_images.size(0)
+
+ utils.save_image(
+ batch_images,
+ os.path.join(self.output_dir, 'samples', f'{name}_{i+1}.jpg'),
+ nrow=int(np.sqrt(batch_size_actual)),
+ normalize=True,
+ value_range=self.dataset.value_range,
+ )
+ # print(f"Image {name} saved successfully")
+ # print("snapshot_dataset completed")
+
+ @torch.no_grad()
+ def snapshot(self, suffix=None, num_samples=50, batch_size=4, verbose=False):
+ """
+ Sample images from the model and save to disk.
+
+ This function coordinates the generation of samples across all processes
+ and gathers them on the master process for saving.
+
+ Args:
+ suffix: Suffix for the output directory name
+ num_samples: Number of samples to generate
+ batch_size: Batch size for generation
+ verbose: Whether to print verbose information
+
+ Note: This function should be called by all processes in distributed training.
+ """
+ # if self.world_size > 1:
+ # dist.barrier()
+ # Print status message from the master process only
+ if self.is_master:
+ print(f'\nSampling {num_samples} images...', end='')
+
+ # Set default suffix to current step if none provided (used for organizing output files)
+ if suffix is None:
+ suffix = f'step{self.step:07d}'
+
+ # Calculate how many samples each process should generate in distributed setting
+ num_samples_per_process = int(np.ceil(num_samples / self.world_size))
+ # # Generate samples using the model's snapshot implementation
+
+ samples = self.run_snapshot(num_samples_per_process, batch_size=batch_size, verbose=verbose)
+
+ for key in list(samples.keys()):
+ if samples[key]['type'] == 'sample':
+ # Convert raw samples to visualizable format using the dataset's visualization method
+ # vis = self.visualize_sample(samples[key]['value'])
+ vis = self.visualize_sample({'x_0': samples[key]['value'], 'part_layouts': samples['layout']['value']})
+ if isinstance(vis, dict):
+ # If visualization returns a dictionary, create multiple entries with different visualizations
+ for k, v in vis.items():
+ samples[f'{key}_{k}'] = {'value': v, 'type': 'image'}
+ # Remove the original entry since it's been replaced with specific visualizations
+ del samples[key]
+ else:
+ # Otherwise, update the existing entry by replacing with visualization
+ samples[key] = {'value': vis, 'type': 'image'}
+
+ # Remove the layout entry after processing
+ if 'layout' in samples:
+ del samples['layout']
+
+ # Gather samples from all processes in distributed training setup
+ if self.world_size > 1:
+ for key in samples.keys():
+ # if isinstance(samples[key]['value'], list):
+ # continue
+ if key in ['sample', 'sample_gt', 'image']:
+ # Ensure tensor is contiguous in memory for efficient gathering operation
+ samples[key]['value'] = samples[key]['value'].contiguous()
+ # print(samples[key]['value'].shape)
+ if self.is_master:
+ # Create buffers on master process to receive data from all processes
+ all_images = [torch.empty_like(samples[key]['value']) for _ in range(self.world_size)]
+ else:
+ # Non-master processes don't need to allocate receive buffers
+ all_images = []
+ # Gather data from all processes to the master (rank 0)
+ dist.gather(samples[key]['value'], all_images, dst=0)
+ if self.is_master:
+ # Concatenate all gathered samples and limit to requested number
+ samples[key]['value'] = torch.cat(all_images, dim=0)[:num_samples]
+
+
+ # Save images to disk (only on master process)
+ if self.is_master:
+ # Create output directory for current snapshot
+ os.makedirs(os.path.join(self.output_dir, 'samples', suffix), exist_ok=True)
+ for key in samples.keys(): # Error: The size of tensor a (3) must match the size of tensor b (518) at non-singleton dimension 2
+ # print(key)
+ # print(samples[key])
+ if samples[key]['type'] == 'image':
+ # print(f"Saving {key} images...")
+ # print(f"shape is {samples[key]['value'].shape}") # shape is torch.Size([64, 3, 3, 518, 518])
+ # Reshape [64, 3, 3, 518, 518] -> [64, 9, 518, 518]
+ if samples[key]['value'].ndim == 5:
+ value = samples[key]['value']
+ value = value.permute(1, 0, 2, 3, 4)
+ # print(f"Reshaped tensor from {value.shape} to {samples[key]['value'].shape}")
+ for indexx in range(value.shape[0]):
+ # Save image samples using torchvision utilities
+ utils.save_image(
+ value[indexx],
+ os.path.join(self.output_dir, 'samples', suffix, f'{key}_{suffix}_{index}_{indexx}.jpg'),
+ nrow=int(np.sqrt(num_samples)), # Arrange images in a square grid
+ normalize=True,
+ value_range=self.dataset.value_range, # Use dataset's specified value range for normalization
+ )
+ else:
+ image = samples[key]['value']
+ # Maximum number of images to save in one file
+ max_images_per_file = 100
+
+ # Get the number of images in this batch
+ num_images = image.size(0)
+
+ if num_images <= max_images_per_file:
+ # If fewer than max_images_per_file, save them all in one file
+ utils.save_image(
+ image,
+ os.path.join(self.output_dir, 'samples', suffix, f'{key}_{suffix}.jpg'),
+ nrow=int(np.sqrt(num_images)),
+ normalize=True,
+ value_range=self.dataset.value_range,
+ )
+ else:
+ # If more than max_images_per_file, split into multiple files
+ num_batches = (num_images + max_images_per_file - 1) // max_images_per_file
+
+ for i in range(num_batches):
+ start_idx = i * max_images_per_file
+ end_idx = min((i + 1) * max_images_per_file, num_images)
+
+ # Extract the current batch of images
+ batch_images = image[start_idx:end_idx]
+ batch_size_actual = batch_images.size(0)
+
+ utils.save_image(
+ batch_images,
+ os.path.join(self.output_dir, 'samples', suffix, f'{key}_{suffix}_{i+1}.jpg'),
+ nrow=int(np.sqrt(batch_size_actual)),
+ normalize=True,
+ value_range=self.dataset.value_range,
+ )
+ # print(f"key is ****{key}")
+ elif samples[key]['type'] == 'number':
+ # Process and save numerical samples as images with annotations
+ min_val = samples[key]['value'].min()
+ max_val = samples[key]['value'].max()
+ # Normalize values to [0, 1] range for visualization
+ images = (samples[key]['value'] - min_val) / (max_val - min_val)
+ # Create a grid of images
+ images = utils.make_grid(
+ images,
+ nrow=int(np.sqrt(num_samples)),
+ normalize=False, # Already normalized above
+ )
+ # Save the image with min/max annotations for reference
+ save_image_with_notes(
+ images,
+ os.path.join(self.output_dir, 'samples', suffix, f'{key}_{suffix}.jpg'),
+ notes=f'{key} min: {min_val}, max: {max_val}',
+ )
+
+ # Print completion message (master process only)
+ if self.is_master:
+ print(' Done.')
+
+ # print(1111111111111111111111)
+ # if self.world_size > 1:
+ # dist.barrier()
+ # print(222222222222222222222)
+
+ @abstractmethod
+ def update_ema(self):
+ """
+ Update exponential moving average of model parameters.
+
+ This method should be implemented to maintain EMA versions of models
+ for more stable inference.
+
+ Note: Should only be called by the rank 0 process.
+ """
+ pass
+
+ @abstractmethod
+ def check_ddp(self):
+ """
+ Check if Distributed Data Parallel (DDP) is working properly.
+
+ This method should verify that parameters are synchronized
+ across processes in distributed training.
+
+ Note: Should be called by all processes.
+ """
+ pass
+
+ @abstractmethod
+ def training_losses(**mb_data):
+ """
+ Compute training losses from a minibatch of data.
+
+ This method should be implemented to compute all loss components
+ needed for training.
+
+ Args:
+ **mb_data: Minibatch data
+
+ Returns:
+ dict: Dictionary of loss components
+ """
+ pass
+
+ def load_data(self):
+ """
+ Load a batch of data from the dataloader.
+
+ If prefetching is enabled, alternates between using a pre-fetched
+ batch and loading the next batch in the background.
+
+ Returns:
+ list: List of data dictionaries, split according to batch_split
+ """
+ if_print = False
+
+ if if_print:
+ print(f"[{self.step}] Beginning load_data() method")
+
+ if self.prefetch_data:
+ if self._data_prefetched is None:
+ if if_print:
+ print(f"[{self.step}] No prefetched data, fetching initial batch")
+
+ data_load = next(self.data_iterator)
+ if if_print:
+ print(f"[{self.step}] Prefetching next batch in background")
+ self._data_prefetched = recursive_to_device(data_load, self.device, non_blocking=True)
+ data = self._data_prefetched
+ if if_print:
+ print(f"[{self.step}] Using prefetched data and loading next batch in background")
+ self._data_prefetched = recursive_to_device(next(self.data_iterator), self.device, non_blocking=True)
+ else:
+ if if_print:
+ print(f"[{self.step}] Prefetching disabled, loading data directly")
+ data = recursive_to_device(next(self.data_iterator), self.device, non_blocking=True)
+
+ # Split data into multiple microbatches if needed
+ if isinstance(data, dict):
+ if self.batch_split == 1:
+ if if_print:
+ print(f"[{self.step}] Batch split=1, using single batch")
+ data_list = [data]
+ else:
+ batch_size = list(data.values())[0].shape[0]
+ if if_print:
+ print(f"[{self.step}] Splitting batch (size {batch_size}) into {self.batch_split} microbatches")
+ data_list = [
+ {k: v[i * batch_size // self.batch_split:(i + 1) * batch_size // self.batch_split] for k, v in data.items()}
+ for i in range(self.batch_split)
+ ]
+ elif isinstance(data, list):
+ if if_print:
+ print(f"[{self.step}] Data is already a list with {len(data)} items")
+ data_list = data
+ else:
+ if if_print:
+ print(f"[{self.step}] ERROR: Unexpected data type: {type(data)}")
+ raise ValueError('Data must be a dict or a list of dicts.')
+
+ if if_print:
+ print(f"[{self.step}] Returning data_list with {len(data_list)} items")
+ return data_list
+
+ @abstractmethod
+ def run_step(self, data_list):
+ """
+ Run a single training step.
+
+ This method should be implemented to process a batch of data,
+ compute losses, and update model parameters.
+
+ Args:
+ data_list: List of data batches
+
+ Returns:
+ dict: Dictionary of metrics/losses for logging
+ """
+ pass
+
+ def run(self):
+ """
+ Run the full training loop.
+
+ This method handles the main training loop, including:
+ - Data loading
+ - Running training steps
+ - Logging metrics
+ - Creating snapshots
+ - Saving checkpoints
+ - Monitoring progress
+ """
+ # if self.is_master:
+ # print('\nStarting training...')
+ # self.snapshot_dataset()
+ # if self.step == 0:
+ # self.snapshot(suffix='init')
+ # else: # resume
+ # self.snapshot(suffix=f'resume_step{self.step:07d}')
+
+ self.snapshot_dataset()
+ # if self.step != 0:
+ # self.snapshot(suffix=f'resume_step{self.step:07d}')
+
+ log = []
+ time_last_print = 0.0
+ time_elapsed = 0.0
+
+ # Initialize progress bar (only on master process)
+ pbar = None
+ if self.is_master:
+ pbar = tqdm(
+ initial=self.step,
+ total=self.max_steps,
+ desc="Training",
+ unit="step",
+ dynamic_ncols=True,
+ leave=True
+ )
+
+ while self.step < self.max_steps:
+
+ # print("self.step", self.step)
+ # print("self.i_log", self.i_log) # 500
+ # print("step:", self.step)
+ time_start = time.time()
+ # print("load data")
+ data_list = self.load_data()
+ # print("run step")
+ step_log = self.run_step(data_list)
+
+ time_end = time.time()
+ time_elapsed += time_end - time_start
+
+ self.step += 1
+
+ # Update progress bar on master process
+ if self.is_master and pbar is not None:
+ pbar.update(1)
+
+ # Update progress bar description with speed and ETA
+ if self.step % self.i_print == 0:
+ speed = self.i_print / (time_elapsed - time_last_print) * 3600
+ pbar_desc = f"Training | Step: {self.step}/{self.max_steps} | " \
+ f"Speed: {speed:.2f} steps/h | " \
+ f"Elapsed: {time_elapsed/3600:.2f}h | " \
+ f"ETA: {(self.max_steps-self.step)/speed:.2f}h"
+ pbar.set_description(pbar_desc)
+ time_last_print = time_elapsed
+
+ # Check DDP synchronization at regular intervals
+ if self.world_size > 1 and self.i_ddpcheck is not None and self.step % self.i_ddpcheck == 0:
+ self.check_ddp()
+
+ # Generate and save sample images at regular intervals
+ # if self.step == 0 or self.step % self.i_sample == 0:
+ # print("snapshot")
+ # self.snapshot()
+
+ # Handle logging on master process
+ if self.is_master:
+
+ # print("self.is_master")
+ log.append((self.step, {}))
+
+ # print(f"log append: {log}")
+ # Log timing information
+ log[-1][1]['time'] = {
+ 'step': time_end - time_start,
+ 'elapsed': time_elapsed,
+ }
+
+ # Log training metrics
+ if step_log is not None:
+ log[-1][1].update(step_log)
+
+ # Log scaling factor for mixed precision training
+ if self.fp16_mode == 'amp':
+ log[-1][1]['scale'] = self.scaler.get_scale()
+ elif self.fp16_mode == 'inflat_all':
+ log[-1][1]['log_scale'] = self.log_scale
+
+ # Save log
+ if self.step % self.i_log == 0:
+ ## save to log file
+ log_str = '\n'.join([
+ f'{step}: {json.dumps(log)}' for step, log in log
+ ])
+ with open(os.path.join(self.output_dir, 'log.txt'), 'a') as log_file:
+ log_file.write(log_str + '\n')
+
+ # show with mlflow
+ log_show = [l for _, l in log if not dict_any(l, lambda x: np.isnan(x))]
+ log_show = dict_reduce(log_show, lambda x: np.mean(x))
+ log_show = dict_flatten(log_show, sep='/')
+ for key, value in log_show.items():
+ self.writer.add_scalar(key, value, self.step)
+ log = []
+
+ # Save checkpoint at regular intervals
+ if self.step % self.i_save == 0:
+ self.save()
+
+ # Clean up progress bar when training is complete
+ if self.is_master and pbar is not None:
+ pbar.close()
+
+ # Final steps after training is complete
+ self.snapshot(suffix='final')
+ self.writer.close()
+ print('Training finished.')
+
+
+ def profile(self, wait=2, warmup=3, active=5):
+ """
+ Profile the training loop for performance analysis.
+
+ Uses PyTorch's profiling tools to collect performance metrics.
+
+ Args:
+ wait: Number of steps to wait before profiling
+ warmup: Number of warmup steps for profiling
+ active: Number of active profiling steps
+ """
+ with torch.profiler.profile(
+ schedule=torch.profiler.schedule(wait=wait, warmup=warmup, active=active, repeat=1),
+ on_trace_ready=torch.profiler.tensorboard_trace_handler(os.path.join(self.output_dir, 'profile')),
+ profile_memory=True,
+ with_stack=True,
+ ) as prof:
+ for _ in range(wait + warmup + active):
+ self.run_step()
+ prof.step()
\ No newline at end of file
diff --git a/OmniPart/training/trainers/basic.py b/OmniPart/training/trainers/basic.py
new file mode 100644
index 0000000..b8584a9
--- /dev/null
+++ b/OmniPart/training/trainers/basic.py
@@ -0,0 +1,599 @@
+import os
+import copy
+from functools import partial
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+import numpy as np
+
+from .utils import *
+from .base import Trainer
+from ..utils.general_utils import *
+from ..utils.dist_utils import *
+from ..utils import grad_clip_utils, elastic_utils
+
+
+class BasicTrainer(Trainer):
+ """
+ Trainer for basic training loop.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+ """
+
+ def __str__(self):
+ """
+ Returns a string representation of the trainer with all its configurations.
+ This provides a comprehensive overview of the training setup.
+ """
+ lines = []
+ lines.append(self.__class__.__name__)
+ lines.append(f' - Models:')
+ for name, model in self.models.items():
+ lines.append(f' - {name}: {model.__class__.__name__}')
+ lines.append(f' - Dataset: {indent(str(self.dataset), 2)}')
+ lines.append(f' - Dataloader:')
+ lines.append(f' - Sampler: {self.dataloader.sampler.__class__.__name__}')
+ lines.append(f' - Num workers: {self.dataloader.num_workers}')
+ lines.append(f' - Number of steps: {self.max_steps}')
+ lines.append(f' - Number of GPUs: {self.world_size}')
+ lines.append(f' - Batch size: {self.batch_size}')
+ lines.append(f' - Batch size per GPU: {self.batch_size_per_gpu}')
+ lines.append(f' - Batch split: {self.batch_split}')
+ lines.append(f' - Optimizer: {self.optimizer.__class__.__name__}')
+ lines.append(f' - Learning rate: {self.optimizer.param_groups[0]["lr"]}')
+ if self.lr_scheduler_config is not None:
+ lines.append(f' - LR scheduler: {self.lr_scheduler.__class__.__name__}')
+ if self.elastic_controller_config is not None:
+ lines.append(f' - Elastic memory: {indent(str(self.elastic_controller), 2)}')
+ if self.grad_clip is not None:
+ lines.append(f' - Gradient clip: {indent(str(self.grad_clip), 2)}')
+ lines.append(f' - EMA rate: {self.ema_rate}')
+ lines.append(f' - FP16 mode: {self.fp16_mode}')
+ return '\n'.join(lines)
+
+ def init_models_and_more(self, **kwargs):
+ """
+ Initialize models and more.
+
+ This method performs the following tasks:
+ 1. Sets up DDP for distributed training if world_size > 1
+ 2. Collects model parameters for optimization
+ 3. Sets up mixed precision training based on fp16_mode
+ 4. Initializes EMA parameters if needed
+ 5. Sets up the optimizer and learning rate scheduler
+ 6. Configures elastic memory management if enabled
+ 7. Sets up gradient clipping if configured
+ """
+ if self.world_size > 1:
+ # Prepare distributed data parallel
+ self.training_models = {
+ name: DDP(
+ model,
+ device_ids=[self.local_rank],
+ output_device=self.local_rank,
+ bucket_cap_mb=128,
+ find_unused_parameters=False
+ )
+ for name, model in self.models.items()
+ }
+ else:
+ self.training_models = self.models
+
+ # Build master params
+ self.model_params = sum(
+ [[p for p in model.parameters() if p.requires_grad] for model in self.models.values()], [])
+ if self.fp16_mode == 'amp':
+ # For AMP mode, we use PyTorch's automatic mixed precision
+ self.master_params = self.model_params
+ # self.scaler = torch.GradScaler() if self.fp16_mode == 'amp' else None
+ self.scaler = torch.cuda.amp.GradScaler() if self.fp16_mode == 'amp' else None
+ elif self.fp16_mode == 'inflat_all':
+ # Manual FP16 mode with master params in FP32
+ self.master_params = make_master_params(self.model_params)
+ self.fp16_scale_growth = self.fp16_scale_growth
+ self.log_scale = 20.0
+ elif self.fp16_mode is None:
+ # Standard FP32 training
+ self.master_params = self.model_params
+ else:
+ raise NotImplementedError(f'FP16 mode {self.fp16_mode} is not implemented.')
+
+ # Build EMA params - only the master process maintains EMA parameters
+ if self.is_master:
+ self.ema_params = [copy.deepcopy(self.master_params) for _ in self.ema_rate]
+
+ # Initialize optimizer
+ if hasattr(torch.optim, self.optimizer_config['name']):
+ self.optimizer = getattr(torch.optim, self.optimizer_config['name'])(self.master_params, **self.optimizer_config['args'])
+ else:
+ self.optimizer = globals()[self.optimizer_config['name']](self.master_params, **self.optimizer_config['args'])
+
+ # Initalize learning rate scheduler
+ if self.lr_scheduler_config is not None:
+ if hasattr(torch.optim.lr_scheduler, self.lr_scheduler_config['name']):
+ self.lr_scheduler = getattr(torch.optim.lr_scheduler, self.lr_scheduler_config['name'])(self.optimizer, **self.lr_scheduler_config['args'])
+ else:
+ self.lr_scheduler = globals()[self.lr_scheduler_config['name']](self.optimizer, **self.lr_scheduler_config['args'])
+
+ # Initialize elastic memory controller
+ if self.elastic_controller_config is not None:
+ assert any([isinstance(model, (elastic_utils.ElasticModule, elastic_utils.ElasticModuleMixin)) for model in self.models.values()]), \
+ 'No elastic module found in models, please inherit from ElasticModule or ElasticModuleMixin'
+ self.elastic_controller = getattr(elastic_utils, self.elastic_controller_config['name'])(**self.elastic_controller_config['args'])
+ for model in self.models.values():
+ if isinstance(model, (elastic_utils.ElasticModule, elastic_utils.ElasticModuleMixin)):
+ model.register_memory_controller(self.elastic_controller)
+
+ # Initialize gradient clipper
+ if self.grad_clip is not None:
+ if isinstance(self.grad_clip, (float, int)):
+ self.grad_clip = float(self.grad_clip)
+ else:
+ self.grad_clip = getattr(grad_clip_utils, self.grad_clip['name'])(**self.grad_clip['args'])
+
+ def _master_params_to_state_dicts(self, master_params):
+ """
+ Convert master params to dict of state_dicts.
+
+ This is used when saving model parameters, to convert from the flat
+ list of master parameters back to the state_dict format for each model.
+
+ Args:
+ master_params: List of parameters in flat format
+
+ Returns:
+ dict: Dictionary of model state dicts
+ """
+ if self.fp16_mode == 'inflat_all':
+ master_params = unflatten_master_params(self.model_params, master_params)
+ state_dicts = {name: model.state_dict() for name, model in self.models.items()}
+ master_params_names = sum(
+ [[(name, n) for n, p in model.named_parameters() if p.requires_grad] for name, model in self.models.items()]
+ , [])
+ for i, (model_name, param_name) in enumerate(master_params_names):
+ state_dicts[model_name][param_name] = master_params[i]
+ return state_dicts
+
+ def _state_dicts_to_master_params(self, master_params, state_dicts):
+ """
+ Convert a state_dict to master params.
+
+ This is used when loading parameters, to convert from the state_dict
+ format to the flat list of master parameters.
+
+ Args:
+ master_params: List of parameters in flat format to be updated
+ state_dicts: Dictionary of model state dicts
+ """
+ master_params_names = sum(
+ [[(name, n) for n, p in model.named_parameters() if p.requires_grad] for name, model in self.models.items()]
+ , [])
+
+ params = []
+ for name, param_name in master_params_names:
+ if name in state_dicts and param_name in state_dicts[name]:
+ # Parameter exists in checkpoint
+ params.append(state_dicts[name][param_name])
+ else:
+ # Parameter missing in checkpoint, use the model's initialized parameter
+ if self.is_master:
+ print(f'Warning: {name}.{param_name} not found in checkpoint, using model initialization.')
+ # Find the parameter in the model
+ for n, p in self.models[name].named_parameters():
+ if n == param_name:
+ params.append(p.detach().clone())
+ break
+
+ if self.fp16_mode == 'inflat_all':
+ model_params_to_master_params(params, master_params)
+ else:
+ for i, param in enumerate(params):
+ master_params[i].data.copy_(param.data)
+
+ def load(self, load_dir, step=0):
+ """
+ Load a checkpoint.
+ Should be called by all processes.
+
+ This method loads model parameters, optimizer state, and other training state
+ from a previously saved checkpoint.
+
+ Args:
+ load_dir: Directory where checkpoints are saved
+ step: Training step to load from
+ """
+ if self.is_master:
+ print(f'\nLoading checkpoint from step {step}...', end='')
+
+ # Load models
+ model_ckpts = {}
+ for name, model in self.models.items():
+ model_ckpt = torch.load(read_file_dist(os.path.join(load_dir, 'ckpts', f'{name}_step{step:07d}.pt')), map_location=self.device, weights_only=True)
+ model_ckpts[name] = model_ckpt
+ model.load_state_dict(model_ckpt, strict=False)
+ if self.fp16_mode == 'inflat_all':
+ model.convert_to_fp16()
+ self._state_dicts_to_master_params(self.master_params, model_ckpts)
+ del model_ckpts
+
+ # Load EMA parameters (only for master process)
+ if self.is_master:
+ for i, ema_rate in enumerate(self.ema_rate):
+ ema_ckpts = {}
+ for name, model in self.models.items():
+ ema_ckpt = torch.load(os.path.join(load_dir, 'ckpts', f'{name}_ema{ema_rate}_step{step:07d}.pt'), map_location=self.device, weights_only=True)
+ ema_ckpts[name] = ema_ckpt
+ self._state_dicts_to_master_params(self.ema_params[i], ema_ckpts)
+ del ema_ckpts
+
+ # Load miscellaneous state (optimizer, step, etc.)
+ misc_ckpt = torch.load(read_file_dist(os.path.join(load_dir, 'ckpts', f'misc_step{step:07d}.pt')), map_location=torch.device('cpu'), weights_only=False)
+ self.optimizer.load_state_dict(misc_ckpt['optimizer'])
+ self.step = misc_ckpt['step']
+ self.data_sampler.load_state_dict(misc_ckpt['data_sampler'])
+ if self.fp16_mode == 'amp':
+ self.scaler.load_state_dict(misc_ckpt['scaler'])
+ elif self.fp16_mode == 'inflat_all':
+ self.log_scale = misc_ckpt['log_scale']
+ if self.lr_scheduler_config is not None:
+ self.lr_scheduler.load_state_dict(misc_ckpt['lr_scheduler'])
+ if self.elastic_controller_config is not None:
+ self.elastic_controller.load_state_dict(misc_ckpt['elastic_controller'])
+ if self.grad_clip is not None and not isinstance(self.grad_clip, float):
+ self.grad_clip.load_state_dict(misc_ckpt['grad_clip'])
+ del misc_ckpt
+
+ # Synchronize processes after loading
+ if self.world_size > 1:
+ dist.barrier()
+ if self.is_master:
+ print(' Done.')
+
+ # Verify that DDP is working correctly
+ if self.world_size > 1:
+ self.check_ddp()
+
+ def finetune_from(self, finetune_ckpt):
+ """
+ Finetune from a checkpoint.
+ Should be called by all processes.
+
+ This method loads model parameters from a checkpoint for finetuning,
+ handling shape mismatches and partial loading.
+
+ Args:
+ finetune_ckpt: Dictionary mapping model names to checkpoint paths
+ """
+ if self.is_master:
+ print('\nFinetuning from:')
+ for name, path in finetune_ckpt.items():
+ print(f' - {name}: {path}')
+
+ # Load models
+ model_ckpts = {}
+ for name, model in self.models.items():
+ model_state_dict = model.state_dict()
+ if name in finetune_ckpt:
+ # Load checkpoint if available for this model
+ model_ckpt = torch.load(read_file_dist(finetune_ckpt[name]), map_location=self.device, weights_only=False)
+
+ # Handle shape mismatches more intelligently
+ for k, v in model_ckpt.items():
+ if k not in model_state_dict:
+ if self.is_master:
+ print(f'Warning: {k} in checkpoint but not in model, skipped.')
+ continue
+
+ if model_ckpt[k].shape != model_state_dict[k].shape:
+ ckpt_shape = model_ckpt[k].shape
+ model_shape = model_state_dict[k].shape
+
+ # Try to adapt the parameter if possible
+ adapted = False
+
+ # Case 1: Weights where model has more input features (like input_layer.weight)
+ if len(ckpt_shape) == 2 and len(model_shape) == 2 and ckpt_shape[0] == model_shape[0] and ckpt_shape[1] < model_shape[1]:
+ if self.is_master:
+ print(f'Adapting {k}: {ckpt_shape} -> {model_shape} (adding features)')
+ new_tensor = torch.zeros(model_shape, dtype=model_ckpt[k].dtype, device=model_ckpt[k].device)
+ new_tensor[:, :ckpt_shape[1]] = model_ckpt[k]
+ model_ckpt[k] = new_tensor
+ adapted = True
+
+ # Case 2: Weights where model has more output features (like out_layer.weight)
+ elif len(ckpt_shape) == 2 and len(model_shape) == 2 and ckpt_shape[0] < model_shape[0] and ckpt_shape[1] == model_shape[1]:
+ if self.is_master:
+ print(f'Adapting {k}: {ckpt_shape} -> {model_shape} (adding outputs)')
+ new_tensor = torch.zeros(model_shape, dtype=model_ckpt[k].dtype, device=model_ckpt[k].device)
+ new_tensor[:ckpt_shape[0], :] = model_ckpt[k]
+ model_ckpt[k] = new_tensor
+ adapted = True
+
+ # Case 3: Biases where model has more outputs (like out_layer.bias)
+ elif len(ckpt_shape) == 1 and len(model_shape) == 1 and ckpt_shape[0] < model_shape[0]:
+ if self.is_master:
+ print(f'Adapting {k}: {ckpt_shape} -> {model_shape} (expanding bias)')
+ new_tensor = torch.zeros(model_shape, dtype=model_ckpt[k].dtype, device=model_ckpt[k].device)
+ new_tensor[:ckpt_shape[0]] = model_ckpt[k]
+ model_ckpt[k] = new_tensor
+ adapted = True
+
+ # If we couldn't adapt the parameter, use the model's initialization
+ if not adapted:
+ if self.is_master:
+ print(f'Warning: {k} shape mismatch, {ckpt_shape} vs {model_shape}, skipped.')
+ model_ckpt[k] = model_state_dict[k]
+
+ model_ckpts[name] = model_ckpt
+ model.load_state_dict(model_ckpt, strict=False)
+ if self.fp16_mode == 'inflat_all':
+ model.convert_to_fp16()
+ else:
+ # Keep original params if no checkpoint for this model
+ if self.is_master:
+ print(f'Warning: {name} not found in finetune_ckpt, skipped.')
+ model_ckpts[name] = model_state_dict
+
+ self._state_dicts_to_master_params(self.master_params, model_ckpts)
+ del model_ckpts
+
+ # Synchronize processes after loading
+ if self.world_size > 1:
+ dist.barrier()
+ if self.is_master:
+ print('Done.')
+
+ # Verify that DDP is working correctly
+ if self.world_size > 1:
+ self.check_ddp()
+
+ def save(self):
+ """
+ Save a checkpoint.
+ Should be called only by the rank 0 process.
+
+ This method saves model parameters, optimizer state, and other training state
+ to checkpoint files for later resumption of training.
+ """
+ assert self.is_master, 'save() should be called only by the rank 0 process.'
+ print(f'\nSaving checkpoint at step {self.step}...', end='')
+
+ # Save models
+ model_ckpts = self._master_params_to_state_dicts(self.master_params)
+ for name, model_ckpt in model_ckpts.items():
+ torch.save(model_ckpt, os.path.join(self.output_dir, 'ckpts', f'{name}_step{self.step:07d}.pt'))
+
+ # Save EMA parameters
+ for i, ema_rate in enumerate(self.ema_rate):
+ ema_ckpts = self._master_params_to_state_dicts(self.ema_params[i])
+ for name, ema_ckpt in ema_ckpts.items():
+ torch.save(ema_ckpt, os.path.join(self.output_dir, 'ckpts', f'{name}_ema{ema_rate}_step{self.step:07d}.pt'))
+
+ # Save miscellaneous state (optimizer, step, etc.)
+ misc_ckpt = {
+ 'optimizer': self.optimizer.state_dict(),
+ 'step': self.step,
+ 'data_sampler': self.data_sampler.state_dict(),
+ }
+ if self.fp16_mode == 'amp':
+ misc_ckpt['scaler'] = self.scaler.state_dict()
+ elif self.fp16_mode == 'inflat_all':
+ misc_ckpt['log_scale'] = self.log_scale
+ if self.lr_scheduler_config is not None:
+ misc_ckpt['lr_scheduler'] = self.lr_scheduler.state_dict()
+ if self.elastic_controller_config is not None:
+ misc_ckpt['elastic_controller'] = self.elastic_controller.state_dict()
+ if self.grad_clip is not None and not isinstance(self.grad_clip, float):
+ misc_ckpt['grad_clip'] = self.grad_clip.state_dict()
+ torch.save(misc_ckpt, os.path.join(self.output_dir, 'ckpts', f'misc_step{self.step:07d}.pt'))
+ print(' Done.')
+
+ def update_ema(self):
+ """
+ Update exponential moving average.
+ Should only be called by the rank 0 process.
+
+ This method updates the EMA parameters using the current model parameters
+ according to the formula: ema_param = ema_rate * ema_param + (1 - ema_rate) * master_param
+ """
+ assert self.is_master, 'update_ema() should be called only by the rank 0 process.'
+ for i, ema_rate in enumerate(self.ema_rate):
+ for master_param, ema_param in zip(self.master_params, self.ema_params[i]):
+ ema_param.detach().mul_(ema_rate).add_(master_param, alpha=1.0 - ema_rate)
+
+ def check_ddp(self):
+ """
+ Check if DDP is working properly.
+ Should be called by all process.
+
+ This method verifies that parameters are consistent across all processes
+ in distributed training, which is crucial for correct DDP operation.
+ """
+ if self.is_master:
+ print('\nPerforming DDP check...')
+
+ if self.is_master:
+ print('Checking if parameters are consistent across processes...')
+ dist.barrier()
+ try:
+ for p in self.master_params:
+ # split to avoid OOM
+ for i in range(0, p.numel(), 10000000):
+ sub_size = min(10000000, p.numel() - i)
+ sub_p = p.detach().view(-1)[i:i+sub_size]
+ # gather from all processes
+ sub_p_gather = [torch.empty_like(sub_p) for _ in range(self.world_size)]
+ dist.all_gather(sub_p_gather, sub_p)
+ # check if equal
+ assert all([torch.equal(sub_p, sub_p_gather[i]) for i in range(self.world_size)]), 'parameters are not consistent across processes'
+ except AssertionError as e:
+ if self.is_master:
+ print(f'\n\033[91mError: {e}\033[0m')
+ print('DDP check failed.')
+ raise e
+
+ dist.barrier()
+ if self.is_master:
+ print('Done.')
+
+ def run_step(self, data_list):
+ """
+ Run a training step.
+
+ This method performs one complete training step:
+ 1. Zero gradients
+ 2. For each micro-batch in the batch split:
+ a. Compute loss
+ b. Scale loss for gradient accumulation
+ c. Backward pass
+ 3. Apply gradient clipping if configured
+ 4. Update parameters
+ 5. Update learning rate if scheduler is configured
+ 6. Update EMA parameters if running on master process
+ 7. Collect and return logs
+
+ Args:
+ data_list: List of data batches for gradient accumulation
+
+ Returns:
+ dict: Dictionary containing loss values and other metrics for logging
+ """
+ step_log = {'loss': {}, 'status': {}}
+ # Set up context managers for mixed precision and elastic memory
+ amp_context = partial(torch.autocast, device_type='cuda') if self.fp16_mode == 'amp' else nullcontext
+ elastic_controller_context = self.elastic_controller.record if self.elastic_controller_config is not None else nullcontext
+
+ # Train
+ losses = []
+ statuses = []
+ elastic_controller_logs = []
+ zero_grad(self.model_params)
+ for i, mb_data in enumerate(data_list):
+ ## sync at the end of each batch split
+ sync_contexts = [self.training_models[name].no_sync for name in self.training_models] if i != len(data_list) - 1 and self.world_size > 1 else [nullcontext]
+ with nested_contexts(*sync_contexts), elastic_controller_context():
+ with amp_context():
+ # Forward pass - compute loss
+ # print("start training loss")
+ loss, status = self.training_losses(**mb_data)
+ # print("end training loss")
+ l = loss['loss'] / len(data_list)
+ ## backward
+ if self.fp16_mode == 'amp':
+ # AMP backward pass with scaling
+ self.scaler.scale(l).backward()
+ elif self.fp16_mode == 'inflat_all':
+ # Manual FP16 backward pass with scaling
+ scaled_l = l * (2 ** self.log_scale)
+ scaled_l.backward()
+ else:
+ # Standard backward pass
+ l.backward()
+ ## log
+ losses.append(dict_foreach(loss, lambda x: x.item() if isinstance(x, torch.Tensor) else x))
+ statuses.append(dict_foreach(status, lambda x: x.item() if isinstance(x, torch.Tensor) else x))
+ if self.elastic_controller_config is not None:
+ elastic_controller_logs.append(self.elastic_controller.log())
+
+ ## gradient clip
+ if self.grad_clip is not None:
+ if self.fp16_mode == 'amp':
+ # Unscale before clipping for AMP
+ self.scaler.unscale_(self.optimizer)
+ elif self.fp16_mode == 'inflat_all':
+ # Convert and unscale gradients for manual FP16
+ model_grads_to_master_grads(self.model_params, self.master_params)
+ self.master_params[0].grad.mul_(1.0 / (2 ** self.log_scale))
+
+ # Apply gradient clipping
+ if isinstance(self.grad_clip, float):
+ grad_norm = torch.nn.utils.clip_grad_norm_(self.master_params, self.grad_clip)
+ else:
+ grad_norm = self.grad_clip(self.master_params)
+ if torch.isfinite(grad_norm):
+ statuses[-1]['grad_norm'] = grad_norm.item()
+
+ ## step
+ if self.fp16_mode == 'amp':
+ # AMP optimizer step with scale adjustment
+ prev_scale = self.scaler.get_scale()
+ self.scaler.step(self.optimizer)
+ self.scaler.update()
+ elif self.fp16_mode == 'inflat_all':
+ # Manual FP16 step with overflow detection and scale adjustment
+ prev_scale = 2 ** self.log_scale
+ if not any(not p.grad.isfinite().all() for p in self.model_params):
+ if self.grad_clip is None:
+ model_grads_to_master_grads(self.model_params, self.master_params)
+ self.master_params[0].grad.mul_(1.0 / (2 ** self.log_scale))
+ self.optimizer.step()
+ master_params_to_model_params(self.model_params, self.master_params)
+ self.log_scale += self.fp16_scale_growth
+ else:
+ self.log_scale -= 1
+ else:
+ # Standard optimizer step with NaN detection
+ prev_scale = 1.0
+ if not any(not p.grad.isfinite().all() for p in self.model_params):
+ self.optimizer.step()
+ else:
+ print('\n\033[93mWarning: NaN detected in gradients. Skipping update.\033[0m')
+
+ ## adjust learning rate
+ if self.lr_scheduler_config is not None:
+ statuses[-1]['lr'] = self.lr_scheduler.get_last_lr()[0]
+ self.lr_scheduler.step()
+
+ # Logs
+ step_log['loss'] = dict_reduce(losses, lambda x: np.mean(x))
+ step_log['status'] = dict_reduce(statuses, lambda x: np.mean(x), special_func={'min': lambda x: np.min(x), 'max': lambda x: np.max(x)})
+ if self.elastic_controller_config is not None:
+ step_log['elastic'] = dict_reduce(elastic_controller_logs, lambda x: np.mean(x))
+ if self.grad_clip is not None:
+ step_log['grad_clip'] = self.grad_clip if isinstance(self.grad_clip, float) else self.grad_clip.log()
+
+ # Check grad and norm of each param
+ if self.log_param_stats:
+ param_norms = {}
+ param_grads = {}
+ for name, param in self.backbone.named_parameters():
+ if param.requires_grad:
+ param_norms[name] = param.norm().item()
+ if param.grad is not None and torch.isfinite(param.grad).all():
+ param_grads[name] = param.grad.norm().item() / prev_scale
+ step_log['param_norms'] = param_norms
+ step_log['param_grads'] = param_grads
+
+ # Update exponential moving average
+ if self.is_master:
+ self.update_ema()
+
+ return step_log
diff --git a/OmniPart/training/trainers/flow_matching/flow_matching.py b/OmniPart/training/trainers/flow_matching/flow_matching.py
new file mode 100644
index 0000000..96d8c91
--- /dev/null
+++ b/OmniPart/training/trainers/flow_matching/flow_matching.py
@@ -0,0 +1,540 @@
+"""
+Flow Matching Trainer Implementation
+
+This file implements trainers for diffusion models using the flow matching objective.
+Flow matching is a generative modeling technique that defines a continuous path between
+a noise distribution and the data distribution, and trains models to learn the velocity field
+of this path. Unlike traditional diffusion models that learn to denoise, flow matching directly
+learns the vector field that transforms noise to data samples.
+
+The file contains several trainer classes:
+1. FlowMatchingTrainer: Base trainer for flow matching
+2. FlowMatchingCFGTrainer: Adds classifier-free guidance support
+3. TextConditionedFlowMatchingCFGTrainer: Supports text conditioning with CFG
+4. ImageConditionedFlowMatchingCFGTrainer: Supports image conditioning with CFG
+"""
+
+from typing import *
+import copy
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+import numpy as np
+from easydict import EasyDict as edict
+
+from ..basic import BasicTrainer
+from ...pipelines import samplers
+from ...utils.general_utils import dict_reduce
+from .mixins.classifier_free_guidance import ClassifierFreeGuidanceMixin
+from .mixins.text_conditioned import TextConditionedMixin
+from .mixins.image_conditioned import ImageConditionedMixin
+
+
+class FlowMatchingTrainer(BasicTrainer):
+ """
+ Trainer for diffusion model with flow matching objective.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ """
+ def __init__(
+ self,
+ *args,
+ t_schedule: dict = {
+ 'name': 'logitNormal',
+ 'args': {
+ 'mean': 0.0,
+ 'std': 1.0,
+ }
+ },
+ sigma_min: float = 1e-5,
+ **kwargs
+ ):
+ # Initialize the parent class with all args and kwargs
+ super().__init__(*args, **kwargs)
+ # Store time schedule configuration for sampling timesteps
+ self.t_schedule = t_schedule
+ # Store minimum sigma value to prevent numerical instability
+ self.sigma_min = sigma_min
+
+ def diffuse(self, x_0: torch.Tensor, t: torch.Tensor, noise: Optional[torch.Tensor] = None) -> torch.Tensor:
+ """
+ Diffuse the data for a given number of diffusion steps.
+ In other words, sample from q(x_t | x_0).
+
+ Args:
+ x_0: The [N x C x ...] tensor of noiseless inputs.
+ t: The [N] tensor of diffusion steps [0-1].
+ noise: If specified, use this noise instead of generating new noise.
+
+ Returns:
+ x_t, the noisy version of x_0 under timestep t.
+ """
+ # Generate random noise if none is provided
+ if noise is None:
+ noise = torch.randn_like(x_0)
+ assert noise.shape == x_0.shape, "noise must have same shape as x_0"
+
+ # Reshape t to broadcast correctly across spatial dimensions
+ t = t.view(-1, *[1 for _ in range(len(x_0.shape) - 1)])
+ # Interpolate between clean data and noise based on timestep
+ # Apply minimum sigma to ensure stability at t=1
+ x_t = (1 - t) * x_0 + (self.sigma_min + (1 - self.sigma_min) * t) * noise
+
+ return x_t
+
+ def reverse_diffuse(self, x_t: torch.Tensor, t: torch.Tensor, noise: torch.Tensor) -> torch.Tensor:
+ """
+ Get original image from noisy version under timestep t.
+
+ Args:
+ x_t: The noisy tensor at timestep t.
+ t: The timestep values [0-1].
+ noise: The noise component to remove.
+
+ Returns:
+ x_0: The recovered clean data.
+ """
+ assert noise.shape == x_t.shape, "noise must have same shape as x_t"
+ # Reshape t for proper broadcasting
+ t = t.view(-1, *[1 for _ in range(len(x_t.shape) - 1)])
+ # Invert the diffusion process to recover x_0
+ x_0 = (x_t - (self.sigma_min + (1 - self.sigma_min) * t) * noise) / (1 - t)
+ return x_0
+
+ def get_v(self, x_0: torch.Tensor, noise: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
+ """
+ Compute the velocity of the diffusion process at time t.
+
+ Args:
+ x_0: Clean data input.
+ noise: Noise input.
+ t: Timestep values.
+
+ Returns:
+ v: Velocity vector field at time t.
+ """
+ # The velocity is the time derivative of the path from data to noise
+ return (1 - self.sigma_min) * noise - x_0
+
+ def get_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data.
+
+ Args:
+ cond: Conditioning inputs.
+ kwargs: Additional arguments.
+
+ Returns:
+ Processed conditioning data.
+ """
+ # print(f"debugging get_cond shape {cond.shape}")
+ return cond
+
+ def get_inference_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data for inference.
+
+ Args:
+ cond: Conditioning inputs.
+ kwargs: Additional arguments for inference.
+
+ Returns:
+ Dictionary with conditioning data and additional arguments.
+ """
+ # print("debugging get_inference_cond")
+ # print(cond)
+ # print(kwargs)
+
+ return {'cond': cond, **kwargs}
+
+ def get_sampler(self, **kwargs) -> samplers.FlowEulerSampler:
+ """
+ Get the sampler for the diffusion process.
+
+ Args:
+ kwargs: Additional arguments for sampler.
+
+ Returns:
+ A flow-based sampler for generating samples.
+ """
+ return samplers.FlowEulerSampler(self.sigma_min)
+
+ def vis_cond(self, **kwargs):
+ """
+ Visualize the conditioning data.
+
+ Args:
+ kwargs: Arguments containing conditioning data.
+
+ Returns:
+ Dictionary with visualization data (empty by default).
+ """
+ return {}
+
+ def sample_t(self, batch_size: int) -> torch.Tensor:
+ """
+ Sample timesteps based on the configured time schedule.
+
+ Args:
+ batch_size: Number of timesteps to sample.
+
+ Returns:
+ Tensor of timestep values in range [0, 1].
+ """
+ if self.t_schedule['name'] == 'uniform':
+ # Uniform sampling between 0 and 1
+ t = torch.rand(batch_size)
+ elif self.t_schedule['name'] == 'logitNormal':
+ # Logit-normal distribution for timestep sampling
+ # Gives more samples near 0 and 1 than uniform
+ mean = self.t_schedule['args']['mean']
+ std = self.t_schedule['args']['std']
+ t = torch.sigmoid(torch.randn(batch_size) * std + mean)
+ else:
+ raise ValueError(f"Unknown t_schedule: {self.t_schedule['name']}")
+ return t
+
+ def training_losses(
+ self,
+ x_0: torch.Tensor,
+ cond=None,
+ **kwargs
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses for a single timestep.
+
+ Args:
+ x_0: The [N x C x ...] tensor of noiseless inputs.
+ cond: The [N x ...] tensor of additional conditions.
+ kwargs: Additional arguments to pass to the backbone.
+
+ Returns:
+ A dict with the key "loss" containing a tensor of shape [N],
+ may also contain other keys for different terms.
+ """
+ # Generate random noise for diffusion
+ noise = torch.randn_like(x_0)
+ # Sample random timesteps for training
+ t = self.sample_t(x_0.shape[0]).to(x_0.device).float()
+ # Diffuse the clean data to timestep t
+ x_t = self.diffuse(x_0, t, noise=noise)
+ # print("cond shape ", cond.shape)
+ # Process conditioning information
+ cond = self.get_cond(cond, **kwargs)
+
+ # print(f"FlowMatchingTrainer cond: {cond.shape}")
+
+ # Get model's prediction of the velocity field
+ # Multiply t by 1000 to match model's expected timestep scale
+ pred = self.training_models['denoiser'](x_t, t * 1000, cond, **kwargs)
+ assert pred.shape == noise.shape == x_0.shape
+
+ # Compute the target velocity vector field
+ target = self.get_v(x_0, noise, t)
+
+ # Calculate loss terms
+ terms = edict()
+ terms["mse"] = F.mse_loss(pred, target)
+ terms["loss"] = terms["mse"] # Total loss is just MSE for basic flow matching
+
+ # Calculate per-time-bin losses for analysis
+ mse_per_instance = np.array([
+ F.mse_loss(pred[i], target[i]).item()
+ for i in range(x_0.shape[0])
+ ])
+ # Divide time range [0,1] into 10 bins and log loss per bin
+ time_bin = np.digitize(t.cpu().numpy(), np.linspace(0, 1, 11)) - 1
+ for i in range(10):
+ if (time_bin == i).sum() != 0:
+ terms[f"bin_{i}"] = {"mse": mse_per_instance[time_bin == i].mean()}
+
+ return terms, {}
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ """
+ Generate samples for visualization during training.
+
+ Args:
+ num_samples: Total number of samples to generate.
+ batch_size: Batch size for generation.
+ verbose: Whether to print progress information.
+
+ Returns:
+ Dictionary with generated samples and ground truth data.
+ """
+ # Create a dataloader to get ground truth samples
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # Get the sampler for inference
+ sampler = self.get_sampler()
+ sample_gt = [] # Ground truth samples
+ sample = [] # Generated samples
+ cond_vis = [] # Visualization of conditioning
+
+ # Generate samples in batches
+ for i in range(0, num_samples, batch_size):
+ batch = min(batch_size, num_samples - i)
+ data = next(iter(dataloader))
+ # print("data is instance")
+
+ # Move data to GPU and slice to current batch size
+ data = {k: v[:batch].cuda() if isinstance(v, torch.Tensor) else v[:batch] for k, v in data.items()}
+
+ # print("data is instance2")
+ # Generate random noise for sampling start point
+ noise = torch.randn_like(data['x_0'])
+ # Store ground truth data
+ sample_gt.append(data['x_0'])
+ # Prepare conditioning visualization
+ cond_vis.append(self.vis_cond(**data))
+
+ # print("data is instance3")
+
+ # Remove ground truth from conditioning data
+ del data['x_0']
+
+ # print("data['cond'] shape ", data['cond'].shape) # torch.Size([4, 3, 3, 518, 518])
+ # print("data is instance4.5")
+ # for k, v in data.items():
+ # print(f"data {k} value shape {len(v)}")
+ # for i in v:
+ # print(f"{i.shape}")
+ # data cond value shape 4
+ # torch.Size([3, 3, 518, 518])
+ # torch.Size([3, 3, 518, 518])
+ # torch.Size([3, 3, 518, 518])
+ # torch.Size([3, 3, 518, 518])
+ # print(**data)
+ # Get conditioning for inference
+ args = self.get_inference_cond(**data)
+ # args['cond']
+ # print("args['cond'] shape ", args['cond'].shape) # torch.Size([4, 4122, 1024])
+ # print("data is instance4")
+ # Run the sampler to generate samples
+ res = sampler.sample(
+ self.models['denoiser'],
+ noise=noise,
+ **args,
+ steps=50, # Number of sampling steps
+ cfg_strength=3.0, # Classifier-free guidance strength
+ verbose=verbose, # Whether to display progress
+ )
+ # print("data is instance5")
+ # Store generated samples
+ sample.append(res.samples)
+
+ # Concatenate batches of samples
+ sample_gt = torch.cat(sample_gt, dim=0)
+ sample = torch.cat(sample, dim=0)
+
+ # print("sample shape ", sample.shape)
+
+ # Prepare results dictionary
+ sample_dict = {
+ 'sample_gt': {'value': sample_gt, 'type': 'sample'},
+ 'sample': {'value': sample, 'type': 'sample'},
+ }
+ # print("cond vis ", cond_vis)
+ # raise NotImplementedError("Debugging sample_dict")
+ # Add conditioning visualizations
+ sample_dict.update(dict_reduce(cond_vis, None, {
+ 'value': lambda x: torch.cat(x, dim=0),
+ 'type': lambda x: x[0],
+ }))
+
+ # print("run snapshot done")
+ # Debug function to print shapes of all values in nested dictionaries
+
+ # Print all shapes in the sample_dict
+ # print("Sample dictionary structure and shapes:")
+ # sample_gt:
+ # tensor with shape torch.Size([64, 8, 16, 16, 16])
+ # sample
+ # sample:
+ # tensor with shape torch.Size([64, 8, 16, 16, 16])
+ # sample
+ # image:
+ # tensor with shape torch.Size([64, 3, 3, 518, 518])
+ # image
+
+ # Sample dictionary structure and shapes:
+ # sample_gt:
+ # tensor with shape torch.Size([64, 8, 16, 16, 16])
+ # sample
+ # sample:
+ # tensor with shape torch.Size([64, 8, 16, 16, 16])
+ # sample
+ # image:
+ # image
+ # tensor with shape torch.Size([64, 3, 518, 518])
+ # print("Sample dictionary structure and shapes:")
+ # for key, value in sample_dict.items():
+ # print(f"{key}: ")
+ # for k, v in value.items():
+ # # print(f" {k.shape}: {v}")
+ # if k == 'type':
+ # print(v)
+ # elif k == 'value':
+ # print(f"tensor with shape {v.shape}")
+
+ return sample_dict
+
+
+class FlowMatchingCFGTrainer(ClassifierFreeGuidanceMixin, FlowMatchingTrainer):
+ """
+ Trainer for diffusion model with flow matching objective and classifier-free guidance.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ """
+ pass
+
+
+class TextConditionedFlowMatchingCFGTrainer(TextConditionedMixin, FlowMatchingCFGTrainer):
+ """
+ Trainer for text-conditioned diffusion model with flow matching objective and classifier-free guidance.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ text_cond_model(str): Text conditioning model.
+ """
+ pass
+
+
+class ImageConditionedFlowMatchingCFGTrainer(ImageConditionedMixin, FlowMatchingCFGTrainer):
+ """
+ Trainer for image-conditioned diffusion model with flow matching objective and classifier-free guidance.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ image_cond_model (str): Image conditioning model.
+ """
+ pass
diff --git a/OmniPart/training/trainers/flow_matching/mixins/classifier_free_guidance.py b/OmniPart/training/trainers/flow_matching/mixins/classifier_free_guidance.py
new file mode 100644
index 0000000..438e406
--- /dev/null
+++ b/OmniPart/training/trainers/flow_matching/mixins/classifier_free_guidance.py
@@ -0,0 +1,140 @@
+"""
+Classifier-Free Guidance Mixin for Flow Matching Models
+
+This file implements a mixin class that adds classifier-free guidance capabilities to flow matching models.
+Classifier-free guidance is a technique that combines conditional and unconditional generation to improve
+sample quality and control. This mixin provides functionality for training with randomly dropped conditions
+and for sampling with guidance during inference.
+"""
+
+import torch
+import numpy as np
+from ....utils.general_utils import dict_foreach
+from ....pipelines import samplers
+
+
+class ClassifierFreeGuidanceMixin:
+ def __init__(self, *args, p_uncond: float = 0.1, **kwargs):
+ """
+ Initialize the ClassifierFreeGuidanceMixin.
+
+ Args:
+ p_uncond: Probability of using the unconditional branch during training.
+ Higher values mean more unconditional training.
+ *args, **kwargs: Arguments to pass to the parent class.
+ """
+ super().__init__(*args, **kwargs)
+ self.p_uncond = p_uncond
+
+ def get_cond(self, cond, neg_cond=None, **kwargs):
+ """
+ Get the conditioning data for training with classifier-free guidance.
+ Randomly replaces conditioning with negative conditioning based on p_uncond.
+
+ Args:
+ cond: The positive conditioning data.
+ neg_cond: The negative conditioning data (usually null/empty conditioning).
+ **kwargs: Additional arguments.
+
+ Returns:
+ Modified conditioning data with some entries replaced by negative conditioning.
+ """
+ # print(f"=== get_cond called ===")
+ # print(f"p_uncond: {self.p_uncond}") # p_uncond: 0.1
+ # print(f"cond type: {type(cond)}")
+ # print(f"cond shape: {cond.shape if isinstance(cond, torch.Tensor) else 'N/A'}") # cond shape: torch.Size([2, 1374, 1024])
+ # print(f"neg_cond type: {type(neg_cond)}")
+
+ assert neg_cond is not None, "neg_cond must be provided for classifier-free guidance"
+
+ if self.p_uncond > 0:
+ # print(f"p_uncond > 0, applying classifier-free guidance training")
+
+ # Helper function to determine batch size from conditioning data
+ def get_batch_size(cond):
+ if isinstance(cond, torch.Tensor):
+ # print(f" cond is tensor with shape {cond.shape}") # ond is tensor with shape torch.Size([2, 1374, 1024])
+ return cond.shape[0]
+ elif isinstance(cond, list):
+ # print(f" cond is list with length {len(cond)}")
+ return len(cond)
+ else:
+ raise ValueError(f"Unsupported type of cond: {type(cond)}")
+
+ # Get the batch size from the first available conditioning element
+ ref_cond = cond if not isinstance(cond, dict) else cond[list(cond.keys())[0]]
+ # print(f"Getting batch size from ref_cond of type: {type(ref_cond)}")
+ B = get_batch_size(ref_cond)
+ # print(f"Determined batch size: {B}") # Determined batch size: 2
+
+ # Helper function to selectively replace conditioning with negative conditioning
+ def select(cond, neg_cond, mask):
+ # print(f" select called with cond type: {type(cond)}, neg_cond type: {type(neg_cond)}")
+ if isinstance(cond, torch.Tensor):
+ # For tensor data, use torch.where for efficient conditional replacement
+ # print(f" Processing tensor with shape {cond.shape}")
+ mask_tensor = torch.tensor(mask, device=cond.device).reshape(-1, *[1] * (cond.ndim - 1))
+ # print(f" Mask shape: {mask_tensor.shape}, replacing {sum(mask)}/{len(mask)} samples")
+ return torch.where(mask_tensor, neg_cond, cond)
+ elif isinstance(cond, list):
+ # For list data, use list comprehension to selectively replace elements
+ # print(f" Processing list with length {len(cond)}, replacing {sum(mask)}/{len(mask)} samples")
+ return [nc if m else c for c, nc, m in zip(cond, neg_cond, mask)]
+ else:
+ raise ValueError(f"Unsupported type of cond: {type(cond)}")
+
+ # Generate random mask for which samples to replace with negative conditioning
+ mask = list(np.random.rand(B) < self.p_uncond)
+ # print(f"Generated mask: {mask}") # Generated mask: [False, True]
+ # print(f"Will replace {sum(mask)}/{len(mask)} samples with negative conditioning")
+
+ # Apply the conditioning replacement based on data type
+ # print(f"Applying conditioning replacement...")
+ if not isinstance(cond, dict):
+ # print(f"Direct conditioning (non-dict) replacement")
+ # import pdb; pdb.set_trace()
+ cond = select(cond, neg_cond, mask)
+ ordered_mask_dino = kwargs.get('ordered_mask_dino', None)
+ if ordered_mask_dino is not None:
+ neg_mask = torch.zeros_like(ordered_mask_dino)
+ ordered_mask_dino = select(ordered_mask_dino, neg_mask, mask)
+ else:
+ # print(f"Dict conditioning with keys: {list(cond.keys())}")
+ # For dictionary conditioning, apply the operation to each key-value pair
+ cond = dict_foreach([cond, neg_cond], lambda x: select(x[0], x[1], mask))
+ # print(f"Completed dict_foreach with resulting keys: {list(cond.keys())}")
+ else:
+ print(f"p_uncond = {self.p_uncond}, skipping classifier-free guidance")
+
+ # print(f"final cond shape: {cond.shape}") # final cond shape: torch.Size([2, 1374, 1024])
+
+ # print(f"=== get_cond returning ===")
+ return cond, ordered_mask_dino
+
+ def get_inference_cond(self, cond, neg_cond=None, **kwargs):
+ """
+ Get the conditioning data prepared for inference with classifier-free guidance.
+ During inference, we need both conditional and unconditional branches.
+
+ Args:
+ cond: The positive conditioning data.
+ neg_cond: The negative/null conditioning data.
+ **kwargs: Additional arguments.
+
+ Returns:
+ Dictionary containing both positive and negative conditioning for the sampler.
+ """
+ assert neg_cond is not None, "neg_cond must be provided for classifier-free guidance"
+ return {'cond': cond, 'neg_cond': neg_cond, **kwargs}
+
+ def get_sampler(self, **kwargs) -> samplers.FlowEulerCfgSampler:
+ """
+ Get the specialized sampler for classifier-free guidance flow matching.
+
+ Args:
+ **kwargs: Additional arguments to pass to the sampler.
+
+ Returns:
+ An instance of FlowEulerCfgSampler configured with the model's sigma_min.
+ """
+ return samplers.FlowEulerCfgSampler(self.sigma_min)
diff --git a/OmniPart/training/trainers/flow_matching/mixins/image_conditioned.py b/OmniPart/training/trainers/flow_matching/mixins/image_conditioned.py
new file mode 100644
index 0000000..0d0a402
--- /dev/null
+++ b/OmniPart/training/trainers/flow_matching/mixins/image_conditioned.py
@@ -0,0 +1,230 @@
+"""
+Image Conditioned Mixin for Flow Matching Models in TRELLIS
+
+This file defines a mixin class that adds image conditioning functionality to flow matching models.
+It provides methods for encoding images using pre-trained DINOv2 vision transformer models,
+which allows the models to condition their generation process on input images.
+The mixin handles image preprocessing, feature extraction, and conditioning integration.
+"""
+
+from typing import *
+import torch
+import torch.nn.functional as F
+from torchvision import transforms
+import numpy as np
+from PIL import Image
+
+from ....utils import dist_utils
+
+
+class ImageConditionedMixin:
+ """
+ Mixin for image-conditioned models.
+
+ This class provides functionality to condition models on image inputs using a pre-trained
+ vision transformer model (DINOv2 by default). It handles image preprocessing, feature extraction,
+ and conditioning integration into the parent model's pipeline.
+
+ Args:
+ image_cond_model: The image conditioning model name to use from the DINOv2 family.
+ Default is 'dinov2_vitl14_reg'.
+ """
+ def __init__(self, *args, image_cond_model: str = 'dinov2_vitl14_reg', **kwargs):
+ super().__init__(*args, **kwargs)
+ self.image_cond_model_name = image_cond_model
+ # The model is initialized lazily to save resources until needed
+ self.image_cond_model = None
+
+ @staticmethod
+ def prepare_for_training(image_cond_model: str, **kwargs):
+ """
+ Prepare for training by pre-downloading the required models.
+
+ This static method ensures the DINOv2 model is downloaded before training starts,
+ which helps prevent issues during distributed training.
+
+ Args:
+ image_cond_model: Name of the DINOv2 model to download.
+ **kwargs: Additional arguments passed to parent class's prepare_for_training if it exists.
+ """
+ if hasattr(super(ImageConditionedMixin, ImageConditionedMixin), 'prepare_for_training'):
+ super(ImageConditionedMixin, ImageConditionedMixin).prepare_for_training(**kwargs)
+ # Download the model in advance to avoid issues during distributed training
+ # torch.hub.load('facebookresearch/dinov2', image_cond_model, pretrained=True)
+
+ def _init_image_cond_model(self):
+ """
+ Initialize the image conditioning model.
+
+ Loads the DINOv2 model and sets up the necessary normalization transforms.
+ Uses distributed utils to ensure proper initialization across processes.
+ """
+ with dist_utils.local_master_first():
+ # Load the model only on the master process first, others will wait
+ # dinov2_model = torch.hub.load('facebookresearch/dinov2', self.image_cond_model_name, pretrained=True)
+ dinov2_model = torch.hub.load('/mnt/pfs/share/pretrained_model/.cache/torch/hub/facebookresearch_dinov2_main', self.image_cond_model_name, trust_repo=True, source='local')
+
+ # Move model to GPU and set to evaluation mode
+ dinov2_model.eval().cuda()
+
+ # Set up normalization transform with ImageNet mean and std
+ transform = transforms.Compose([
+ transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ])
+
+ # Store both model and transform for later use
+ self.image_cond_model = {
+ 'model': dinov2_model,
+ 'transform': transform,
+ }
+
+ @torch.no_grad()
+ def encode_image(self, image: Union[torch.Tensor, List[Image.Image], List[torch.Tensor]]) -> torch.Tensor:
+ """
+ Encode the image into feature representations using the DINOv2 model.
+
+ Args:
+ image: Either a batch of image tensors [B, C, H, W] or a list of PIL images.
+
+ Returns:
+ torch.Tensor: The patch token features from DINOv2.
+
+ Raises:
+ ValueError: If the image input is not a supported type.
+ """
+ # Initialize model if not already initialized
+ if self.image_cond_model is None:
+ self._init_image_cond_model()
+
+ # Handle different image input formats
+ if isinstance(image, torch.Tensor) and image.ndim == 4:
+ # Process 4D tensor (batch) at once without for loop
+ image = image.cuda()
+ image = self.image_cond_model['transform'](image)
+ features = self.image_cond_model['model'](image, is_training=True)['x_prenorm']
+ patchtokens = F.layer_norm(features, features.shape[-1:])
+ # print(f"shape of patchtokens: {patchtokens.shape}") # shape of patchtokens: torch.Size([4, 1374, 1024])
+ return patchtokens
+
+ elif isinstance(image, torch.Tensor) and image.ndim == 5:
+ if all(isinstance(i, torch.Tensor) for i in image):
+ # print("image is list of tensors")
+ image = image.cuda()
+ else:
+ raise ValueError("Image list should be either list of PIL images or list of tensors")
+
+ elif isinstance(image, list) and all(isinstance(i, Image.Image) for i in image):
+ # print("image is list of PIL images")
+ # Resize all images to 518x518 pixels using high-quality LANCZOS resampling
+ image = [i.resize((518, 518), Image.LANCZOS) for i in image]
+ # Convert images to RGB, transform to numpy arrays, convert to float32, and normalize pixel values to range [0,1]
+ image = [np.array(i.convert('RGB')).astype(np.float32) / 255 for i in image]
+ # Convert numpy arrays to PyTorch tensors and rearrange dimensions from (H,W,C) to (C,H,W) format required by PyTorch
+ image = [torch.from_numpy(i).permute(2, 0, 1).float() for i in image]
+ # Stack individual tensors into a batch and move to GPU for faster processing
+ image = torch.stack(image).cuda()
+ else:
+ raise ValueError(f"Unsupported type of image: {type(image)}")
+
+ # For non-4D tensor cases, process images one by one
+ patchtoken_list = []
+ # print(f"shape of image: {image.shape}") # shape of image: torch.Size([4, 3, 3, 518, 518])
+ for img in image:
+ # print(img.shape)
+ img = self.image_cond_model['transform'](img).cuda()
+ # print(f"shape of img: {img.shape}") # shape of img: torch.Size([4, 3, 518, 518])
+ features = self.image_cond_model['model'](img, is_training=True)['x_prenorm']
+ patchtokens = F.layer_norm(features, features.shape[-1:])
+ # print(f"shape of patchtokens: {patchtokens.shape}")
+ patchtoken_list.append(patchtokens)
+ # Concatenate the patch tokens along the batch dimension
+ # print(f"shape of patchtoken_list: {len(patchtoken_list)}")
+ patchtokens = torch.concat(patchtoken_list, dim=-2)
+ # print(f"shape of patchtokens: {patchtokens.shape}") # shape of patchtokens: torch.Size([4, 4122, 1024])
+ # raise ValueError(f"Unsupported type of image: {type(image)}")
+ return patchtokens
+ # shape of patchtokens: torch.Size([3, 1374, 1024])
+ # shape of patchtokens: torch.Size([3, 1374, 1024])
+ # shape of patchtokens: torch.Size([3, 1374, 1024])
+ # shape of patchtokens: torch.Size([3, 1374, 1024])
+ # shape of patchtoken_list: 4
+ # shape of patchtokens: torch.Size([3, 5496, 1024])
+
+ def get_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data for training.
+
+ Processes the input images through the DINOv2 encoder and prepares
+ both positive and negative conditioning data.
+
+ Args:
+ cond: Input images to condition on.
+ **kwargs: Additional conditioning parameters passed to parent class.
+
+ Returns:
+ Conditioning data processed by the parent class's get_cond method.
+ """
+ # print(f"shape of cond: {cond.shape}") # shape of cond: torch.Size([2, 3, 518, 518])
+ # if cond.ndim == 5:
+ # cond = cond.permute(1, 0, 2, 3, 4)
+ # print(f"shape of cond after permute: {cond.shape}") # shape of cond after permute: torch.Size([2, 3, 518, 518])
+ cond = self.encode_image(cond)
+ # print(f"shape of cond after encode: {cond.shape}") # shape of cond after encode: torch.Size([2, 1374, 1024])
+ # print(f"get cond shape: {cond.shape}") # get cond shape: torch.Size([2, 1374, 1024])
+ # Create negative conditioning as zeros (used for classifier-free guidance)
+ kwargs['neg_cond'] = torch.zeros_like(cond)
+ kwargs['neg_mask'] = torch.zeros_like(kwargs['ordered_mask_dino'])
+ cond = super().get_cond(cond, **kwargs)
+ # print(f"get cond done shape: {cond.shape}") # get cond done shape: torch.Size([2, 1374, 1024])
+ return cond
+
+ def get_inference_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data for inference.
+
+ Similar to get_cond but specifically used during inference/generation.
+
+ Args:
+ cond: Input images to condition on.
+ **kwargs: Additional conditioning parameters passed to parent class.
+
+ Returns:
+ Conditioning data processed by the parent class's get_inference_cond method.
+ """
+ # print(f"get inference cond: {cond}")
+ # print(kwargs)
+ # cond.shape torch.Size([4, 3, 3, 518, 518])
+ # if cond.ndim == 5:
+ # cond = cond.permute(1, 0, 2, 3, 4)
+ # cond.shape torch.Size([3, 4, 3, 518, 518])
+ cond = self.encode_image(cond)
+ # torch.Size([4, 4122, 1024])
+ # print(f"get inference cond2222")
+ # Create negative conditioning as zeros (used for classifier-free guidance)
+ kwargs['neg_cond'] = torch.zeros_like(cond)
+ kwargs['neg_mask'] = torch.zeros_like(kwargs['ordered_mask_dino'])
+ # print("get inference cond done2")
+ # print(f"{kwargs}")
+ cond = super().get_inference_cond(cond, **kwargs)
+ # print("get_inference_cond done")
+ # print("shape of cond: ", cond.shape)
+ return cond
+
+ def vis_cond(self, cond, **kwargs):
+ """
+ Visualize the conditioning data.
+
+ Prepares the conditioning data for visualization, typically used for debugging
+ or monitoring the model's behavior.
+
+ Args:
+ cond: The conditioning image data.
+ **kwargs: Additional visualization parameters.
+
+ Returns:
+ dict: Dictionary containing the image data and its type for visualization.
+ """
+ if isinstance(cond, torch.Tensor):
+ return {'image': {'value': cond, 'type': 'image'}}
+ else:
+ raise ValueError(f"Unsupported type of cond: {type(cond)}")
diff --git a/OmniPart/training/trainers/flow_matching/mixins/text_conditioned.py b/OmniPart/training/trainers/flow_matching/mixins/text_conditioned.py
new file mode 100644
index 0000000..85f1dcf
--- /dev/null
+++ b/OmniPart/training/trainers/flow_matching/mixins/text_conditioned.py
@@ -0,0 +1,68 @@
+from typing import *
+import os
+os.environ['TOKENIZERS_PARALLELISM'] = 'true'
+import torch
+from transformers import AutoTokenizer, CLIPTextModel
+
+from ....utils import dist_utils
+
+
+class TextConditionedMixin:
+ """
+ Mixin for text-conditioned models.
+
+ Args:
+ text_cond_model: The text conditioning model.
+ """
+ def __init__(self, *args, text_cond_model: str = 'openai/clip-vit-large-patch14', **kwargs):
+ super().__init__(*args, **kwargs)
+ self.text_cond_model_name = text_cond_model
+ self.text_cond_model = None # the model is init lazily
+
+ def _init_text_cond_model(self):
+ """
+ Initialize the text conditioning model.
+ """
+ # load model
+ with dist_utils.local_master_first():
+ model = CLIPTextModel.from_pretrained(self.text_cond_model_name)
+ tokenizer = AutoTokenizer.from_pretrained(self.text_cond_model_name)
+ model.eval()
+ model = model.cuda()
+ self.text_cond_model = {
+ 'model': model,
+ 'tokenizer': tokenizer,
+ }
+ self.text_cond_model['null_cond'] = self.encode_text([''])
+
+ @torch.no_grad()
+ def encode_text(self, text: List[str]) -> torch.Tensor:
+ """
+ Encode the text.
+ """
+ assert isinstance(text, list) and isinstance(text[0], str), "TextConditionedMixin only supports list of strings as cond"
+ if self.text_cond_model is None:
+ self._init_text_cond_model()
+ encoding = self.text_cond_model['tokenizer'](text, max_length=77, padding='max_length', truncation=True, return_tensors='pt')
+ tokens = encoding['input_ids'].cuda()
+ embeddings = self.text_cond_model['model'](input_ids=tokens).last_hidden_state
+
+ return embeddings
+
+ def get_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data.
+ """
+ cond = self.encode_text(cond)
+ kwargs['neg_cond'] = self.text_cond_model['null_cond'].repeat(cond.shape[0], 1, 1)
+ cond = super().get_cond(cond, **kwargs)
+ return cond
+
+ def get_inference_cond(self, cond, **kwargs):
+ """
+ Get the conditioning data for inference.
+ """
+ cond = self.encode_text(cond)
+ kwargs['neg_cond'] = self.text_cond_model['null_cond'].repeat(cond.shape[0], 1, 1)
+ cond = super().get_inference_cond(cond, **kwargs)
+ return cond
diff --git a/OmniPart/training/trainers/flow_matching/sparse_flow_matching.py b/OmniPart/training/trainers/flow_matching/sparse_flow_matching.py
new file mode 100644
index 0000000..73ec209
--- /dev/null
+++ b/OmniPart/training/trainers/flow_matching/sparse_flow_matching.py
@@ -0,0 +1,398 @@
+"""
+Sparse Flow Matching Trainer Implementation
+
+This file implements trainers for sparse generative models using flow matching objectives.
+Flow matching is a technique for generative modeling that defines probability flows between
+noise and data distributions. This implementation specifically handles sparse data structures,
+which are common in 3D point clouds, graphs, and other non-dense representations.
+
+The file contains multiple trainer classes:
+- SparseFlowMatchingTrainer: Base trainer for sparse flow matching models
+- SparseFlowMatchingCFGTrainer: Adds classifier-free guidance for improved generation
+- TextConditionedSparseFlowMatchingCFGTrainer: Enables text conditioning for sparse generation
+- ImageConditionedSparseFlowMatchingCFGTrainer: Enables image conditioning for sparse generation
+
+These trainers handle the training loop, loss calculation, data loading, and sampling for
+sparse flow matching models.
+"""
+
+from typing import *
+import os
+import copy
+import functools
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+import numpy as np
+from easydict import EasyDict as edict
+
+from ...modules import sparse as sp
+from ...utils.general_utils import dict_reduce
+from ...utils.data_utils import cycle, BalancedResumableSampler
+from .flow_matching import FlowMatchingTrainer
+from .mixins.classifier_free_guidance import ClassifierFreeGuidanceMixin
+from .mixins.text_conditioned import TextConditionedMixin
+from .mixins.image_conditioned import ImageConditionedMixin
+
+
+class SparseFlowMatchingTrainer(FlowMatchingTrainer):
+ """
+ Trainer for sparse diffusion model with flow matching objective.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ """
+
+ def prepare_dataloader(self, **kwargs):
+ """
+ Prepare dataloader for training.
+
+ This method initializes the data sampler and dataloader with proper configurations
+ for efficient batch processing. It uses BalancedResumableSampler to ensure training
+ can be resumed from checkpoints, and sets up an infinite iterator over the data.
+ """
+ print("original dataset size:", len(self.dataset))
+ num_dataset = 128
+ # Wrap your dataset in the DuplicatedDataset if it's too small
+ # print(f"Dataset size: {len(self.dataset)}")
+ if len(self.dataset) < num_dataset: # Adjust this threshold as needed
+ from ...utils.data_utils import DuplicatedDataset
+
+ self.dataset = DuplicatedDataset(self.dataset, repeat=num_dataset)
+ print(f"Dataset duplicated to {len(self.dataset)} samples")
+
+ # print("data_sampler:")
+ # Create a sampler that can be resumed from checkpoints
+ self.data_sampler = BalancedResumableSampler(
+ self.dataset,
+ shuffle=True,
+ batch_size=self.batch_size_per_gpu,
+ )
+
+ # Create the dataloader with optimized settings
+ self.dataloader = DataLoader(
+ self.dataset,
+ batch_size=self.batch_size_per_gpu,
+ num_workers=int(np.ceil(os.cpu_count() / torch.cuda.device_count())), # Scale workers by GPU count
+ pin_memory=True, # Speed up CPU to GPU transfer
+ drop_last=True, # Ensure all batches are the same size
+ persistent_workers=True, # Keep workers alive between epochs for efficiency
+ collate_fn=functools.partial(self.dataset.collate_fn, split_size=self.batch_split),
+ sampler=self.data_sampler,
+ )
+
+ # Create an infinite data iterator to simplify training loop
+ self.data_iterator = cycle(self.dataloader)
+
+ def training_losses(
+ self,
+ x_0: sp.SparseTensor,
+ cond=None,
+ **kwargs
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses for a single timestep.
+
+ This method implements the flow matching training objective for sparse data.
+ It diffuses the input data according to the flow matching schedule,
+ predicts the velocity field, and computes the loss between the prediction and target.
+
+ Args:
+ x_0: The [N x ... x C] sparse tensor of the inputs.
+ cond: The [N x ...] tensor of additional conditions.
+ kwargs: Additional arguments to pass to the backbone.
+
+ Returns:
+ A tuple containing:
+ - terms: Dictionary with the key "loss" and other loss components
+ - An empty dictionary (for compatibility with other trainers)
+ """
+ # Generate random noise with the same sparsity pattern as input
+ noise = x_0.replace(torch.randn_like(x_0.feats))
+
+ # Sample random timesteps for each item in the batch
+ t = self.sample_t(x_0.shape[0]).to(x_0.device).float()
+
+ # Apply diffusion process to get x_t
+ x_t = self.diffuse(x_0, t, noise=noise)
+
+ # Process conditional inputs if any
+ cond, ordered_mask_dino = self.get_cond(cond, **kwargs)
+ kwargs['ordered_mask_dino'] = ordered_mask_dino
+ # print(f"loss shape cond: {cond.shape}") # loss shape cond: torch.Size([2, 1374, 1024])
+
+ # Run model to predict velocity field
+ pred = self.training_models['denoiser'](x_t, t * 1000, cond, **kwargs)
+ # print(pred.shape, noise.shape, x_0.shape)
+ assert pred.shape == noise.shape == x_0.shape
+
+ # Calculate target vector field based on flow matching objective
+ target = self.get_v(x_0, noise, t)
+
+ # Compute loss terms
+ terms = edict()
+ terms["mse"] = F.mse_loss(pred.feats, target.feats)
+ terms["loss"] = terms["mse"]
+
+ # Log detailed loss statistics binned by timestep
+ mse_per_instance = np.array([
+ F.mse_loss(pred.feats[x_0.layout[i]], target.feats[x_0.layout[i]]).item()
+ for i in range(x_0.shape[0])
+ ])
+ # Divide time range [0,1] into 10 bins and compute per-bin statistics
+ time_bin = np.digitize(t.cpu().numpy(), np.linspace(0, 1, 11)) - 1
+ for i in range(10):
+ if (time_bin == i).sum() != 0:
+ terms[f"bin_{i}"] = {"mse": mse_per_instance[time_bin == i].mean()}
+
+ return terms, {}
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ """
+ Generate samples for visualization and evaluation.
+
+ This method creates samples from the model for visualization purposes. It processes
+ batches of data from the dataset, generates conditional samples, and organizes
+ them for logging and visualization.
+
+ Args:
+ num_samples: Number of samples to generate
+ batch_size: Batch size to use for generation
+ verbose: Whether to print progress information
+
+ Returns:
+ Dictionary containing generated samples, ground truth, and conditioning information
+ """
+ # Create a temporary dataloader for sampling
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0, # No parallelization for simplicity
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # Get the sampler for generation
+ sampler = self.get_sampler()
+
+ # Initialize lists to store results
+ sample_gt = [] # Ground truth samples
+ sample = [] # Generated samples
+ cond_vis = [] # Visualization of conditioning
+
+ part_layouts_list = []
+
+ # Generate samples in batches
+ for i in range(0, num_samples, batch_size):
+ # Get actual batch size (might be smaller for the last batch)
+ batch = min(batch_size, num_samples - i)
+
+ # Get a batch of data
+ data = next(iter(dataloader))
+ data = {k: v[:batch].cuda() if not isinstance(v, list) else v[:batch] for k, v in data.items()}
+
+ for layout in data['part_layouts']:
+ part_layouts_list.append(layout)
+
+ # Create initial noise with same sparsity pattern as input
+ noise = data['x_0'].replace(torch.randn_like(data['x_0'].feats))
+
+ # Store ground truth and conditioning visualization
+ sample_gt.append(data['x_0'])
+ cond_vis.append(self.vis_cond(**data))
+
+ # Remove ground truth from data dictionary
+ del data['x_0']
+
+ # Prepare conditioning for inference
+ args = self.get_inference_cond(**data)
+
+ # Generate samples using the sampler
+ res = sampler.sample(
+ self.models['denoiser'],
+ noise=noise,
+ **args,
+ steps=50, # Number of sampling steps
+ cfg_strength=3.0, # Classifier-free guidance strength
+ verbose=verbose,
+ )
+ sample.append(res.samples)
+
+ sample_gt = sp.sparse_cat(sample_gt)
+ sample = sp.sparse_cat(sample)
+
+ sample_dict = {
+ 'sample_gt': {'value': sample_gt, 'type': 'sample'}, # Ground truth
+ 'sample': {'value': sample, 'type': 'sample'}, # Generated samples
+ }
+
+ # Add conditioning visualization to dictionary
+ sample_dict.update(dict_reduce(cond_vis, None, {
+ 'value': lambda x: torch.cat(x, dim=0),
+ 'type': lambda x: x[0],
+ }))
+ sample_dict['layout'] = {'value': part_layouts_list, 'type': 'layout'}
+
+ return sample_dict
+
+
+class SparseFlowMatchingCFGTrainer(ClassifierFreeGuidanceMixin, SparseFlowMatchingTrainer):
+ """
+ Trainer for sparse diffusion model with flow matching objective and classifier-free guidance.
+
+ This class extends SparseFlowMatchingTrainer with classifier-free guidance capabilities,
+ which helps improve sample quality by learning both conditional and unconditional models.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ """
+ pass
+
+
+class TextConditionedSparseFlowMatchingCFGTrainer(TextConditionedMixin, SparseFlowMatchingCFGTrainer):
+ """
+ Trainer for sparse text-conditioned diffusion model with flow matching objective and classifier-free guidance.
+
+ This class adds text conditioning capabilities to the sparse flow matching trainer,
+ allowing the generation of sparse data conditioned on text prompts.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ text_cond_model(str): Text conditioning model.
+ """
+ pass
+
+
+class ImageConditionedSparseFlowMatchingCFGTrainer(ImageConditionedMixin, SparseFlowMatchingCFGTrainer):
+ """
+ Trainer for sparse image-conditioned diffusion model with flow matching objective and classifier-free guidance.
+
+ This class adds image conditioning capabilities to the sparse flow matching trainer,
+ allowing the generation of sparse data conditioned on input images.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ t_schedule (dict): Time schedule for flow matching.
+ sigma_min (float): Minimum noise level.
+ p_uncond (float): Probability of dropping conditions.
+ image_cond_model (str): Image conditioning model.
+ """
+ pass
diff --git a/OmniPart/training/trainers/utils.py b/OmniPart/training/trainers/utils.py
new file mode 100644
index 0000000..aa9cfb8
--- /dev/null
+++ b/OmniPart/training/trainers/utils.py
@@ -0,0 +1,97 @@
+import torch.nn as nn
+
+import open3d as o3d
+import numpy as np
+
+# FP16 utils
+from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
+
+def make_master_params(model_params):
+ """
+ Copy model parameters into a inflated tensor of full-precision parameters.
+ """
+ master_params = _flatten_dense_tensors(
+ [param.detach().float() for param in model_params]
+ )
+ master_params = nn.Parameter(master_params)
+ master_params.requires_grad = True
+ return [master_params]
+
+
+def unflatten_master_params(model_params, master_params):
+ """
+ Unflatten the master parameters to look like model_params.
+ """
+ return _unflatten_dense_tensors(master_params[0].detach(), model_params)
+
+
+def model_params_to_master_params(model_params, master_params):
+ """
+ Copy the model parameter data into the master parameters.
+ """
+ master_params[0].detach().copy_(
+ _flatten_dense_tensors([param.detach().float() for param in model_params])
+ )
+
+
+def master_params_to_model_params(model_params, master_params):
+ """
+ Copy the master parameter data back into the model parameters.
+ """
+ for param, master_param in zip(
+ model_params, _unflatten_dense_tensors(master_params[0].detach(), model_params)
+ ):
+ param.detach().copy_(master_param)
+
+
+def model_grads_to_master_grads(model_params, master_params):
+ """
+ Copy the gradients from the model parameters into the master parameters
+ from make_master_params().
+ """
+ master_params[0].grad = _flatten_dense_tensors(
+ [param.grad.data.detach().float() for param in model_params]
+ )
+
+
+def zero_grad(model_params):
+ for param in model_params:
+ if param.grad is not None:
+ if param.grad.grad_fn is not None:
+ param.grad.detach_()
+ else:
+ param.grad.requires_grad_(False)
+ param.grad.zero_()
+
+
+# LR Schedulers
+from torch.optim.lr_scheduler import LambdaLR
+
+class LinearWarmupLRScheduler(LambdaLR):
+ def __init__(self, optimizer, warmup_steps, last_epoch=-1):
+ self.warmup_steps = warmup_steps
+ super(LinearWarmupLRScheduler, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch)
+
+ def lr_lambda(self, current_step):
+ if current_step < self.warmup_steps:
+ return float(current_step + 1) / self.warmup_steps
+ return 1.0
+
+
+def save_ply(point_cloud, filename):
+ """
+ Save a point cloud to a PLY file.
+
+ Args:
+ point_cloud (o3d.geometry.PointCloud): The point cloud to save.
+ filename (str): The name of the output PLY file.
+ """
+ o3d.io.write_point_cloud(filename, point_cloud)
+
+ points = np.random.rand(100, 3)
+ colors = np.random.rand(100, 3)
+ point_cloud = o3d.geometry.PointCloud()
+ point_cloud.points = o3d.utility.Vector3dVector(points)
+ point_cloud.colors = o3d.utility.Vector3dVector(colors)
+
+ o3d.io.write_point_cloud("output.ply", point_cloud)
\ No newline at end of file
diff --git a/OmniPart/training/trainers/vae/sparse_structure_vae.py b/OmniPart/training/trainers/vae/sparse_structure_vae.py
new file mode 100644
index 0000000..5c0c418
--- /dev/null
+++ b/OmniPart/training/trainers/vae/sparse_structure_vae.py
@@ -0,0 +1,130 @@
+from typing import *
+import copy
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from easydict import EasyDict as edict
+
+from ..basic import BasicTrainer
+
+
+class SparseStructureVaeTrainer(BasicTrainer):
+ """
+ Trainer for Sparse Structure VAE.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ loss_type (str): Loss type. 'bce' for binary cross entropy, 'l1' for L1 loss, 'dice' for Dice loss.
+ lambda_kl (float): KL divergence loss weight.
+ """
+
+ def __init__(
+ self,
+ *args,
+ loss_type='bce',
+ lambda_kl=1e-6,
+ **kwargs
+ ):
+ super().__init__(*args, **kwargs)
+ self.loss_type = loss_type
+ self.lambda_kl = lambda_kl
+
+ def training_losses(
+ self,
+ ss: torch.Tensor,
+ **kwargs
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses.
+
+ Args:
+ ss: The [N x 1 x H x W x D] tensor of binary sparse structure.
+
+ Returns:
+ a dict with the key "loss" containing a scalar tensor.
+ may also contain other keys for different terms.
+ """
+ z, mean, logvar = self.training_models['encoder'](ss.float(), sample_posterior=True, return_raw=True)
+ logits = self.training_models['decoder'](z)
+
+ terms = edict(loss = 0.0)
+ if self.loss_type == 'bce':
+ terms["bce"] = F.binary_cross_entropy_with_logits(logits, ss.float(), reduction='mean')
+ terms["loss"] = terms["loss"] + terms["bce"]
+ elif self.loss_type == 'l1':
+ terms["l1"] = F.l1_loss(F.sigmoid(logits), ss.float(), reduction='mean')
+ terms["loss"] = terms["loss"] + terms["l1"]
+ elif self.loss_type == 'dice':
+ logits = F.sigmoid(logits)
+ terms["dice"] = 1 - (2 * (logits * ss.float()).sum() + 1) / (logits.sum() + ss.float().sum() + 1)
+ terms["loss"] = terms["loss"] + terms["dice"]
+ else:
+ raise ValueError(f'Invalid loss type {self.loss_type}')
+ terms["kl"] = 0.5 * torch.mean(mean.pow(2) + logvar.exp() - logvar - 1)
+ terms["loss"] = terms["loss"] + self.lambda_kl * terms["kl"]
+
+ return terms, {}
+
+ @torch.no_grad()
+ def snapshot(self, suffix=None, num_samples=64, batch_size=1, verbose=False):
+ super().snapshot(suffix=suffix, num_samples=num_samples, batch_size=batch_size, verbose=verbose)
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # inference
+ gts = []
+ recons = []
+ for i in range(0, num_samples, batch_size):
+ batch = min(batch_size, num_samples - i)
+ data = next(iter(dataloader))
+ args = {k: v[:batch].cuda() if isinstance(v, torch.Tensor) else v[:batch] for k, v in data.items()}
+ z = self.models['encoder'](args['ss'].float(), sample_posterior=False)
+ logits = self.models['decoder'](z)
+ recon = (logits > 0).long()
+ gts.append(args['ss'])
+ recons.append(recon)
+
+ sample_dict = {
+ 'gt': {'value': torch.cat(gts, dim=0), 'type': 'sample'},
+ 'recon': {'value': torch.cat(recons, dim=0), 'type': 'sample'},
+ }
+ return sample_dict
diff --git a/OmniPart/training/trainers/vae/structured_latent_vae_gaussian.py b/OmniPart/training/trainers/vae/structured_latent_vae_gaussian.py
new file mode 100644
index 0000000..29ff365
--- /dev/null
+++ b/OmniPart/training/trainers/vae/structured_latent_vae_gaussian.py
@@ -0,0 +1,275 @@
+from typing import *
+import copy
+import torch
+from torch.utils.data import DataLoader
+import numpy as np
+from easydict import EasyDict as edict
+import utils3d.torch
+
+from ..basic import BasicTrainer
+from ...representations import Gaussian
+from ...renderers import GaussianRenderer
+from ...modules.sparse import SparseTensor
+from ...utils.loss_utils import l1_loss, l2_loss, ssim, lpips
+
+
+class SLatVaeGaussianTrainer(BasicTrainer):
+ """
+ Trainer for structured latent VAE.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ loss_type (str): Loss type. Can be 'l1', 'l2'
+ lambda_ssim (float): SSIM loss weight.
+ lambda_lpips (float): LPIPS loss weight.
+ lambda_kl (float): KL loss weight.
+ regularizations (dict): Regularization config.
+ """
+
+ def __init__(
+ self,
+ *args,
+ loss_type: str = 'l1',
+ lambda_ssim: float = 0.2,
+ lambda_lpips: float = 0.2,
+ lambda_kl: float = 1e-6,
+ regularizations: Dict = {},
+ **kwargs
+ ):
+ super().__init__(*args, **kwargs)
+ self.loss_type = loss_type
+ self.lambda_ssim = lambda_ssim
+ self.lambda_lpips = lambda_lpips
+ self.lambda_kl = lambda_kl
+ self.regularizations = regularizations
+
+ self._init_renderer()
+
+ def _init_renderer(self):
+ rendering_options = {"near" : 0.8,
+ "far" : 1.6,
+ "bg_color" : 'random'}
+ self.renderer = GaussianRenderer(rendering_options)
+ self.renderer.pipe.kernel_size = self.models['decoder'].rep_config['2d_filter_kernel_size']
+
+ def _render_batch(self, reps: List[Gaussian], extrinsics: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+ """
+ Render a batch of representations.
+
+ Args:
+ reps: The dictionary of lists of representations.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+ """
+ ret = None
+ for i, representation in enumerate(reps):
+ render_pack = self.renderer.render(representation, extrinsics[i], intrinsics[i])
+ if ret is None:
+ ret = {k: [] for k in list(render_pack.keys()) + ['bg_color']}
+ for k, v in render_pack.items():
+ ret[k].append(v)
+ ret['bg_color'].append(self.renderer.bg_color)
+ for k, v in ret.items():
+ ret[k] = torch.stack(v, dim=0)
+ return ret
+
+ @torch.no_grad()
+ def _get_status(self, z: SparseTensor, reps: List[Gaussian]) -> Dict:
+ xyz = torch.cat([g.get_xyz for g in reps], dim=0)
+ xyz_base = (z.coords[:, 1:].float() + 0.5) / self.models['decoder'].resolution - 0.5
+ offset = xyz - xyz_base.unsqueeze(1).expand(-1, self.models['decoder'].rep_config['num_gaussians'], -1).reshape(-1, 3)
+ status = {
+ 'xyz': xyz,
+ 'offset': offset,
+ 'scale': torch.cat([g.get_scaling for g in reps], dim=0),
+ 'opacity': torch.cat([g.get_opacity for g in reps], dim=0),
+ }
+
+ for k in list(status.keys()):
+ status[k] = {
+ 'mean': status[k].mean().item(),
+ 'max': status[k].max().item(),
+ 'min': status[k].min().item(),
+ }
+
+ return status
+
+ def _get_regularization_loss(self, reps: List[Gaussian]) -> Tuple[torch.Tensor, Dict]:
+ loss = 0.0
+ terms = {}
+ if 'lambda_vol' in self.regularizations:
+ scales = torch.cat([g.get_scaling for g in reps], dim=0) # [N x 3]
+ volume = torch.prod(scales, dim=1) # [N]
+ terms[f'reg_vol'] = volume.mean()
+ loss = loss + self.regularizations['lambda_vol'] * terms[f'reg_vol']
+ if 'lambda_opacity' in self.regularizations:
+ opacity = torch.cat([g.get_opacity for g in reps], dim=0)
+ terms[f'reg_opacity'] = (opacity - 1).pow(2).mean()
+ loss = loss + self.regularizations['lambda_opacity'] * terms[f'reg_opacity']
+ return loss, terms
+
+ def training_losses(
+ self,
+ feats: SparseTensor,
+ image: torch.Tensor,
+ alpha: torch.Tensor,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ return_aux: bool = False,
+ **kwargs
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses.
+
+ Args:
+ feats: The [N x * x C] sparse tensor of features.
+ image: The [N x 3 x H x W] tensor of images.
+ alpha: The [N x H x W] tensor of alpha channels.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+ return_aux: Whether to return auxiliary information.
+
+ Returns:
+ a dict with the key "loss" containing a scalar tensor.
+ may also contain other keys for different terms.
+ """
+ z, mean, logvar = self.training_models['encoder'](feats, sample_posterior=True, return_raw=True)
+ reps = self.training_models['decoder'](z)
+ self.renderer.rendering_options.resolution = image.shape[-1]
+ render_results = self._render_batch(reps, extrinsics, intrinsics)
+
+ terms = edict(loss = 0.0, rec = 0.0)
+
+ rec_image = render_results['color']
+ gt_image = image * alpha[:, None] + (1 - alpha[:, None]) * render_results['bg_color'][..., None, None]
+
+ if self.loss_type == 'l1':
+ terms["l1"] = l1_loss(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + terms["l1"]
+ elif self.loss_type == 'l2':
+ terms["l2"] = l2_loss(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + terms["l2"]
+ else:
+ raise ValueError(f"Invalid loss type: {self.loss_type}")
+ if self.lambda_ssim > 0:
+ terms["ssim"] = 1 - ssim(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + self.lambda_ssim * terms["ssim"]
+ if self.lambda_lpips > 0:
+ terms["lpips"] = lpips(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + self.lambda_lpips * terms["lpips"]
+ terms["loss"] = terms["loss"] + terms["rec"]
+
+ terms["kl"] = 0.5 * torch.mean(mean.pow(2) + logvar.exp() - logvar - 1)
+ terms["loss"] = terms["loss"] + self.lambda_kl * terms["kl"]
+
+ reg_loss, reg_terms = self._get_regularization_loss(reps)
+ terms.update(reg_terms)
+ terms["loss"] = terms["loss"] + reg_loss
+
+ status = self._get_status(z, reps)
+
+ if return_aux:
+ return terms, status, {'rec_image': rec_image, 'gt_image': gt_image}
+ return terms, status
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # inference
+ ret_dict = {}
+ gt_images = []
+ exts = []
+ ints = []
+ reps = []
+ for i in range(0, num_samples, batch_size):
+ batch = min(batch_size, num_samples - i)
+ data = next(iter(dataloader))
+ args = {k: v[:batch].cuda() for k, v in data.items()}
+ gt_images.append(args['image'] * args['alpha'][:, None])
+ exts.append(args['extrinsics'])
+ ints.append(args['intrinsics'])
+ z = self.models['encoder'](args['feats'], sample_posterior=True, return_raw=False)
+ reps.extend(self.models['decoder'](z))
+ gt_images = torch.cat(gt_images, dim=0)
+ ret_dict.update({f'gt_image': {'value': gt_images, 'type': 'image'}})
+
+ # render single view
+ exts = torch.cat(exts, dim=0)
+ ints = torch.cat(ints, dim=0)
+ self.renderer.rendering_options.bg_color = (0, 0, 0)
+ self.renderer.rendering_options.resolution = gt_images.shape[-1]
+ render_results = self._render_batch(reps, exts, ints)
+ ret_dict.update({f'rec_image': {'value': render_results['color'], 'type': 'image'}})
+
+ # render multiview
+ self.renderer.rendering_options.resolution = 512
+ ## Build camera
+ yaws = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
+ yaws_offset = np.random.uniform(-np.pi / 4, np.pi / 4)
+ yaws = [y + yaws_offset for y in yaws]
+ pitch = [np.random.uniform(-np.pi / 4, np.pi / 4) for _ in range(4)]
+
+ ## render each view
+ miltiview_images = []
+ for yaw, pitch in zip(yaws, pitch):
+ orig = torch.tensor([
+ np.sin(yaw) * np.cos(pitch),
+ np.cos(yaw) * np.cos(pitch),
+ np.sin(pitch),
+ ]).float().cuda() * 2
+ fov = torch.deg2rad(torch.tensor(30)).cuda()
+ extrinsics = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intrinsics = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ extrinsics = extrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ intrinsics = intrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ render_results = self._render_batch(reps, extrinsics, intrinsics)
+ miltiview_images.append(render_results['color'])
+
+ ## Concatenate views
+ miltiview_images = torch.cat([
+ torch.cat(miltiview_images[:2], dim=-2),
+ torch.cat(miltiview_images[2:], dim=-2),
+ ], dim=-1)
+ ret_dict.update({f'miltiview_image': {'value': miltiview_images, 'type': 'image'}})
+
+ self.renderer.rendering_options.bg_color = 'random'
+
+ return ret_dict
diff --git a/OmniPart/training/trainers/vae/structured_latent_vae_mesh_dec.py b/OmniPart/training/trainers/vae/structured_latent_vae_mesh_dec.py
new file mode 100644
index 0000000..7cd17e0
--- /dev/null
+++ b/OmniPart/training/trainers/vae/structured_latent_vae_mesh_dec.py
@@ -0,0 +1,382 @@
+from typing import *
+import copy
+import torch
+from torch.utils.data import DataLoader
+import numpy as np
+from easydict import EasyDict as edict
+import utils3d.torch
+
+from ..basic import BasicTrainer
+from ...representations import MeshExtractResult
+from ...renderers import MeshRenderer
+from ...modules.sparse import SparseTensor
+from ...utils.loss_utils import l1_loss, smooth_l1_loss, ssim, lpips
+from ...utils.data_utils import recursive_to_device
+
+
+class SLatVaeMeshDecoderTrainer(BasicTrainer):
+ """
+ Trainer for structured latent VAE Mesh Decoder.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ loss_type (str): Loss type. Can be 'l1', 'l2'
+ lambda_ssim (float): SSIM loss weight.
+ lambda_lpips (float): LPIPS loss weight.
+ """
+
+ def __init__(
+ self,
+ *args,
+ depth_loss_type: str = 'l1',
+ lambda_depth: int = 1,
+ lambda_ssim: float = 0.2,
+ lambda_lpips: float = 0.2,
+ lambda_tsdf: float = 0.01,
+ lambda_color: float = 0.1,
+ **kwargs
+ ):
+ super().__init__(*args, **kwargs)
+ self.depth_loss_type = depth_loss_type
+ self.lambda_depth = lambda_depth
+ self.lambda_ssim = lambda_ssim
+ self.lambda_lpips = lambda_lpips
+ self.lambda_tsdf = lambda_tsdf
+ self.lambda_color = lambda_color
+ self.use_color = self.lambda_color > 0
+
+ self._init_renderer()
+
+ def _init_renderer(self):
+ rendering_options = {"near" : 1,
+ "far" : 3}
+ self.renderer = MeshRenderer(rendering_options, device=self.device)
+
+ def _render_batch(self, reps: List[MeshExtractResult], extrinsics: torch.Tensor, intrinsics: torch.Tensor,
+ return_types=['mask', 'normal', 'depth']) -> Dict[str, torch.Tensor]:
+ """
+ Render a batch of representations.
+
+ Args:
+ reps: The dictionary of lists of representations.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+ return_types: vary in ['mask', 'normal', 'depth', 'normal_map', 'color']
+
+ Returns:
+ a dict with
+ reg_loss : [N] tensor of regularization losses
+ mask : [N x 1 x H x W] tensor of rendered masks
+ normal : [N x 3 x H x W] tensor of rendered normals
+ depth : [N x 1 x H x W] tensor of rendered depths
+ """
+ ret = {k : [] for k in return_types}
+ for i, rep in enumerate(reps):
+ out_dict = self.renderer.render(rep, extrinsics[i], intrinsics[i], return_types=return_types)
+ for k in out_dict:
+ ret[k].append(out_dict[k][None] if k in ['mask', 'depth'] else out_dict[k])
+ for k in ret:
+ ret[k] = torch.stack(ret[k])
+ return ret
+
+ @staticmethod
+ def _tsdf_reg_loss(rep: MeshExtractResult, depth_map: torch.Tensor, extrinsics: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+ # Calculate tsdf
+ with torch.no_grad():
+ # Project points to camera and calculate pseudo-sdf as difference between gt depth and projected depth
+ projected_pts, pts_depth = utils3d.torch.project_cv(extrinsics=extrinsics, intrinsics=intrinsics, points=rep.tsdf_v)
+ projected_pts = (projected_pts - 0.5) * 2.0
+ depth_map_res = depth_map.shape[1]
+ gt_depth = torch.nn.functional.grid_sample(depth_map.reshape(1, 1, depth_map_res, depth_map_res),
+ projected_pts.reshape(1, 1, -1, 2), mode='bilinear', padding_mode='border', align_corners=True)
+ pseudo_sdf = gt_depth.flatten() - pts_depth.flatten()
+ # Truncate pseudo-sdf
+ delta = 1 / rep.res * 3.0
+ trunc_mask = pseudo_sdf > -delta
+
+ # Loss
+ gt_tsdf = pseudo_sdf[trunc_mask]
+ tsdf = rep.tsdf_s.flatten()[trunc_mask]
+ gt_tsdf = torch.clamp(gt_tsdf, -delta, delta)
+ return torch.mean((tsdf - gt_tsdf) ** 2)
+
+ def _calc_tsdf_loss(self, reps : List[MeshExtractResult], depth_maps, extrinsics, intrinsics) -> torch.Tensor:
+ tsdf_loss = 0.0
+ for i, rep in enumerate(reps):
+ tsdf_loss += self._tsdf_reg_loss(rep, depth_maps[i], extrinsics[i], intrinsics[i])
+ return tsdf_loss / len(reps)
+
+ @torch.no_grad()
+ def _flip_normal(self, normal: torch.Tensor, extrinsics: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+ """
+ Flip normal to align with camera.
+ """
+ normal = normal * 2.0 - 1.0
+ R = torch.zeros_like(extrinsics)
+ R[:, :3, :3] = extrinsics[:, :3, :3]
+ R[:, 3, 3] = 1.0
+ view_dir = utils3d.torch.unproject_cv(
+ utils3d.torch.image_uv(*normal.shape[-2:], device=self.device).reshape(1, -1, 2),
+ torch.ones(*normal.shape[-2:], device=self.device).reshape(1, -1),
+ R, intrinsics
+ ).reshape(-1, *normal.shape[-2:], 3).permute(0, 3, 1, 2)
+ unflip = (normal * view_dir).sum(1, keepdim=True) < 0
+ normal *= unflip * 2.0 - 1.0
+ return (normal + 1.0) / 2.0
+
+ def _perceptual_loss(self, gt: torch.Tensor, pred: torch.Tensor, name: str) -> Dict[str, torch.Tensor]:
+ """
+ Combination of L1, SSIM, and LPIPS loss.
+ """
+ if gt.shape[1] != 3:
+ assert gt.shape[-1] == 3
+ gt = gt.permute(0, 3, 1, 2)
+ if pred.shape[1] != 3:
+ assert pred.shape[-1] == 3
+ pred = pred.permute(0, 3, 1, 2)
+ terms = {
+ f"{name}_loss" : l1_loss(gt, pred),
+ f"{name}_loss_ssim" : 1 - ssim(gt, pred),
+ f"{name}_loss_lpips" : lpips(gt, pred)
+ }
+ terms[f"{name}_loss_perceptual"] = terms[f"{name}_loss"] + terms[f"{name}_loss_ssim"] * self.lambda_ssim + terms[f"{name}_loss_lpips"] * self.lambda_lpips
+ return terms
+
+ def geometry_losses(
+ self,
+ reps: List[MeshExtractResult],
+ mesh: List[Dict],
+ normal_map: torch.Tensor,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ ):
+ with torch.no_grad():
+ gt_meshes = []
+ for i in range(len(reps)):
+ gt_mesh = MeshExtractResult(mesh[i]['vertices'].to(self.device), mesh[i]['faces'].to(self.device))
+ gt_meshes.append(gt_mesh)
+ target = self._render_batch(gt_meshes, extrinsics, intrinsics, return_types=['mask', 'depth', 'normal'])
+ target['normal'] = self._flip_normal(target['normal'], extrinsics, intrinsics)
+
+ terms = edict(geo_loss = 0.0)
+ if self.lambda_tsdf > 0:
+ tsdf_loss = self._calc_tsdf_loss(reps, target['depth'], extrinsics, intrinsics)
+ terms['tsdf_loss'] = tsdf_loss
+ terms['geo_loss'] += tsdf_loss * self.lambda_tsdf
+
+ return_types = ['mask', 'depth', 'normal', 'normal_map'] if self.use_color else ['mask', 'depth', 'normal']
+ buffer = self._render_batch(reps, extrinsics, intrinsics, return_types=return_types)
+
+ success_mask = torch.tensor([rep.success for rep in reps], device=self.device)
+ if success_mask.sum() != 0:
+ for k, v in buffer.items():
+ buffer[k] = v[success_mask]
+ for k, v in target.items():
+ target[k] = v[success_mask]
+
+ terms['mask_loss'] = l1_loss(buffer['mask'], target['mask'])
+ if self.depth_loss_type == 'l1':
+ terms['depth_loss'] = l1_loss(buffer['depth'] * target['mask'], target['depth'] * target['mask'])
+ elif self.depth_loss_type == 'smooth_l1':
+ terms['depth_loss'] = smooth_l1_loss(buffer['depth'] * target['mask'], target['depth'] * target['mask'], beta=1.0 / (2 * reps[0].res))
+ else:
+ raise ValueError(f"Unsupported depth loss type: {self.depth_loss_type}")
+ terms.update(self._perceptual_loss(buffer['normal'] * target['mask'], target['normal'] * target['mask'], 'normal'))
+ terms['geo_loss'] = terms['geo_loss'] + terms['mask_loss'] + terms['depth_loss'] * self.lambda_depth + terms['normal_loss_perceptual']
+ if self.use_color and normal_map is not None:
+ terms.update(self._perceptual_loss(normal_map[success_mask], buffer['normal_map'], 'normal_map'))
+ terms['geo_loss'] = terms['geo_loss'] + terms['normal_map_loss_perceptual'] * self.lambda_color
+
+ return terms
+
+ def color_losses(self, reps, image, alpha, extrinsics, intrinsics):
+ terms = edict(color_loss = torch.tensor(0.0, device=self.device))
+ buffer = self._render_batch(reps, extrinsics, intrinsics, return_types=['color'])
+ success_mask = torch.tensor([rep.success for rep in reps], device=self.device)
+ if success_mask.sum() != 0:
+ terms.update(self._perceptual_loss(image * alpha[:, None][success_mask], buffer['color'][success_mask], 'color'))
+ terms['color_loss'] = terms['color_loss'] + terms['color_loss_perceptual'] * self.lambda_color
+ return terms
+
+ def training_losses(
+ self,
+ latents: SparseTensor,
+ image: torch.Tensor,
+ alpha: torch.Tensor,
+ mesh: List[Dict],
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ normal_map: torch.Tensor = None,
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses.
+
+ Args:
+ latents: The [N x * x C] sparse latents
+ image: The [N x 3 x H x W] tensor of images.
+ alpha: The [N x H x W] tensor of alpha channels.
+ mesh: The list of dictionaries of meshes.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+
+ Returns:
+ a dict with the key "loss" containing a scalar tensor.
+ may also contain other keys for different terms.
+ """
+ reps = self.training_models['decoder'](latents)
+ self.renderer.rendering_options.resolution = image.shape[-1]
+
+ terms = edict(loss = 0.0, rec = 0.0)
+
+ terms['reg_loss'] = sum([rep.reg_loss for rep in reps]) / len(reps)
+ terms['loss'] = terms['loss'] + terms['reg_loss']
+
+ geo_terms = self.geometry_losses(reps, mesh, normal_map, extrinsics, intrinsics)
+ terms.update(geo_terms)
+ terms['loss'] = terms['loss'] + terms['geo_loss']
+
+ if self.use_color:
+ color_terms = self.color_losses(reps, image, alpha, extrinsics, intrinsics)
+ terms.update(color_terms)
+ terms['loss'] = terms['loss'] + terms['color_loss']
+
+ return terms, {}
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # inference
+ ret_dict = {}
+ gt_images = []
+ gt_normal_maps = []
+ gt_meshes = []
+ exts = []
+ ints = []
+ reps = []
+ for i in range(0, num_samples, batch_size):
+ batch = min(batch_size, num_samples - i)
+ data = next(iter(dataloader))
+ args = recursive_to_device(data, 'cuda')
+ gt_images.append(args['image'] * args['alpha'][:, None])
+ if self.use_color and 'normal_map' in data:
+ gt_normal_maps.append(args['normal_map'])
+ gt_meshes.extend(args['mesh'])
+ exts.append(args['extrinsics'])
+ ints.append(args['intrinsics'])
+ reps.extend(self.models['decoder'](args['latents']))
+ gt_images = torch.cat(gt_images, dim=0)
+ ret_dict.update({f'gt_image': {'value': gt_images, 'type': 'image'}})
+ if self.use_color and gt_normal_maps:
+ gt_normal_maps = torch.cat(gt_normal_maps, dim=0)
+ ret_dict.update({f'gt_normal_map': {'value': gt_normal_maps, 'type': 'image'}})
+
+ # render single view
+ exts = torch.cat(exts, dim=0)
+ ints = torch.cat(ints, dim=0)
+ self.renderer.rendering_options.bg_color = (0, 0, 0)
+ self.renderer.rendering_options.resolution = gt_images.shape[-1]
+ gt_render_results = self._render_batch([
+ MeshExtractResult(vertices=mesh['vertices'].to(self.device), faces=mesh['faces'].to(self.device))
+ for mesh in gt_meshes
+ ], exts, ints, return_types=['normal'])
+ ret_dict.update({f'gt_normal': {'value': self._flip_normal(gt_render_results['normal'], exts, ints), 'type': 'image'}})
+ return_types = ['normal']
+ if self.use_color:
+ return_types.append('color')
+ if 'normal_map' in data:
+ return_types.append('normal_map')
+ render_results = self._render_batch(reps, exts, ints, return_types=return_types)
+ ret_dict.update({f'rec_normal': {'value': render_results['normal'], 'type': 'image'}})
+ if 'color' in return_types:
+ ret_dict.update({f'rec_image': {'value': render_results['color'], 'type': 'image'}})
+ if 'normal_map' in return_types:
+ ret_dict.update({f'rec_normal_map': {'value': render_results['normal_map'], 'type': 'image'}})
+
+ # render multiview
+ self.renderer.rendering_options.resolution = 512
+ ## Build camera
+ yaws = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
+ yaws_offset = np.random.uniform(-np.pi / 4, np.pi / 4)
+ yaws = [y + yaws_offset for y in yaws]
+ pitch = [np.random.uniform(-np.pi / 4, np.pi / 4) for _ in range(4)]
+
+ ## render each view
+ multiview_normals = []
+ multiview_normal_maps = []
+ miltiview_images = []
+ for yaw, pitch in zip(yaws, pitch):
+ orig = torch.tensor([
+ np.sin(yaw) * np.cos(pitch),
+ np.cos(yaw) * np.cos(pitch),
+ np.sin(pitch),
+ ]).float().cuda() * 2
+ fov = torch.deg2rad(torch.tensor(30)).cuda()
+ extrinsics = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intrinsics = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ extrinsics = extrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ intrinsics = intrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ render_results = self._render_batch(reps, extrinsics, intrinsics, return_types=return_types)
+ multiview_normals.append(render_results['normal'])
+ if 'color' in return_types:
+ miltiview_images.append(render_results['color'])
+ if 'normal_map' in return_types:
+ multiview_normal_maps.append(render_results['normal_map'])
+
+ ## Concatenate views
+ multiview_normals = torch.cat([
+ torch.cat(multiview_normals[:2], dim=-2),
+ torch.cat(multiview_normals[2:], dim=-2),
+ ], dim=-1)
+ ret_dict.update({f'multiview_normal': {'value': multiview_normals, 'type': 'image'}})
+ if 'color' in return_types:
+ miltiview_images = torch.cat([
+ torch.cat(miltiview_images[:2], dim=-2),
+ torch.cat(miltiview_images[2:], dim=-2),
+ ], dim=-1)
+ ret_dict.update({f'multiview_image': {'value': miltiview_images, 'type': 'image'}})
+ if 'normal_map' in return_types:
+ multiview_normal_maps = torch.cat([
+ torch.cat(multiview_normal_maps[:2], dim=-2),
+ torch.cat(multiview_normal_maps[2:], dim=-2),
+ ], dim=-1)
+ ret_dict.update({f'multiview_normal_map': {'value': multiview_normal_maps, 'type': 'image'}})
+
+ return ret_dict
diff --git a/OmniPart/training/trainers/vae/structured_latent_vae_rf_dec.py b/OmniPart/training/trainers/vae/structured_latent_vae_rf_dec.py
new file mode 100644
index 0000000..6021ea1
--- /dev/null
+++ b/OmniPart/training/trainers/vae/structured_latent_vae_rf_dec.py
@@ -0,0 +1,223 @@
+from typing import *
+import copy
+import torch
+from torch.utils.data import DataLoader
+import numpy as np
+from easydict import EasyDict as edict
+import utils3d.torch
+
+from ..basic import BasicTrainer
+from ...representations import Strivec
+from ...renderers import OctreeRenderer
+from ...modules.sparse import SparseTensor
+from ...utils.loss_utils import l1_loss, l2_loss, ssim, lpips
+
+
+class SLatVaeRadianceFieldDecoderTrainer(BasicTrainer):
+ """
+ Trainer for structured latent VAE Radiance Field Decoder.
+
+ Args:
+ models (dict[str, nn.Module]): Models to train.
+ dataset (torch.utils.data.Dataset): Dataset.
+ output_dir (str): Output directory.
+ load_dir (str): Load directory.
+ step (int): Step to load.
+ batch_size (int): Batch size.
+ batch_size_per_gpu (int): Batch size per GPU. If specified, batch_size will be ignored.
+ batch_split (int): Split batch with gradient accumulation.
+ max_steps (int): Max steps.
+ optimizer (dict): Optimizer config.
+ lr_scheduler (dict): Learning rate scheduler config.
+ elastic (dict): Elastic memory management config.
+ grad_clip (float or dict): Gradient clip config.
+ ema_rate (float or list): Exponential moving average rates.
+ fp16_mode (str): FP16 mode.
+ - None: No FP16.
+ - 'inflat_all': Hold a inflated fp32 master param for all params.
+ - 'amp': Automatic mixed precision.
+ fp16_scale_growth (float): Scale growth for FP16 gradient backpropagation.
+ finetune_ckpt (dict): Finetune checkpoint.
+ log_param_stats (bool): Log parameter stats.
+ i_print (int): Print interval.
+ i_log (int): Log interval.
+ i_sample (int): Sample interval.
+ i_save (int): Save interval.
+ i_ddpcheck (int): DDP check interval.
+
+ loss_type (str): Loss type. Can be 'l1', 'l2'
+ lambda_ssim (float): SSIM loss weight.
+ lambda_lpips (float): LPIPS loss weight.
+ """
+
+ def __init__(
+ self,
+ *args,
+ loss_type: str = 'l1',
+ lambda_ssim: float = 0.2,
+ lambda_lpips: float = 0.2,
+ **kwargs
+ ):
+ super().__init__(*args, **kwargs)
+ self.loss_type = loss_type
+ self.lambda_ssim = lambda_ssim
+ self.lambda_lpips = lambda_lpips
+
+ self._init_renderer()
+
+ def _init_renderer(self):
+ rendering_options = {"near" : 0.8,
+ "far" : 1.6,
+ "bg_color" : 'random'}
+ self.renderer = OctreeRenderer(rendering_options)
+ self.renderer.pipe.primitive = 'trivec'
+
+ def _render_batch(self, reps: List[Strivec], extrinsics: torch.Tensor, intrinsics: torch.Tensor) -> torch.Tensor:
+ """
+ Render a batch of representations.
+
+ Args:
+ reps: The dictionary of lists of representations.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+ """
+ ret = None
+ for i, representation in enumerate(reps):
+ render_pack = self.renderer.render(representation, extrinsics[i], intrinsics[i])
+ if ret is None:
+ ret = {k: [] for k in list(render_pack.keys()) + ['bg_color']}
+ for k, v in render_pack.items():
+ ret[k].append(v)
+ ret['bg_color'].append(self.renderer.bg_color)
+ for k, v in ret.items():
+ ret[k] = torch.stack(v, dim=0)
+ return ret
+
+ def training_losses(
+ self,
+ latents: SparseTensor,
+ image: torch.Tensor,
+ alpha: torch.Tensor,
+ extrinsics: torch.Tensor,
+ intrinsics: torch.Tensor,
+ return_aux: bool = False,
+ **kwargs
+ ) -> Tuple[Dict, Dict]:
+ """
+ Compute training losses.
+
+ Args:
+ latents: The [N x * x C] sparse latents
+ image: The [N x 3 x H x W] tensor of images.
+ alpha: The [N x H x W] tensor of alpha channels.
+ extrinsics: The [N x 4 x 4] tensor of extrinsics.
+ intrinsics: The [N x 3 x 3] tensor of intrinsics.
+ return_aux: Whether to return auxiliary information.
+
+ Returns:
+ a dict with the key "loss" containing a scalar tensor.
+ may also contain other keys for different terms.
+ """
+ reps = self.training_models['decoder'](latents)
+ self.renderer.rendering_options.resolution = image.shape[-1]
+ render_results = self._render_batch(reps, extrinsics, intrinsics)
+
+ terms = edict(loss = 0.0, rec = 0.0)
+
+ rec_image = render_results['color']
+ gt_image = image * alpha[:, None] + (1 - alpha[:, None]) * render_results['bg_color'][..., None, None]
+
+ if self.loss_type == 'l1':
+ terms["l1"] = l1_loss(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + terms["l1"]
+ elif self.loss_type == 'l2':
+ terms["l2"] = l2_loss(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + terms["l2"]
+ else:
+ raise ValueError(f"Invalid loss type: {self.loss_type}")
+ if self.lambda_ssim > 0:
+ terms["ssim"] = 1 - ssim(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + self.lambda_ssim * terms["ssim"]
+ if self.lambda_lpips > 0:
+ terms["lpips"] = lpips(rec_image, gt_image)
+ terms["rec"] = terms["rec"] + self.lambda_lpips * terms["lpips"]
+ terms["loss"] = terms["loss"] + terms["rec"]
+
+ if return_aux:
+ return terms, {}, {'rec_image': rec_image, 'gt_image': gt_image}
+ return terms, {}
+
+ @torch.no_grad()
+ def run_snapshot(
+ self,
+ num_samples: int,
+ batch_size: int,
+ verbose: bool = False,
+ ) -> Dict:
+ dataloader = DataLoader(
+ copy.deepcopy(self.dataset),
+ batch_size=batch_size,
+ shuffle=True,
+ num_workers=0,
+ collate_fn=self.dataset.collate_fn if hasattr(self.dataset, 'collate_fn') else None,
+ )
+
+ # inference
+ ret_dict = {}
+ gt_images = []
+ exts = []
+ ints = []
+ reps = []
+ for i in range(0, num_samples, batch_size):
+ batch = min(batch_size, num_samples - i)
+ data = next(iter(dataloader))
+ args = {k: v[:batch].cuda() for k, v in data.items()}
+ gt_images.append(args['image'] * args['alpha'][:, None])
+ exts.append(args['extrinsics'])
+ ints.append(args['intrinsics'])
+ reps.extend(self.models['decoder'](args['latents']))
+ gt_images = torch.cat(gt_images, dim=0)
+ ret_dict.update({f'gt_image': {'value': gt_images, 'type': 'image'}})
+
+ # render single view
+ exts = torch.cat(exts, dim=0)
+ ints = torch.cat(ints, dim=0)
+ self.renderer.rendering_options.bg_color = (0, 0, 0)
+ self.renderer.rendering_options.resolution = gt_images.shape[-1]
+ render_results = self._render_batch(reps, exts, ints)
+ ret_dict.update({f'rec_image': {'value': render_results['color'], 'type': 'image'}})
+
+ # render multiview
+ self.renderer.rendering_options.resolution = 512
+ ## Build camera
+ yaws = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
+ yaws_offset = np.random.uniform(-np.pi / 4, np.pi / 4)
+ yaws = [y + yaws_offset for y in yaws]
+ pitch = [np.random.uniform(-np.pi / 4, np.pi / 4) for _ in range(4)]
+
+ ## render each view
+ miltiview_images = []
+ for yaw, pitch in zip(yaws, pitch):
+ orig = torch.tensor([
+ np.sin(yaw) * np.cos(pitch),
+ np.cos(yaw) * np.cos(pitch),
+ np.sin(pitch),
+ ]).float().cuda() * 2
+ fov = torch.deg2rad(torch.tensor(30)).cuda()
+ extrinsics = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intrinsics = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ extrinsics = extrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ intrinsics = intrinsics.unsqueeze(0).expand(num_samples, -1, -1)
+ render_results = self._render_batch(reps, extrinsics, intrinsics)
+ miltiview_images.append(render_results['color'])
+
+ ## Concatenate views
+ miltiview_images = torch.cat([
+ torch.cat(miltiview_images[:2], dim=-2),
+ torch.cat(miltiview_images[2:], dim=-2),
+ ], dim=-1)
+ ret_dict.update({f'miltiview_image': {'value': miltiview_images, 'type': 'image'}})
+
+ self.renderer.rendering_options.bg_color = 'random'
+
+ return ret_dict
diff --git a/OmniPart/training/utils/__init__.py b/OmniPart/training/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/OmniPart/training/utils/data_utils.py b/OmniPart/training/utils/data_utils.py
new file mode 100644
index 0000000..368d70a
--- /dev/null
+++ b/OmniPart/training/utils/data_utils.py
@@ -0,0 +1,398 @@
+from typing import *
+import math
+import torch
+import numpy as np
+from torch.utils.data import Sampler, Dataset, DataLoader, DistributedSampler
+import torch.distributed as dist
+
+
+def recursive_to_device(
+ data: Any,
+ device: torch.device,
+ non_blocking: bool = False,
+) -> Any:
+ """
+ Recursively move all tensors in a data structure to a device.
+
+ This function traverses nested data structures (lists, tuples, dictionaries)
+ and moves any PyTorch tensor to the specified device.
+
+ Args:
+ data: The data structure containing tensors to be moved
+ device: The target device (CPU, GPU) to move tensors to
+ non_blocking: If True, allows asynchronous copy to device if possible
+
+ Returns:
+ The same data structure with all tensors moved to the specified device
+ """
+ if hasattr(data, "to"):
+ # print("Moving data to device")
+ # print(data)
+ return data.to(device, non_blocking=non_blocking)
+ elif isinstance(data, (list, tuple)):
+ # print("list or tuple detected")
+ return type(data)(recursive_to_device(d, device, non_blocking) for d in data)
+ elif isinstance(data, dict):
+ # print("dict detected")
+ return {k: recursive_to_device(v, device, non_blocking) for k, v in data.items()}
+ else:
+ # print(f"{type(data)} detected")
+ return data
+
+
+def load_balanced_group_indices(
+ load: List[int],
+ num_groups: int,
+ equal_size: bool = False,
+) -> List[List[int]]:
+ """
+ Split indices into groups with balanced load.
+
+ This function distributes indices across groups to achieve balanced workload.
+ It uses a greedy algorithm that assigns each index to the group with the
+ minimum current load.
+
+ Args:
+ load: List of load values for each index
+ num_groups: Number of groups to split indices into
+ equal_size: If True, each group will have the same number of elements
+
+ Returns:
+ List of lists, where each inner list contains indices assigned to a group
+ """
+ if equal_size:
+ group_size = len(load) // num_groups
+ indices = np.argsort(load)[::-1] # Sort indices by load in descending order
+ groups = [[] for _ in range(num_groups)]
+ group_load = np.zeros(num_groups)
+ for idx in indices:
+ min_group_idx = np.argmin(group_load)
+ groups[min_group_idx].append(idx)
+ if equal_size and len(groups[min_group_idx]) == group_size:
+ group_load[min_group_idx] = float('inf') # Mark group as full
+ else:
+ group_load[min_group_idx] += load[idx]
+ return groups
+
+
+def cycle(data_loader: DataLoader) -> Iterator:
+ """
+ Creates an infinite iterator over a data loader.
+
+ This function wraps a data loader to cycle through it repeatedly,
+ handling epoch tracking for various sampler types.
+
+ Args:
+ data_loader: The DataLoader to cycle through
+
+ Returns:
+ An iterator that indefinitely yields batches from the data loader
+ """
+ while True:
+ for data in data_loader:
+ if isinstance(data_loader.sampler, ResumableSampler):
+ data_loader.sampler.idx += data_loader.batch_size # Update position for resumability
+ yield data
+ if isinstance(data_loader.sampler, DistributedSampler):
+ data_loader.sampler.epoch += 1 # Update epoch for DistributedSampler
+ if isinstance(data_loader.sampler, ResumableSampler):
+ data_loader.sampler.epoch += 1 # Update epoch for ResumableSampler
+ data_loader.sampler.idx = 0 # Reset position index
+
+
+class ResumableSampler(Sampler):
+ """
+ Distributed sampler that is resumable.
+
+ This sampler extends PyTorch's Sampler to support resuming training from
+ a specific point. It tracks the current position (idx) and epoch to
+ enable checkpointing and resuming.
+
+ Args:
+ dataset: Dataset used for sampling.
+ rank (int, optional): Rank of the current process within :attr:`num_replicas`.
+ By default, :attr:`rank` is retrieved from the current distributed
+ group.
+ shuffle (bool, optional): If ``True`` (default), sampler will shuffle the
+ indices.
+ seed (int, optional): random seed used to shuffle the sampler if
+ :attr:`shuffle=True`. This number should be identical across all
+ processes in the distributed group. Default: ``0``.
+ drop_last (bool, optional): if ``True``, then the sampler will drop the
+ tail of the data to make it evenly divisible across the number of
+ replicas. If ``False``, the sampler will add extra indices to make
+ the data evenly divisible across the replicas. Default: ``False``.
+ """
+
+ def __init__(
+ self,
+ dataset: Dataset,
+ shuffle: bool = True,
+ seed: int = 0,
+ drop_last: bool = False,
+ ) -> None:
+ self.dataset = dataset
+ self.epoch = 0 # Current epoch counter
+ self.idx = 0 # Current index position for resuming
+ self.drop_last = drop_last
+ self.world_size = dist.get_world_size() if dist.is_initialized() else 1 # Get total number of processes
+ self.rank = dist.get_rank() if dist.is_initialized() else 0 # Get current process rank
+
+ # Calculate number of samples per process
+ if self.drop_last and len(self.dataset) % self.world_size != 0:
+ # Split to nearest available length that is evenly divisible
+ # This ensures each rank receives the same amount of data
+ self.num_samples = math.ceil(
+ (len(self.dataset) - self.world_size) / self.world_size
+ )
+ else:
+ self.num_samples = math.ceil(len(self.dataset) / self.world_size)
+
+ self.total_size = self.num_samples * self.world_size # Total size after padding
+ self.shuffle = shuffle
+ self.seed = seed
+
+ def __iter__(self) -> Iterator:
+ if self.shuffle:
+ # Deterministically shuffle based on epoch and seed
+ g = torch.Generator()
+ g.manual_seed(self.seed + self.epoch)
+ indices = torch.randperm(len(self.dataset), generator=g).tolist()
+ else:
+ indices = list(range(len(self.dataset)))
+
+ if not self.drop_last:
+ # Add extra samples to make it evenly divisible across processes
+ padding_size = self.total_size - len(indices)
+ if padding_size <= len(indices):
+ indices += indices[:padding_size] # Reuse some samples from the beginning
+ else:
+ indices += (indices * math.ceil(padding_size / len(indices)))[
+ :padding_size
+ ] # Repeat samples if padding_size > len(indices)
+ else:
+ # Remove tail of data to make it evenly divisible
+ indices = indices[: self.total_size]
+ assert len(indices) == self.total_size
+
+ # Subsample according to rank for distributed training
+ indices = indices[self.rank : self.total_size : self.world_size]
+
+ # Resume from previous state by skipping already processed indices
+ indices = indices[self.idx:]
+
+ return iter(indices)
+
+ def __len__(self) -> int:
+ return self.num_samples
+
+ def state_dict(self) -> Dict[str, int]:
+ """
+ Returns the state of the sampler as a dictionary.
+
+ This enables saving the sampler state for checkpointing.
+
+ Returns:
+ Dictionary containing epoch and current index
+ """
+ return {
+ 'epoch': self.epoch,
+ 'idx': self.idx,
+ }
+
+ def load_state_dict(self, state_dict):
+ """
+ Loads the sampler state from a dictionary.
+
+ This enables restoring the sampler state from a checkpoint.
+
+ Args:
+ state_dict: Dictionary containing sampler state
+ """
+ self.epoch = state_dict['epoch']
+ self.idx = state_dict['idx']
+
+
+class BalancedResumableSampler(ResumableSampler):
+ """
+ Distributed sampler that is resumable and balances the load among the processes.
+
+ This sampler extends ResumableSampler to distribute data across processes
+ in a load-balanced manner, ensuring that each process receives a similar
+ computational workload despite potentially varying sample processing times.
+
+ Args:
+ dataset: Dataset used for sampling. Must have 'loads' attribute.
+ shuffle (bool, optional): If ``True`` (default), sampler will shuffle the
+ indices.
+ seed (int, optional): random seed used to shuffle the sampler if
+ :attr:`shuffle=True`. This number should be identical across all
+ processes in the distributed group. Default: ``0``.
+ drop_last (bool, optional): if ``True``, then the sampler will drop the
+ tail of the data to make it evenly divisible across the number of
+ replicas. If ``False``, the sampler will add extra indices to make
+ the data evenly divisible across the replicas. Default: ``False``.
+ batch_size (int, optional): Size of mini-batches used for balancing. Default: 1.
+ """
+
+ def __init__(
+ self,
+ dataset: Dataset,
+ shuffle: bool = True,
+ seed: int = 0,
+ drop_last: bool = False,
+ batch_size: int = 1,
+ ) -> None:
+ assert hasattr(dataset, 'loads'), 'Dataset must have "loads" attribute to use BalancedResumableSampler'
+ super().__init__(dataset, shuffle, seed, drop_last)
+ self.batch_size = batch_size
+ self.loads = dataset.loads # Load values for each sample in the dataset
+
+ def __iter__(self) -> Iterator:
+ # print(f"[BalancedResumableSampler] Starting __iter__ for rank {self.rank}, epoch {self.epoch}")
+
+ if self.shuffle:
+ # Deterministically shuffle based on epoch and seed
+ g = torch.Generator()
+ g.manual_seed(self.seed + self.epoch)
+ # print(f"[BalancedResumableSampler] Shuffling with seed {self.seed + self.epoch}") # 0
+ indices = torch.randperm(len(self.dataset), generator=g).tolist()
+ else:
+ # print(f"[BalancedResumableSampler] No shuffle, using sequential indices")
+ indices = list(range(len(self.dataset)))
+ # print(indices)
+ # print(f"[BalancedResumableSampler] Initial indices length: {len(indices)}") # 128
+ if not self.drop_last:
+ # Add extra samples to make it evenly divisible
+ padding_size = self.total_size - len(indices)
+ # print(f"[BalancedResumableSampler] Adding padding of size {padding_size}") # 0
+ if padding_size <= len(indices):
+ indices += indices[:padding_size]
+ else:
+ indices += (indices * math.ceil(padding_size / len(indices)))[:padding_size]
+ else:
+ # Remove tail of data to make it evenly divisible
+ # print(f"[BalancedResumableSampler] Dropping last, trimming to {self.total_size}")
+ indices = indices[: self.total_size]
+ # print(indices)
+ assert len(indices) == self.total_size
+ # print(f"[BalancedResumableSampler] After padding/trimming, indices length: {len(indices)}") # 128
+
+ # Balance load among processes by distributing batches based on their loads
+ num_batches = len(indices) // (self.batch_size * self.world_size)
+ # print(f"[BalancedResumableSampler] Number of batches: {num_batches}") # 16
+ balanced_indices = []
+
+ if len(self.loads) < len(indices):
+ # repeat the loads to match the indices
+ self.loads = self.loads * (len(indices) // len(self.loads)) + self.loads[:len(indices) % len(self.loads)]
+
+ for i in range(num_batches):
+ start_idx = i * self.batch_size * self.world_size
+ end_idx = (i + 1) * self.batch_size * self.world_size
+ # print("start idx", start_idx) # 0
+ # print("end idx", end_idx) # 8
+ # print("batch size", self.batch_size) # 8
+ # print("world size", self.world_size) # 1
+ batch_indices = indices[start_idx:end_idx]
+ # print(f"[BalancedResumableSampler] Processing batch {i+1}/{num_batches}, size: {len(batch_indices)}") #1/16 8
+ batch_loads = [self.loads[idx] for idx in batch_indices]
+ groups = load_balanced_group_indices(batch_loads, self.world_size, equal_size=True)
+ balanced_indices.extend([batch_indices[j] for j in groups[self.rank]])
+
+ # print(f"[BalancedResumableSampler] Total balanced indices for rank {self.rank}: {len(balanced_indices)}")
+ # Resume from previous state
+ indices = balanced_indices[self.idx:]
+ # print(f"[BalancedResumableSampler] After resuming from idx {self.idx}, returning {len(indices)} indices")
+ return iter(indices)
+
+
+class DuplicatedDataset(torch.utils.data.Dataset):
+ """Dataset wrapper that duplicates a dataset multiple times."""
+
+ def __init__(self, dataset, repeat=1000):
+ """
+ Initialize the duplicated dataset.
+
+ Args:
+ dataset: Original dataset to duplicate
+ repeat: Number of times to repeat the dataset
+ """
+ self.dataset = dataset
+ self.repeat = repeat
+ self.original_length = len(dataset)
+
+ def __getitem__(self, idx):
+ """Get an item from the original dataset, repeating as needed."""
+ return self.dataset[idx % self.original_length]
+
+ def __len__(self):
+ """Return the length of the duplicated dataset."""
+ return self.original_length * self.repeat
+
+ def __getattr__(self, name):
+ """Forward all other attribute accesses to the original dataset."""
+ if name == 'dataset' or name == 'repeat' or name == 'original_length':
+ return object.__getattribute__(self, name)
+ return getattr(self.dataset, name)
+
+def save_coords_as_ply(coords, save_dir: str):
+ """
+ Save the coordinates to a PLY file using normalization similar to voxelize.py.
+
+ Args:
+ file_path (str): The directory path to save the PLY file.
+ """
+ import os
+ # import numpy as np
+
+ os.makedirs(save_dir, exist_ok=True) # Ensure the directory exists
+
+ # Get coordinates and convert to numpy
+ coords_np = coords.cpu().numpy()
+
+ # Print debug info
+ # print(f"Original coordinates shape: {coords_np.shape}")
+ # print(f"First few coordinates:\n{coords_np[:5]}")
+
+ if coords_np.shape[1] == 4:
+ # Extract XYZ coordinates (skip batch index at position 0)
+ vertices = coords_np[:, 1:4]
+ else:
+ vertices = coords_np
+
+ # Normalize coordinates to [-0.5, 0.5] like in voxelize.py
+ # Assuming the coordinates are in a 64³ grid
+ GRID_SIZE = 64
+ vertices = (vertices + 0.5) / GRID_SIZE - 0.5
+
+ # print(f"Normalized vertex range: min={np.min(vertices, axis=0)}, max={np.max(vertices, axis=0)}")
+
+ # Create PLY file (simplified format like in voxelize.py)
+ filename = os.path.join(save_dir, 'coords.ply')
+
+ try:
+ with open(filename, 'w') as f:
+ # Write header (no color, just XYZ coordinates)
+ f.write("ply\n")
+ f.write("format ascii 1.0\n")
+ f.write(f"element vertex {vertices.shape[0]}\n")
+ f.write("property float x\n")
+ f.write("property float y\n")
+ f.write("property float z\n")
+ f.write("end_header\n")
+
+ # Write vertices (no color)
+ for i in range(vertices.shape[0]):
+ f.write(f"{vertices[i, 0]} {vertices[i, 1]} {vertices[i, 2]}\n")
+
+ # print(f"PLY file saved to {filename} with {vertices.shape[0]} points")
+
+ # Verify file creation
+ # file_size = os.path.getsize(filename)
+ # print(f"File size: {file_size} bytes")
+
+ except Exception as e:
+ print(f"Error creating PLY file: {e}")
+
+ return filename
\ No newline at end of file
diff --git a/OmniPart/training/utils/dist_utils.py b/OmniPart/training/utils/dist_utils.py
new file mode 100644
index 0000000..0290f45
--- /dev/null
+++ b/OmniPart/training/utils/dist_utils.py
@@ -0,0 +1,138 @@
+import os
+import io
+from contextlib import contextmanager
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+
+def setup_dist(rank, local_rank, world_size, master_addr, master_port):
+ """
+ Set up the distributed training environment.
+
+ Args:
+ rank (int): Global rank of the current process
+ local_rank (int): Local rank of the current process on this node
+ world_size (int): Total number of processes in the distributed training
+ master_addr (str): IP address of the master node
+ master_port (str): Port on the master node for communication
+ """
+ os.environ['MASTER_ADDR'] = master_addr
+ os.environ['MASTER_PORT'] = master_port
+ os.environ['WORLD_SIZE'] = str(world_size)
+ os.environ['RANK'] = str(rank)
+ os.environ['LOCAL_RANK'] = str(local_rank)
+ # Set the device for the current process
+ torch.cuda.set_device(local_rank)
+ # Initialize the process group for distributed communication
+ dist.init_process_group('nccl', rank=rank, world_size=world_size)
+
+
+def read_file_dist(path):
+ """
+ Read the binary file distributedly.
+ File is only read once by the rank 0 process and broadcasted to other processes.
+ This reduces I/O overhead in distributed training.
+
+ Args:
+ path (str): Path to the file to be read
+
+ Returns:
+ data (io.BytesIO): The binary data read from the file.
+ """
+ if dist.is_initialized() and dist.get_world_size() > 1:
+ # Prepare tensor to store file size
+ size = torch.LongTensor(1).cuda()
+ if dist.get_rank() == 0:
+ # Master process reads the file
+ with open(path, 'rb') as f:
+ data = f.read()
+ # Convert binary data to CUDA tensor for broadcasting
+ data = torch.ByteTensor(
+ torch.UntypedStorage.from_buffer(data, dtype=torch.uint8)
+ ).cuda()
+ size[0] = data.shape[0]
+ # Broadcast file size to all processes
+ dist.broadcast(size, src=0)
+ if dist.get_rank() != 0:
+ # Non-master processes allocate buffer for receiving data
+ data = torch.ByteTensor(size[0].item()).cuda()
+ # Broadcast actual file data to all processes
+ dist.broadcast(data, src=0)
+ # Convert tensor back to binary data
+ data = data.cpu().numpy().tobytes()
+ data = io.BytesIO(data)
+ return data
+ else:
+ # For non-distributed or single-process case, just read directly
+ with open(path, 'rb') as f:
+ data = f.read()
+ data = io.BytesIO(data)
+ return data
+
+
+def unwrap_dist(model):
+ """
+ Unwrap the model from distributed training wrapper.
+
+ Args:
+ model: A potentially wrapped PyTorch model
+
+ Returns:
+ The underlying model without DistributedDataParallel wrapper
+ """
+ if isinstance(model, DDP):
+ return model.module
+ return model
+
+
+@contextmanager
+def master_first():
+ """
+ A context manager that ensures master process (rank 0) executes first.
+ All other processes wait for the master to finish before proceeding.
+
+ Usage:
+ with master_first():
+ # Code that should execute in master first, then others
+ """
+ if not dist.is_initialized():
+ # If not in distributed mode, just execute normally
+ yield
+ else:
+ if dist.get_rank() == 0:
+ # Master process executes the code
+ yield
+ # Signal completion to other processes
+ dist.barrier()
+ else:
+ # Other processes wait for master to finish
+ dist.barrier()
+ # Then execute the code
+ yield
+
+
+@contextmanager
+def local_master_first():
+ """
+ A context manager that ensures local master process (first process on each node)
+ executes first. Other processes on the same node wait before proceeding.
+
+ Usage:
+ with local_master_first():
+ # Code that should execute in local master first, then others
+ """
+ if not dist.is_initialized():
+ # If not in distributed mode, just execute normally
+ yield
+ else:
+ if dist.get_rank() % torch.cuda.device_count() == 0:
+ # Local master process executes the code
+ yield
+ # Signal completion to other processes
+ dist.barrier()
+ else:
+ # Other processes wait for local master to finish
+ dist.barrier()
+ # Then execute the code
+ yield
\ No newline at end of file
diff --git a/OmniPart/training/utils/elastic_utils.py b/OmniPart/training/utils/elastic_utils.py
new file mode 100644
index 0000000..cba3cf8
--- /dev/null
+++ b/OmniPart/training/utils/elastic_utils.py
@@ -0,0 +1,228 @@
+from abc import abstractmethod
+from contextlib import contextmanager
+from typing import Tuple
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class MemoryController:
+ """
+ Base class for memory management during training.
+ """
+
+ _last_input_size = None
+ _last_mem_ratio = []
+
+ @contextmanager
+ def record(self):
+ pass
+
+ def update_run_states(self, input_size=None, mem_ratio=None):
+ if self._last_input_size is None:
+ self._last_input_size = input_size
+ elif self._last_input_size!= input_size:
+ raise ValueError(f'Input size should not change for different ElasticModules.')
+ self._last_mem_ratio.append(mem_ratio)
+
+ @abstractmethod
+ def get_mem_ratio(self, input_size):
+ pass
+
+ @abstractmethod
+ def state_dict(self):
+ pass
+
+ @abstractmethod
+ def log(self):
+ pass
+
+
+class LinearMemoryController(MemoryController):
+ """
+ A simple controller for memory management during training.
+ The memory usage is modeled as a linear function of:
+ - the number of input parameters
+ - the ratio of memory the model use compared to the maximum usage (with no checkpointing)
+ memory_usage = k * input_size * mem_ratio + b
+ The controller keeps track of the memory usage and gives the
+ expected memory ratio to keep the memory usage under a target
+ """
+ def __init__(
+ self,
+ buffer_size=1000,
+ update_every=500,
+ target_ratio=0.8,
+ available_memory=None,
+ max_mem_ratio_start=0.1,
+ params=None,
+ device=None
+ ):
+ self.buffer_size = buffer_size
+ self.update_every = update_every
+ self.target_ratio = target_ratio
+ self.device = device or torch.cuda.current_device()
+ self.available_memory = available_memory or torch.cuda.get_device_properties(self.device).total_memory / 1024**3
+
+ self._memory = np.zeros(buffer_size, dtype=np.float32)
+ self._input_size = np.zeros(buffer_size, dtype=np.float32)
+ self._mem_ratio = np.zeros(buffer_size, dtype=np.float32)
+ self._buffer_ptr = 0
+ self._buffer_length = 0
+ self._params = tuple(params) if params is not None else (0.0, 0.0)
+ self._max_mem_ratio = max_mem_ratio_start
+ self.step = 0
+
+ def __repr__(self):
+ return f'LinearMemoryController(target_ratio={self.target_ratio}, available_memory={self.available_memory})'
+
+ def _add_sample(self, memory, input_size, mem_ratio):
+ self._memory[self._buffer_ptr] = memory
+ self._input_size[self._buffer_ptr] = input_size
+ self._mem_ratio[self._buffer_ptr] = mem_ratio
+ self._buffer_ptr = (self._buffer_ptr + 1) % self.buffer_size
+ self._buffer_length = min(self._buffer_length + 1, self.buffer_size)
+
+ @contextmanager
+ def record(self):
+ torch.cuda.reset_peak_memory_stats(self.device)
+ self._last_input_size = None
+ self._last_mem_ratio = []
+ yield
+ self._last_memory = torch.cuda.max_memory_allocated(self.device) / 1024**3
+ self._last_mem_ratio = sum(self._last_mem_ratio) / len(self._last_mem_ratio)
+ self._add_sample(self._last_memory, self._last_input_size, self._last_mem_ratio)
+ self.step += 1
+ if self.step % self.update_every == 0:
+ self._max_mem_ratio = min(1.0, self._max_mem_ratio + 0.1)
+ self._fit_params()
+
+ def _fit_params(self):
+ memory_usage = self._memory[:self._buffer_length]
+ input_size = self._input_size[:self._buffer_length]
+ mem_ratio = self._mem_ratio[:self._buffer_length]
+
+ x = input_size * mem_ratio
+ y = memory_usage
+ k, b = np.polyfit(x, y, 1)
+ self._params = (k, b)
+ # self._visualize()
+
+ def _visualize(self):
+ import matplotlib.pyplot as plt
+ memory_usage = self._memory[:self._buffer_length]
+ input_size = self._input_size[:self._buffer_length]
+ mem_ratio = self._mem_ratio[:self._buffer_length]
+ k, b = self._params
+
+ plt.scatter(input_size * mem_ratio, memory_usage, c=mem_ratio, cmap='viridis')
+ x = np.array([0.0, 20000.0])
+ plt.plot(x, k * x + b, c='r')
+ plt.savefig(f'linear_memory_controller_{self.step}.png')
+ plt.cla()
+
+ def get_mem_ratio(self, input_size):
+ k, b = self._params
+ if k == 0: return np.random.rand() * self._max_mem_ratio
+ pred = (self.available_memory * self.target_ratio - b) / (k * input_size)
+ return min(self._max_mem_ratio, max(0.0, pred))
+
+ def state_dict(self):
+ return {
+ 'params': self._params,
+ }
+
+ def load_state_dict(self, state_dict):
+ self._params = tuple(state_dict['params'])
+
+ def log(self):
+ return {
+ 'params/k': self._params[0],
+ 'params/b': self._params[1],
+ 'memory': self._last_memory,
+ 'input_size': self._last_input_size,
+ 'mem_ratio': self._last_mem_ratio,
+ }
+
+
+class ElasticModule(nn.Module):
+ """
+ Module for training with elastic memory management.
+ """
+ def __init__(self):
+ super().__init__()
+ self._memory_controller: MemoryController = None
+
+ @abstractmethod
+ def _get_input_size(self, *args, **kwargs) -> int:
+ """
+ Get the size of the input data.
+
+ Returns:
+ int: The size of the input data.
+ """
+ pass
+
+ @abstractmethod
+ def _forward_with_mem_ratio(self, *args, mem_ratio=0.0, **kwargs) -> Tuple[float, Tuple]:
+ """
+ Forward with a given memory ratio.
+ """
+ pass
+
+ def register_memory_controller(self, memory_controller: MemoryController):
+ self._memory_controller = memory_controller
+
+ def forward(self, *args, **kwargs):
+ if self._memory_controller is None or not torch.is_grad_enabled() or not self.training:
+ _, ret = self._forward_with_mem_ratio(*args, **kwargs)
+ else:
+ input_size = self._get_input_size(*args, **kwargs)
+ mem_ratio = self._memory_controller.get_mem_ratio(input_size)
+ mem_ratio, ret = self._forward_with_mem_ratio(*args, mem_ratio=mem_ratio, **kwargs)
+ self._memory_controller.update_run_states(input_size, mem_ratio)
+ return ret
+
+
+class ElasticModuleMixin:
+ """
+ Mixin for training with elastic memory management.
+ """
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._memory_controller: MemoryController = None
+
+ @abstractmethod
+ def _get_input_size(self, *args, **kwargs) -> int:
+ """
+ Get the size of the input data.
+
+ Returns:
+ int: The size of the input data.
+ """
+ pass
+
+ @abstractmethod
+ @contextmanager
+ def with_mem_ratio(self, mem_ratio=1.0) -> float:
+ """
+ Context manager for training with a reduced memory ratio compared to the full memory usage.
+
+ Returns:
+ float: The exact memory ratio used during the forward pass.
+ """
+ pass
+
+ def register_memory_controller(self, memory_controller: MemoryController):
+ self._memory_controller = memory_controller
+
+ def forward(self, *args, **kwargs):
+ if self._memory_controller is None or not torch.is_grad_enabled() or not self.training:
+ ret = super().forward(*args, **kwargs)
+ else:
+ input_size = self._get_input_size(*args, **kwargs)
+ mem_ratio = self._memory_controller.get_mem_ratio(input_size)
+ with self.with_mem_ratio(mem_ratio) as exact_mem_ratio:
+ ret = super().forward(*args, **kwargs)
+ self._memory_controller.update_run_states(input_size, exact_mem_ratio)
+ return ret
diff --git a/OmniPart/training/utils/general_utils.py b/OmniPart/training/utils/general_utils.py
new file mode 100644
index 0000000..bbc2c19
--- /dev/null
+++ b/OmniPart/training/utils/general_utils.py
@@ -0,0 +1,354 @@
+import re
+import numpy as np
+import cv2
+import torch
+import contextlib
+
+
+# Dictionary utils
+def _dict_merge(dicta, dictb, prefix=''):
+ """
+ Merge two dictionaries recursively with conflict detection.
+
+ Args:
+ dicta: First dictionary to merge
+ dictb: Second dictionary to merge
+ prefix: Used for error reporting to track nested keys
+
+ Returns:
+ A new merged dictionary
+
+ Raises:
+ ValueError: If the same key exists in both dictionaries but has different types
+ """
+ assert isinstance(dicta, dict), 'input must be a dictionary'
+ assert isinstance(dictb, dict), 'input must be a dictionary'
+ dict_ = {}
+ # Get all unique keys from both dictionaries
+ all_keys = set(dicta.keys()).union(set(dictb.keys()))
+ for key in all_keys:
+ if key in dicta.keys() and key in dictb.keys():
+ # If key exists in both, recursively merge if both are dictionaries
+ if isinstance(dicta[key], dict) and isinstance(dictb[key], dict):
+ dict_[key] = _dict_merge(dicta[key], dictb[key], prefix=f'{prefix}.{key}')
+ else:
+ # Raise error for conflicting non-dictionary values
+ raise ValueError(f'Duplicate key {prefix}.{key} found in both dictionaries. Types: {type(dicta[key])}, {type(dictb[key])}')
+ elif key in dicta.keys():
+ # Copy values from first dictionary
+ dict_[key] = dicta[key]
+ else:
+ # Copy values from second dictionary
+ dict_[key] = dictb[key]
+ return dict_
+
+
+def dict_merge(dicta, dictb):
+ """
+ Merge two dictionaries.
+
+ This is the public interface that wraps _dict_merge with default prefix.
+ """
+ return _dict_merge(dicta, dictb, prefix='')
+
+
+def dict_foreach(dic, func, special_func={}):
+ """
+ Recursively apply a function to all non-dictionary leaf values in a dictionary.
+
+ Args:
+ dic: Dictionary to process
+ func: Default function to apply to each leaf value
+ special_func: Dictionary mapping keys to special functions for specific keys
+
+ Returns:
+ Transformed dictionary with function applied to all leaf values
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively process nested dictionaries
+ dic[key] = dict_foreach(dic[key], func)
+ else:
+ # Apply special function if key is in special_func, otherwise use default
+ if key in special_func.keys():
+ dic[key] = special_func[key](dic[key])
+ else:
+ dic[key] = func(dic[key])
+ return dic
+
+
+def dict_reduce(dicts, func, special_func={}):
+ """
+ Reduce a list of dictionaries. Leaf values must be scalars.
+
+ Args:
+ dicts: List of dictionaries to reduce
+ func: Default reduction function (takes a list of values, returns single value)
+ special_func: Dictionary mapping keys to special reduction functions
+
+ Returns:
+ A single merged dictionary with values reduced according to the provided functions
+ """
+ assert isinstance(dicts, list), 'input must be a list of dictionaries'
+ assert all([isinstance(d, dict) for d in dicts]), 'input must be a list of dictionaries'
+ assert len(dicts) > 0, 'input must be a non-empty list of dictionaries'
+ # Collect all unique keys across all dictionaries
+ all_keys = set([key for dict_ in dicts for key in dict_.keys()])
+ reduced_dict = {}
+ for key in all_keys:
+ # Extract values for this key from all dictionaries
+ vlist = [dict_[key] for dict_ in dicts if key in dict_.keys()]
+ if isinstance(vlist[0], dict):
+ # Recursively reduce nested dictionaries
+ reduced_dict[key] = dict_reduce(vlist, func, special_func)
+ else:
+ # Apply special function if key is in special_func, otherwise use default
+ if key in special_func.keys():
+ reduced_dict[key] = special_func[key](vlist)
+ else:
+ reduced_dict[key] = func(vlist)
+ return reduced_dict
+
+
+def dict_any(dic, func):
+ """
+ Check if any value in the dictionary satisfies the given predicate function.
+
+ Args:
+ dic: Dictionary to check
+ func: Predicate function that returns True/False for each leaf value
+
+ Returns:
+ True if any leaf value satisfies the predicate, False otherwise
+
+ dict any time: {'step': 16.795613527297974, 'elapsed': 16.795613527297974}
+ dict any step: 16.795613527297974
+ dict any elapsed: 16.795613527297974
+ dict any loss: {'bin_3': {'mse': nan}, 'bin_5': {'mse': nan}, 'mse': nan, 'loss': nan, 'bin_4': {'mse': nan}, 'bin_7': {'mse': nan}, 'bin_8': {'mse': nan}}
+ dict any bin_3: {'mse': nan}
+ dict any mse: nan
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ # print(f"dict any {key}: {dic[key]}")
+ if isinstance(dic[key], dict):
+ # Recursively check nested dictionaries
+ if dict_any(dic[key], func):
+ return True
+ else:
+ # Check current value against predicate
+ if func(dic[key]):
+ return True
+ return False
+
+
+def dict_all(dic, func):
+ """
+ Check if all values in the dictionary satisfy the given predicate function.
+
+ Args:
+ dic: Dictionary to check
+ func: Predicate function that returns True/False for each leaf value
+
+ Returns:
+ True if all leaf values satisfy the predicate, False otherwise
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively check nested dictionaries
+ if not dict_all(dic[key], func):
+ return False
+ else:
+ # Check current value against predicate
+ if not func(dic[key]):
+ return False
+ return True
+
+
+def dict_flatten(dic, sep='.'):
+ """
+ Flatten a nested dictionary into a dictionary with no nested dictionaries.
+
+ Args:
+ dic: Dictionary to flatten
+ sep: Separator string used to join key levels in the flattened dictionary
+
+ Returns:
+ A flattened dictionary with compound keys joined by the separator
+ """
+ assert isinstance(dic, dict), 'input must be a dictionary'
+ flat_dict = {}
+ for key in dic.keys():
+ if isinstance(dic[key], dict):
+ # Recursively flatten nested dictionaries and prefix with current key
+ sub_dict = dict_flatten(dic[key], sep=sep)
+ for sub_key in sub_dict.keys():
+ flat_dict[str(key) + sep + str(sub_key)] = sub_dict[sub_key]
+ else:
+ # Copy leaf values directly
+ flat_dict[key] = dic[key]
+ return flat_dict
+
+
+# Context utils
+@contextlib.contextmanager
+def nested_contexts(*contexts):
+ """
+ Create a single context manager from multiple context manager factories.
+
+ This utility allows combining multiple context managers into a single
+ context manager, simplifying code that needs to use multiple contexts.
+
+ Args:
+ *contexts: Context manager factory functions (functions that return context managers)
+
+ Yields:
+ Control to the inner block when all contexts are entered
+ """
+ with contextlib.ExitStack() as stack:
+ for ctx in contexts:
+ stack.enter_context(ctx())
+ yield
+
+
+# Image utils
+def make_grid(images, nrow=None, ncol=None, aspect_ratio=None):
+ """
+ Arrange multiple images into a grid.
+
+ Args:
+ images: List of images to arrange
+ nrow: Number of rows (calculated if not provided)
+ ncol: Number of columns (calculated if not provided)
+ aspect_ratio: Desired width/height ratio for the grid layout
+
+ Returns:
+ A single image containing the grid of input images
+ """
+ num_images = len(images)
+ # Calculate grid dimensions if not explicitly provided
+ if nrow is None and ncol is None:
+ if aspect_ratio is not None:
+ # Calculate rows to achieve desired aspect ratio
+ nrow = int(np.round(np.sqrt(num_images / aspect_ratio)))
+ else:
+ # Default to a roughly square grid
+ nrow = int(np.sqrt(num_images))
+ ncol = (num_images + nrow - 1) // nrow
+ elif nrow is None and ncol is not None:
+ # Calculate rows based on fixed columns
+ nrow = (num_images + ncol - 1) // ncol
+ elif nrow is not None and ncol is None:
+ # Calculate columns based on fixed rows
+ ncol = (num_images + nrow - 1) // nrow
+ else:
+ assert nrow * ncol >= num_images, 'nrow * ncol must be greater than or equal to the number of images'
+
+ # Create empty grid with appropriate dimensions
+ if images[0].ndim == 2:
+ # Grayscale images
+ grid = np.zeros((nrow * images[0].shape[0], ncol * images[0].shape[1]), dtype=images[0].dtype)
+ else:
+ # Color images
+ grid = np.zeros((nrow * images[0].shape[0], ncol * images[0].shape[1], images[0].shape[2]), dtype=images[0].dtype)
+
+ # Place each image in the grid
+ for i, img in enumerate(images):
+ row = i // ncol
+ col = i % ncol
+ grid[row * img.shape[0]:(row + 1) * img.shape[0], col * img.shape[1]:(col + 1) * img.shape[1]] = img
+ return grid
+
+
+def notes_on_image(img, notes=None):
+ """
+ Add text notes to an image by padding the bottom and adding text.
+
+ Args:
+ img: Input image
+ notes: Text to add at the bottom of the image
+
+ Returns:
+ Image with notes added
+ """
+ # Add padding at the bottom for the notes
+ img = np.pad(img, ((0, 32), (0, 0), (0, 0)), 'constant', constant_values=0)
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+ if notes is not None:
+ # Add text to the padded area
+ img = cv2.putText(img, notes, (0, img.shape[0] - 4), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1)
+ img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+ return img
+
+
+def save_image_with_notes(img, path, notes=None):
+ """
+ Save an image with optional text notes at the bottom.
+
+ Args:
+ img: Input image (numpy array or PyTorch tensor)
+ path: File path to save the image
+ notes: Optional text to add at the bottom of the image
+ """
+ # Convert PyTorch tensor to numpy if needed
+ if isinstance(img, torch.Tensor):
+ img = img.cpu().numpy().transpose(1, 2, 0)
+ # Scale floating point images to 0-255 range
+ if img.dtype == np.float32 or img.dtype == np.float64:
+ img = np.clip(img * 255, 0, 255).astype(np.uint8)
+ # Add notes to the image
+ img = notes_on_image(img, notes)
+ # Save with proper color conversion for OpenCV
+ cv2.imwrite(path, cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+
+
+# debug utils
+def atol(x, y):
+ """
+ Absolute tolerance - computes absolute difference between x and y.
+
+ Useful for numerical comparisons when absolute error matters.
+
+ Args:
+ x, y: Tensors to compare
+
+ Returns:
+ Absolute difference |x - y|
+ """
+ return torch.abs(x - y)
+
+
+def rtol(x, y):
+ """
+ Relative tolerance - computes relative difference between x and y.
+
+ Useful for numerical comparisons when relative error matters,
+ especially when comparing values of different magnitudes.
+
+ Args:
+ x, y: Tensors to compare
+
+ Returns:
+ Relative difference |x - y| / max(|x|, |y|)
+ """
+ return torch.abs(x - y) / torch.clamp_min(torch.maximum(torch.abs(x), torch.abs(y)), 1e-12)
+
+
+# print utils
+def indent(s, n=4):
+ """
+ Indent a multi-line string.
+
+ Args:
+ s: Input string to indent
+ n: Number of spaces to add before each line (except the first)
+
+ Returns:
+ Indented string with all lines except the first indented by n spaces
+ """
+ lines = s.split('\n')
+ for i in range(1, len(lines)):
+ lines[i] = ' ' * n + lines[i]
+ return '\n'.join(lines)
diff --git a/OmniPart/training/utils/grad_clip_utils.py b/OmniPart/training/utils/grad_clip_utils.py
new file mode 100644
index 0000000..990a435
--- /dev/null
+++ b/OmniPart/training/utils/grad_clip_utils.py
@@ -0,0 +1,81 @@
+from typing import *
+import torch
+import numpy as np
+import torch.utils
+
+
+class AdaptiveGradClipper:
+ """
+ Adaptive gradient clipping for training.
+ """
+ def __init__(
+ self,
+ max_norm=None,
+ clip_percentile=95.0,
+ buffer_size=1000,
+ ):
+ self.max_norm = max_norm
+ self.clip_percentile = clip_percentile
+ self.buffer_size = buffer_size
+
+ self._grad_norm = np.zeros(buffer_size, dtype=np.float32)
+ self._max_norm = max_norm
+ self._buffer_ptr = 0
+ self._buffer_length = 0
+
+ def __repr__(self):
+ return f'AdaptiveGradClipper(max_norm={self.max_norm}, clip_percentile={self.clip_percentile})'
+
+ def state_dict(self):
+ return {
+ 'grad_norm': self._grad_norm,
+ 'max_norm': self._max_norm,
+ 'buffer_ptr': self._buffer_ptr,
+ 'buffer_length': self._buffer_length,
+ }
+
+ def load_state_dict(self, state_dict):
+ self._grad_norm = state_dict['grad_norm']
+ self._max_norm = state_dict['max_norm']
+ self._buffer_ptr = state_dict['buffer_ptr']
+ self._buffer_length = state_dict['buffer_length']
+
+ def log(self):
+ return {
+ 'max_norm': self._max_norm,
+ }
+
+ def __call__(self, parameters, norm_type=2.0, error_if_nonfinite=False, foreach=None):
+ """Clip the gradient norm of an iterable of parameters.
+
+ The norm is computed over all gradients together, as if they were
+ concatenated into a single vector. Gradients are modified in-place.
+
+ Args:
+ parameters (Iterable[Tensor] or Tensor): an iterable of Tensors or a
+ single Tensor that will have gradients normalized
+ norm_type (float): type of the used p-norm. Can be ``'inf'`` for
+ infinity norm.
+ error_if_nonfinite (bool): if True, an error is thrown if the total
+ norm of the gradients from :attr:`parameters` is ``nan``,
+ ``inf``, or ``-inf``. Default: False (will switch to True in the future)
+ foreach (bool): use the faster foreach-based implementation.
+ If ``None``, use the foreach implementation for CUDA and CPU native tensors and silently
+ fall back to the slow implementation for other device types.
+ Default: ``None``
+
+ Returns:
+ Total norm of the parameter gradients (viewed as a single vector).
+ """
+ max_norm = self._max_norm if self._max_norm is not None else float('inf')
+ grad_norm = torch.nn.utils.clip_grad_norm_(parameters, max_norm=max_norm, norm_type=norm_type, error_if_nonfinite=error_if_nonfinite, foreach=foreach)
+
+ if torch.isfinite(grad_norm):
+ self._grad_norm[self._buffer_ptr] = grad_norm
+ self._buffer_ptr = (self._buffer_ptr + 1) % self.buffer_size
+ self._buffer_length = min(self._buffer_length + 1, self.buffer_size)
+ if self._buffer_length == self.buffer_size:
+ self._max_norm = np.percentile(self._grad_norm, self.clip_percentile)
+ self._max_norm = min(self._max_norm, self.max_norm) if self.max_norm is not None else self._max_norm
+
+ return grad_norm
\ No newline at end of file
diff --git a/OmniPart/training/utils/loss_utils.py b/OmniPart/training/utils/loss_utils.py
new file mode 100644
index 0000000..52049f6
--- /dev/null
+++ b/OmniPart/training/utils/loss_utils.py
@@ -0,0 +1,92 @@
+import torch
+import torch.nn.functional as F
+from torch.autograd import Variable
+from math import exp
+from lpips import LPIPS
+
+
+def smooth_l1_loss(pred, target, beta=1.0):
+ diff = torch.abs(pred - target)
+ loss = torch.where(diff < beta, 0.5 * diff ** 2 / beta, diff - 0.5 * beta)
+ return loss.mean()
+
+
+def l1_loss(network_output, gt):
+ return torch.abs((network_output - gt)).mean()
+
+
+def l2_loss(network_output, gt):
+ return ((network_output - gt) ** 2).mean()
+
+
+def gaussian(window_size, sigma):
+ gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)])
+ return gauss / gauss.sum()
+
+
+def create_window(window_size, channel):
+ _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+ _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
+ window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
+ return window
+
+
+def psnr(img1, img2, max_val=1.0):
+ mse = F.mse_loss(img1, img2)
+ return 20 * torch.log10(max_val / torch.sqrt(mse))
+
+
+def ssim(img1, img2, window_size=11, size_average=True):
+ channel = img1.size(-3)
+ window = create_window(window_size, channel)
+
+ if img1.is_cuda:
+ window = window.cuda(img1.get_device())
+ window = window.type_as(img1)
+
+ return _ssim(img1, img2, window, window_size, channel, size_average)
+
+def _ssim(img1, img2, window, window_size, channel, size_average=True):
+ mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel)
+ mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel)
+
+ mu1_sq = mu1.pow(2)
+ mu2_sq = mu2.pow(2)
+ mu1_mu2 = mu1 * mu2
+
+ sigma1_sq = F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) - mu1_sq
+ sigma2_sq = F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) - mu2_sq
+ sigma12 = F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) - mu1_mu2
+
+ C1 = 0.01 ** 2
+ C2 = 0.03 ** 2
+
+ ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
+
+ if size_average:
+ return ssim_map.mean()
+ else:
+ return ssim_map.mean(1).mean(1).mean(1)
+
+
+loss_fn_vgg = None
+def lpips(img1, img2, value_range=(0, 1)):
+ global loss_fn_vgg
+ if loss_fn_vgg is None:
+ loss_fn_vgg = LPIPS(net='vgg').cuda().eval()
+ # normalize to [-1, 1]
+ img1 = (img1 - value_range[0]) / (value_range[1] - value_range[0]) * 2 - 1
+ img2 = (img2 - value_range[0]) / (value_range[1] - value_range[0]) * 2 - 1
+ return loss_fn_vgg(img1, img2).mean()
+
+
+def normal_angle(pred, gt):
+ pred = pred * 2.0 - 1.0
+ gt = gt * 2.0 - 1.0
+ norms = pred.norm(dim=-1) * gt.norm(dim=-1)
+ cos_sim = (pred * gt).sum(-1) / (norms + 1e-9)
+ cos_sim = torch.clamp(cos_sim, -1.0, 1.0)
+ ang = torch.rad2deg(torch.acos(cos_sim[norms > 1e-9])).mean()
+ if ang.isnan():
+ return -1
+ return ang
diff --git a/OmniPart/training/utils/postprocessing_utils.py b/OmniPart/training/utils/postprocessing_utils.py
new file mode 100644
index 0000000..c5405f1
--- /dev/null
+++ b/OmniPart/training/utils/postprocessing_utils.py
@@ -0,0 +1,714 @@
+from typing import *
+import numpy as np
+import torch
+import utils3d
+import nvdiffrast.torch as dr
+from tqdm import tqdm
+import trimesh
+import trimesh.visual
+import xatlas
+import pyvista as pv
+from pymeshfix import _meshfix
+import igraph
+import cv2
+from PIL import Image
+from .random_utils import sphere_hammersley_sequence
+from .render_utils import render_multiview
+from ..renderers import GaussianRenderer
+from ..representations import Strivec, Gaussian, MeshExtractResult
+
+def _rgb_to_srgb(f: torch.Tensor) -> torch.Tensor:
+ """
+ convert a tensor, in any form / dimension, from rgb space to srgb space
+ Args:
+ f (torch.Tensor): input tensor
+
+ """
+ return torch.where(f <= 0.0031308, f * 12.92, torch.pow(torch.clamp(f, 0.0031308), 1.0/2.4)*1.055 - 0.055)
+
+def rgb_to_srgb_image(f: torch.Tensor) -> torch.Tensor:
+ """
+ convert an image tensor from rgb space to srgb space
+ Args:
+ f (torch.Tensor): input tensor
+
+ """
+ assert f.shape[-1] == 3 or f.shape[-1] == 4
+ out = torch.cat((_rgb_to_srgb(f[..., 0:3]), f[..., 3:4]), dim=-1) if f.shape[-1] == 4 else _rgb_to_srgb(f)
+ assert out.shape[0] == f.shape[0] and out.shape[1] == f.shape[1] and out.shape[2] == f.shape[2]
+ return out
+
+@torch.no_grad()
+def _fill_holes(
+ verts,
+ faces,
+ max_hole_size=0.04,
+ max_hole_nbe=32,
+ resolution=128,
+ num_views=500,
+ debug=False,
+ verbose=False
+):
+ """
+ Rasterize a mesh from multiple views and remove invisible faces.
+ Also includes postprocessing to:
+ 1. Remove connected components that are have low visibility.
+ 2. Mincut to remove faces at the inner side of the mesh connected to the outer side with a small hole.
+
+ Args:
+ verts (torch.Tensor): Vertices of the mesh. Shape (V, 3).
+ faces (torch.Tensor): Faces of the mesh. Shape (F, 3).
+ max_hole_size (float): Maximum area of a hole to fill.
+ max_hole_nbe (int): Maximum number of boundary edges in a hole to fill.
+ resolution (int): Resolution of the rasterization.
+ num_views (int): Number of views to rasterize the mesh.
+ debug (bool): Whether to output debug information and meshes.
+ verbose (bool): Whether to print progress.
+ """
+ # Construct cameras at uniformly distributed positions on a sphere
+ yaws = []
+ pitchs = []
+ for i in range(num_views):
+ y, p = sphere_hammersley_sequence(i, num_views) # Generate uniformly distributed points on sphere
+ yaws.append(y)
+ pitchs.append(p)
+ yaws = torch.tensor(yaws).cuda()
+ pitchs = torch.tensor(pitchs).cuda()
+ radius = 2.0 # Camera distance from origin
+ fov = torch.deg2rad(torch.tensor(40)).cuda() # Camera field of view
+ projection = utils3d.torch.perspective_from_fov_xy(fov, fov, 1, 3) # Create projection matrix
+ views = []
+ for (yaw, pitch) in zip(yaws, pitchs):
+ # Calculate camera position from spherical coordinates
+ orig = torch.tensor([
+ torch.sin(yaw) * torch.cos(pitch),
+ torch.cos(yaw) * torch.cos(pitch),
+ torch.sin(pitch),
+ ]).cuda().float() * radius
+ # Create view matrix looking at origin
+ view = utils3d.torch.view_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ views.append(view)
+ views = torch.stack(views, dim=0)
+
+ # Rasterize mesh from multiple viewpoints to determine visible faces
+ visblity = torch.zeros(faces.shape[0], dtype=torch.int32, device=verts.device)
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+ for i in tqdm(range(views.shape[0]), total=views.shape[0], disable=not verbose, desc='Rasterizing'):
+ view = views[i]
+ # Render from current viewpoint
+ buffers = utils3d.torch.rasterize_triangle_faces(
+ rastctx, verts[None], faces, resolution, resolution, view=view, projection=projection
+ )
+ # Collect face IDs that are visible from this view
+ face_id = buffers['face_id'][0][buffers['mask'][0] > 0.95] - 1
+ face_id = torch.unique(face_id).long()
+ visblity[face_id] += 1
+ # Normalize visibility to [0,1]
+ visblity = visblity.float() / num_views
+
+ # Prepare for mincut-based mesh cleaning
+ ## Construct edge data structures
+ edges, face2edge, edge_degrees = utils3d.torch.compute_edges(faces)
+ boundary_edge_indices = torch.nonzero(edge_degrees == 1).reshape(-1)
+ connected_components = utils3d.torch.compute_connected_components(faces, edges, face2edge)
+
+ ## Identify outer faces (those with high visibility)
+ outer_face_indices = torch.zeros(faces.shape[0], dtype=torch.bool, device=faces.device)
+ for i in range(len(connected_components)):
+ # Use visibility threshold - faces visible in at least 25-50% of views are considered outer faces
+ outer_face_indices[connected_components[i]] = visblity[connected_components[i]] > min(max(visblity[connected_components[i]].quantile(0.75).item(), 0.25), 0.5)
+ outer_face_indices = outer_face_indices.nonzero().reshape(-1)
+
+ ## Identify inner faces (completely invisible)
+ inner_face_indices = torch.nonzero(visblity == 0).reshape(-1)
+ if verbose:
+ tqdm.write(f'Found {inner_face_indices.shape[0]} invisible faces')
+ if inner_face_indices.shape[0] == 0:
+ return verts, faces
+
+ ## Construct dual graph (faces as nodes, edges as edges)
+ dual_edges, dual_edge2edge = utils3d.torch.compute_dual_graph(face2edge)
+ dual_edge2edge = edges[dual_edge2edge]
+ # Edge weights based on edge length - used for min-cut algorithm
+ dual_edges_weights = torch.norm(verts[dual_edge2edge[:, 0]] - verts[dual_edge2edge[:, 1]], dim=1)
+ if verbose:
+ tqdm.write(f'Dual graph: {dual_edges.shape[0]} edges')
+
+ ## Solve mincut problem using igraph
+ ### Construct main graph
+ g = igraph.Graph()
+ g.add_vertices(faces.shape[0])
+ g.add_edges(dual_edges.cpu().numpy())
+ g.es['weight'] = dual_edges_weights.cpu().numpy()
+
+ ### Add source and target nodes
+ g.add_vertex('s')
+ g.add_vertex('t')
+
+ ### Connect invisible faces to source with weight 1
+ g.add_edges([(f, 's') for f in inner_face_indices], attributes={'weight': torch.ones(inner_face_indices.shape[0], dtype=torch.float32).cpu().numpy()})
+
+ ### Connect outer faces to target with weight 1
+ g.add_edges([(f, 't') for f in outer_face_indices], attributes={'weight': torch.ones(outer_face_indices.shape[0], dtype=torch.float32).cpu().numpy()})
+
+ ### Solve mincut to separate inner from outer faces
+ cut = g.mincut('s', 't', (np.array(g.es['weight']) * 1000).tolist())
+ remove_face_indices = torch.tensor([v for v in cut.partition[0] if v < faces.shape[0]], dtype=torch.long, device=faces.device)
+ if verbose:
+ tqdm.write(f'Mincut solved, start checking the cut')
+
+ ### Validate the cut by checking each connected component
+ to_remove_cc = utils3d.torch.compute_connected_components(faces[remove_face_indices])
+ if debug:
+ tqdm.write(f'Number of connected components of the cut: {len(to_remove_cc)}')
+ valid_remove_cc = []
+ cutting_edges = []
+ for cc in to_remove_cc:
+ #### Check if the connected component has low visibility
+ visblity_median = visblity[remove_face_indices[cc]].median()
+ if debug:
+ tqdm.write(f'visblity_median: {visblity_median}')
+ if visblity_median > 0.25:
+ continue
+
+ #### Check if the cutting loop is small enough
+ cc_edge_indices, cc_edges_degree = torch.unique(face2edge[remove_face_indices[cc]], return_counts=True)
+ cc_boundary_edge_indices = cc_edge_indices[cc_edges_degree == 1]
+ cc_new_boundary_edge_indices = cc_boundary_edge_indices[~torch.isin(cc_boundary_edge_indices, boundary_edge_indices)]
+ if len(cc_new_boundary_edge_indices) > 0:
+ # Group boundary edges into connected components
+ cc_new_boundary_edge_cc = utils3d.torch.compute_edge_connected_components(edges[cc_new_boundary_edge_indices])
+ # Calculate the center of each boundary loop
+ cc_new_boundary_edges_cc_center = [verts[edges[cc_new_boundary_edge_indices[edge_cc]]].mean(dim=1).mean(dim=0) for edge_cc in cc_new_boundary_edge_cc]
+ cc_new_boundary_edges_cc_area = []
+ # Calculate the area of each boundary loop
+ for i, edge_cc in enumerate(cc_new_boundary_edge_cc):
+ _e1 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 0]] - cc_new_boundary_edges_cc_center[i]
+ _e2 = verts[edges[cc_new_boundary_edge_indices[edge_cc]][:, 1]] - cc_new_boundary_edges_cc_center[i]
+ cc_new_boundary_edges_cc_area.append(torch.norm(torch.cross(_e1, _e2, dim=-1), dim=1).sum() * 0.5)
+ if debug:
+ cutting_edges.append(cc_new_boundary_edge_indices)
+ tqdm.write(f'Area of the cutting loop: {cc_new_boundary_edges_cc_area}')
+ # Skip if any loop is too large
+ if any([l > max_hole_size for l in cc_new_boundary_edges_cc_area]):
+ continue
+
+ valid_remove_cc.append(cc)
+
+ # Generate debug visualizations if requested
+ if debug:
+ face_v = verts[faces].mean(dim=1).cpu().numpy()
+ vis_dual_edges = dual_edges.cpu().numpy()
+ vis_colors = np.zeros((faces.shape[0], 3), dtype=np.uint8)
+ vis_colors[inner_face_indices.cpu().numpy()] = [0, 0, 255] # Blue for inner
+ vis_colors[outer_face_indices.cpu().numpy()] = [0, 255, 0] # Green for outer
+ vis_colors[remove_face_indices.cpu().numpy()] = [255, 0, 255] # Magenta for removed by mincut
+ if len(valid_remove_cc) > 0:
+ vis_colors[remove_face_indices[torch.cat(valid_remove_cc)].cpu().numpy()] = [255, 0, 0] # Red for valid removal
+ utils3d.io.write_ply('dbg_dual.ply', face_v, edges=vis_dual_edges, vertex_colors=vis_colors)
+
+ vis_verts = verts.cpu().numpy()
+ vis_edges = edges[torch.cat(cutting_edges)].cpu().numpy()
+ utils3d.io.write_ply('dbg_cut.ply', vis_verts, edges=vis_edges)
+
+ # Remove the identified faces
+ if len(valid_remove_cc) > 0:
+ remove_face_indices = remove_face_indices[torch.cat(valid_remove_cc)]
+ mask = torch.ones(faces.shape[0], dtype=torch.bool, device=faces.device)
+ mask[remove_face_indices] = 0
+ faces = faces[mask]
+ # Clean up disconnected vertices
+ faces, verts = utils3d.torch.remove_unreferenced_vertices(faces, verts)
+ if verbose:
+ tqdm.write(f'Removed {(~mask).sum()} faces by mincut')
+ else:
+ if verbose:
+ tqdm.write(f'Removed 0 faces by mincut')
+
+ # Use meshfix to fill small holes in the mesh
+ mesh = _meshfix.PyTMesh()
+ mesh.load_array(verts.cpu().numpy(), faces.cpu().numpy())
+ mesh.fill_small_boundaries(nbe=max_hole_nbe, refine=True)
+ verts, faces = mesh.return_arrays()
+ verts, faces = torch.tensor(verts, device='cuda', dtype=torch.float32), torch.tensor(faces, device='cuda', dtype=torch.int32)
+
+ return verts, faces
+
+
+def postprocess_mesh(
+ vertices: np.array,
+ faces: np.array,
+ simplify: bool = True,
+ simplify_ratio: float = 0.9,
+ fill_holes: bool = True,
+ fill_holes_max_hole_size: float = 0.04,
+ fill_holes_max_hole_nbe: int = 32,
+ fill_holes_resolution: int = 1024,
+ fill_holes_num_views: int = 1000,
+ debug: bool = False,
+ verbose: bool = False,
+):
+ """
+ Postprocess a mesh by simplifying, removing invisible faces, and removing isolated pieces.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+ simplify (bool): Whether to simplify the mesh, using quadric edge collapse.
+ simplify_ratio (float): Ratio of faces to keep after simplification.
+ fill_holes (bool): Whether to fill holes in the mesh.
+ fill_holes_max_hole_size (float): Maximum area of a hole to fill.
+ fill_holes_max_hole_nbe (int): Maximum number of boundary edges of a hole to fill.
+ fill_holes_resolution (int): Resolution of the rasterization.
+ fill_holes_num_views (int): Number of views to rasterize the mesh.
+ debug (bool): Whether to output debug visualizations.
+ verbose (bool): Whether to print progress.
+ """
+
+ if verbose:
+ tqdm.write(f'Before postprocess: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+
+ if vertices.shape[0] == 0 or faces.shape[0] == 0:
+ return vertices, faces
+
+ try:
+ # Simplify mesh using quadric edge collapse decimation
+ if simplify and simplify_ratio > 0:
+ mesh = pv.PolyData(vertices, np.concatenate([np.full((faces.shape[0], 1), 3), faces], axis=1))
+ mesh = mesh.decimate(simplify_ratio, progress_bar=verbose)
+ vertices, faces = mesh.points, mesh.faces.reshape(-1, 4)[:, 1:]
+ if verbose:
+ tqdm.write(f'After decimate: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+
+ # Remove invisible faces and fill small holes
+ if fill_holes:
+ vertices, faces = torch.tensor(vertices).cuda(), torch.tensor(faces.astype(np.int32)).cuda()
+ vertices, faces = _fill_holes(
+ vertices, faces,
+ max_hole_size=fill_holes_max_hole_size,
+ max_hole_nbe=fill_holes_max_hole_nbe,
+ resolution=fill_holes_resolution,
+ num_views=fill_holes_num_views,
+ debug=debug,
+ verbose=verbose,
+ )
+ vertices, faces = vertices.cpu().numpy(), faces.cpu().numpy()
+ if verbose:
+ tqdm.write(f'After remove invisible faces: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+ except Exception as e:
+ tqdm.write(f'Error in postprocess_mesh: {e}')
+ return None, None
+
+ return vertices, faces
+
+
+def parametrize_mesh(vertices: np.array, faces: np.array):
+ """
+ Parametrize a mesh to a texture space, using xatlas.
+ This creates UV coordinates for the mesh that can be used for texture mapping.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+
+ Returns:
+ tuple: (remapped_vertices, remapped_faces, uvs) where uvs are the texture coordinates
+ """
+
+ # Parametrize the mesh using xatlas
+ vmapping, indices, uvs = xatlas.parametrize(vertices, faces)
+
+ # Apply the vertex mapping to get the final vertices
+ vertices = vertices[vmapping]
+ faces = indices
+
+ return vertices, faces, uvs
+
+
+def bake_texture(
+ vertices: np.array,
+ faces: np.array,
+ uvs: np.array,
+ observations: List[np.array],
+ masks: List[np.array],
+ extrinsics: List[np.array],
+ intrinsics: List[np.array],
+ texture_size: int = 2048,
+ near: float = 0.1,
+ far: float = 10.0,
+ mode: Literal['fast', 'opt'] = 'opt',
+ lambda_tv: float = 1e-2,
+ verbose: bool = False,
+ srgb_space: bool = False,
+):
+ """
+ Bake texture to a mesh from multiple observations.
+
+ Args:
+ vertices (np.array): Vertices of the mesh. Shape (V, 3).
+ faces (np.array): Faces of the mesh. Shape (F, 3).
+ uvs (np.array): UV coordinates of the mesh. Shape (V, 2).
+ observations (List[np.array]): List of observations. Each observation is a 2D image. Shape (H, W, 3).
+ masks (List[np.array]): List of masks. Each mask is a 2D image. Shape (H, W).
+ extrinsics (List[np.array]): List of extrinsics. Shape (4, 4).
+ intrinsics (List[np.array]): List of intrinsics. Shape (3, 3).
+ texture_size (int): Size of the texture.
+ near (float): Near plane of the camera.
+ far (float): Far plane of the camera.
+ mode (Literal['fast', 'opt']): Mode of texture baking:
+ 'fast': Simple weighted averaging of observed colors.
+ 'opt': Optimization-based texture generation with regularization.
+ lambda_tv (float): Weight of total variation loss in optimization.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ np.array: The baked texture as an RGB image (H, W, 3)
+ """
+ # Move data to GPU
+ vertices = torch.tensor(vertices).cuda()
+ faces = torch.tensor(faces.astype(np.int32)).cuda()
+ uvs = torch.tensor(uvs).cuda()
+ observations = [torch.tensor(obs / 255.0).float().cuda() for obs in observations]
+ masks = [torch.tensor(m>0).bool().cuda() for m in masks]
+ views = [utils3d.torch.extrinsics_to_view(torch.tensor(extr).cuda()) for extr in extrinsics]
+ projections = [utils3d.torch.intrinsics_to_perspective(torch.tensor(intr).cuda(), near, far) for intr in intrinsics]
+
+ if mode == 'fast':
+ # Fast texture baking - weighted average of observed colors
+ texture = torch.zeros((texture_size * texture_size, 3), dtype=torch.float32).cuda()
+ texture_weights = torch.zeros((texture_size * texture_size), dtype=torch.float32).cuda()
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+
+ # Iterate through each observation and accumulate colors
+ for observation, view, projection in tqdm(zip(observations, views, projections), total=len(observations), disable=not verbose, desc='Texture baking (fast)'):
+ with torch.no_grad():
+ # Rasterize the mesh from this viewpoint
+ rast = utils3d.torch.rasterize_triangle_faces(
+ rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection
+ )
+ uv_map = rast['uv'][0].detach().flip(0) # Flip Y to match texture convention
+ mask = rast['mask'][0].detach().bool() & masks[0] # Only use valid mask pixels
+
+ # Map UV coordinates to texture pixels
+ uv_map = (uv_map * texture_size).floor().long()
+ obs = observation[mask]
+ uv_map = uv_map[mask]
+ # Convert 2D UV to 1D indices for scattering
+ idx = uv_map[:, 0] + (texture_size - uv_map[:, 1] - 1) * texture_size
+ # Accumulate colors and weights
+ texture = texture.scatter_add(0, idx.view(-1, 1).expand(-1, 3), obs)
+ texture_weights = texture_weights.scatter_add(0, idx, torch.ones((obs.shape[0]), dtype=torch.float32, device=texture.device))
+
+ # Normalize by summed weights
+ mask = texture_weights > 0
+ texture[mask] /= texture_weights[mask][:, None]
+ texture = np.clip(texture.reshape(texture_size, texture_size, 3).cpu().numpy() * 255, 0, 255).astype(np.uint8)
+
+ if srgb_space:
+ # convert the texture from rgb space to srgb
+ texture = rgb_to_srgb_image(texture)
+
+ # Fill holes in texture using inpainting
+ mask = (texture_weights == 0).cpu().numpy().astype(np.uint8).reshape(texture_size, texture_size)
+ texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA)
+
+ elif mode == 'opt':
+ # Optimization-based texture baking with total variation regularization
+ rastctx = utils3d.torch.RastContext(backend='cuda')
+ observations = [observations.flip(0) for observations in observations] # Flip Y for rendering
+ masks = [m.flip(0) for m in masks]
+
+ # Precompute UV maps for efficiency
+ _uv = []
+ _uv_dr = []
+ for observation, view, projection in tqdm(zip(observations, views, projections), total=len(views), disable=not verbose, desc='Texture baking (opt): UV'):
+ with torch.no_grad():
+ rast = utils3d.torch.rasterize_triangle_faces(
+ rastctx, vertices[None], faces, observation.shape[1], observation.shape[0], uv=uvs[None], view=view, projection=projection
+ )
+ _uv.append(rast['uv'].detach())
+ _uv_dr.append(rast['uv_dr'].detach()) # Gradient information for differentiable rendering
+
+ # Initialize texture as a learnable parameter
+ texture = torch.nn.Parameter(torch.zeros((1, texture_size, texture_size, 3), dtype=torch.float32).cuda())
+ optimizer = torch.optim.Adam([texture], betas=(0.5, 0.9), lr=1e-2)
+
+ # Learning rate scheduling functions
+ def exp_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Exponential learning rate annealing"""
+ return start_lr * (end_lr / start_lr) ** (step / total_steps)
+
+ def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Cosine learning rate annealing"""
+ return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps))
+
+ def tv_loss(texture):
+ """Total variation loss for regularization"""
+ return torch.nn.functional.l1_loss(texture[:, :-1, :, :], texture[:, 1:, :, :]) + \
+ torch.nn.functional.l1_loss(texture[:, :, :-1, :], texture[:, :, 1:, :])
+
+ # Optimization loop
+ total_steps = 2500
+ with tqdm(total=total_steps, disable=not verbose, desc='Texture baking (opt): optimizing') as pbar:
+ for step in range(total_steps):
+ optimizer.zero_grad()
+ # Random sample a view for stochastic optimization
+ selected = np.random.randint(0, len(views))
+ uv, uv_dr, observation, mask = _uv[selected], _uv_dr[selected], observations[selected], masks[selected]
+ # Differentiable rendering of texture
+ render = dr.texture(texture, uv, uv_dr)[0]
+ # Loss calculation - L1 reconstruction loss + TV regularization
+ loss = torch.nn.functional.l1_loss(render[mask], observation[mask])
+ if lambda_tv > 0:
+ loss += lambda_tv * tv_loss(texture)
+ loss.backward()
+ optimizer.step()
+ # Learning rate annealing
+ optimizer.param_groups[0]['lr'] = cosine_anealing(optimizer, step, total_steps, 1e-2, 1e-5)
+ pbar.set_postfix({'loss': loss.item()})
+ pbar.update()
+
+ if srgb_space:
+ # convert the texture from rgb space to srgb
+ texture = rgb_to_srgb_image(texture)
+
+ # Convert optimized texture to numpy array
+ texture = np.clip(texture[0].flip(0).detach().cpu().numpy() * 255, 0, 255).astype(np.uint8)
+
+ # Fill any remaining holes in the texture
+ mask = 1 - utils3d.torch.rasterize_triangle_faces(
+ rastctx, (uvs * 2 - 1)[None], faces, texture_size, texture_size
+ )['mask'][0].detach().cpu().numpy().astype(np.uint8)
+ texture = cv2.inpaint(texture, mask, 3, cv2.INPAINT_TELEA)
+ else:
+ raise ValueError(f'Unknown mode: {mode}')
+
+ return texture
+
+
+def to_glb(
+ app_rep: Union[Strivec, Gaussian],
+ mesh: MeshExtractResult,
+ simplify: float = 0.95,
+ fill_holes: bool = True,
+ fill_holes_max_size: float = 0.04,
+ texture_size: int = 1024,
+ debug: bool = False,
+ verbose: bool = True,
+) -> trimesh.Trimesh:
+ """
+ Convert a generated asset to a glb file.
+
+ Args:
+ app_rep (Union[Strivec, Gaussian]): Appearance representation.
+ mesh (MeshExtractResult): Extracted mesh.
+ simplify (float): Ratio of faces to remove in simplification.
+ fill_holes (bool): Whether to fill holes in the mesh.
+ fill_holes_max_size (float): Maximum area of a hole to fill.
+ texture_size (int): Size of the texture.
+ debug (bool): Whether to print debug information.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ trimesh.Trimesh: The processed mesh with texture, ready for GLB export
+ """
+ # Extract mesh data from the result
+ vertices = mesh.vertices.cpu().numpy()
+ faces = mesh.faces.cpu().numpy()
+
+ # Apply mesh post-processing
+ vertices, faces = postprocess_mesh(
+ vertices, faces,
+ simplify=simplify > 0,
+ simplify_ratio=simplify,
+ fill_holes=fill_holes,
+ fill_holes_max_hole_size=fill_holes_max_size,
+ fill_holes_max_hole_nbe=int(250 * np.sqrt(1-simplify)), # Scale hole size by mesh complexity
+ fill_holes_resolution=1024,
+ fill_holes_num_views=1000,
+ debug=debug,
+ verbose=verbose,
+ )
+
+ if vertices is None or faces is None:
+ return None
+
+ if vertices.shape[0] == 0 or faces.shape[0] == 0:
+ return None
+
+ # Create UV mapping for the mesh
+ vertices, faces, uvs = parametrize_mesh(vertices, faces)
+
+ # Render multi-view images from the appearance representation for texturing
+ observations, extrinsics, intrinsics = render_multiview(app_rep, resolution=1024, nviews=100)
+ # Create masks from the rendered images
+ masks = [np.any(observation > 0, axis=-1) for observation in observations]
+ # Convert camera parameters to numpy
+ extrinsics = [extrinsics[i].cpu().numpy() for i in range(len(extrinsics))]
+ intrinsics = [intrinsics[i].cpu().numpy() for i in range(len(intrinsics))]
+
+ # Bake texture from the rendered views onto the mesh
+ texture = bake_texture(
+ vertices, faces, uvs,
+ observations, masks, extrinsics, intrinsics,
+ texture_size=texture_size, mode='opt', # Use optimization-based texturing
+ lambda_tv=0.01, # Total variation regularization
+ verbose=verbose
+ )
+ texture = Image.fromarray(texture)
+
+ # Convert from z-up to y-up coordinate system (common in many 3D formats)
+ vertices = vertices @ np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]])
+
+ # Create PBR material for the mesh
+ material = trimesh.visual.material.PBRMaterial(
+ roughnessFactor=1.0,
+ baseColorTexture=texture,
+ baseColorFactor=np.array([255, 255, 255, 255], dtype=np.uint8)
+ )
+
+ # Create the final trimesh object with texture
+ mesh = trimesh.Trimesh(vertices, faces, visual=trimesh.visual.TextureVisuals(uv=uvs, material=material))
+ return mesh
+
+
+def simplify_gs(
+ gs: Gaussian,
+ simplify: float = 0.95,
+ verbose: bool = True,
+):
+ """
+ Simplify 3D Gaussians using an optimization-based approach
+ NOTE: this function is not used in the current implementation for the unsatisfactory performance.
+
+ Args:
+ gs (Gaussian): 3D Gaussian representation to simplify.
+ simplify (float): Ratio of Gaussians to remove in simplification.
+ verbose (bool): Whether to print progress.
+
+ Returns:
+ Gaussian: The simplified Gaussian representation
+ """
+ if simplify <= 0:
+ return gs
+
+ # Render multi-view images from the original Gaussian representation
+ observations, extrinsics, intrinsics = render_multiview(gs, resolution=1024, nviews=100)
+ observations = [torch.tensor(obs / 255.0).float().cuda().permute(2, 0, 1) for obs in observations]
+
+ # Following https://arxiv.org/pdf/2411.06019
+ # Initialize renderer
+ renderer = GaussianRenderer({
+ "resolution": 1024,
+ "near": 0.8,
+ "far": 1.6,
+ "ssaa": 1,
+ "bg_color": (0,0,0),
+ })
+
+ # Clone the Gaussian representation
+ new_gs = Gaussian(**gs.init_params)
+ new_gs._features_dc = gs._features_dc.clone()
+ new_gs._features_rest = gs._features_rest.clone() if gs._features_rest is not None else None
+ new_gs._opacity = torch.nn.Parameter(gs._opacity.clone())
+ new_gs._rotation = torch.nn.Parameter(gs._rotation.clone())
+ new_gs._scaling = torch.nn.Parameter(gs._scaling.clone())
+ new_gs._xyz = torch.nn.Parameter(gs._xyz.clone())
+
+ # Set up optimizer with different learning rates for different parameters
+ start_lr = [1e-4, 1e-3, 5e-3, 0.025] # Position, rotation, scaling, opacity
+ end_lr = [1e-6, 1e-5, 5e-5, 0.00025]
+ optimizer = torch.optim.Adam([
+ {"params": new_gs._xyz, "lr": start_lr[0]},
+ {"params": new_gs._rotation, "lr": start_lr[1]},
+ {"params": new_gs._scaling, "lr": start_lr[2]},
+ {"params": new_gs._opacity, "lr": start_lr[3]},
+ ], lr=start_lr[0])
+
+ # Learning rate scheduling functions
+ def exp_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Exponential learning rate annealing"""
+ return start_lr * (end_lr / start_lr) ** (step / total_steps)
+
+ def cosine_anealing(optimizer, step, total_steps, start_lr, end_lr):
+ """Cosine learning rate annealing"""
+ return end_lr + 0.5 * (start_lr - end_lr) * (1 + np.cos(np.pi * step / total_steps))
+
+ # Auxiliary variables for proximal optimization algorithm
+ _zeta = new_gs.get_opacity.clone().detach().squeeze()
+ _lambda = torch.zeros_like(_zeta)
+ _delta = 1e-7 # Regularization parameter
+ _interval = 10 # Interval for updates
+ num_target = int((1 - simplify) * _zeta.shape[0]) # Target number of Gaussians after simplification
+
+ # Optimization loop
+ with tqdm(total=2500, disable=not verbose, desc='Simplifying Gaussian') as pbar:
+ for i in range(2500):
+ # Prune low-opacity Gaussians periodically
+ if i % 100 == 0:
+ mask = new_gs.get_opacity.squeeze() > 0.05
+ mask = torch.nonzero(mask).squeeze()
+ # Update all relevant parameters
+ new_gs._xyz = torch.nn.Parameter(new_gs._xyz[mask])
+ new_gs._rotation = torch.nn.Parameter(new_gs._rotation[mask])
+ new_gs._scaling = torch.nn.Parameter(new_gs._scaling[mask])
+ new_gs._opacity = torch.nn.Parameter(new_gs._opacity[mask])
+ new_gs._features_dc = new_gs._features_dc[mask]
+ new_gs._features_rest = new_gs._features_rest[mask] if new_gs._features_rest is not None else None
+ _zeta = _zeta[mask]
+ _lambda = _lambda[mask]
+ # Update optimizer state
+ for param_group, new_param in zip(optimizer.param_groups, [new_gs._xyz, new_gs._rotation, new_gs._scaling, new_gs._opacity]):
+ stored_state = optimizer.state[param_group['params'][0]]
+ if 'exp_avg' in stored_state:
+ stored_state['exp_avg'] = stored_state['exp_avg'][mask]
+ stored_state['exp_avg_sq'] = stored_state['exp_avg_sq'][mask]
+ del optimizer.state[param_group['params'][0]]
+ param_group['params'][0] = new_param
+ optimizer.state[param_group['params'][0]] = stored_state
+
+ opacity = new_gs.get_opacity.squeeze()
+
+ # Sparsify using proximal gradient method
+ if i % _interval == 0:
+ _zeta = _lambda + opacity.detach()
+ if opacity.shape[0] > num_target:
+ # Keep only the top K Gaussians by importance
+ index = _zeta.topk(num_target)[1]
+ _m = torch.ones_like(_zeta, dtype=torch.bool)
+ _m[index] = 0
+ _zeta[_m] = 0
+ _lambda = _lambda + opacity.detach() - _zeta
+
+ # Sample a random view for this iteration
+ view_idx = np.random.randint(len(observations))
+ observation = observations[view_idx]
+ extrinsic = extrinsics[view_idx]
+ intrinsic = intrinsics[view_idx]
+
+ # Render and compute loss
+ color = renderer.render(new_gs, extrinsic, intrinsic)['color']
+ rgb_loss = torch.nn.functional.l1_loss(color, observation)
+ # Loss includes reconstruction and sparsity term
+ loss = rgb_loss + \
+ _delta * torch.sum(torch.pow(_lambda + opacity - _zeta, 2))
+
+ # Optimization step
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+ # Update learning rate
+ for j in range(len(optimizer.param_groups)):
+ optimizer.param_groups[j]['lr'] = cosine_anealing(optimizer, i, 2500, start_lr[j], end_lr[j])
+
+ pbar.set_postfix({'loss': rgb_loss.item(), 'num': opacity.shape[0], 'lambda': _lambda.mean().item()})
+ pbar.update()
+
+ # Convert parameters back to data
+ new_gs._xyz = new_gs._xyz.data
+ new_gs._rotation = new_gs._rotation.data
+ new_gs._scaling = new_gs._scaling.data
+ new_gs._opacity = new_gs._opacity.data
+
+ return new_gs
diff --git a/OmniPart/training/utils/random_utils.py b/OmniPart/training/utils/random_utils.py
new file mode 100644
index 0000000..5b668c2
--- /dev/null
+++ b/OmniPart/training/utils/random_utils.py
@@ -0,0 +1,30 @@
+import numpy as np
+
+PRIMES = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
+
+def radical_inverse(base, n):
+ val = 0
+ inv_base = 1.0 / base
+ inv_base_n = inv_base
+ while n > 0:
+ digit = n % base
+ val += digit * inv_base_n
+ n //= base
+ inv_base_n *= inv_base
+ return val
+
+def halton_sequence(dim, n):
+ return [radical_inverse(PRIMES[dim], n) for dim in range(dim)]
+
+def hammersley_sequence(dim, n, num_samples):
+ return [n / num_samples] + halton_sequence(dim - 1, n)
+
+def sphere_hammersley_sequence(n, num_samples, offset=(0, 0), remap=False):
+ u, v = hammersley_sequence(2, n, num_samples)
+ u += offset[0] / num_samples
+ v += offset[1]
+ if remap:
+ u = 2 * u if u < 0.25 else 2 / 3 * u + 1 / 3
+ theta = np.arccos(1 - 2 * u) - np.pi / 2
+ phi = v * 2 * np.pi
+ return [phi, theta]
\ No newline at end of file
diff --git a/OmniPart/training/utils/render_utils.py b/OmniPart/training/utils/render_utils.py
new file mode 100644
index 0000000..7903367
--- /dev/null
+++ b/OmniPart/training/utils/render_utils.py
@@ -0,0 +1,156 @@
+import torch
+import numpy as np
+from tqdm import tqdm
+import utils3d
+import json
+
+from ..renderers import OctreeRenderer, GaussianRenderer, MeshRenderer
+from ..representations import Octree, Gaussian, MeshExtractResult
+from .random_utils import sphere_hammersley_sequence
+
+
+def yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, rs, fovs):
+ is_list = isinstance(yaws, list)
+ if not is_list:
+ yaws = [yaws]
+ pitchs = [pitchs]
+ if not isinstance(rs, list):
+ rs = [rs] * len(yaws)
+ if not isinstance(fovs, list):
+ fovs = [fovs] * len(yaws)
+ extrinsics = []
+ intrinsics = []
+ for yaw, pitch, r, fov in zip(yaws, pitchs, rs, fovs):
+ fov = torch.deg2rad(torch.tensor(float(fov))).cuda()
+ yaw = torch.tensor(float(yaw)).cuda()
+ pitch = torch.tensor(float(pitch)).cuda()
+ orig = torch.tensor([
+ torch.sin(yaw) * torch.cos(pitch),
+ torch.cos(yaw) * torch.cos(pitch),
+ torch.sin(pitch),
+ ]).cuda() * r
+ extr = utils3d.torch.extrinsics_look_at(orig, torch.tensor([0, 0, 0]).float().cuda(), torch.tensor([0, 0, 1]).float().cuda())
+ intr = utils3d.torch.intrinsics_from_fov_xy(fov, fov)
+ extrinsics.append(extr)
+ intrinsics.append(intr)
+ if not is_list:
+ extrinsics = extrinsics[0]
+ intrinsics = intrinsics[0]
+ return extrinsics, intrinsics
+
+
+def get_renderer(sample, **kwargs):
+ if isinstance(sample, Octree):
+ renderer = OctreeRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 0.8)
+ renderer.rendering_options.far = kwargs.get('far', 1.6)
+ renderer.rendering_options.bg_color = kwargs.get('bg_color', (0, 0, 0))
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 4)
+ renderer.pipe.primitive = sample.primitive
+ elif isinstance(sample, Gaussian):
+ renderer = GaussianRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 0.8)
+ renderer.rendering_options.far = kwargs.get('far', 1.6)
+ renderer.rendering_options.bg_color = kwargs.get('bg_color', (0, 0, 0))
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 1)
+ renderer.pipe.kernel_size = kwargs.get('kernel_size', 0.1)
+ renderer.pipe.use_mip_gaussian = True
+ elif isinstance(sample, MeshExtractResult):
+ renderer = MeshRenderer()
+ renderer.rendering_options.resolution = kwargs.get('resolution', 512)
+ renderer.rendering_options.near = kwargs.get('near', 1)
+ renderer.rendering_options.far = kwargs.get('far', 100)
+ renderer.rendering_options.ssaa = kwargs.get('ssaa', 4)
+ else:
+ raise ValueError(f'Unsupported sample type: {type(sample)}')
+ return renderer
+
+
+def render_frames(sample, extrinsics, intrinsics, options={}, colors_overwrite=None, verbose=True, **kwargs):
+ renderer = get_renderer(sample, **options)
+ rets = {}
+ for j, (extr, intr) in tqdm(enumerate(zip(extrinsics, intrinsics)), desc='Rendering', disable=not verbose):
+ if isinstance(sample, MeshExtractResult):
+ res = renderer.render(sample, extr, intr)
+ if 'normal' not in rets: rets['normal'] = []
+ rets['normal'].append(np.clip(res['normal'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
+ else:
+ res = renderer.render(sample, extr, intr, colors_overwrite=colors_overwrite)
+ if 'color' not in rets: rets['color'] = []
+ if 'depth' not in rets: rets['depth'] = []
+ rets['color'].append(np.clip(res['color'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
+ if 'percent_depth' in res:
+ rets['depth'].append(res['percent_depth'].detach().cpu().numpy())
+ elif 'depth' in res:
+ rets['depth'].append(res['depth'].detach().cpu().numpy())
+ else:
+ rets['depth'].append(None)
+ return rets
+
+
+def render_video(sample, resolution=512, bg_color=(0, 0, 0), num_frames=300, r=2, fov=40, **kwargs):
+ yaws = torch.linspace(0, 2 * 3.1415, num_frames)
+ pitch = 0.25 + 0.5 * torch.sin(torch.linspace(0, 2 * 3.1415, num_frames))
+ yaws = yaws.tolist()
+ pitch = pitch.tolist()
+ extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitch, r, fov)
+ return render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': bg_color}, **kwargs)
+
+
+def render_multiview(sample, resolution=512, nviews=30):
+ r = 2
+ fov = 40
+ cams = [sphere_hammersley_sequence(i, nviews) for i in range(nviews)]
+ yaws = [cam[0] for cam in cams]
+ pitchs = [cam[1] for cam in cams]
+ extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaws, pitchs, r, fov)
+ res = render_frames(sample, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': (0, 0, 0)})
+ return res['color'], extrinsics, intrinsics
+
+
+def render_snapshot(samples, resolution=512, bg_color=(0, 0, 0), offset=(-16 / 180 * np.pi, 20 / 180 * np.pi), r=10, fov=8, **kwargs):
+ yaw = [0, np.pi/2, np.pi, 3*np.pi/2]
+ yaw_offset = offset[0]
+ yaw = [y + yaw_offset for y in yaw]
+ pitch = [offset[1] for _ in range(4)]
+ extrinsics, intrinsics = yaw_pitch_r_fov_to_extrinsics_intrinsics(yaw, pitch, r, fov)
+ return render_frames(samples, extrinsics, intrinsics, {'resolution': resolution, 'bg_color': bg_color}, **kwargs)
+
+def get_part_bbox(part_name=None, bbox_file_path=None):
+ """
+ Retrieve bounding box information for a specified part name from a bbox_info.json file.
+
+ Args:
+ part_name (str): Name of the part to search for (e.g., "body", "head", "left leg")
+ bbox_file_path (str): Path to the bbox_info.json file
+
+ Returns:
+ dict: Bounding box information containing min, max, center and size for the part
+ Returns None if part is not found
+ """
+ import json
+
+ if bbox_file_path is None:
+ raise ValueError("bbox_file_path must be provided")
+ # Load the bbox information from JSON file
+ with open(bbox_file_path, 'r') as f:
+ bbox_info = json.load(f)
+
+ if part_name is None:
+ # return all the parts information
+ return bbox_info['parts']
+
+ # Check if looking for the whole object
+ if part_name == "whole_object" and "whole_object" in bbox_info:
+ return bbox_info["whole_object"]
+
+ # Search for the part in the parts list
+ if "parts" in bbox_info:
+ for part in bbox_info["parts"]:
+ if part["name"] == part_name:
+ return part
+
+ # Part not found
+ return None
\ No newline at end of file
diff --git a/OmniPart/training/utils/transfer_st_pt.py b/OmniPart/training/utils/transfer_st_pt.py
new file mode 100644
index 0000000..f27f5b2
--- /dev/null
+++ b/OmniPart/training/utils/transfer_st_pt.py
@@ -0,0 +1,168 @@
+import torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+def load_safetensors_content(safetensors_file_path):
+ """
+ Load and return the content from a safetensors file without saving
+
+ Args:
+ safetensors_file_path (str): Path to the input safetensors file
+
+ Returns:
+ dict: Dictionary containing the tensors from the safetensors file
+ """
+ try:
+ # Load the safetensors file
+ tensors = {}
+ with safe_open(safetensors_file_path, framework="pt") as f:
+ for key in f.keys():
+ tensors[key] = f.get_tensor(key)
+
+ print(f"Successfully loaded content from {safetensors_file_path}")
+ return tensors
+ except Exception as e:
+ print(f"Error loading {safetensors_file_path}: {str(e)}")
+ return None
+
+def convert_safetensors_to_pt(safetensors_file_path, pt_file_path):
+ """
+ Convert a safetensors file to PyTorch (.pt) format
+
+ Args:
+ safetensors_file_path (str): Path to the input safetensors file
+ pt_file_path (str): Path where the output PyTorch file will be saved
+
+ Returns:
+ bool: True if conversion was successful, False otherwise
+ """
+ try:
+ tensors = load_safetensors_content(safetensors_file_path)
+ if tensors is None:
+ return False
+
+ # Save as PyTorch file
+ torch.save(tensors, pt_file_path)
+
+ print(f"Successfully converted {safetensors_file_path} to {pt_file_path}")
+ return True
+ except Exception as e:
+ print(f"Error converting {safetensors_file_path} to {pt_file_path}: {str(e)}")
+ return False
+
+def load_pt_content(pt_file_path):
+ """
+ Load and return the content from a PyTorch (.pt) file
+
+ Args:
+ pt_file_path (str): Path to the input PyTorch file
+
+ Returns:
+ dict: Dictionary containing the tensors from the PyTorch file
+ """
+ try:
+ # Load the PyTorch file
+ tensors = torch.load(pt_file_path)
+
+ print(f"Successfully loaded content from {pt_file_path}")
+ return tensors
+ except Exception as e:
+ print(f"Error loading {pt_file_path}: {str(e)}")
+ return None
+
+def convert_pt_to_safetensors(pt_file_path, safetensors_file_path=None):
+ """
+ Convert a PyTorch (.pt) file to safetensors format
+
+ Args:
+ pt_file_path (str): Path to the input PyTorch file
+ safetensors_file_path (str, optional): Path where the output safetensors file will be saved.
+ If None, saves to the same location as pt_file with .safetensors extension.
+
+ Returns:
+ bool: True if conversion was successful, False otherwise
+ """
+ save_path_name = None
+ try:
+ # Generate default output path if not provided
+ if safetensors_file_path is None:
+ if pt_file_path.endswith('.pt'):
+ safetensors_file_path = pt_file_path[:-3] + '.safetensors'
+ save_path_name = pt_file_path[:-3]
+ else:
+ safetensors_file_path = pt_file_path + '.safetensors'
+ save_path_name = pt_file_path
+
+ tensors = load_pt_content(pt_file_path)
+ if tensors is None:
+ return False
+
+ # Save as safetensors file
+ save_file(tensors, safetensors_file_path)
+
+ print(f"Successfully converted {pt_file_path} to {safetensors_file_path}")
+ return save_path_name
+
+ except Exception as e:
+
+ raise RuntimeError(f"Error converting {pt_file_path} to {safetensors_file_path}: {str(e)}")
+
+def save_json(model_name, st_path_name):
+ """
+ Save the model name and path to a JSON file.
+
+ Args:
+ model_name (str): Name of the model
+ st_path_name (str): Path to the safetensors file
+ """
+ import json
+ import os
+ import shutil
+ # Define the source directory where JSON files are stored
+ source_dir = "/mnt/pfs/users/yangyunhan/tool-repo/trellis_dev/ckpts"
+
+ # Define known model paths
+ model_paths = {
+ "sparse_structure_decoder": "ss_dec_conv3d_16l8_fp16",
+ "sparse_structure_flow_model": "ss_flow_img_dit_L_16l8_fp16",
+ "slat_decoder_gs": "slat_dec_gs_swin8_B_64l8gs32_fp16",
+ "slat_decoder_rf": "slat_dec_rf_swin8_B_64l8r16_fp16",
+ "slat_decoder_mesh": "slat_dec_mesh_swin8_B_64l8m256c_fp16",
+ "slat_flow_model": "slat_flow_img_dit_L_64l8p2_fp16"
+ }
+
+ ckpt_name = model_paths[model_name]
+
+ # Construct path to the source JSON file
+ source_json_path = os.path.join(source_dir, f"{ckpt_name}.json")
+ print(source_json_path)
+
+ # Check if the source JSON exists
+ if os.path.exists(source_json_path):
+ # Copy the JSON file to the destination
+ shutil.copy(source_json_path, f"{st_path_name}.json")
+ print(f"Copied JSON for model {model_name} from {source_json_path}")
+ else:
+ print(f"JSON for model {model_name} not found in {source_dir}, creating new one")
+
+
+# Example usage
+if __name__ == "__main__":
+ import argparse
+ from safetensors.torch import save_file
+
+ parser = argparse.ArgumentParser(description="Convert safetensors file to PyTorch format or return content")
+ parser.add_argument("--input", type=str, required=True, help="Input safetensors file path")
+ parser.add_argument("--output", type=str, help="Output PyTorch file path (if not provided, content will just be loaded)")
+ parser.add_argument("--print-keys", action="store_true", help="Print the keys of tensors in the file")
+
+ args = parser.parse_args()
+
+ if args.output:
+ convert_safetensors_to_pt(args.input, args.output)
+ else:
+ tensors = load_safetensors_content(args.input)
+ if tensors and args.print_keys:
+ print("Keys in the safetensors file:")
+ for key in tensors.keys():
+ print(f"- {key}: {tensors[key].shape}")
diff --git a/OmniPart_node.py b/OmniPart_node.py
new file mode 100644
index 0000000..82b73c0
--- /dev/null
+++ b/OmniPart_node.py
@@ -0,0 +1,320 @@
+ # !/usr/bin/env python
+# -*- coding: UTF-8 -*-
+
+import numpy as np
+import torch
+import os
+from .model_loader_utils import tensor2image,phi2narry,nomarl_upscale
+from .OmniPart.scripts.inference_omnipart import (
+ inference_omnipart,prepare_inputs,apply_base_model,save_state_data,load_state_data,
+ process_image,apply_merge)
+import folder_paths
+import comfy
+import node_helpers
+from typing_extensions import override
+from comfy_api.latest import ComfyExtension, io
+from pathlib import PureWindowsPath
+from datetime import datetime
+import nodes
+os.environ["OPENCV_IO_ENABLE_OPENEXR"] = "1"
+
+MAX_SEED = np.iinfo(np.int32).max
+node_cr_path = os.path.dirname(os.path.abspath(__file__))
+
+device = torch.device(
+ "cuda:0") if torch.cuda.is_available() else torch.device(
+ "mps") if torch.backends.mps.is_available() else torch.device(
+ "cpu")
+
+weigths_OmniPart_current_path = os.path.join(folder_paths.models_dir, "OmniPart")
+if not os.path.exists(weigths_OmniPart_current_path):
+ os.makedirs(weigths_OmniPart_current_path)
+
+weigths_dinov2_current_path = os.path.join(folder_paths.models_dir, "dinov2")
+if not os.path.exists(weigths_dinov2_current_path):
+ os.makedirs(weigths_dinov2_current_path)
+
+folder_paths.add_model_folder_path("OmniPart", weigths_OmniPart_current_path) # OmniPart dir
+folder_paths.add_model_folder_path("dinov2", weigths_dinov2_current_path)
+
+class OmniPart_SM_Model(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+
+ return io.Schema(
+ node_id="OmniPart_SM_Model",
+ display_name="OmniPart_SM_Model",
+ category="OmniPart",
+ inputs=[
+ io.String.Input("custom_path", multiline=False,default="omnipart/OmniPart",),
+ io.Combo.Input("box_ckpt",options= ["none"] + [i for i in folder_paths.get_filename_list("OmniPart") if "box" in i.lower()]),
+ io.Combo.Input("partfield_encoder",options= ["none"] + [i for i in folder_paths.get_filename_list("OmniPart") if "encoder" in i.lower()]),
+ io.Combo.Input("dino",options= ["none"] + folder_paths.get_filename_list("dinov2") ),
+ ],
+ outputs=[
+ io.Custom("OmniPart_SM_Model").Output(),
+ ],
+ )
+ @classmethod
+ def execute(cls, custom_path,box_ckpt,partfield_encoder,dino) -> io.NodeOutput:
+ part_synthesis_ckpt=PureWindowsPath(custom_path).as_posix() if custom_path else None
+ bbox_gen_ckpt=folder_paths.get_full_path("OmniPart", box_ckpt) if box_ckpt != "none" else None
+ partfield_encoder_path=folder_paths.get_full_path("OmniPart", partfield_encoder) if box_ckpt != "none" else None
+ dino_path=folder_paths.get_full_path("dinov2", dino) if dino != "none" else None
+ assert bbox_gen_ckpt is not None and partfield_encoder is not None and dino_path is not None, "Please select the BboxGen and partfield_encoder and dino checkpoint file"
+ config_path=os.path.join(node_cr_path,"OmniPart/configs/bbox_gen.yaml")
+ if part_synthesis_ckpt is None:
+ part_synthesis_ckpt="omnipart/OmniPart"
+ part_synthesis_pipeline,bbox_gen_model=apply_base_model(part_synthesis_ckpt,partfield_encoder_path,bbox_gen_ckpt,dino_path,config_path,node_cr_path)
+ model={"part_synthesis_pipeline":part_synthesis_pipeline,"bbox_gen_model":bbox_gen_model}
+ return io.NodeOutput(model)
+
+
+class OmniPart_SM_PreModel(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return io.Schema(
+ node_id="OmniPart_SM_PreModel",
+ display_name="OmniPart_SM_PreModel",
+ category="OmniPart",
+ inputs=[
+ io.Combo.Input("rmgb",options= ["none"] + folder_paths.get_filename_list("OmniPart")),
+ io.Combo.Input("sam",options= ["none"] + [i for i in folder_paths.get_filename_list("OmniPart") if "sam" in i.lower()]),
+ ],
+ outputs=[
+ io.Custom("OmniPart_SM_SamModel").Output(display_name="sam_model"),
+ io.Custom("OmniPart_SM_SegModel").Output(display_name="rmbg_model"),
+ ],
+ )
+ @classmethod
+ def execute(cls, rmgb,sam,) -> io.NodeOutput:
+ sam_ckpt_path=folder_paths.get_full_path("OmniPart", sam) if sam != "none" else None
+ rmgb_ckpt_path=folder_paths.get_full_path("OmniPart", rmgb) if rmgb != "none" else None
+ assert sam_ckpt_path is not None and rmgb_ckpt_path is not None, "Please select the SAM and RMBG 2.0 checkpoint file"
+
+ print("Loading SAM model...")
+ from segment_anything import SamAutomaticMaskGenerator, build_sam #seg
+ sam_model = build_sam(checkpoint=sam_ckpt_path)
+
+ print("Loading BriaRMBG 2.0 model...")
+ from transformers import AutoConfig
+ from .OmniPart.configs.RMBG.birefnet import BiRefNet
+ rmgb_repo=os.path.join(node_cr_path,"OmniPart/configs/RMBG")
+ config = AutoConfig.from_pretrained(rmgb_repo, trust_remote_code=True)
+ rmbg_model = BiRefNet(config=config)
+ sd=comfy.utils.load_torch_file(rmgb_ckpt_path)
+ rmbg_model.load_state_dict(sd,strict=False)
+ del sd
+ rmbg_model.eval()
+ # rmbg_model = AutoModelForImageSegmentation.from_pretrained(rmgb_repo, trust_remote_code=True)
+
+ return io.NodeOutput (sam_model,rmbg_model)
+
+class OmniPart_SM_PreImg(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return io.Schema(
+ node_id="OmniPart_SM_PreImg",
+ display_name="OmniPart_SM_PreImg",
+ category="OmniPart",
+ inputs=[
+ io.Custom("OmniPart_SM_SamModel").Input("sam_model"),
+ io.Custom("OmniPart_SM_SegModel").Input("rmbg_model"),
+ io.Image.Input("image"),
+ io.Int.Input("threshold", default=1600, min=600, max=4000,step=200),
+ ],
+ outputs=[
+ io.Image.Output(display_name="image"),
+ io.String.Output( display_name="dir_prefix"),
+ ],
+ )
+ @classmethod
+ def execute(cls, sam_model,rmbg_model,image,threshold) -> io.NodeOutput:
+ phi_in=tensor2image(image)
+
+ dir_prefix = datetime.now().strftime("%y%m%d%H%M%S")[-6:]
+ user_dir=os.path.join(folder_paths.get_output_directory(), f"OmniPart/temp_{dir_prefix}")
+ if not os.path.exists(user_dir):
+ os.makedirs(user_dir)
+
+ image_path=os.path.join(user_dir,f"img_{dir_prefix}.png")
+ phi_in.save(image_path)
+
+ sam_model.to(device)
+ from segment_anything import SamAutomaticMaskGenerator
+ sam_mask_generator = SamAutomaticMaskGenerator(sam_model)
+ rmbg_model.to(device)
+
+ init_seg_path, pre_merge_image, state=process_image(image_path, threshold, sam_mask_generator,rmbg_model,user_dir,device)
+ save_state_data(state, user_dir,threshold)
+
+ sam_model.to("cpu")
+ del sam_mask_generator
+ rmbg_model.to("cpu")
+
+ torch.cuda.empty_cache()
+ image=phi2narry(pre_merge_image)
+ return io.NodeOutput(image, dir_prefix)
+
+
+class OmniPart_SM_MergeImg(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return io.Schema(
+ node_id="OmniPart_SM_MergeImg",
+ display_name="OmniPart_SM_MergeImg",
+ category="OmniPart",
+ inputs=[
+ io.Custom("OmniPart_SM_SamModel").Input("sam_model"),
+ io.String.Input( "dir_prefix", multiline=False,default="",),
+ io.String.Input( "merge_input", multiline=False,default="1,3;2,4",),
+ io.Image.Input("image",optional=True),
+ ],
+ outputs=[
+ io.Conditioning.Output(display_name="state"),
+ ],
+ )
+ @classmethod
+ def execute(cls, sam_model,dir_prefix,merge_input,image=None) -> io.NodeOutput:
+ if image is not None:
+ image=tensor2image(image)
+ if not dir_prefix:
+ dir_prefix_list=extract_loadimage_filenames(recent_workflow_data_sm)
+ if not dir_prefix_list:
+ raise ValueError("dir_prefix is required if no active workflow found input a valid dir_prefix")
+ else:
+ print(dir_prefix_list)
+ for prefix in dir_prefix_list:
+ if isinstance(prefix, str) and "_" in prefix:
+ dir_prefix_ = prefix.split("_",1)[0]
+ print(dir_prefix_)
+ if len(dir_prefix_)==6:
+ dir_prefix = dir_prefix_
+ break
+ else:
+ continue
+
+ else:
+ if len(dir_prefix)!=6:
+ raise ValueError("dir_prefix is required a number of 6 digits ")
+ user_dir=os.path.join(folder_paths.get_output_directory(), f"OmniPart/temp_{dir_prefix}")
+ img_name=f"img_{dir_prefix}"
+ state={
+ "processed_image": os.path.join(user_dir, f"{img_name}_processed.png"),
+ "img_name": img_name,
+ "pre_split_path": os.path.join(user_dir, f"{img_name}_pre_split.png"),
+ "user_dir": user_dir,
+ }
+ state=load_state_data(state, user_dir)
+
+ sam_model.to(device)
+ from segment_anything import SamAutomaticMaskGenerator
+ sam_mask_generator = SamAutomaticMaskGenerator(sam_model)
+ merged_seg_path, cond=apply_merge(merge_input, sam_mask_generator,state, user_dir,int(state.get("threshold",2000)))
+ cond.update(state)
+ sam_model.to("cpu")
+ del sam_mask_generator
+ torch.cuda.empty_cache()
+ return io.NodeOutput(state)
+
+
+class OmniPart_SM_Prebox(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return io.Schema(
+ node_id="OmniPart_SM_Prebox",
+ display_name="OmniPart_SM_Prebox",
+ category="OmniPart",
+ inputs=[
+ io.Custom("OmniPart_SM_Model").Input("model"),
+ io.Conditioning.Input("state"),
+ io.Int.Input("seed", default=0, min=0, max=MAX_SEED),
+ ],
+ outputs=[
+ io.Conditioning.Output(display_name="cond"),
+ ],
+ )
+ @classmethod
+ def execute(cls, model, state,seed) -> io.NodeOutput:
+ cond=prepare_inputs(state,model["part_synthesis_pipeline"],model["bbox_gen_model"],user_dir=state.get("user_dir"),seed=seed,output_dir=folder_paths.get_output_directory(),device=device)
+ cond.update({"seed":seed})
+ return io.NodeOutput(cond,)
+
+
+class OmniPart_SM_KSampler(io.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return io.Schema(
+ node_id="OmniPart_SM_KSampler",
+ display_name="OmniPart_SM_KSampler",
+ category="OmniPart",
+ inputs=[
+ io.Custom("OmniPart_SM_Model").Input("model"),
+ io.Int.Input("steps", default=20, min=1, max=10000),
+ io.Float.Input("cfg", default=8.0, min=0.0, max=100.0, step=0.1, round=0.01,),
+ io.Conditioning.Input("cond"),
+ io.Float.Input("simplify_ratio", default=0.3, min=0.0, max=1.0, step=0.1,display_mode=io.NumberDisplay.slider),
+
+ ],
+ outputs=[
+ io.String.Output(display_name="scene_texture"),
+ io.String.Output(display_name="mesh_segment"),
+ ],
+ )
+
+ @classmethod
+ def execute(cls, model, steps, cfg, cond,simplify_ratio ) -> io.NodeOutput:
+ scene_texture,mesh_segment=inference_omnipart(model["part_synthesis_pipeline"],cond,steps,cfg,simplify_ratio,device)
+ return io.NodeOutput(scene_texture,mesh_segment)
+
+from aiohttp import web
+from server import PromptServer
+@PromptServer.instance.routes.get("/OmniPart_SM_Extension")
+async def get_hello(request):
+ return web.json_response("OmniPart_SM_Extension")
+
+class OmniPart_SM_Extension(ComfyExtension):
+ @override
+ async def get_node_list(self) -> list[type[io.ComfyNode]]:
+ return [
+ OmniPart_SM_Model,
+ OmniPart_SM_PreModel,
+ OmniPart_SM_PreImg,
+ OmniPart_SM_MergeImg,
+ OmniPart_SM_Prebox,
+ OmniPart_SM_KSampler,
+ ]
+async def comfy_entrypoint() -> OmniPart_SM_Extension: # ComfyUI calls this to load your extension and its nodes.
+ return OmniPart_SM_Extension()
+
+
+recent_workflow_data_sm = None
+
+def on_prompt_handler(json_data):
+ global recent_workflow_data_sm
+ recent_workflow_data_sm = json_data
+ return json_data
+
+PromptServer.instance.add_on_prompt_handler(on_prompt_handler)
+
+def extract_loadimage_filenames(json_data):
+ filenames = []
+ if not json_data or not isinstance(json_data, dict):
+ return filenames
+
+ nodes_data = json_data.get("prompt", {}).get("nodes", [])
+ if not nodes_data and "nodes" in json_data:
+ nodes_data = json_data.get("nodes", [])
+
+
+ for node in nodes_data:
+ if node.get("type") == "LoadImage":
+ widgets_values = node.get("widgets_values", [])
+ if widgets_values and len(widgets_values) > 0:
+ filename = widgets_values[0]
+ if isinstance(filename, str):
+ filenames.append(filename)
+
+ return filenames
+
+
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000..5e445ae
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1,2 @@
+
+from .OmniPart_node import *
diff --git a/example_workflows/example.png b/example_workflows/example.png
index ec56135..6ccf53b 100644
Binary files a/example_workflows/example.png and b/example_workflows/example.png differ
diff --git a/example_workflows/omipart.json b/example_workflows/omipart.json
new file mode 100644
index 0000000..562aa77
--- /dev/null
+++ b/example_workflows/omipart.json
@@ -0,0 +1,667 @@
+{
+ "id": "b92b238b-eda1-4e92-b26f-ff5ed09a7c3f",
+ "revision": 0,
+ "last_node_id": 13,
+ "last_link_id": 17,
+ "nodes": [
+ {
+ "id": 5,
+ "type": "OmniPart_SM_PreModel",
+ "pos": [
+ 565.340087890625,
+ -137.2583465576172
+ ],
+ "size": [
+ 270,
+ 102
+ ],
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [
+ {
+ "name": "sam_model",
+ "type": "OmniPart_SM_SamModel",
+ "links": [
+ 5,
+ 7
+ ]
+ },
+ {
+ "name": "rmbg_model",
+ "type": "OmniPart_SM_SegModel",
+ "links": [
+ 6
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_PreModel"
+ },
+ "widgets_values": [
+ "model.safetensors",
+ "sam_vit_h_4b8939.pth"
+ ]
+ },
+ {
+ "id": 1,
+ "type": "OmniPart_SM_Model",
+ "pos": [
+ 1220.4803466796875,
+ 110.20159912109375
+ ],
+ "size": [
+ 270,
+ 130
+ ],
+ "flags": {},
+ "order": 1,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [
+ {
+ "name": "OmniPart_SM_Model",
+ "type": "OmniPart_SM_Model",
+ "links": [
+ 1,
+ 13
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_Model"
+ },
+ "widgets_values": [
+ "F:\\test\\ComfyUI\\models\\diffusers\\OmniPart",
+ "bbox_gen.ckpt",
+ "partfield_encoder.ckpt",
+ "dinov2_vitl14_reg4_pretrain.pth"
+ ]
+ },
+ {
+ "id": 2,
+ "type": "OmniPart_SM_Prebox",
+ "pos": [
+ 1546.1116943359375,
+ 93.35263061523438
+ ],
+ "size": [
+ 279.9546813964844,
+ 102
+ ],
+ "flags": {},
+ "order": 8,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "model",
+ "type": "OmniPart_SM_Model",
+ "link": 1
+ },
+ {
+ "name": "state",
+ "type": "CONDITIONING",
+ "link": 4
+ }
+ ],
+ "outputs": [
+ {
+ "name": "cond",
+ "type": "CONDITIONING",
+ "links": [
+ 14
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_Prebox"
+ },
+ "widgets_values": [
+ 682639378,
+ "randomize"
+ ]
+ },
+ {
+ "id": 11,
+ "type": "OmniPart_SM_KSampler",
+ "pos": [
+ 1538.918212890625,
+ 308.5582275390625
+ ],
+ "size": [
+ 270,
+ 126
+ ],
+ "flags": {},
+ "order": 9,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "model",
+ "type": "OmniPart_SM_Model",
+ "link": 13
+ },
+ {
+ "name": "cond",
+ "type": "CONDITIONING",
+ "link": 14
+ }
+ ],
+ "outputs": [
+ {
+ "name": "scene_texture",
+ "type": "STRING",
+ "links": [
+ 16
+ ]
+ },
+ {
+ "name": "mesh_segment",
+ "type": "STRING",
+ "links": [
+ 17
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_KSampler"
+ },
+ "widgets_values": [
+ 20,
+ 8,
+ 0.3
+ ]
+ },
+ {
+ "id": 8,
+ "type": "LoadImage",
+ "pos": [
+ 202.83811950683594,
+ 205.92686462402344
+ ],
+ "size": [
+ 296.6199951171875,
+ 344.6130065917969
+ ],
+ "flags": {},
+ "order": 2,
+ "mode": 2,
+ "inputs": [],
+ "outputs": [
+ {
+ "name": "IMAGE",
+ "type": "IMAGE",
+ "links": [
+ 10
+ ]
+ },
+ {
+ "name": "MASK",
+ "type": "MASK",
+ "links": null
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "LoadImage"
+ },
+ "widgets_values": [
+ "pasted/image (3).png",
+ "image"
+ ]
+ },
+ {
+ "id": 12,
+ "type": "Preview3D",
+ "pos": [
+ 1899.134033203125,
+ 469.2892150878906
+ ],
+ "size": [
+ 432.6700134277344,
+ 380.6000061035156
+ ],
+ "flags": {},
+ "order": 11,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "camera_info",
+ "shape": 7,
+ "type": "LOAD3D_CAMERA",
+ "link": null
+ },
+ {
+ "name": "model_file",
+ "type": "STRING",
+ "widget": {
+ "name": "model_file"
+ },
+ "link": 17
+ }
+ ],
+ "outputs": [],
+ "properties": {
+ "Node name for S&R": "Preview3D",
+ "Last Time Model File": "F:/ComfyUI311/ComfyUI/output/omni_mesh_segment.glb",
+ "Resource Folder": "ComfyUI311/ComfyUI/output",
+ "Camera Info": {
+ "position": {
+ "x": 0.21106112490752765,
+ "y": 4.553873108002032,
+ "z": -8.757605890826467
+ },
+ "target": {
+ "x": 0,
+ "y": 2.5,
+ "z": 0
+ },
+ "zoom": 1,
+ "cameraType": "perspective"
+ }
+ },
+ "widgets_values": [
+ "F:/ComfyUI311/ComfyUI/output/omni_mesh_segment.glb",
+ ""
+ ]
+ },
+ {
+ "id": 9,
+ "type": "Preview3D",
+ "pos": [
+ 1913.458984375,
+ 61.599273681640625
+ ],
+ "size": [
+ 432.6700134277344,
+ 380.6000061035156
+ ],
+ "flags": {},
+ "order": 10,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "camera_info",
+ "shape": 7,
+ "type": "LOAD3D_CAMERA",
+ "link": null
+ },
+ {
+ "name": "model_file",
+ "type": "STRING",
+ "widget": {
+ "name": "model_file"
+ },
+ "link": 16
+ }
+ ],
+ "outputs": [],
+ "properties": {
+ "Node name for S&R": "Preview3D",
+ "Last Time Model File": "F:/ComfyUI311/ComfyUI/output/omni_mesh_textured.glb",
+ "Resource Folder": "ComfyUI311/ComfyUI/output",
+ "Camera Info": {
+ "position": {
+ "x": -1.8449624733601526,
+ "y": 3.8908731194792407,
+ "z": -6.567685383150526
+ },
+ "target": {
+ "x": 0,
+ "y": 2.5,
+ "z": 0
+ },
+ "zoom": 1,
+ "cameraType": "perspective"
+ }
+ },
+ "widgets_values": [
+ "F:/ComfyUI311/ComfyUI/output/omni_mesh_textured.glb",
+ ""
+ ]
+ },
+ {
+ "id": 6,
+ "type": "OmniPart_SM_PreImg",
+ "pos": [
+ 534.1347045898438,
+ 100.50750732421875
+ ],
+ "size": [
+ 299.1499938964844,
+ 138.5
+ ],
+ "flags": {},
+ "order": 5,
+ "mode": 2,
+ "inputs": [
+ {
+ "name": "sam_model",
+ "type": "OmniPart_SM_SamModel",
+ "link": 7
+ },
+ {
+ "name": "rmbg_model",
+ "type": "OmniPart_SM_SegModel",
+ "link": 6
+ },
+ {
+ "name": "image",
+ "type": "IMAGE",
+ "link": 10
+ }
+ ],
+ "outputs": [
+ {
+ "name": "image",
+ "type": "IMAGE",
+ "links": [
+ 8
+ ]
+ },
+ {
+ "name": "dir_prefix",
+ "type": "STRING",
+ "links": [
+ 9
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_PreImg"
+ },
+ "widgets_values": [
+ 1600
+ ]
+ },
+ {
+ "id": 7,
+ "type": "SaveImage",
+ "pos": [
+ 542.306640625,
+ 286.7527770996094
+ ],
+ "size": [
+ 284.29998779296875,
+ 270
+ ],
+ "flags": {},
+ "order": 7,
+ "mode": 2,
+ "inputs": [
+ {
+ "name": "images",
+ "type": "IMAGE",
+ "link": 8
+ },
+ {
+ "name": "filename_prefix",
+ "type": "STRING",
+ "widget": {
+ "name": "filename_prefix"
+ },
+ "link": 9
+ }
+ ],
+ "outputs": [],
+ "properties": {},
+ "widgets_values": [
+ "ComfyUI"
+ ]
+ },
+ {
+ "id": 10,
+ "type": "LoadImage",
+ "pos": [
+ 931.633544921875,
+ 236.13815307617188
+ ],
+ "size": [
+ 270,
+ 314
+ ],
+ "flags": {},
+ "order": 3,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [
+ {
+ "name": "IMAGE",
+ "type": "IMAGE",
+ "links": [
+ 12
+ ]
+ },
+ {
+ "name": "MASK",
+ "type": "MASK",
+ "links": null
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "LoadImage"
+ },
+ "widgets_values": [
+ "141311_00001_.png",
+ "image"
+ ]
+ },
+ {
+ "id": 4,
+ "type": "OmniPart_SM_MergeImg",
+ "pos": [
+ 1213.916015625,
+ 301.4980163574219
+ ],
+ "size": [
+ 285,
+ 102
+ ],
+ "flags": {},
+ "order": 6,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "sam_model",
+ "type": "OmniPart_SM_SamModel",
+ "link": 5
+ },
+ {
+ "name": "image",
+ "shape": 7,
+ "type": "IMAGE",
+ "link": 12
+ }
+ ],
+ "outputs": [
+ {
+ "name": "state",
+ "type": "CONDITIONING",
+ "links": [
+ 4
+ ]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "OmniPart_SM_MergeImg"
+ },
+ "widgets_values": [
+ "141311",
+ "0,8,9;1,2,6,11,12;3;4;5;7;10"
+ ]
+ },
+ {
+ "id": 13,
+ "type": "Note",
+ "pos": [
+ 1032.968505859375,
+ -162.00013732910156
+ ],
+ "size": [
+ 509.04998779296875,
+ 156.8000030517578
+ ],
+ "flags": {},
+ "order": 4,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [],
+ "properties": {},
+ "widgets_values": [
+ "1 先禁用stage2 ，启用stage1 ，推理完成后，禁用stage1，启用stage2\n2、dir prefix 输入保存图片的前6位时间戳（在output）\n3、merge input 输入你想要合并的部位\n4、推理\n1, disable stage2 and enable stage1. After inference is complete, disable stage1 and enable stage2\n2. Dir prefix: Input the first 6 timestamps of the saved image\n3. Merge input: Enter the part you want to merge\n4. infer"
+ ],
+ "color": "#432",
+ "bgcolor": "#653"
+ }
+ ],
+ "links": [
+ [
+ 1,
+ 1,
+ 0,
+ 2,
+ 0,
+ "OmniPart_SM_Model"
+ ],
+ [
+ 4,
+ 4,
+ 0,
+ 2,
+ 1,
+ "CONDITIONING"
+ ],
+ [
+ 5,
+ 5,
+ 0,
+ 4,
+ 0,
+ "OmniPart_SM_SamModel"
+ ],
+ [
+ 6,
+ 5,
+ 1,
+ 6,
+ 1,
+ "OmniPart_SM_SegModel"
+ ],
+ [
+ 7,
+ 5,
+ 0,
+ 6,
+ 0,
+ "OmniPart_SM_SamModel"
+ ],
+ [
+ 8,
+ 6,
+ 0,
+ 7,
+ 0,
+ "IMAGE"
+ ],
+ [
+ 9,
+ 6,
+ 1,
+ 7,
+ 1,
+ "STRING"
+ ],
+ [
+ 10,
+ 8,
+ 0,
+ 6,
+ 2,
+ "IMAGE"
+ ],
+ [
+ 12,
+ 10,
+ 0,
+ 4,
+ 1,
+ "IMAGE"
+ ],
+ [
+ 13,
+ 1,
+ 0,
+ 11,
+ 0,
+ "OmniPart_SM_Model"
+ ],
+ [
+ 14,
+ 2,
+ 0,
+ 11,
+ 1,
+ "CONDITIONING"
+ ],
+ [
+ 16,
+ 11,
+ 0,
+ 9,
+ 1,
+ "STRING"
+ ],
+ [
+ 17,
+ 11,
+ 1,
+ 12,
+ 1,
+ "STRING"
+ ]
+ ],
+ "groups": [
+ {
+ "id": 1,
+ "title": "stage 1",
+ "bounding": [
+ 149.05661010742188,
+ 35.52260208129883,
+ 729.3800048828125,
+ 550.469970703125
+ ],
+ "color": "#3f789e",
+ "font_size": 24,
+ "flags": {}
+ },
+ {
+ "id": 2,
+ "title": "stage2",
+ "bounding": [
+ 915.0872802734375,
+ 35.10811996459961,
+ 1436.9989013671875,
+ 850.6489868164062
+ ],
+ "color": "#3f789e",
+ "font_size": 24,
+ "flags": {}
+ }
+ ],
+ "config": {},
+ "extra": {
+ "ds": {
+ "scale": 0.6209213230591553,
+ "offset": [
+ 72.33415540575886,
+ 284.7602034522187
+ ]
+ },
+ "frontendVersion": "1.26.13",
+ "VHS_latentpreview": false,
+ "VHS_latentpreviewrate": 0,
+ "VHS_MetadataImage": true,
+ "VHS_KeepIntermediate": true
+ },
+ "version": 0.4
+}
\ No newline at end of file
diff --git a/facebookresearch/dinov2/.gitignore b/facebookresearch/dinov2/.gitignore
new file mode 100644
index 0000000..f6893ca
--- /dev/null
+++ b/facebookresearch/dinov2/.gitignore
@@ -0,0 +1,11 @@
+build/
+dist/
+*.egg-info/
+**/__pycache__/
+
+**/.ipynb_checkpoints
+**/.ipynb_checkpoints/**
+
+*.swp
+
+.vscode/
diff --git a/facebookresearch/dinov2/CODE_OF_CONDUCT.md b/facebookresearch/dinov2/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..3232ed6
--- /dev/null
+++ b/facebookresearch/dinov2/CODE_OF_CONDUCT.md
@@ -0,0 +1,80 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+This Code of Conduct also applies outside the project spaces when there is a
+reasonable belief that an individual's behavior may have a negative impact on
+the project or its community.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at . All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/facebookresearch/dinov2/CONTRIBUTING.md b/facebookresearch/dinov2/CONTRIBUTING.md
new file mode 100644
index 0000000..afc8982
--- /dev/null
+++ b/facebookresearch/dinov2/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to DINOv2
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `main`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+6. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Meta's open source projects.
+
+Complete your CLA here:
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Meta has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## License
+By contributing to DINOv2, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/LICENSE b/facebookresearch/dinov2/LICENSE
new file mode 100644
index 0000000..5471dc1
--- /dev/null
+++ b/facebookresearch/dinov2/LICENSE
@@ -0,0 +1,203 @@
+
+
+ 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.
diff --git a/facebookresearch/dinov2/MODEL_CARD.md b/facebookresearch/dinov2/MODEL_CARD.md
new file mode 100644
index 0000000..21b9bf2
--- /dev/null
+++ b/facebookresearch/dinov2/MODEL_CARD.md
@@ -0,0 +1,272 @@
+# Model Card for DINOv2-S/B/L/g
+
+These are Vision Transformer models trained following the method described in the papers:
+"DINOv2: Learning Robust Visual Features without Supervision"
+and
+"Vision Transformers Need Registers".
+
+We provide 8 models:
+- 1 ViT-g trained from scratch with 3 ViT-S/B/L models distilled from the ViT-g, without registers.
+- 1 ViT-g trained from scratch with 3 ViT-S/B/L models distilled from the ViT-g, with registers.
+
+## Model Details
+The model takes an image as input and returns a class token and patch tokens, and optionally 4 register tokens.
+
+The embedding dimension is:
+- 384 for ViT-S.
+- 768 for ViT-B.
+- 1024 for ViT-L.
+- 1536 for ViT-g.
+
+The models follow a Transformer architecture, with a patch size of 14. In the case of registers, we add 4 register tokens, learned during training, to the input sequence after the patch embedding.
+
+For a 224x224 image, this results in 1 class token + 256 patch tokens, and optionally 4 register tokens.
+
+The models can accept larger images provided the image shapes are multiples of the patch size (14).
+If this condition is not verified, the model will crop to the closest smaller multiple of the patch size.
+
+### Model Description
+
+- **Developed by:** Meta AI
+- **Model type:** Vision Transformer
+- **License:** Apache License 2.0
+
+- **Repository:** https://github.com/facebookresearch/dinov2
+- **Paper:** https://arxiv.org/abs/2304.07193
+- **Demo:** https://dinov2.metademolab.com/
+
+## Uses
+
+The models are vision backbones providing multi-purpose features for downstream tasks.
+
+### Direct Use
+
+The models can be used without fine-tuning, with downstream classifiers as simple as linear layers, to obtain competitive results:
+- on depth estimation, semantic segmentation, using linear layers.
+- on image classification, using k-NN classifiers on the class token.
+- on image classification, with logistic regression classifiers applied on the class token.
+- on image classification, with a linear layer applied on the class token and the average of the patch tokens.
+- on image retrieval using nearest neighbors.
+
+### Downstream Use
+
+It is technically possible to perform fine-tuning on the models, for small gains (we measured +2% on ImageNet-1k classification).
+We recommend keeping this as a very last step and only when necessary, as the features already provide good performance out-of-the-box.
+
+## Bias, Risks, and Limitations
+
+Despite improvements thanks to the training method not using annotations, we still observe significant biases in our models toward rich households from Western countries.
+
+### Recommendations
+
+We expect fine-tuning will increase the biases in the features produced by the model as they will be tuned to the fine-tuning labels.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+```python
+import torch
+
+# DINOv2
+dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14')
+dinov2_vitb14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14')
+dinov2_vitl14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14')
+dinov2_vitg14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14')
+
+# DINOv2 with registers
+dinov2_vits14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg')
+dinov2_vitb14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg')
+dinov2_vitl14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg')
+dinov2_vitg14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg')
+```
+
+## Training Details
+
+### Training Data
+
+- **Training data:** LVD-142M (see paper)
+- **Training regime:** fp16 using PyTorch-FSDP mixed-precision.
+
+### Training Procedure
+
+- **Training objective:**
+ - DINO self-distillation loss with multi-crop
+ - iBOT masked-image modeling loss
+ - KoLeo regularization on [CLS] tokens
+- **Architectures:**
+ - ViT-S (21M params): Patch size 14, embedding dimension 384, 6 heads, MLP FFN
+ - ViT-B (86M params): Patch size 14, embedding dimension 768, 12 heads, MLP FFN
+ - ViT-L (0.3B params): Patch size 14, embedding dimension 1024, 16 heads, MLP FFN
+ - ViT-g (1.1B params): Patch size 14, embedding dimension 1536, 24 heads, SwiGLU FFN
+- **Distillation:**
+ - Distillation follows the standard DINOv2 pretraining procedure, except the teacher is a pretrained ViT-g, frozen.
+
+## Evaluation
+
+We refer users to the associated papers for the evaluation protocols.
+
+
+
+ |
+ ImageNet-1k |
+ NYU-Depth v2 |
+ SUN-RGBD |
+ ADE20k |
+ iNaturalist 2018 |
+ Oxford-H |
+
+
+ | model |
+ with
registers |
+ classif. (acc) |
+ classif. (acc) |
+ classif. V2 (acc) |
+ depth (RMSE) |
+ depth (RMSE) |
+ segm. (mAP) |
+ classif. (acc) |
+ retrieval (mAP) |
+
+
+
+ | k-NN |
+ linear |
+ linear |
+ linear
4 layers |
+ NYU-D transfer |
+ multiscale |
+ linear |
+ nearest neighbor |
+
+
+ | ViT-S/14 |
+ :x: |
+ 79.0% |
+ 81.1% |
+ 70.8% |
+ 0.417 |
+ 0.431 |
+ 47.2 |
+ 69.5% |
+ 43.2 |
+
+
+ | ViT-S/14 |
+ :white_check_mark: |
+ 79.1% |
+ 80.9% |
+ 71.0% |
+ N/A |
+ N/A |
+ N/A |
+ 67.6% |
+ 39.5 |
+
+
+ | ViT-B/14 |
+ :x: |
+ 82.1% |
+ 84.5% |
+ 74.9% |
+ 0.362 |
+ 0.400 |
+ 51.3 |
+ 76.3% |
+ 49.5 |
+
+ ViT-B/14 |
+ :white_check_mark: |
+ 82.0% |
+ 84.6% |
+ 75.6% |
+ N/A |
+ N/A |
+ N/A |
+ 73.8% |
+ 51.0 |
+
+
+ | ViT-L/14 |
+ :x: |
+ 83.5% |
+ 86.3% |
+ 77.6% |
+ 0.333 |
+ 0.396 |
+ 53.1 |
+ 79.8% |
+ 54.0 |
+
+
+ | ViT-L/14 |
+ :white_check_mark: |
+ 83.8% |
+ 86.7% |
+ 78.5% |
+ N/A |
+ N/A |
+ N/A |
+ 80.9% |
+ 55.7 |
+
+
+ | ViT-g/14 |
+ :x: |
+ 83.5% |
+ 86.5% |
+ 78.4% |
+ 0.298 |
+ 0.362 |
+ 53.0 |
+ 81.6% |
+ 52.3 |
+
+
+
+ | ViT-g/14 |
+ :white_check_mark: |
+ 83.7% |
+ 87.1% |
+ 78.8% |
+ N/A |
+ N/A |
+ N/A |
+ 81.5% |
+ 58.2 |
+
+
+
+## Environmental Impact
+
+- **Hardware Type:** Nvidia A100
+- **Hours used:** 22,000 for ViT-g, 4,500 for ViT-S distillation, 5,300 for ViT-B distillation, 8,000 for ViT-L distillation
+- **Cloud Provider:** Private infra
+- **Compute Region:** USA
+- **Carbon Emitted:** 7t CO2eq
+
+#### Hardware
+
+Nvidia A100 GPUs
+
+#### Software
+
+PyTorch 2.0,
+xFormers 0.0.18
+
+**BibTeX**
+
+```
+@misc{oquab2023dinov2,
+ title={DINOv2: Learning Robust Visual Features without Supervision},
+ author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr},
+ journal={arXiv:2304.07193},
+ year={2023}
+}
+@misc{darcet2023vitneedreg,
+ title={Vision Transformers Need Registers},
+ author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr},
+ journal={arXiv:2309.16588},
+ year={2023}
+}
+```
diff --git a/facebookresearch/dinov2/README.md b/facebookresearch/dinov2/README.md
new file mode 100644
index 0000000..c188088
--- /dev/null
+++ b/facebookresearch/dinov2/README.md
@@ -0,0 +1,620 @@
+:new: [2023-10-26] *Added DINOv2 backbones with registers, following [Vision Transformers Need Registers](https://arxiv.org/abs/2309.16588).*
+
+# DINOv2: Learning Robust Visual Features without Supervision
+
+**[Meta AI Research, FAIR](https://ai.facebook.com/research/)**
+
+Maxime Oquab,
+Timothée Darcet,
+Théo Moutakanni,
+Huy V. Vo,
+Marc Szafraniec,
+Vasil Khalidov,
+Patrick Labatut,
+Armand Joulin,
+Piotr Bojanowski
+
+[[`Paper #1`](https://arxiv.org/abs/2304.07193)] [`Paper #2`](https://arxiv.org/abs/2309.16588)] [[`Blog`](https://ai.facebook.com/blog/dino-v2-computer-vision-self-supervised-learning/)] [[`Demo`](https://dinov2.metademolab.com)] [[`BibTeX`](#citing-dinov2)]
+
+PyTorch implementation and pretrained models for DINOv2. For details, see the papers: **[DINOv2: Learning Robust Visual Features without Supervision](https://arxiv.org/abs/2304.07193)** and **[Vision Transformers Need Registers](https://arxiv.org/abs/2309.16588)**.
+
+DINOv2 models produce high-performance visual features that can be directly employed with classifiers as simple as linear layers on a variety of computer vision tasks; these visual features are robust and perform well across domains without any requirement for fine-tuning. The models were pretrained on a dataset of 142 M images without using any labels or annotations.
+
+https://github.com/facebookresearch/dinov2/assets/60359573/f168823e-7922-415a-b429-578badf5c356
+
+
+ Visualization of the three first principal components of the patch features of all frames, mapped to RGB values.
+
+
+## Pretrained models
+
+
+
+
+ | model |
+ # of
params |
+ with
registers |
+ ImageNet
k-NN |
+ ImageNet
linear |
+ download |
+
+
+
+
+ | ViT-S/14 distilled |
+ 21 M |
+ :x: |
+ 79.0% |
+ 81.1% |
+ backbone only |
+
+
+ | ViT-S/14 distilled |
+ 21 M |
+ :white_check_mark: |
+ 79.1% |
+ 80.9% |
+ backbone only |
+
+
+ | ViT-B/14 distilled |
+ 86 M |
+ :x: |
+ 82.1% |
+ 84.5% |
+ backbone only |
+
+
+ | ViT-B/14 distilled |
+ 86 M |
+ :white_check_mark: |
+ 82.0% |
+ 84.6% |
+ backbone only |
+
+
+ | ViT-L/14 distilled |
+ 300 M |
+ :x: |
+ 83.5% |
+ 86.3% |
+ backbone only |
+
+
+ | ViT-L/14 distilled |
+ 300 M |
+ :white_check_mark: |
+ 83.8% |
+ 86.7% |
+ backbone only |
+
+
+ | ViT-g/14 |
+ 1,100 M |
+ :x: |
+ 83.5% |
+ 86.5% |
+ backbone only |
+
+
+ | ViT-g/14 |
+ 1,100 M |
+ :white_check_mark: |
+ 83.7% |
+ 87.1% |
+ backbone only |
+
+
+
+
+### Pretrained backbones (via PyTorch Hub)
+
+Please follow the instructions [here](https://pytorch.org/get-started/locally/) to install PyTorch (the only required dependency for loading the model). Installing PyTorch with CUDA support is strongly recommended.
+
+A corresponding [model card](MODEL_CARD.md) is included in the repository.
+
+```python
+import torch
+
+# DINOv2
+dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14')
+dinov2_vitb14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14')
+dinov2_vitl14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14')
+dinov2_vitg14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14')
+
+# DINOv2 with registers
+dinov2_vits14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg')
+dinov2_vitb14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg')
+dinov2_vitl14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg')
+dinov2_vitg14_reg = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg')
+```
+
+### Pretrained heads - Image classification
+
+
+
+
+ | backbone |
+ with
registers |
+ download |
+
+
+ | ImageNet |
+
+
+
+
+ | ViT-S/14 distilled |
+ :x: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+
+ | ViT-S/14 distilled |
+ :white_check_mark: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+
+ | ViT-B/14 distilled |
+ :x: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+ | ViT-B/14 distilled |
+ :white_check_mark: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+ | ViT-L/14 distilled |
+ :x: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+ | ViT-L/14 distilled |
+ :white_check_mark: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+ | ViT-g/14 |
+ :x: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+ | ViT-g/14 |
+ :white_check_mark: |
+
+ linear head (1 layer,
+ 4 layers)
+ |
+
+
+
+The (full) classifier models can be loaded via PyTorch Hub:
+
+```python
+import torch
+
+# DINOv2
+dinov2_vits14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_lc')
+dinov2_vitb14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_lc')
+dinov2_vitl14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_lc')
+dinov2_vitg14_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_lc')
+
+# DINOv2 with registers
+dinov2_vits14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14_reg_lc')
+dinov2_vitb14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitb14_reg_lc')
+dinov2_vitl14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14_reg_lc')
+dinov2_vitg14_reg_lc = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitg14_reg_lc')
+```
+
+### Pretrained heads - Depth estimation
+
+
+
+
+ | backbone |
+ download head |
+
+
+ | NYUd |
+ KITTI |
+
+
+
+
+ | ViT-S/14 distilled |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+
+ | ViT-B/14 distilled |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+
+ | ViT-L/14 distilled |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+
+ | ViT-g/14 |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+ linear (1 layer,
+ 4 layers),
+ DPT
+ |
+
+
+
+
+### Pretrained heads - Semantic segmentation
+
+
+
+## Installation
+
+The training and evaluation code requires PyTorch 2.0 and [xFormers](https://github.com/facebookresearch/xformers) 0.0.18 as well as a number of other 3rd party packages. Note that the code has only been tested with the specified versions and also expects a Linux environment. To setup all the required dependencies for training and evaluation, please follow the instructions below:
+
+*[conda](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)* **(Recommended)** - Clone the repository and then create and activate a `dinov2` conda environment using the provided environment definition:
+
+```shell
+conda env create -f conda.yaml
+conda activate dinov2
+```
+
+*[pip](https://pip.pypa.io/en/stable/getting-started/)* - Clone the repository and then use the provided `requirements.txt` to install the dependencies:
+
+```shell
+pip install -r requirements.txt
+```
+
+For dense tasks (depth estimation and semantic segmentation), there are additional dependencies (specific versions of `mmcv` and `mmsegmentation`) which are captured in the `extras` dependency specifications:
+
+*[conda](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)* **(Recommended)**:
+
+```shell
+conda env create -f conda-extras.yaml
+conda activate dinov2-extras
+```
+
+*[pip](https://pip.pypa.io/en/stable/getting-started/)*:
+
+```shell
+pip install -r requirements.txt -r requirements-extras.txt
+```
+
+## Data preparation
+
+### ImageNet-1k
+
+The root directory of the dataset should hold the following contents:
+
+- `/test/ILSVRC2012_test_00000001.JPEG`
+- `/test/[..]`
+- `/test/ILSVRC2012_test_00100000.JPEG`
+- `/train/n01440764/n01440764_10026.JPEG`
+- `/train/[...]`
+- `/train/n15075141/n15075141_9993.JPEG`
+- `/val/n01440764/ILSVRC2012_val_00000293.JPEG`
+- `/val/[...]`
+- `/val/n15075141/ILSVRC2012_val_00049174.JPEG`
+- `/labels.txt`
+
+The provided dataset implementation expects a few additional metadata files to be present under the extra directory:
+
+- `/class-ids-TRAIN.npy`
+- `/class-ids-VAL.npy`
+- `/class-names-TRAIN.npy`
+- `/class-names-VAL.npy`
+- `/entries-TEST.npy`
+- `/entries-TRAIN.npy`
+- `/entries-VAL.npy`
+
+These metadata files can be generated (once) with the following lines of Python code:
+
+```python
+from dinov2.data.datasets import ImageNet
+
+for split in ImageNet.Split:
+ dataset = ImageNet(split=split, root="", extra="")
+ dataset.dump_extra()
+```
+
+Note that the root and extra directories do not have to be distinct directories.
+
+### ImageNet-22k
+
+Please adapt the [dataset class](dinov2/data/datasets/image_net_22k.py) to match your local setup.
+
+
+
+:warning: To execute the commands provided in the next sections for training and evaluation, the `dinov2` package should be included in the Python module search path, i.e. simply prefix the command to run with `PYTHONPATH=.`.
+
+## Training
+
+### Fast setup: training DINOv2 ViT-L/16 on ImageNet-1k
+
+Run DINOv2 training on 4 A100-80GB nodes (32 GPUs) in a SLURM cluster environment with submitit:
+
+```shell
+python dinov2/run/train/train.py \
+ --nodes 4 \
+ --config-file dinov2/configs/train/vitl16_short.yaml \
+ --output-dir \
+ train.dataset_path=ImageNet:split=TRAIN:root=:extra=
+```
+
+Training time is approximately 1 day and the resulting checkpoint should reach 81.6% on k-NN eval and 82.9% on linear eval.
+
+The training code saves the weights of the teacher in the `eval` folder every 12500 iterations for evaluation.
+
+### Long setup: training DINOv2 ViT-L/14 on ImageNet-22k
+
+Run DINOv2 training on 12 A100-80GB nodes (96 GPUs) in a SLURM cluster environment with submitit:
+
+```shell
+python dinov2/run/train/train.py \
+ --nodes 12 \
+ --config-file dinov2/configs/train/vitl14.yaml \
+ --output-dir \
+ train.dataset_path=ImageNet22k:root=:extra=
+```
+
+Training time is approximately 3.3 days and the resulting checkpoint should reach 82.0% on k-NN eval and 84.5% on linear eval.
+
+The training code saves the weights of the teacher in the `eval` folder every 12500 iterations for evaluation.
+
+
+## Evaluation
+
+The training code regularly saves the teacher weights. In order to evaluate the model, run the following evaluation on a single node:
+
+### k-NN classification on ImageNet-1k
+
+```shell
+python dinov2/run/eval/knn.py \
+ --config-file /config.yaml \
+ --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \
+ --output-dir /eval/training_24999/knn \
+ --train-dataset ImageNet:split=TRAIN:root=:extra= \
+ --val-dataset ImageNet:split=VAL:root=:extra=
+```
+
+### Logistic regression classification on ImageNet-1k
+
+```shell
+python dinov2/run/eval/log_regression.py \
+ --config-file /config.yaml \
+ --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \
+ --output-dir /eval/training_24999/logreg \
+ --train-dataset ImageNet:split=TRAIN:root=:extra= \
+ --val-dataset ImageNet:split=VAL:root=:extra=
+```
+
+### Linear classification with data augmentation on ImageNet-1k
+
+```shell
+python dinov2/run/eval/linear.py \
+ --config-file /config.yaml \
+ --pretrained-weights /eval/training_24999/teacher_checkpoint.pth \
+ --output-dir /eval/training_24999/linear \
+ --train-dataset ImageNet:split=TRAIN:root=:extra= \
+ --val-dataset ImageNet:split=VAL:root=:extra=
+```
+
+We release the weights from evaluating the different models:
+
+
+
+The performance of the provided pretrained model weights can be evaluated as follows on ImageNet-1k:
+
+```shell
+python dinov2/run/eval/linear.py \
+ --config-file dinov2/configs/eval/vitg14_pretrain.yaml \
+ --pretrained-weights https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_pretrain.pth \
+ --train-dataset ImageNet:split=TRAIN:root=:extra= \
+ --val-dataset ImageNet:split=VAL:root=:extra=
+```
+
+## Notebooks
+
+A few notebooks are provided to help the community leverage the models and code:
+
+
+ - Depth estimation - How to load and use the depth heads in combination with a matching backbone via mmcv
+ - Semantic segmentation - How to load and use the segmentation heads in combination with a matching backbone via mmcv, and also how to load and use the Mask2Former-based segmentation model trained on ADE20K
+
+
+## License
+
+DINOv2 code and model weights are released under the Apache License 2.0. See [LICENSE](LICENSE) for additional details.
+
+## Contributing
+
+See [contributing](CONTRIBUTING.md) and the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Citing DINOv2
+
+If you find this repository useful, please consider giving a star :star: and citation :t-rex::
+
+```
+@misc{oquab2023dinov2,
+ title={DINOv2: Learning Robust Visual Features without Supervision},
+ author={Oquab, Maxime and Darcet, Timothée and Moutakanni, Theo and Vo, Huy V. and Szafraniec, Marc and Khalidov, Vasil and Fernandez, Pierre and Haziza, Daniel and Massa, Francisco and El-Nouby, Alaaeldin and Howes, Russell and Huang, Po-Yao and Xu, Hu and Sharma, Vasu and Li, Shang-Wen and Galuba, Wojciech and Rabbat, Mike and Assran, Mido and Ballas, Nicolas and Synnaeve, Gabriel and Misra, Ishan and Jegou, Herve and Mairal, Julien and Labatut, Patrick and Joulin, Armand and Bojanowski, Piotr},
+ journal={arXiv:2304.07193},
+ year={2023}
+}
+```
+
+```
+@misc{darcet2023vitneedreg,
+ title={Vision Transformers Need Registers},
+ author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr},
+ journal={arXiv:2309.16588},
+ year={2023}
+}
+```
diff --git a/facebookresearch/dinov2/conda-extras.yaml b/facebookresearch/dinov2/conda-extras.yaml
new file mode 100644
index 0000000..71574c4
--- /dev/null
+++ b/facebookresearch/dinov2/conda-extras.yaml
@@ -0,0 +1,24 @@
+name: dinov2-extras
+channels:
+ - defaults
+ - pytorch
+ - nvidia
+ - xformers
+ - conda-forge
+dependencies:
+ - python=3.9
+ - pytorch::pytorch=2.0.0
+ - pytorch::pytorch-cuda=11.7.0
+ - pytorch::torchvision=0.15.0
+ - omegaconf
+ - torchmetrics=0.10.3
+ - fvcore
+ - iopath
+ - xformers::xformers=0.0.18
+ - pip
+ - pip:
+ - git+https://github.com/facebookincubator/submitit
+ - --extra-index-url https://pypi.nvidia.com
+ - cuml-cu11
+ - mmcv-full==1.5.0
+ - mmsegmentation==0.27.0
diff --git a/facebookresearch/dinov2/conda.yaml b/facebookresearch/dinov2/conda.yaml
new file mode 100644
index 0000000..35dfc30
--- /dev/null
+++ b/facebookresearch/dinov2/conda.yaml
@@ -0,0 +1,22 @@
+name: dinov2
+channels:
+ - defaults
+ - pytorch
+ - nvidia
+ - xformers
+ - conda-forge
+dependencies:
+ - python=3.9
+ - pytorch::pytorch=2.0.0
+ - pytorch::pytorch-cuda=11.7.0
+ - pytorch::torchvision=0.15.0
+ - omegaconf
+ - torchmetrics=0.10.3
+ - fvcore
+ - iopath
+ - xformers::xformers=0.0.18
+ - pip
+ - pip:
+ - git+https://github.com/facebookincubator/submitit
+ - --extra-index-url https://pypi.nvidia.com
+ - cuml-cu11
diff --git a/facebookresearch/dinov2/dinov2/__init__.py b/facebookresearch/dinov2/dinov2/__init__.py
new file mode 100644
index 0000000..ae847e4
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+__version__ = "0.0.1"
diff --git a/facebookresearch/dinov2/dinov2/configs/__init__.py b/facebookresearch/dinov2/dinov2/configs/__init__.py
new file mode 100644
index 0000000..68e0830
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/__init__.py
@@ -0,0 +1,22 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import pathlib
+
+from omegaconf import OmegaConf
+
+
+def load_config(config_name: str):
+ config_filename = config_name + ".yaml"
+ return OmegaConf.load(pathlib.Path(__file__).parent.resolve() / config_filename)
+
+
+dinov2_default_config = load_config("ssl_default_config")
+
+
+def load_and_merge_config(config_name: str):
+ default_config = OmegaConf.create(dinov2_default_config)
+ loaded_config = load_config(config_name)
+ return OmegaConf.merge(default_config, loaded_config)
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitb14_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitb14_pretrain.yaml
new file mode 100644
index 0000000..117d0f0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitb14_pretrain.yaml
@@ -0,0 +1,6 @@
+student:
+ arch: vit_base
+ patch_size: 14
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitb14_reg4_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitb14_reg4_pretrain.yaml
new file mode 100644
index 0000000..d53edc0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitb14_reg4_pretrain.yaml
@@ -0,0 +1,9 @@
+student:
+ arch: vit_base
+ patch_size: 14
+ num_register_tokens: 4
+ interpolate_antialias: true
+ interpolate_offset: 0.0
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitg14_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitg14_pretrain.yaml
new file mode 100644
index 0000000..a96dd5b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitg14_pretrain.yaml
@@ -0,0 +1,7 @@
+student:
+ arch: vit_giant2
+ patch_size: 14
+ ffn_layer: swiglufused
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitg14_reg4_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitg14_reg4_pretrain.yaml
new file mode 100644
index 0000000..15948f8
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitg14_reg4_pretrain.yaml
@@ -0,0 +1,10 @@
+student:
+ arch: vit_giant2
+ patch_size: 14
+ ffn_layer: swiglufused
+ num_register_tokens: 4
+ interpolate_antialias: true
+ interpolate_offset: 0.0
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitl14_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitl14_pretrain.yaml
new file mode 100644
index 0000000..7a98454
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitl14_pretrain.yaml
@@ -0,0 +1,6 @@
+student:
+ arch: vit_large
+ patch_size: 14
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vitl14_reg4_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vitl14_reg4_pretrain.yaml
new file mode 100644
index 0000000..0e2bc4e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vitl14_reg4_pretrain.yaml
@@ -0,0 +1,9 @@
+student:
+ arch: vit_large
+ patch_size: 14
+ num_register_tokens: 4
+ interpolate_antialias: true
+ interpolate_offset: 0.0
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vits14_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vits14_pretrain.yaml
new file mode 100644
index 0000000..afbdb4b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vits14_pretrain.yaml
@@ -0,0 +1,6 @@
+student:
+ arch: vit_small
+ patch_size: 14
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/eval/vits14_reg4_pretrain.yaml b/facebookresearch/dinov2/dinov2/configs/eval/vits14_reg4_pretrain.yaml
new file mode 100644
index 0000000..d25fd63
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/eval/vits14_reg4_pretrain.yaml
@@ -0,0 +1,9 @@
+student:
+ arch: vit_small
+ patch_size: 14
+ num_register_tokens: 4
+ interpolate_antialias: true
+ interpolate_offset: 0.0
+crops:
+ global_crops_size: 518 # this is to set up the position embeddings properly
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/ssl_default_config.yaml b/facebookresearch/dinov2/dinov2/configs/ssl_default_config.yaml
new file mode 100644
index 0000000..ccaae1c
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/ssl_default_config.yaml
@@ -0,0 +1,118 @@
+MODEL:
+ WEIGHTS: ''
+compute_precision:
+ grad_scaler: true
+ teacher:
+ backbone:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp16
+ buffer_dtype: fp32
+ dino_head:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp16
+ buffer_dtype: fp32
+ ibot_head:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp16
+ buffer_dtype: fp32
+ student:
+ backbone:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp16
+ buffer_dtype: fp32
+ dino_head:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp32
+ buffer_dtype: fp32
+ ibot_head:
+ sharding_strategy: SHARD_GRAD_OP
+ mixed_precision:
+ param_dtype: fp16
+ reduce_dtype: fp32
+ buffer_dtype: fp32
+dino:
+ loss_weight: 1.0
+ head_n_prototypes: 65536
+ head_bottleneck_dim: 256
+ head_nlayers: 3
+ head_hidden_dim: 2048
+ koleo_loss_weight: 0.1
+ibot:
+ loss_weight: 1.0
+ mask_sample_probability: 0.5
+ mask_ratio_min_max:
+ - 0.1
+ - 0.5
+ separate_head: false
+ head_n_prototypes: 65536
+ head_bottleneck_dim: 256
+ head_nlayers: 3
+ head_hidden_dim: 2048
+train:
+ batch_size_per_gpu: 64
+ dataset_path: ImageNet:split=TRAIN
+ output_dir: .
+ saveckp_freq: 20
+ seed: 0
+ num_workers: 10
+ OFFICIAL_EPOCH_LENGTH: 1250
+ cache_dataset: true
+ centering: "centering" # or "sinkhorn_knopp"
+student:
+ arch: vit_large
+ patch_size: 16
+ drop_path_rate: 0.3
+ layerscale: 1.0e-05
+ drop_path_uniform: true
+ pretrained_weights: ''
+ ffn_layer: "mlp"
+ block_chunks: 0
+ qkv_bias: true
+ proj_bias: true
+ ffn_bias: true
+ num_register_tokens: 0
+ interpolate_antialias: false
+ interpolate_offset: 0.1
+teacher:
+ momentum_teacher: 0.992
+ final_momentum_teacher: 1
+ warmup_teacher_temp: 0.04
+ teacher_temp: 0.07
+ warmup_teacher_temp_epochs: 30
+optim:
+ epochs: 100
+ weight_decay: 0.04
+ weight_decay_end: 0.4
+ base_lr: 0.004 # learning rate for a batch size of 1024
+ lr: 0. # will be set after applying scaling rule
+ warmup_epochs: 10
+ min_lr: 1.0e-06
+ clip_grad: 3.0
+ freeze_last_layer_epochs: 1
+ scaling_rule: sqrt_wrt_1024
+ patch_embed_lr_mult: 0.2
+ layerwise_decay: 0.9
+ adamw_beta1: 0.9
+ adamw_beta2: 0.999
+crops:
+ global_crops_scale:
+ - 0.32
+ - 1.0
+ local_crops_number: 8
+ local_crops_scale:
+ - 0.05
+ - 0.32
+ global_crops_size: 224
+ local_crops_size: 96
+evaluation:
+ eval_period_iterations: 12500
diff --git a/facebookresearch/dinov2/dinov2/configs/train/vitg14.yaml b/facebookresearch/dinov2/dinov2/configs/train/vitg14.yaml
new file mode 100644
index 0000000..d05cf0d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/train/vitg14.yaml
@@ -0,0 +1,26 @@
+dino:
+ head_n_prototypes: 131072
+ head_bottleneck_dim: 384
+ibot:
+ separate_head: true
+ head_n_prototypes: 131072
+train:
+ batch_size_per_gpu: 12
+ dataset_path: ImageNet22k
+ centering: sinkhorn_knopp
+student:
+ arch: vit_giant2
+ patch_size: 14
+ drop_path_rate: 0.4
+ ffn_layer: swiglufused
+ block_chunks: 4
+teacher:
+ momentum_teacher: 0.994
+optim:
+ epochs: 500
+ weight_decay_end: 0.2
+ base_lr: 2.0e-04 # learning rate for a batch size of 1024
+ warmup_epochs: 80
+ layerwise_decay: 1.0
+crops:
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/train/vitl14.yaml b/facebookresearch/dinov2/dinov2/configs/train/vitl14.yaml
new file mode 100644
index 0000000..d9b491d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/train/vitl14.yaml
@@ -0,0 +1,26 @@
+dino:
+ head_n_prototypes: 131072
+ head_bottleneck_dim: 384
+ibot:
+ separate_head: true
+ head_n_prototypes: 131072
+train:
+ batch_size_per_gpu: 32
+ dataset_path: ImageNet22k
+ centering: sinkhorn_knopp
+student:
+ arch: vit_large
+ patch_size: 14
+ drop_path_rate: 0.4
+ ffn_layer: swiglufused
+ block_chunks: 4
+teacher:
+ momentum_teacher: 0.994
+optim:
+ epochs: 500
+ weight_decay_end: 0.2
+ base_lr: 2.0e-04 # learning rate for a batch size of 1024
+ warmup_epochs: 80
+ layerwise_decay: 1.0
+crops:
+ local_crops_size: 98
\ No newline at end of file
diff --git a/facebookresearch/dinov2/dinov2/configs/train/vitl16_short.yaml b/facebookresearch/dinov2/dinov2/configs/train/vitl16_short.yaml
new file mode 100644
index 0000000..3e7e728
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/configs/train/vitl16_short.yaml
@@ -0,0 +1,6 @@
+# this corresponds to the default config
+train:
+ dataset_path: ImageNet:split=TRAIN
+ batch_size_per_gpu: 64
+student:
+ block_chunks: 4
diff --git a/facebookresearch/dinov2/dinov2/data/__init__.py b/facebookresearch/dinov2/dinov2/data/__init__.py
new file mode 100644
index 0000000..2ded47e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .adapters import DatasetWithEnumeratedTargets
+from .loaders import make_data_loader, make_dataset, SamplerType
+from .collate import collate_data_and_cast
+from .masking import MaskingGenerator
+from .augmentations import DataAugmentationDINO
diff --git a/facebookresearch/dinov2/dinov2/data/adapters.py b/facebookresearch/dinov2/dinov2/data/adapters.py
new file mode 100644
index 0000000..2097bad
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/adapters.py
@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from typing import Any, Tuple
+
+from torch.utils.data import Dataset
+
+
+class DatasetWithEnumeratedTargets(Dataset):
+ def __init__(self, dataset):
+ self._dataset = dataset
+
+ def get_image_data(self, index: int) -> bytes:
+ return self._dataset.get_image_data(index)
+
+ def get_target(self, index: int) -> Tuple[Any, int]:
+ target = self._dataset.get_target(index)
+ return (index, target)
+
+ def __getitem__(self, index: int) -> Tuple[Any, Tuple[Any, int]]:
+ image, target = self._dataset[index]
+ target = index if target is None else target
+ return image, (index, target)
+
+ def __len__(self) -> int:
+ return len(self._dataset)
diff --git a/facebookresearch/dinov2/dinov2/data/augmentations.py b/facebookresearch/dinov2/dinov2/data/augmentations.py
new file mode 100644
index 0000000..05b1eaa
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/augmentations.py
@@ -0,0 +1,118 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+
+from torchvision import transforms
+
+from .transforms import (
+ GaussianBlur,
+ make_normalize_transform,
+)
+
+
+logger = logging.getLogger("dinov2")
+
+
+class DataAugmentationDINO(object):
+ def __init__(
+ self,
+ global_crops_scale,
+ local_crops_scale,
+ local_crops_number,
+ global_crops_size=224,
+ local_crops_size=96,
+ ):
+ self.global_crops_scale = global_crops_scale
+ self.local_crops_scale = local_crops_scale
+ self.local_crops_number = local_crops_number
+ self.global_crops_size = global_crops_size
+ self.local_crops_size = local_crops_size
+
+ logger.info("###################################")
+ logger.info("Using data augmentation parameters:")
+ logger.info(f"global_crops_scale: {global_crops_scale}")
+ logger.info(f"local_crops_scale: {local_crops_scale}")
+ logger.info(f"local_crops_number: {local_crops_number}")
+ logger.info(f"global_crops_size: {global_crops_size}")
+ logger.info(f"local_crops_size: {local_crops_size}")
+ logger.info("###################################")
+
+ # random resized crop and flip
+ self.geometric_augmentation_global = transforms.Compose(
+ [
+ transforms.RandomResizedCrop(
+ global_crops_size, scale=global_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC
+ ),
+ transforms.RandomHorizontalFlip(p=0.5),
+ ]
+ )
+
+ self.geometric_augmentation_local = transforms.Compose(
+ [
+ transforms.RandomResizedCrop(
+ local_crops_size, scale=local_crops_scale, interpolation=transforms.InterpolationMode.BICUBIC
+ ),
+ transforms.RandomHorizontalFlip(p=0.5),
+ ]
+ )
+
+ # color distorsions / blurring
+ color_jittering = transforms.Compose(
+ [
+ transforms.RandomApply(
+ [transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)],
+ p=0.8,
+ ),
+ transforms.RandomGrayscale(p=0.2),
+ ]
+ )
+
+ global_transfo1_extra = GaussianBlur(p=1.0)
+
+ global_transfo2_extra = transforms.Compose(
+ [
+ GaussianBlur(p=0.1),
+ transforms.RandomSolarize(threshold=128, p=0.2),
+ ]
+ )
+
+ local_transfo_extra = GaussianBlur(p=0.5)
+
+ # normalization
+ self.normalize = transforms.Compose(
+ [
+ transforms.ToTensor(),
+ make_normalize_transform(),
+ ]
+ )
+
+ self.global_transfo1 = transforms.Compose([color_jittering, global_transfo1_extra, self.normalize])
+ self.global_transfo2 = transforms.Compose([color_jittering, global_transfo2_extra, self.normalize])
+ self.local_transfo = transforms.Compose([color_jittering, local_transfo_extra, self.normalize])
+
+ def __call__(self, image):
+ output = {}
+
+ # global crops:
+ im1_base = self.geometric_augmentation_global(image)
+ global_crop_1 = self.global_transfo1(im1_base)
+
+ im2_base = self.geometric_augmentation_global(image)
+ global_crop_2 = self.global_transfo2(im2_base)
+
+ output["global_crops"] = [global_crop_1, global_crop_2]
+
+ # global crops for teacher:
+ output["global_crops_teacher"] = [global_crop_1, global_crop_2]
+
+ # local crops:
+ local_crops = [
+ self.local_transfo(self.geometric_augmentation_local(image)) for _ in range(self.local_crops_number)
+ ]
+ output["local_crops"] = local_crops
+ output["offsets"] = ()
+
+ return output
diff --git a/facebookresearch/dinov2/dinov2/data/collate.py b/facebookresearch/dinov2/dinov2/data/collate.py
new file mode 100644
index 0000000..b3e32f3
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/collate.py
@@ -0,0 +1,49 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import random
+
+
+def collate_data_and_cast(samples_list, mask_ratio_tuple, mask_probability, dtype, n_tokens=None, mask_generator=None):
+ # dtype = torch.half # TODO: Remove
+
+ n_global_crops = len(samples_list[0][0]["global_crops"])
+ n_local_crops = len(samples_list[0][0]["local_crops"])
+
+ collated_global_crops = torch.stack([s[0]["global_crops"][i] for i in range(n_global_crops) for s in samples_list])
+
+ collated_local_crops = torch.stack([s[0]["local_crops"][i] for i in range(n_local_crops) for s in samples_list])
+
+ B = len(collated_global_crops)
+ N = n_tokens
+ n_samples_masked = int(B * mask_probability)
+ probs = torch.linspace(*mask_ratio_tuple, n_samples_masked + 1)
+ upperbound = 0
+ masks_list = []
+ for i in range(0, n_samples_masked):
+ prob_min = probs[i]
+ prob_max = probs[i + 1]
+ masks_list.append(torch.BoolTensor(mask_generator(int(N * random.uniform(prob_min, prob_max)))))
+ upperbound += int(N * prob_max)
+ for i in range(n_samples_masked, B):
+ masks_list.append(torch.BoolTensor(mask_generator(0)))
+
+ random.shuffle(masks_list)
+
+ collated_masks = torch.stack(masks_list).flatten(1)
+ mask_indices_list = collated_masks.flatten().nonzero().flatten()
+
+ masks_weight = (1 / collated_masks.sum(-1).clamp(min=1.0)).unsqueeze(-1).expand_as(collated_masks)[collated_masks]
+
+ return {
+ "collated_global_crops": collated_global_crops.to(dtype),
+ "collated_local_crops": collated_local_crops.to(dtype),
+ "collated_masks": collated_masks,
+ "mask_indices_list": mask_indices_list,
+ "masks_weight": masks_weight,
+ "upperbound": upperbound,
+ "n_masked_patches": torch.full((1,), fill_value=mask_indices_list.shape[0], dtype=torch.long),
+ }
diff --git a/facebookresearch/dinov2/dinov2/data/datasets/__init__.py b/facebookresearch/dinov2/dinov2/data/datasets/__init__.py
new file mode 100644
index 0000000..5550fdc
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/datasets/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .image_net import ImageNet
+from .image_net_22k import ImageNet22k
diff --git a/facebookresearch/dinov2/dinov2/data/datasets/decoders.py b/facebookresearch/dinov2/dinov2/data/datasets/decoders.py
new file mode 100644
index 0000000..3769f77
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/datasets/decoders.py
@@ -0,0 +1,31 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from io import BytesIO
+from typing import Any
+
+from PIL import Image
+
+
+class Decoder:
+ def decode(self) -> Any:
+ raise NotImplementedError
+
+
+class ImageDataDecoder(Decoder):
+ def __init__(self, image_data: bytes) -> None:
+ self._image_data = image_data
+
+ def decode(self) -> Image:
+ f = BytesIO(self._image_data)
+ return Image.open(f).convert(mode="RGB")
+
+
+class TargetDecoder(Decoder):
+ def __init__(self, target: Any):
+ self._target = target
+
+ def decode(self) -> Any:
+ return self._target
diff --git a/facebookresearch/dinov2/dinov2/data/datasets/extended.py b/facebookresearch/dinov2/dinov2/data/datasets/extended.py
new file mode 100644
index 0000000..f60b619
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/datasets/extended.py
@@ -0,0 +1,38 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from typing import Any, Tuple
+
+from torchvision.datasets import VisionDataset
+
+from .decoders import TargetDecoder, ImageDataDecoder
+
+
+class ExtendedVisionDataset(VisionDataset):
+ def __init__(self, *args, **kwargs) -> None:
+ super().__init__(*args, **kwargs) # type: ignore
+
+ def get_image_data(self, index: int) -> bytes:
+ raise NotImplementedError
+
+ def get_target(self, index: int) -> Any:
+ raise NotImplementedError
+
+ def __getitem__(self, index: int) -> Tuple[Any, Any]:
+ try:
+ image_data = self.get_image_data(index)
+ image = ImageDataDecoder(image_data).decode()
+ except Exception as e:
+ raise RuntimeError(f"can not read image for sample {index}") from e
+ target = self.get_target(index)
+ target = TargetDecoder(target).decode()
+
+ if self.transforms is not None:
+ image, target = self.transforms(image, target)
+
+ return image, target
+
+ def __len__(self) -> int:
+ raise NotImplementedError
diff --git a/facebookresearch/dinov2/dinov2/data/datasets/image_net.py b/facebookresearch/dinov2/dinov2/data/datasets/image_net.py
new file mode 100644
index 0000000..8d08446
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/datasets/image_net.py
@@ -0,0 +1,290 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import csv
+from enum import Enum
+import logging
+import os
+from typing import Callable, List, Optional, Tuple, Union
+
+import numpy as np
+
+from .extended import ExtendedVisionDataset
+
+
+logger = logging.getLogger("dinov2")
+_Target = int
+
+
+class _Split(Enum):
+ TRAIN = "train"
+ VAL = "val"
+ TEST = "test" # NOTE: torchvision does not support the test split
+
+ @property
+ def length(self) -> int:
+ split_lengths = {
+ _Split.TRAIN: 1_281_167,
+ _Split.VAL: 50_000,
+ _Split.TEST: 100_000,
+ }
+ return split_lengths[self]
+
+ def get_dirname(self, class_id: Optional[str] = None) -> str:
+ return self.value if class_id is None else os.path.join(self.value, class_id)
+
+ def get_image_relpath(self, actual_index: int, class_id: Optional[str] = None) -> str:
+ dirname = self.get_dirname(class_id)
+ if self == _Split.TRAIN:
+ basename = f"{class_id}_{actual_index}"
+ else: # self in (_Split.VAL, _Split.TEST):
+ basename = f"ILSVRC2012_{self.value}_{actual_index:08d}"
+ return os.path.join(dirname, basename + ".JPEG")
+
+ def parse_image_relpath(self, image_relpath: str) -> Tuple[str, int]:
+ assert self != _Split.TEST
+ dirname, filename = os.path.split(image_relpath)
+ class_id = os.path.split(dirname)[-1]
+ basename, _ = os.path.splitext(filename)
+ actual_index = int(basename.split("_")[-1])
+ return class_id, actual_index
+
+
+class ImageNet(ExtendedVisionDataset):
+ Target = Union[_Target]
+ Split = Union[_Split]
+
+ def __init__(
+ self,
+ *,
+ split: "ImageNet.Split",
+ root: str,
+ extra: str,
+ transforms: Optional[Callable] = None,
+ transform: Optional[Callable] = None,
+ target_transform: Optional[Callable] = None,
+ ) -> None:
+ super().__init__(root, transforms, transform, target_transform)
+ self._extra_root = extra
+ self._split = split
+
+ self._entries = None
+ self._class_ids = None
+ self._class_names = None
+
+ @property
+ def split(self) -> "ImageNet.Split":
+ return self._split
+
+ def _get_extra_full_path(self, extra_path: str) -> str:
+ return os.path.join(self._extra_root, extra_path)
+
+ def _load_extra(self, extra_path: str) -> np.ndarray:
+ extra_full_path = self._get_extra_full_path(extra_path)
+ return np.load(extra_full_path, mmap_mode="r")
+
+ def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None:
+ extra_full_path = self._get_extra_full_path(extra_path)
+ os.makedirs(self._extra_root, exist_ok=True)
+ np.save(extra_full_path, extra_array)
+
+ @property
+ def _entries_path(self) -> str:
+ return f"entries-{self._split.value.upper()}.npy"
+
+ @property
+ def _class_ids_path(self) -> str:
+ return f"class-ids-{self._split.value.upper()}.npy"
+
+ @property
+ def _class_names_path(self) -> str:
+ return f"class-names-{self._split.value.upper()}.npy"
+
+ def _get_entries(self) -> np.ndarray:
+ if self._entries is None:
+ self._entries = self._load_extra(self._entries_path)
+ assert self._entries is not None
+ return self._entries
+
+ def _get_class_ids(self) -> np.ndarray:
+ if self._split == _Split.TEST:
+ assert False, "Class IDs are not available in TEST split"
+ if self._class_ids is None:
+ self._class_ids = self._load_extra(self._class_ids_path)
+ assert self._class_ids is not None
+ return self._class_ids
+
+ def _get_class_names(self) -> np.ndarray:
+ if self._split == _Split.TEST:
+ assert False, "Class names are not available in TEST split"
+ if self._class_names is None:
+ self._class_names = self._load_extra(self._class_names_path)
+ assert self._class_names is not None
+ return self._class_names
+
+ def find_class_id(self, class_index: int) -> str:
+ class_ids = self._get_class_ids()
+ return str(class_ids[class_index])
+
+ def find_class_name(self, class_index: int) -> str:
+ class_names = self._get_class_names()
+ return str(class_names[class_index])
+
+ def get_image_data(self, index: int) -> bytes:
+ entries = self._get_entries()
+ actual_index = entries[index]["actual_index"]
+
+ class_id = self.get_class_id(index)
+
+ image_relpath = self.split.get_image_relpath(actual_index, class_id)
+ image_full_path = os.path.join(self.root, image_relpath)
+ with open(image_full_path, mode="rb") as f:
+ image_data = f.read()
+ return image_data
+
+ def get_target(self, index: int) -> Optional[Target]:
+ entries = self._get_entries()
+ class_index = entries[index]["class_index"]
+ return None if self.split == _Split.TEST else int(class_index)
+
+ def get_targets(self) -> Optional[np.ndarray]:
+ entries = self._get_entries()
+ return None if self.split == _Split.TEST else entries["class_index"]
+
+ def get_class_id(self, index: int) -> Optional[str]:
+ entries = self._get_entries()
+ class_id = entries[index]["class_id"]
+ return None if self.split == _Split.TEST else str(class_id)
+
+ def get_class_name(self, index: int) -> Optional[str]:
+ entries = self._get_entries()
+ class_name = entries[index]["class_name"]
+ return None if self.split == _Split.TEST else str(class_name)
+
+ def __len__(self) -> int:
+ entries = self._get_entries()
+ assert len(entries) == self.split.length
+ return len(entries)
+
+ def _load_labels(self, labels_path: str) -> List[Tuple[str, str]]:
+ labels_full_path = os.path.join(self.root, labels_path)
+ labels = []
+
+ try:
+ with open(labels_full_path, "r") as f:
+ reader = csv.reader(f)
+ for row in reader:
+ class_id, class_name = row
+ labels.append((class_id, class_name))
+ except OSError as e:
+ raise RuntimeError(f'can not read labels file "{labels_full_path}"') from e
+
+ return labels
+
+ def _dump_entries(self) -> None:
+ split = self.split
+ if split == ImageNet.Split.TEST:
+ dataset = None
+ sample_count = split.length
+ max_class_id_length, max_class_name_length = 0, 0
+ else:
+ labels_path = "labels.txt"
+ logger.info(f'loading labels from "{labels_path}"')
+ labels = self._load_labels(labels_path)
+
+ # NOTE: Using torchvision ImageFolder for consistency
+ from torchvision.datasets import ImageFolder
+
+ dataset_root = os.path.join(self.root, split.get_dirname())
+ dataset = ImageFolder(dataset_root)
+ sample_count = len(dataset)
+ max_class_id_length, max_class_name_length = -1, -1
+ for sample in dataset.samples:
+ _, class_index = sample
+ class_id, class_name = labels[class_index]
+ max_class_id_length = max(len(class_id), max_class_id_length)
+ max_class_name_length = max(len(class_name), max_class_name_length)
+
+ dtype = np.dtype(
+ [
+ ("actual_index", " old_percent:
+ logger.info(f"creating entries: {percent}%")
+ old_percent = percent
+
+ actual_index = index + 1
+ class_index = np.uint32(-1)
+ class_id, class_name = "", ""
+ entries_array[index] = (actual_index, class_index, class_id, class_name)
+ else:
+ class_names = {class_id: class_name for class_id, class_name in labels}
+
+ assert dataset
+ old_percent = -1
+ for index in range(sample_count):
+ percent = 100 * (index + 1) // sample_count
+ if percent > old_percent:
+ logger.info(f"creating entries: {percent}%")
+ old_percent = percent
+
+ image_full_path, class_index = dataset.samples[index]
+ image_relpath = os.path.relpath(image_full_path, self.root)
+ class_id, actual_index = split.parse_image_relpath(image_relpath)
+ class_name = class_names[class_id]
+ entries_array[index] = (actual_index, class_index, class_id, class_name)
+
+ logger.info(f'saving entries to "{self._entries_path}"')
+ self._save_extra(entries_array, self._entries_path)
+
+ def _dump_class_ids_and_names(self) -> None:
+ split = self.split
+ if split == ImageNet.Split.TEST:
+ return
+
+ entries_array = self._load_extra(self._entries_path)
+
+ max_class_id_length, max_class_name_length, max_class_index = -1, -1, -1
+ for entry in entries_array:
+ class_index, class_id, class_name = (
+ entry["class_index"],
+ entry["class_id"],
+ entry["class_name"],
+ )
+ max_class_index = max(int(class_index), max_class_index)
+ max_class_id_length = max(len(str(class_id)), max_class_id_length)
+ max_class_name_length = max(len(str(class_name)), max_class_name_length)
+
+ class_count = max_class_index + 1
+ class_ids_array = np.empty(class_count, dtype=f"U{max_class_id_length}")
+ class_names_array = np.empty(class_count, dtype=f"U{max_class_name_length}")
+ for entry in entries_array:
+ class_index, class_id, class_name = (
+ entry["class_index"],
+ entry["class_id"],
+ entry["class_name"],
+ )
+ class_ids_array[class_index] = class_id
+ class_names_array[class_index] = class_name
+
+ logger.info(f'saving class IDs to "{self._class_ids_path}"')
+ self._save_extra(class_ids_array, self._class_ids_path)
+
+ logger.info(f'saving class names to "{self._class_names_path}"')
+ self._save_extra(class_names_array, self._class_names_path)
+
+ def dump_extra(self) -> None:
+ self._dump_entries()
+ self._dump_class_ids_and_names()
diff --git a/facebookresearch/dinov2/dinov2/data/datasets/image_net_22k.py b/facebookresearch/dinov2/dinov2/data/datasets/image_net_22k.py
new file mode 100644
index 0000000..52b36a2
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/datasets/image_net_22k.py
@@ -0,0 +1,302 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from dataclasses import dataclass
+from enum import Enum
+from functools import lru_cache
+from gzip import GzipFile
+from io import BytesIO
+from mmap import ACCESS_READ, mmap
+import os
+from typing import Any, Callable, List, Optional, Set, Tuple
+import warnings
+
+import numpy as np
+
+from .extended import ExtendedVisionDataset
+
+
+_Labels = int
+
+_DEFAULT_MMAP_CACHE_SIZE = 16 # Warning: This can exhaust file descriptors
+
+
+@dataclass
+class _ClassEntry:
+ block_offset: int
+ maybe_filename: Optional[str] = None
+
+
+@dataclass
+class _Entry:
+ class_index: int # noqa: E701
+ start_offset: int
+ end_offset: int
+ filename: str
+
+
+class _Split(Enum):
+ TRAIN = "train"
+ VAL = "val"
+
+ @property
+ def length(self) -> int:
+ return {
+ _Split.TRAIN: 11_797_647,
+ _Split.VAL: 561_050,
+ }[self]
+
+ def entries_path(self):
+ return f"imagenet21kp_{self.value}.txt"
+
+
+def _get_tarball_path(class_id: str) -> str:
+ return f"{class_id}.tar"
+
+
+def _make_mmap_tarball(tarballs_root: str, mmap_cache_size: int):
+ @lru_cache(maxsize=mmap_cache_size)
+ def _mmap_tarball(class_id: str) -> mmap:
+ tarball_path = _get_tarball_path(class_id)
+ tarball_full_path = os.path.join(tarballs_root, tarball_path)
+ with open(tarball_full_path) as f:
+ return mmap(fileno=f.fileno(), length=0, access=ACCESS_READ)
+
+ return _mmap_tarball
+
+
+class ImageNet22k(ExtendedVisionDataset):
+ _GZIPPED_INDICES: Set[int] = {
+ 841_545,
+ 1_304_131,
+ 2_437_921,
+ 2_672_079,
+ 2_795_676,
+ 2_969_786,
+ 6_902_965,
+ 6_903_550,
+ 6_903_628,
+ 7_432_557,
+ 7_432_589,
+ 7_813_809,
+ 8_329_633,
+ 10_296_990,
+ 10_417_652,
+ 10_492_265,
+ 10_598_078,
+ 10_782_398,
+ 10_902_612,
+ 11_203_736,
+ 11_342_890,
+ 11_397_596,
+ 11_589_762,
+ 11_705_103,
+ 12_936_875,
+ 13_289_782,
+ }
+ Labels = _Labels
+
+ def __init__(
+ self,
+ *,
+ root: str,
+ extra: str,
+ transforms: Optional[Callable] = None,
+ transform: Optional[Callable] = None,
+ target_transform: Optional[Callable] = None,
+ mmap_cache_size: int = _DEFAULT_MMAP_CACHE_SIZE,
+ ) -> None:
+ super().__init__(root, transforms, transform, target_transform)
+ self._extra_root = extra
+
+ entries_path = self._get_entries_path(root)
+ self._entries = self._load_extra(entries_path)
+
+ class_ids_path = self._get_class_ids_path(root)
+ self._class_ids = self._load_extra(class_ids_path)
+
+ self._gzipped_indices = ImageNet22k._GZIPPED_INDICES
+ self._mmap_tarball = _make_mmap_tarball(self._tarballs_root, mmap_cache_size)
+
+ def _get_entries_path(self, root: Optional[str] = None) -> str:
+ return "entries.npy"
+
+ def _get_class_ids_path(self, root: Optional[str] = None) -> str:
+ return "class-ids.npy"
+
+ def _find_class_ids(self, path: str) -> List[str]:
+ class_ids = []
+
+ with os.scandir(path) as entries:
+ for entry in entries:
+ root, ext = os.path.splitext(entry.name)
+ if ext != ".tar":
+ continue
+ class_ids.append(root)
+
+ return sorted(class_ids)
+
+ def _load_entries_class_ids(self, root: Optional[str] = None) -> Tuple[List[_Entry], List[str]]:
+ root = self.get_root(root)
+ entries: List[_Entry] = []
+ class_ids = self._find_class_ids(root)
+
+ for class_index, class_id in enumerate(class_ids):
+ path = os.path.join(root, "blocks", f"{class_id}.log")
+ class_entries = []
+
+ try:
+ with open(path) as f:
+ for line in f:
+ line = line.rstrip()
+ block, filename = line.split(":")
+ block_offset = int(block[6:])
+ filename = filename[1:]
+
+ maybe_filename = None
+ if filename != "** Block of NULs **":
+ maybe_filename = filename
+ _, ext = os.path.splitext(filename)
+ # assert ext == ".JPEG"
+
+ class_entry = _ClassEntry(block_offset, maybe_filename)
+ class_entries.append(class_entry)
+ except OSError as e:
+ raise RuntimeError(f'can not read blocks file "{path}"') from e
+
+ assert class_entries[-1].maybe_filename is None
+
+ for class_entry1, class_entry2 in zip(class_entries, class_entries[1:]):
+ assert class_entry1.block_offset <= class_entry2.block_offset
+ start_offset = 512 * class_entry1.block_offset
+ end_offset = 512 * class_entry2.block_offset
+ assert class_entry1.maybe_filename is not None
+ filename = class_entry1.maybe_filename
+ entry = _Entry(class_index, start_offset, end_offset, filename)
+ # Skip invalid image files (PIL throws UnidentifiedImageError)
+ if filename == "n06470073_47249.JPEG":
+ continue
+ entries.append(entry)
+
+ return entries, class_ids
+
+ def _load_extra(self, extra_path: str) -> np.ndarray:
+ extra_root = self._extra_root
+ extra_full_path = os.path.join(extra_root, extra_path)
+ return np.load(extra_full_path, mmap_mode="r")
+
+ def _save_extra(self, extra_array: np.ndarray, extra_path: str) -> None:
+ extra_root = self._extra_root
+ extra_full_path = os.path.join(extra_root, extra_path)
+ os.makedirs(extra_root, exist_ok=True)
+ np.save(extra_full_path, extra_array)
+
+ @property
+ def _tarballs_root(self) -> str:
+ return self.root
+
+ def find_class_id(self, class_index: int) -> str:
+ return str(self._class_ids[class_index])
+
+ def get_image_data(self, index: int) -> bytes:
+ entry = self._entries[index]
+ class_id = entry["class_id"]
+ class_mmap = self._mmap_tarball(class_id)
+
+ start_offset, end_offset = entry["start_offset"], entry["end_offset"]
+ try:
+ mapped_data = class_mmap[start_offset:end_offset]
+ data = mapped_data[512:] # Skip entry header block
+
+ if len(data) >= 2 and tuple(data[:2]) == (0x1F, 0x8B):
+ assert index in self._gzipped_indices, f"unexpected gzip header for sample {index}"
+ with GzipFile(fileobj=BytesIO(data)) as g:
+ data = g.read()
+ except Exception as e:
+ raise RuntimeError(f"can not retrieve image data for sample {index} " f'from "{class_id}" tarball') from e
+
+ return data
+
+ def get_target(self, index: int) -> Any:
+ return int(self._entries[index]["class_index"])
+
+ def get_targets(self) -> np.ndarray:
+ return self._entries["class_index"]
+
+ def get_class_id(self, index: int) -> str:
+ return str(self._entries[index]["class_id"])
+
+ def get_class_ids(self) -> np.ndarray:
+ return self._entries["class_id"]
+
+ def __getitem__(self, index: int) -> Tuple[Any, Any]:
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ return super().__getitem__(index)
+
+ def __len__(self) -> int:
+ return len(self._entries)
+
+ def _dump_entries(self, *args, **kwargs) -> None:
+ entries, class_ids = self._load_entries_class_ids(*args, **kwargs)
+
+ max_class_id_length, max_filename_length, max_class_index = -1, -1, -1
+ for entry in entries:
+ class_id = class_ids[entry.class_index]
+ max_class_index = max(entry.class_index, max_class_index)
+ max_class_id_length = max(len(class_id), max_class_id_length)
+ max_filename_length = max(len(entry.filename), max_filename_length)
+
+ dtype = np.dtype(
+ [
+ ("class_index", " None:
+ entries_path = self._get_entries_path(*args, **kwargs)
+ entries_array = self._load_extra(entries_path)
+
+ max_class_id_length, max_class_index = -1, -1
+ for entry in entries_array:
+ class_index, class_id = entry["class_index"], entry["class_id"]
+ max_class_index = max(int(class_index), max_class_index)
+ max_class_id_length = max(len(str(class_id)), max_class_id_length)
+
+ class_ids_array = np.empty(max_class_index + 1, dtype=f"U{max_class_id_length}")
+ for entry in entries_array:
+ class_index, class_id = entry["class_index"], entry["class_id"]
+ class_ids_array[class_index] = class_id
+ class_ids_path = self._get_class_ids_path(*args, **kwargs)
+ self._save_extra(class_ids_array, class_ids_path)
+
+ def _dump_extra(self, *args, **kwargs) -> None:
+ self._dump_entries(*args, *kwargs)
+ self._dump_class_ids(*args, *kwargs)
+
+ def dump_extra(self, root: Optional[str] = None) -> None:
+ return self._dump_extra(root)
diff --git a/facebookresearch/dinov2/dinov2/data/loaders.py b/facebookresearch/dinov2/dinov2/data/loaders.py
new file mode 100644
index 0000000..d6a2f02
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/loaders.py
@@ -0,0 +1,222 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+from enum import Enum
+from typing import Any, Callable, List, Optional, TypeVar
+
+import torch
+from torch.utils.data import Sampler
+
+from .datasets import ImageNet, ImageNet22k
+from .samplers import EpochSampler, InfiniteSampler, ShardedInfiniteSampler
+
+
+logger = logging.getLogger("dinov2")
+
+
+class SamplerType(Enum):
+ DISTRIBUTED = 0
+ EPOCH = 1
+ INFINITE = 2
+ SHARDED_INFINITE = 3
+ SHARDED_INFINITE_NEW = 4
+
+
+def _make_bool_str(b: bool) -> str:
+ return "yes" if b else "no"
+
+
+def _make_sample_transform(image_transform: Optional[Callable] = None, target_transform: Optional[Callable] = None):
+ def transform(sample):
+ image, target = sample
+ if image_transform is not None:
+ image = image_transform(image)
+ if target_transform is not None:
+ target = target_transform(target)
+ return image, target
+
+ return transform
+
+
+def _parse_dataset_str(dataset_str: str):
+ tokens = dataset_str.split(":")
+
+ name = tokens[0]
+ kwargs = {}
+
+ for token in tokens[1:]:
+ key, value = token.split("=")
+ assert key in ("root", "extra", "split")
+ kwargs[key] = value
+
+ if name == "ImageNet":
+ class_ = ImageNet
+ if "split" in kwargs:
+ kwargs["split"] = ImageNet.Split[kwargs["split"]]
+ elif name == "ImageNet22k":
+ class_ = ImageNet22k
+ else:
+ raise ValueError(f'Unsupported dataset "{name}"')
+
+ return class_, kwargs
+
+
+def make_dataset(
+ *,
+ dataset_str: str,
+ transform: Optional[Callable] = None,
+ target_transform: Optional[Callable] = None,
+):
+ """
+ Creates a dataset with the specified parameters.
+
+ Args:
+ dataset_str: A dataset string description (e.g. ImageNet:split=TRAIN).
+ transform: A transform to apply to images.
+ target_transform: A transform to apply to targets.
+
+ Returns:
+ The created dataset.
+ """
+ logger.info(f'using dataset: "{dataset_str}"')
+
+ class_, kwargs = _parse_dataset_str(dataset_str)
+ dataset = class_(transform=transform, target_transform=target_transform, **kwargs)
+
+ logger.info(f"# of dataset samples: {len(dataset):,d}")
+
+ # Aggregated datasets do not expose (yet) these attributes, so add them.
+ if not hasattr(dataset, "transform"):
+ setattr(dataset, "transform", transform)
+ if not hasattr(dataset, "target_transform"):
+ setattr(dataset, "target_transform", target_transform)
+
+ return dataset
+
+
+def _make_sampler(
+ *,
+ dataset,
+ type: Optional[SamplerType] = None,
+ shuffle: bool = False,
+ seed: int = 0,
+ size: int = -1,
+ advance: int = 0,
+) -> Optional[Sampler]:
+ sample_count = len(dataset)
+
+ if type == SamplerType.INFINITE:
+ logger.info("sampler: infinite")
+ if size > 0:
+ raise ValueError("sampler size > 0 is invalid")
+ return InfiniteSampler(
+ sample_count=sample_count,
+ shuffle=shuffle,
+ seed=seed,
+ advance=advance,
+ )
+ elif type in (SamplerType.SHARDED_INFINITE, SamplerType.SHARDED_INFINITE_NEW):
+ logger.info("sampler: sharded infinite")
+ if size > 0:
+ raise ValueError("sampler size > 0 is invalid")
+ # TODO: Remove support for old shuffling
+ use_new_shuffle_tensor_slice = type == SamplerType.SHARDED_INFINITE_NEW
+ return ShardedInfiniteSampler(
+ sample_count=sample_count,
+ shuffle=shuffle,
+ seed=seed,
+ advance=advance,
+ use_new_shuffle_tensor_slice=use_new_shuffle_tensor_slice,
+ )
+ elif type == SamplerType.EPOCH:
+ logger.info("sampler: epoch")
+ if advance > 0:
+ raise NotImplementedError("sampler advance > 0 is not supported")
+ size = size if size > 0 else sample_count
+ logger.info(f"# of samples / epoch: {size:,d}")
+ return EpochSampler(
+ size=size,
+ sample_count=sample_count,
+ shuffle=shuffle,
+ seed=seed,
+ )
+ elif type == SamplerType.DISTRIBUTED:
+ logger.info("sampler: distributed")
+ if size > 0:
+ raise ValueError("sampler size > 0 is invalid")
+ if advance > 0:
+ raise ValueError("sampler advance > 0 is invalid")
+ return torch.utils.data.DistributedSampler(
+ dataset=dataset,
+ shuffle=shuffle,
+ seed=seed,
+ drop_last=False,
+ )
+
+ logger.info("sampler: none")
+ return None
+
+
+T = TypeVar("T")
+
+
+def make_data_loader(
+ *,
+ dataset,
+ batch_size: int,
+ num_workers: int,
+ shuffle: bool = True,
+ seed: int = 0,
+ sampler_type: Optional[SamplerType] = SamplerType.INFINITE,
+ sampler_size: int = -1,
+ sampler_advance: int = 0,
+ drop_last: bool = True,
+ persistent_workers: bool = False,
+ collate_fn: Optional[Callable[[List[T]], Any]] = None,
+):
+ """
+ Creates a data loader with the specified parameters.
+
+ Args:
+ dataset: A dataset (third party, LaViDa or WebDataset).
+ batch_size: The size of batches to generate.
+ num_workers: The number of workers to use.
+ shuffle: Whether to shuffle samples.
+ seed: The random seed to use.
+ sampler_type: Which sampler to use: EPOCH, INFINITE, SHARDED_INFINITE, SHARDED_INFINITE_NEW, DISTRIBUTED or None.
+ sampler_size: The number of images per epoch (when applicable) or -1 for the entire dataset.
+ sampler_advance: How many samples to skip (when applicable).
+ drop_last: Whether the last non-full batch of data should be dropped.
+ persistent_workers: maintain the workers Dataset instances alive after a dataset has been consumed once.
+ collate_fn: Function that performs batch collation
+ """
+
+ sampler = _make_sampler(
+ dataset=dataset,
+ type=sampler_type,
+ shuffle=shuffle,
+ seed=seed,
+ size=sampler_size,
+ advance=sampler_advance,
+ )
+
+ logger.info("using PyTorch data loader")
+ data_loader = torch.utils.data.DataLoader(
+ dataset,
+ sampler=sampler,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ pin_memory=True,
+ drop_last=drop_last,
+ persistent_workers=persistent_workers,
+ collate_fn=collate_fn,
+ )
+
+ try:
+ logger.info(f"# of batches: {len(data_loader):,d}")
+ except TypeError: # data loader has no length
+ logger.info("infinite data loader")
+ return data_loader
diff --git a/facebookresearch/dinov2/dinov2/data/masking.py b/facebookresearch/dinov2/dinov2/data/masking.py
new file mode 100644
index 0000000..ab12aa7
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/masking.py
@@ -0,0 +1,86 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import random
+import math
+import numpy as np
+
+
+class MaskingGenerator:
+ def __init__(
+ self,
+ input_size,
+ num_masking_patches=None,
+ min_num_patches=4,
+ max_num_patches=None,
+ min_aspect=0.3,
+ max_aspect=None,
+ ):
+ if not isinstance(input_size, tuple):
+ input_size = (input_size,) * 2
+ self.height, self.width = input_size
+
+ self.num_patches = self.height * self.width
+ self.num_masking_patches = num_masking_patches
+
+ self.min_num_patches = min_num_patches
+ self.max_num_patches = num_masking_patches if max_num_patches is None else max_num_patches
+
+ max_aspect = max_aspect or 1 / min_aspect
+ self.log_aspect_ratio = (math.log(min_aspect), math.log(max_aspect))
+
+ def __repr__(self):
+ repr_str = "Generator(%d, %d -> [%d ~ %d], max = %d, %.3f ~ %.3f)" % (
+ self.height,
+ self.width,
+ self.min_num_patches,
+ self.max_num_patches,
+ self.num_masking_patches,
+ self.log_aspect_ratio[0],
+ self.log_aspect_ratio[1],
+ )
+ return repr_str
+
+ def get_shape(self):
+ return self.height, self.width
+
+ def _mask(self, mask, max_mask_patches):
+ delta = 0
+ for _ in range(10):
+ target_area = random.uniform(self.min_num_patches, max_mask_patches)
+ aspect_ratio = math.exp(random.uniform(*self.log_aspect_ratio))
+ h = int(round(math.sqrt(target_area * aspect_ratio)))
+ w = int(round(math.sqrt(target_area / aspect_ratio)))
+ if w < self.width and h < self.height:
+ top = random.randint(0, self.height - h)
+ left = random.randint(0, self.width - w)
+
+ num_masked = mask[top : top + h, left : left + w].sum()
+ # Overlap
+ if 0 < h * w - num_masked <= max_mask_patches:
+ for i in range(top, top + h):
+ for j in range(left, left + w):
+ if mask[i, j] == 0:
+ mask[i, j] = 1
+ delta += 1
+
+ if delta > 0:
+ break
+ return delta
+
+ def __call__(self, num_masking_patches=0):
+ mask = np.zeros(shape=self.get_shape(), dtype=bool)
+ mask_count = 0
+ while mask_count < num_masking_patches:
+ max_mask_patches = num_masking_patches - mask_count
+ max_mask_patches = min(max_mask_patches, self.max_num_patches)
+
+ delta = self._mask(mask, max_mask_patches)
+ if delta == 0:
+ break
+ else:
+ mask_count += delta
+
+ return mask
diff --git a/facebookresearch/dinov2/dinov2/data/samplers.py b/facebookresearch/dinov2/dinov2/data/samplers.py
new file mode 100644
index 0000000..6562197
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/samplers.py
@@ -0,0 +1,229 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import itertools
+from typing import Any, Optional
+import warnings
+
+import numpy as np
+import torch
+from torch.utils.data.sampler import Sampler
+
+import dinov2.distributed as distributed
+
+
+class EpochSampler(Sampler):
+ def __init__(
+ self,
+ *,
+ size: int,
+ sample_count: int,
+ shuffle: bool = False,
+ seed: int = 0,
+ start: Optional[int] = None,
+ step: Optional[int] = None,
+ ):
+ self._size = size
+ self._sample_count = sample_count
+ self._shuffle = shuffle
+ self._seed = seed
+ self._start = distributed.get_global_rank() if start is None else start
+ self._step = distributed.get_global_size() if step is None else step
+ self._epoch = 0
+
+ def __iter__(self):
+ count = (self._size + self._sample_count - 1) // self._sample_count
+ tiled_indices = np.tile(np.arange(self._sample_count), count)
+ if self._shuffle:
+ seed = self._seed * self._epoch if self._seed != 0 else self._epoch
+ rng = np.random.default_rng(seed)
+ iterable = rng.choice(tiled_indices, self._size, replace=False)
+ else:
+ iterable = tiled_indices[: self._size]
+
+ yield from itertools.islice(iterable, self._start, None, self._step)
+
+ def __len__(self):
+ return (self._size - self._start + self._step - 1) // self._step
+
+ def set_epoch(self, epoch):
+ self._epoch = epoch
+
+
+def _get_numpy_dtype(size: int) -> Any:
+ return np.int32 if size <= 2**31 else np.int64
+
+
+def _get_torch_dtype(size: int) -> Any:
+ return torch.int32 if size <= 2**31 else torch.int64
+
+
+def _generate_randperm_indices(*, size: int, generator: torch.Generator):
+ """Generate the indices of a random permutation."""
+ dtype = _get_torch_dtype(size)
+ # This is actually matching PyTorch's CPU implementation, see: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/TensorFactories.cpp#L900-L921
+ perm = torch.arange(size, dtype=dtype)
+ for i in range(size):
+ j = torch.randint(i, size, size=(1,), generator=generator).item()
+
+ # Always swap even if no-op
+ value = perm[j].item()
+ perm[j] = perm[i].item()
+ perm[i] = value
+ yield value
+
+
+class InfiniteSampler(Sampler):
+ def __init__(
+ self,
+ *,
+ sample_count: int,
+ shuffle: bool = False,
+ seed: int = 0,
+ start: Optional[int] = None,
+ step: Optional[int] = None,
+ advance: int = 0,
+ ):
+ self._sample_count = sample_count
+ self._seed = seed
+ self._shuffle = shuffle
+ self._start = distributed.get_global_rank() if start is None else start
+ self._step = distributed.get_global_size() if step is None else step
+ self._advance = advance
+
+ def __iter__(self):
+ if self._shuffle:
+ iterator = self._shuffled_iterator()
+ else:
+ iterator = self._iterator()
+
+ yield from itertools.islice(iterator, self._advance, None)
+
+ def _iterator(self):
+ assert not self._shuffle
+
+ while True:
+ iterable = range(self._sample_count)
+ yield from itertools.islice(iterable, self._start, None, self._step)
+
+ def _shuffled_iterator(self):
+ assert self._shuffle
+
+ # Instantiate a generator here (rather than in the ctor) to keep the class
+ # picklable (requirement of mp.spawn)
+ generator = torch.Generator().manual_seed(self._seed)
+
+ while True:
+ iterable = _generate_randperm_indices(size=self._sample_count, generator=generator)
+ yield from itertools.islice(iterable, self._start, None, self._step)
+
+
+# The following function is somewhat equivalent to _new_shuffle_tensor_slice below,
+# but avoids a full in-place random permutation generation.
+def _shuffle_tensor_slice(
+ *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator
+) -> np.ndarray:
+ stop = len(tensor)
+ count = stop // step
+ drop_count = stop - step * count
+ if drop_count:
+ warnings.warn(f"# of dropped samples: {drop_count}")
+
+ dtype = _get_numpy_dtype(stop)
+ result = np.empty(count, dtype=dtype)
+
+ for i in range(count):
+ j = torch.randint(0, i + 1, size=(1,), generator=generator).item() if i > 0 else 0
+
+ result[i] = result[j]
+ result[j] = tensor[start + i * step].item()
+
+ return result
+
+
+def _new_shuffle_tensor_slice(
+ *, tensor: torch.Tensor, start: int = 0, step: int = 1, generator: torch.Generator
+) -> np.ndarray:
+ stop = len(tensor)
+ count = stop // step
+ dtype = torch.int64 # Needed for using randperm result as indices
+ count = stop // step
+ drop_count = stop - step * count
+ if drop_count:
+ warnings.warn(f"# of dropped samples: {drop_count}")
+ indices = torch.randperm(count, dtype=dtype, generator=generator)
+ return tensor[start::step][indices].numpy()
+
+
+def _make_seed(seed: int, start: int, iter_count: int) -> int:
+ # NOTE: Tried a few variants (including iter_count << 32), this one worked best.
+ return seed + start + (iter_count << 24)
+
+
+class ShardedInfiniteSampler(Sampler):
+ def __init__(
+ self,
+ *,
+ sample_count: int,
+ shuffle: bool = False,
+ seed: int = 0,
+ start: Optional[int] = None,
+ step: Optional[int] = None,
+ advance: int = 0,
+ use_new_shuffle_tensor_slice: bool = False,
+ ):
+ self._sample_count = sample_count
+ self._seed = seed
+ self._shuffle = shuffle
+ self._start = distributed.get_global_rank() if start is None else start
+ self._step = distributed.get_global_size() if step is None else step
+ self._advance = advance
+ self._iter_count = 0
+ self._shuffle_tensor_slice_fn = (
+ _new_shuffle_tensor_slice if use_new_shuffle_tensor_slice else _shuffle_tensor_slice
+ )
+
+ def __iter__(self):
+ iter_count = self._advance // self._sample_count
+ if iter_count > 0:
+ self._advance -= iter_count * self._sample_count
+ self._iter_count += iter_count
+
+ if self._shuffle:
+ iterator = self._shuffled_iterator()
+ else:
+ iterator = self._iterator()
+
+ yield from itertools.islice(iterator, self._advance, None)
+
+ def _iterator(self):
+ assert not self._shuffle
+
+ while True:
+ iterable = range(self._sample_count)
+ yield from itertools.islice(iterable, self._start, None, self._step)
+
+ def _shuffled_iterator(self):
+ assert self._shuffle
+
+ # Instantiate a generator here (rather than in the ctor) to be keep the class
+ # picklable (requirement of mp.spawn)
+ generator = torch.Generator()
+
+ # Always shuffle everything first
+ generator.manual_seed(self._seed)
+ dtype = _get_torch_dtype(self._sample_count)
+ perm = torch.randperm(self._sample_count, dtype=dtype, generator=generator)
+
+ while True:
+ # Re-seed on each iteration to allow skipping whole permutations
+ seed = _make_seed(self._seed, self._start, self._iter_count)
+ generator.manual_seed(seed)
+
+ iterable = self._shuffle_tensor_slice_fn(
+ tensor=perm, start=self._start, step=self._step, generator=generator
+ )
+ yield from iterable
+ self._iter_count += 1
diff --git a/facebookresearch/dinov2/dinov2/data/transforms.py b/facebookresearch/dinov2/dinov2/data/transforms.py
new file mode 100644
index 0000000..eb5f252
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/data/transforms.py
@@ -0,0 +1,91 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from typing import Sequence
+
+import torch
+from torchvision import transforms
+
+
+class GaussianBlur(transforms.RandomApply):
+ """
+ Apply Gaussian Blur to the PIL image.
+ """
+
+ def __init__(self, *, p: float = 0.5, radius_min: float = 0.1, radius_max: float = 2.0):
+ # NOTE: torchvision is applying 1 - probability to return the original image
+ keep_p = 1 - p
+ transform = transforms.GaussianBlur(kernel_size=9, sigma=(radius_min, radius_max))
+ super().__init__(transforms=[transform], p=keep_p)
+
+
+class MaybeToTensor(transforms.ToTensor):
+ """
+ Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor, or keep as is if already a tensor.
+ """
+
+ def __call__(self, pic):
+ """
+ Args:
+ pic (PIL Image, numpy.ndarray or torch.tensor): Image to be converted to tensor.
+ Returns:
+ Tensor: Converted image.
+ """
+ if isinstance(pic, torch.Tensor):
+ return pic
+ return super().__call__(pic)
+
+
+# Use timm's names
+IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225)
+
+
+def make_normalize_transform(
+ mean: Sequence[float] = IMAGENET_DEFAULT_MEAN,
+ std: Sequence[float] = IMAGENET_DEFAULT_STD,
+) -> transforms.Normalize:
+ return transforms.Normalize(mean=mean, std=std)
+
+
+# This roughly matches torchvision's preset for classification training:
+# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L6-L44
+def make_classification_train_transform(
+ *,
+ crop_size: int = 224,
+ interpolation=transforms.InterpolationMode.BICUBIC,
+ hflip_prob: float = 0.5,
+ mean: Sequence[float] = IMAGENET_DEFAULT_MEAN,
+ std: Sequence[float] = IMAGENET_DEFAULT_STD,
+):
+ transforms_list = [transforms.RandomResizedCrop(crop_size, interpolation=interpolation)]
+ if hflip_prob > 0.0:
+ transforms_list.append(transforms.RandomHorizontalFlip(hflip_prob))
+ transforms_list.extend(
+ [
+ MaybeToTensor(),
+ make_normalize_transform(mean=mean, std=std),
+ ]
+ )
+ return transforms.Compose(transforms_list)
+
+
+# This matches (roughly) torchvision's preset for classification evaluation:
+# https://github.com/pytorch/vision/blob/main/references/classification/presets.py#L47-L69
+def make_classification_eval_transform(
+ *,
+ resize_size: int = 256,
+ interpolation=transforms.InterpolationMode.BICUBIC,
+ crop_size: int = 224,
+ mean: Sequence[float] = IMAGENET_DEFAULT_MEAN,
+ std: Sequence[float] = IMAGENET_DEFAULT_STD,
+) -> transforms.Compose:
+ transforms_list = [
+ transforms.Resize(resize_size, interpolation=interpolation),
+ transforms.CenterCrop(crop_size),
+ MaybeToTensor(),
+ make_normalize_transform(mean=mean, std=std),
+ ]
+ return transforms.Compose(transforms_list)
diff --git a/facebookresearch/dinov2/dinov2/distributed/__init__.py b/facebookresearch/dinov2/dinov2/distributed/__init__.py
new file mode 100644
index 0000000..23226f4
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/distributed/__init__.py
@@ -0,0 +1,270 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import os
+import random
+import re
+import socket
+from typing import Dict, List
+
+import torch
+import torch.distributed as dist
+
+_LOCAL_RANK = -1
+_LOCAL_WORLD_SIZE = -1
+
+
+def is_enabled() -> bool:
+ """
+ Returns:
+ True if distributed training is enabled
+ """
+ return dist.is_available() and dist.is_initialized()
+
+
+def get_global_size() -> int:
+ """
+ Returns:
+ The number of processes in the process group
+ """
+ return dist.get_world_size() if is_enabled() else 1
+
+
+def get_global_rank() -> int:
+ """
+ Returns:
+ The rank of the current process within the global process group.
+ """
+ return dist.get_rank() if is_enabled() else 0
+
+
+def get_local_rank() -> int:
+ """
+ Returns:
+ The rank of the current process within the local (per-machine) process group.
+ """
+ if not is_enabled():
+ return 0
+ assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE
+ return _LOCAL_RANK
+
+
+def get_local_size() -> int:
+ """
+ Returns:
+ The size of the per-machine process group,
+ i.e. the number of processes per machine.
+ """
+ if not is_enabled():
+ return 1
+ assert 0 <= _LOCAL_RANK < _LOCAL_WORLD_SIZE
+ return _LOCAL_WORLD_SIZE
+
+
+def is_main_process() -> bool:
+ """
+ Returns:
+ True if the current process is the main one.
+ """
+ return get_global_rank() == 0
+
+
+def _restrict_print_to_main_process() -> None:
+ """
+ This function disables printing when not in the main process
+ """
+ import builtins as __builtin__
+
+ builtin_print = __builtin__.print
+
+ def print(*args, **kwargs):
+ force = kwargs.pop("force", False)
+ if is_main_process() or force:
+ builtin_print(*args, **kwargs)
+
+ __builtin__.print = print
+
+
+def _get_master_port(seed: int = 0) -> int:
+ MIN_MASTER_PORT, MAX_MASTER_PORT = (20_000, 60_000)
+
+ master_port_str = os.environ.get("MASTER_PORT")
+ if master_port_str is None:
+ rng = random.Random(seed)
+ return rng.randint(MIN_MASTER_PORT, MAX_MASTER_PORT)
+
+ return int(master_port_str)
+
+
+def _get_available_port() -> int:
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ # A "" host address means INADDR_ANY i.e. binding to all interfaces.
+ # Note this is not compatible with IPv6.
+ s.bind(("", 0))
+ port = s.getsockname()[1]
+ return port
+
+
+_TORCH_DISTRIBUTED_ENV_VARS = (
+ "MASTER_ADDR",
+ "MASTER_PORT",
+ "RANK",
+ "WORLD_SIZE",
+ "LOCAL_RANK",
+ "LOCAL_WORLD_SIZE",
+)
+
+
+def _collect_env_vars() -> Dict[str, str]:
+ return {env_var: os.environ[env_var] for env_var in _TORCH_DISTRIBUTED_ENV_VARS if env_var in os.environ}
+
+
+def _is_slurm_job_process() -> bool:
+ return "SLURM_JOB_ID" in os.environ
+
+
+def _parse_slurm_node_list(s: str) -> List[str]:
+ nodes = []
+ # Extract "hostname", "hostname[1-2,3,4-5]," substrings
+ p = re.compile(r"(([^\[]+)(?:\[([^\]]+)\])?),?")
+ for m in p.finditer(s):
+ prefix, suffixes = s[m.start(2) : m.end(2)], s[m.start(3) : m.end(3)]
+ for suffix in suffixes.split(","):
+ span = suffix.split("-")
+ if len(span) == 1:
+ nodes.append(prefix + suffix)
+ else:
+ width = len(span[0])
+ start, end = int(span[0]), int(span[1]) + 1
+ nodes.extend([prefix + f"{i:0{width}}" for i in range(start, end)])
+ return nodes
+
+
+def _check_env_variable(key: str, new_value: str):
+ # Only check for difference with preset environment variables
+ if key in os.environ and os.environ[key] != new_value:
+ raise RuntimeError(f"Cannot export environment variables as {key} is already set")
+
+
+class _TorchDistributedEnvironment:
+ def __init__(self):
+ self.master_addr = "127.0.0.1"
+ self.master_port = 0
+ self.rank = -1
+ self.world_size = -1
+ self.local_rank = -1
+ self.local_world_size = -1
+
+ if _is_slurm_job_process():
+ return self._set_from_slurm_env()
+
+ env_vars = _collect_env_vars()
+ if not env_vars:
+ # Environment is not set
+ pass
+ elif len(env_vars) == len(_TORCH_DISTRIBUTED_ENV_VARS):
+ # Environment is fully set
+ return self._set_from_preset_env()
+ else:
+ # Environment is partially set
+ collected_env_vars = ", ".join(env_vars.keys())
+ raise RuntimeError(f"Partially set environment: {collected_env_vars}")
+
+ if torch.cuda.device_count() > 0:
+ return self._set_from_local()
+
+ raise RuntimeError("Can't initialize PyTorch distributed environment")
+
+ # Slurm job created with sbatch, submitit, etc...
+ def _set_from_slurm_env(self):
+ # logger.info("Initialization from Slurm environment")
+ job_id = int(os.environ["SLURM_JOB_ID"])
+ node_count = int(os.environ["SLURM_JOB_NUM_NODES"])
+ nodes = _parse_slurm_node_list(os.environ["SLURM_JOB_NODELIST"])
+ assert len(nodes) == node_count
+
+ self.master_addr = nodes[0]
+ self.master_port = _get_master_port(seed=job_id)
+ self.rank = int(os.environ["SLURM_PROCID"])
+ self.world_size = int(os.environ["SLURM_NTASKS"])
+ assert self.rank < self.world_size
+ self.local_rank = int(os.environ["SLURM_LOCALID"])
+ self.local_world_size = self.world_size // node_count
+ assert self.local_rank < self.local_world_size
+
+ # Single node job with preset environment (i.e. torchrun)
+ def _set_from_preset_env(self):
+ # logger.info("Initialization from preset environment")
+ self.master_addr = os.environ["MASTER_ADDR"]
+ self.master_port = os.environ["MASTER_PORT"]
+ self.rank = int(os.environ["RANK"])
+ self.world_size = int(os.environ["WORLD_SIZE"])
+ assert self.rank < self.world_size
+ self.local_rank = int(os.environ["LOCAL_RANK"])
+ self.local_world_size = int(os.environ["LOCAL_WORLD_SIZE"])
+ assert self.local_rank < self.local_world_size
+
+ # Single node and GPU job (i.e. local script run)
+ def _set_from_local(self):
+ # logger.info("Initialization from local")
+ self.master_addr = "127.0.0.1"
+ self.master_port = _get_available_port()
+ self.rank = 0
+ self.world_size = 1
+ self.local_rank = 0
+ self.local_world_size = 1
+
+ def export(self, *, overwrite: bool) -> "_TorchDistributedEnvironment":
+ # See the "Environment variable initialization" section from
+ # https://pytorch.org/docs/stable/distributed.html for the complete list of
+ # environment variables required for the env:// initialization method.
+ env_vars = {
+ "MASTER_ADDR": self.master_addr,
+ "MASTER_PORT": str(self.master_port),
+ "RANK": str(self.rank),
+ "WORLD_SIZE": str(self.world_size),
+ "LOCAL_RANK": str(self.local_rank),
+ "LOCAL_WORLD_SIZE": str(self.local_world_size),
+ }
+ if not overwrite:
+ for k, v in env_vars.items():
+ _check_env_variable(k, v)
+
+ os.environ.update(env_vars)
+ return self
+
+
+def enable(*, set_cuda_current_device: bool = True, overwrite: bool = False, allow_nccl_timeout: bool = False):
+ """Enable distributed mode
+
+ Args:
+ set_cuda_current_device: If True, call torch.cuda.set_device() to set the
+ current PyTorch CUDA device to the one matching the local rank.
+ overwrite: If True, overwrites already set variables. Else fails.
+ """
+
+ global _LOCAL_RANK, _LOCAL_WORLD_SIZE
+ if _LOCAL_RANK >= 0 or _LOCAL_WORLD_SIZE >= 0:
+ raise RuntimeError("Distributed mode has already been enabled")
+ torch_env = _TorchDistributedEnvironment()
+ torch_env.export(overwrite=overwrite)
+
+ if set_cuda_current_device:
+ torch.cuda.set_device(torch_env.local_rank)
+
+ if allow_nccl_timeout:
+ # This allows to use torch distributed timeout in a NCCL backend
+ key, value = "NCCL_ASYNC_ERROR_HANDLING", "1"
+ if not overwrite:
+ _check_env_variable(key, value)
+ os.environ[key] = value
+
+ dist.init_process_group(backend="nccl")
+ dist.barrier()
+
+ # Finalize setup
+ _LOCAL_RANK = torch_env.local_rank
+ _LOCAL_WORLD_SIZE = torch_env.local_world_size
+ _restrict_print_to_main_process()
diff --git a/facebookresearch/dinov2/dinov2/eval/__init__.py b/facebookresearch/dinov2/dinov2/eval/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/models/__init__.py
new file mode 100644
index 0000000..9a58251
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .backbones import * # noqa: F403
+from .builder import BACKBONES, DEPTHER, HEADS, LOSSES, build_backbone, build_depther, build_head, build_loss
+from .decode_heads import * # noqa: F403
+from .depther import * # noqa: F403
+from .losses import * # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/__init__.py
new file mode 100644
index 0000000..520d75b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .vision_transformer import DinoVisionTransformer
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/vision_transformer.py b/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/vision_transformer.py
new file mode 100644
index 0000000..69bda46
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/backbones/vision_transformer.py
@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from mmcv.runner import BaseModule
+
+from ..builder import BACKBONES
+
+
+@BACKBONES.register_module()
+class DinoVisionTransformer(BaseModule):
+ """Vision Transformer."""
+
+ def __init__(self, *args, **kwargs):
+ super().__init__()
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/builder.py b/facebookresearch/dinov2/dinov2/eval/depth/models/builder.py
new file mode 100644
index 0000000..c152643
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/builder.py
@@ -0,0 +1,49 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import warnings
+
+from mmcv.cnn import MODELS as MMCV_MODELS
+from mmcv.cnn.bricks.registry import ATTENTION as MMCV_ATTENTION
+from mmcv.utils import Registry
+
+MODELS = Registry("models", parent=MMCV_MODELS)
+ATTENTION = Registry("attention", parent=MMCV_ATTENTION)
+
+
+BACKBONES = MODELS
+NECKS = MODELS
+HEADS = MODELS
+LOSSES = MODELS
+DEPTHER = MODELS
+
+
+def build_backbone(cfg):
+ """Build backbone."""
+ return BACKBONES.build(cfg)
+
+
+def build_neck(cfg):
+ """Build neck."""
+ return NECKS.build(cfg)
+
+
+def build_head(cfg):
+ """Build head."""
+ return HEADS.build(cfg)
+
+
+def build_loss(cfg):
+ """Build loss."""
+ return LOSSES.build(cfg)
+
+
+def build_depther(cfg, train_cfg=None, test_cfg=None):
+ """Build depther."""
+ if train_cfg is not None or test_cfg is not None:
+ warnings.warn("train_cfg and test_cfg is deprecated, " "please specify them in model", UserWarning)
+ assert cfg.get("train_cfg") is None or train_cfg is None, "train_cfg specified in both outer field and model field "
+ assert cfg.get("test_cfg") is None or test_cfg is None, "test_cfg specified in both outer field and model field "
+ return DEPTHER.build(cfg, default_args=dict(train_cfg=train_cfg, test_cfg=test_cfg))
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/__init__.py
new file mode 100644
index 0000000..bd0f075
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .dpt_head import DPTHead
+from .linear_head import BNHead
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/decode_head.py b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/decode_head.py
new file mode 100644
index 0000000..f8c867a
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/decode_head.py
@@ -0,0 +1,225 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import copy
+from abc import ABCMeta, abstractmethod
+
+import mmcv
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.runner import BaseModule, auto_fp16, force_fp32
+
+from ...ops import resize
+from ..builder import build_loss
+
+
+class DepthBaseDecodeHead(BaseModule, metaclass=ABCMeta):
+ """Base class for BaseDecodeHead.
+
+ Args:
+ in_channels (List): Input channels.
+ channels (int): Channels after modules, before conv_depth.
+ conv_cfg (dict|None): Config of conv layers. Default: None.
+ act_cfg (dict): Config of activation layers.
+ Default: dict(type='ReLU')
+ loss_decode (dict): Config of decode loss.
+ Default: dict(type='SigLoss').
+ sampler (dict|None): The config of depth map sampler.
+ Default: None.
+ align_corners (bool): align_corners argument of F.interpolate.
+ Default: False.
+ min_depth (int): Min depth in dataset setting.
+ Default: 1e-3.
+ max_depth (int): Max depth in dataset setting.
+ Default: None.
+ norm_cfg (dict|None): Config of norm layers.
+ Default: None.
+ classify (bool): Whether predict depth in a cls.-reg. manner.
+ Default: False.
+ n_bins (int): The number of bins used in cls. step.
+ Default: 256.
+ bins_strategy (str): The discrete strategy used in cls. step.
+ Default: 'UD'.
+ norm_strategy (str): The norm strategy on cls. probability
+ distribution. Default: 'linear'
+ scale_up (str): Whether predict depth in a scale-up manner.
+ Default: False.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ channels=96,
+ conv_cfg=None,
+ act_cfg=dict(type="ReLU"),
+ loss_decode=dict(type="SigLoss", valid_mask=True, loss_weight=10),
+ sampler=None,
+ align_corners=False,
+ min_depth=1e-3,
+ max_depth=None,
+ norm_cfg=None,
+ classify=False,
+ n_bins=256,
+ bins_strategy="UD",
+ norm_strategy="linear",
+ scale_up=False,
+ ):
+ super(DepthBaseDecodeHead, self).__init__()
+
+ self.in_channels = in_channels
+ self.channels = channels
+ self.conv_cfg = conv_cfg
+ self.act_cfg = act_cfg
+ if isinstance(loss_decode, dict):
+ self.loss_decode = build_loss(loss_decode)
+ elif isinstance(loss_decode, (list, tuple)):
+ self.loss_decode = nn.ModuleList()
+ for loss in loss_decode:
+ self.loss_decode.append(build_loss(loss))
+ self.align_corners = align_corners
+ self.min_depth = min_depth
+ self.max_depth = max_depth
+ self.norm_cfg = norm_cfg
+ self.classify = classify
+ self.n_bins = n_bins
+ self.scale_up = scale_up
+
+ if self.classify:
+ assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID"
+ assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid"
+
+ self.bins_strategy = bins_strategy
+ self.norm_strategy = norm_strategy
+ self.softmax = nn.Softmax(dim=1)
+ self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1)
+ else:
+ self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1)
+
+ self.fp16_enabled = False
+ self.relu = nn.ReLU()
+ self.sigmoid = nn.Sigmoid()
+
+ def extra_repr(self):
+ """Extra repr."""
+ s = f"align_corners={self.align_corners}"
+ return s
+
+ @auto_fp16()
+ @abstractmethod
+ def forward(self, inputs, img_metas):
+ """Placeholder of forward function."""
+ pass
+
+ def forward_train(self, img, inputs, img_metas, depth_gt, train_cfg):
+ """Forward function for training.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ depth_gt (Tensor): GT depth
+ train_cfg (dict): The training config.
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+ depth_pred = self.forward(inputs, img_metas)
+ losses = self.losses(depth_pred, depth_gt)
+
+ log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0])
+ losses.update(**log_imgs)
+
+ return losses
+
+ def forward_test(self, inputs, img_metas, test_cfg):
+ """Forward function for testing.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ test_cfg (dict): The testing config.
+
+ Returns:
+ Tensor: Output depth map.
+ """
+ return self.forward(inputs, img_metas)
+
+ def depth_pred(self, feat):
+ """Prediction each pixel."""
+ if self.classify:
+ logit = self.conv_depth(feat)
+
+ if self.bins_strategy == "UD":
+ bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device)
+ elif self.bins_strategy == "SID":
+ bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device)
+
+ # following Adabins, default linear
+ if self.norm_strategy == "linear":
+ logit = torch.relu(logit)
+ eps = 0.1
+ logit = logit + eps
+ logit = logit / logit.sum(dim=1, keepdim=True)
+ elif self.norm_strategy == "softmax":
+ logit = torch.softmax(logit, dim=1)
+ elif self.norm_strategy == "sigmoid":
+ logit = torch.sigmoid(logit)
+ logit = logit / logit.sum(dim=1, keepdim=True)
+
+ output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1)
+
+ else:
+ if self.scale_up:
+ output = self.sigmoid(self.conv_depth(feat)) * self.max_depth
+ else:
+ output = self.relu(self.conv_depth(feat)) + self.min_depth
+ return output
+
+ @force_fp32(apply_to=("depth_pred",))
+ def losses(self, depth_pred, depth_gt):
+ """Compute depth loss."""
+ loss = dict()
+ depth_pred = resize(
+ input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False
+ )
+ if not isinstance(self.loss_decode, nn.ModuleList):
+ losses_decode = [self.loss_decode]
+ else:
+ losses_decode = self.loss_decode
+ for loss_decode in losses_decode:
+ if loss_decode.loss_name not in loss:
+ loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt)
+ else:
+ loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt)
+ return loss
+
+ def log_images(self, img_path, depth_pred, depth_gt, img_meta):
+ show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0))
+ show_img = show_img.numpy().astype(np.float32)
+ show_img = mmcv.imdenormalize(
+ show_img,
+ img_meta["img_norm_cfg"]["mean"],
+ img_meta["img_norm_cfg"]["std"],
+ img_meta["img_norm_cfg"]["to_rgb"],
+ )
+ show_img = np.clip(show_img, 0, 255)
+ show_img = show_img.astype(np.uint8)
+ show_img = show_img[:, :, ::-1]
+ show_img = show_img.transpose(0, 2, 1)
+ show_img = show_img.transpose(1, 0, 2)
+
+ depth_pred = depth_pred / torch.max(depth_pred)
+ depth_gt = depth_gt / torch.max(depth_gt)
+
+ depth_pred_color = copy.deepcopy(depth_pred.detach().cpu())
+ depth_gt_color = copy.deepcopy(depth_gt.detach().cpu())
+
+ return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color}
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/dpt_head.py b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/dpt_head.py
new file mode 100644
index 0000000..c6c6d94
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/dpt_head.py
@@ -0,0 +1,270 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+
+import torch
+import torch.nn as nn
+from mmcv.cnn import ConvModule, Linear, build_activation_layer
+from mmcv.runner import BaseModule
+
+from ...ops import resize
+from ..builder import HEADS
+from .decode_head import DepthBaseDecodeHead
+
+
+class Interpolate(nn.Module):
+ def __init__(self, scale_factor, mode, align_corners=False):
+ super(Interpolate, self).__init__()
+ self.interp = nn.functional.interpolate
+ self.scale_factor = scale_factor
+ self.mode = mode
+ self.align_corners = align_corners
+
+ def forward(self, x):
+ x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners)
+ return x
+
+
+class HeadDepth(nn.Module):
+ def __init__(self, features):
+ super(HeadDepth, self).__init__()
+ self.head = nn.Sequential(
+ nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
+ Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
+ nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
+ )
+
+ def forward(self, x):
+ x = self.head(x)
+ return x
+
+
+class ReassembleBlocks(BaseModule):
+ """ViTPostProcessBlock, process cls_token in ViT backbone output and
+ rearrange the feature vector to feature map.
+ Args:
+ in_channels (int): ViT feature channels. Default: 768.
+ out_channels (List): output channels of each stage.
+ Default: [96, 192, 384, 768].
+ readout_type (str): Type of readout operation. Default: 'ignore'.
+ patch_size (int): The patch size. Default: 16.
+ init_cfg (dict, optional): Initialization config dict. Default: None.
+ """
+
+ def __init__(
+ self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16, init_cfg=None
+ ):
+ super(ReassembleBlocks, self).__init__(init_cfg)
+
+ assert readout_type in ["ignore", "add", "project"]
+ self.readout_type = readout_type
+ self.patch_size = patch_size
+
+ self.projects = nn.ModuleList(
+ [
+ ConvModule(
+ in_channels=in_channels,
+ out_channels=out_channel,
+ kernel_size=1,
+ act_cfg=None,
+ )
+ for out_channel in out_channels
+ ]
+ )
+
+ self.resize_layers = nn.ModuleList(
+ [
+ nn.ConvTranspose2d(
+ in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0
+ ),
+ nn.ConvTranspose2d(
+ in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0
+ ),
+ nn.Identity(),
+ nn.Conv2d(
+ in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1
+ ),
+ ]
+ )
+ if self.readout_type == "project":
+ self.readout_projects = nn.ModuleList()
+ for _ in range(len(self.projects)):
+ self.readout_projects.append(
+ nn.Sequential(Linear(2 * in_channels, in_channels), build_activation_layer(dict(type="GELU")))
+ )
+
+ def forward(self, inputs):
+ assert isinstance(inputs, list)
+ out = []
+ for i, x in enumerate(inputs):
+ assert len(x) == 2
+ x, cls_token = x[0], x[1]
+ feature_shape = x.shape
+ if self.readout_type == "project":
+ x = x.flatten(2).permute((0, 2, 1))
+ readout = cls_token.unsqueeze(1).expand_as(x)
+ x = self.readout_projects[i](torch.cat((x, readout), -1))
+ x = x.permute(0, 2, 1).reshape(feature_shape)
+ elif self.readout_type == "add":
+ x = x.flatten(2) + cls_token.unsqueeze(-1)
+ x = x.reshape(feature_shape)
+ else:
+ pass
+ x = self.projects[i](x)
+ x = self.resize_layers[i](x)
+ out.append(x)
+ return out
+
+
+class PreActResidualConvUnit(BaseModule):
+ """ResidualConvUnit, pre-activate residual unit.
+ Args:
+ in_channels (int): number of channels in the input feature map.
+ act_cfg (dict): dictionary to construct and config activation layer.
+ norm_cfg (dict): dictionary to construct and config norm layer.
+ stride (int): stride of the first block. Default: 1
+ dilation (int): dilation rate for convs layers. Default: 1.
+ init_cfg (dict, optional): Initialization config dict. Default: None.
+ """
+
+ def __init__(self, in_channels, act_cfg, norm_cfg, stride=1, dilation=1, init_cfg=None):
+ super(PreActResidualConvUnit, self).__init__(init_cfg)
+
+ self.conv1 = ConvModule(
+ in_channels,
+ in_channels,
+ 3,
+ stride=stride,
+ padding=dilation,
+ dilation=dilation,
+ norm_cfg=norm_cfg,
+ act_cfg=act_cfg,
+ bias=False,
+ order=("act", "conv", "norm"),
+ )
+
+ self.conv2 = ConvModule(
+ in_channels,
+ in_channels,
+ 3,
+ padding=1,
+ norm_cfg=norm_cfg,
+ act_cfg=act_cfg,
+ bias=False,
+ order=("act", "conv", "norm"),
+ )
+
+ def forward(self, inputs):
+ inputs_ = inputs.clone()
+ x = self.conv1(inputs)
+ x = self.conv2(x)
+ return x + inputs_
+
+
+class FeatureFusionBlock(BaseModule):
+ """FeatureFusionBlock, merge feature map from different stages.
+ Args:
+ in_channels (int): Input channels.
+ act_cfg (dict): The activation config for ResidualConvUnit.
+ norm_cfg (dict): Config dict for normalization layer.
+ expand (bool): Whether expand the channels in post process block.
+ Default: False.
+ align_corners (bool): align_corner setting for bilinear upsample.
+ Default: True.
+ init_cfg (dict, optional): Initialization config dict. Default: None.
+ """
+
+ def __init__(self, in_channels, act_cfg, norm_cfg, expand=False, align_corners=True, init_cfg=None):
+ super(FeatureFusionBlock, self).__init__(init_cfg)
+
+ self.in_channels = in_channels
+ self.expand = expand
+ self.align_corners = align_corners
+
+ self.out_channels = in_channels
+ if self.expand:
+ self.out_channels = in_channels // 2
+
+ self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_cfg=None, bias=True)
+
+ self.res_conv_unit1 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg)
+ self.res_conv_unit2 = PreActResidualConvUnit(in_channels=self.in_channels, act_cfg=act_cfg, norm_cfg=norm_cfg)
+
+ def forward(self, *inputs):
+ x = inputs[0]
+ if len(inputs) == 2:
+ if x.shape != inputs[1].shape:
+ res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False)
+ else:
+ res = inputs[1]
+ x = x + self.res_conv_unit1(res)
+ x = self.res_conv_unit2(x)
+ x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners)
+ x = self.project(x)
+ return x
+
+
+@HEADS.register_module()
+class DPTHead(DepthBaseDecodeHead):
+ """Vision Transformers for Dense Prediction.
+ This head is implemented of `DPT `_.
+ Args:
+ embed_dims (int): The embed dimension of the ViT backbone.
+ Default: 768.
+ post_process_channels (List): Out channels of post process conv
+ layers. Default: [96, 192, 384, 768].
+ readout_type (str): Type of readout operation. Default: 'ignore'.
+ patch_size (int): The patch size. Default: 16.
+ expand_channels (bool): Whether expand the channels in post process
+ block. Default: False.
+ """
+
+ def __init__(
+ self,
+ embed_dims=768,
+ post_process_channels=[96, 192, 384, 768],
+ readout_type="ignore",
+ patch_size=16,
+ expand_channels=False,
+ **kwargs
+ ):
+ super(DPTHead, self).__init__(**kwargs)
+
+ self.in_channels = self.in_channels
+ self.expand_channels = expand_channels
+ self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size)
+
+ self.post_process_channels = [
+ channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels)
+ ]
+ self.convs = nn.ModuleList()
+ for channel in self.post_process_channels:
+ self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_cfg=None, bias=False))
+ self.fusion_blocks = nn.ModuleList()
+ for _ in range(len(self.convs)):
+ self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_cfg, self.norm_cfg))
+ self.fusion_blocks[0].res_conv_unit1 = None
+ self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_cfg=self.norm_cfg)
+ self.num_fusion_blocks = len(self.fusion_blocks)
+ self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers)
+ self.num_post_process_channels = len(self.post_process_channels)
+ assert self.num_fusion_blocks == self.num_reassemble_blocks
+ assert self.num_reassemble_blocks == self.num_post_process_channels
+ self.conv_depth = HeadDepth(self.channels)
+
+ def forward(self, inputs, img_metas):
+ assert len(inputs) == self.num_reassemble_blocks
+ x = [inp for inp in inputs]
+ x = self.reassemble_blocks(x)
+ x = [self.convs[i](feature) for i, feature in enumerate(x)]
+ out = self.fusion_blocks[0](x[-1])
+ for i in range(1, len(self.fusion_blocks)):
+ out = self.fusion_blocks[i](out, x[-(i + 1)])
+ out = self.project(out)
+ out = self.depth_pred(out)
+ return out
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/linear_head.py b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/linear_head.py
new file mode 100644
index 0000000..3da1436
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/decode_heads/linear_head.py
@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+
+from ...ops import resize
+from ..builder import HEADS
+from .decode_head import DepthBaseDecodeHead
+
+
+@HEADS.register_module()
+class BNHead(DepthBaseDecodeHead):
+ """Just a batchnorm."""
+
+ def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs):
+ super().__init__(**kwargs)
+ self.input_transform = input_transform
+ self.in_index = in_index
+ self.upsample = upsample
+ # self.bn = nn.SyncBatchNorm(self.in_channels)
+ if self.classify:
+ self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1)
+ else:
+ self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1)
+
+ def _transform_inputs(self, inputs):
+ """Transform inputs for decoder.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ Returns:
+ Tensor: The transformed inputs
+ """
+
+ if "concat" in self.input_transform:
+ inputs = [inputs[i] for i in self.in_index]
+ if "resize" in self.input_transform:
+ inputs = [
+ resize(
+ input=x,
+ size=[s * self.upsample for s in inputs[0].shape[2:]],
+ mode="bilinear",
+ align_corners=self.align_corners,
+ )
+ for x in inputs
+ ]
+ inputs = torch.cat(inputs, dim=1)
+ elif self.input_transform == "multiple_select":
+ inputs = [inputs[i] for i in self.in_index]
+ else:
+ inputs = inputs[self.in_index]
+
+ return inputs
+
+ def _forward_feature(self, inputs, img_metas=None, **kwargs):
+ """Forward function for feature maps before classifying each pixel with
+ ``self.cls_seg`` fc.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ Returns:
+ feats (Tensor): A tensor of shape (batch_size, self.channels,
+ H, W) which is feature map for last layer of decoder head.
+ """
+ # accept lists (for cls token)
+ inputs = list(inputs)
+ for i, x in enumerate(inputs):
+ if len(x) == 2:
+ x, cls_token = x[0], x[1]
+ if len(x.shape) == 2:
+ x = x[:, :, None, None]
+ cls_token = cls_token[:, :, None, None].expand_as(x)
+ inputs[i] = torch.cat((x, cls_token), 1)
+ else:
+ x = x[0]
+ if len(x.shape) == 2:
+ x = x[:, :, None, None]
+ inputs[i] = x
+ x = self._transform_inputs(inputs)
+ # feats = self.bn(x)
+ return x
+
+ def forward(self, inputs, img_metas=None, **kwargs):
+ """Forward function."""
+ output = self._forward_feature(inputs, img_metas=img_metas, **kwargs)
+ output = self.depth_pred(output)
+
+ return output
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/depther/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/__init__.py
new file mode 100644
index 0000000..be99743
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .base import BaseDepther
+from .encoder_decoder import DepthEncoderDecoder
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/depther/base.py b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/base.py
new file mode 100644
index 0000000..e133a82
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/base.py
@@ -0,0 +1,194 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from abc import ABCMeta, abstractmethod
+from collections import OrderedDict
+
+import torch
+import torch.distributed as dist
+from mmcv.runner import BaseModule, auto_fp16
+
+
+class BaseDepther(BaseModule, metaclass=ABCMeta):
+ """Base class for depther."""
+
+ def __init__(self, init_cfg=None):
+ super(BaseDepther, self).__init__(init_cfg)
+ self.fp16_enabled = False
+
+ @property
+ def with_neck(self):
+ """bool: whether the depther has neck"""
+ return hasattr(self, "neck") and self.neck is not None
+
+ @property
+ def with_auxiliary_head(self):
+ """bool: whether the depther has auxiliary head"""
+ return hasattr(self, "auxiliary_head") and self.auxiliary_head is not None
+
+ @property
+ def with_decode_head(self):
+ """bool: whether the depther has decode head"""
+ return hasattr(self, "decode_head") and self.decode_head is not None
+
+ @abstractmethod
+ def extract_feat(self, imgs):
+ """Placeholder for extract features from images."""
+ pass
+
+ @abstractmethod
+ def encode_decode(self, img, img_metas):
+ """Placeholder for encode images with backbone and decode into a
+ semantic depth map of the same size as input."""
+ pass
+
+ @abstractmethod
+ def forward_train(self, imgs, img_metas, **kwargs):
+ """Placeholder for Forward function for training."""
+ pass
+
+ @abstractmethod
+ def simple_test(self, img, img_meta, **kwargs):
+ """Placeholder for single image test."""
+ pass
+
+ @abstractmethod
+ def aug_test(self, imgs, img_metas, **kwargs):
+ """Placeholder for augmentation test."""
+ pass
+
+ def forward_test(self, imgs, img_metas, **kwargs):
+ """
+ Args:
+ imgs (List[Tensor]): the outer list indicates test-time
+ augmentations and inner Tensor should have a shape NxCxHxW,
+ which contains all images in the batch.
+ img_metas (List[List[dict]]): the outer list indicates test-time
+ augs (multiscale, flip, etc.) and the inner list indicates
+ images in a batch.
+ """
+ for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]:
+ if not isinstance(var, list):
+ raise TypeError(f"{name} must be a list, but got " f"{type(var)}")
+ num_augs = len(imgs)
+ if num_augs != len(img_metas):
+ raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})")
+ # all images in the same aug batch all of the same ori_shape and pad
+ # shape
+ for img_meta in img_metas:
+ ori_shapes = [_["ori_shape"] for _ in img_meta]
+ assert all(shape == ori_shapes[0] for shape in ori_shapes)
+ img_shapes = [_["img_shape"] for _ in img_meta]
+ assert all(shape == img_shapes[0] for shape in img_shapes)
+ pad_shapes = [_["pad_shape"] for _ in img_meta]
+ assert all(shape == pad_shapes[0] for shape in pad_shapes)
+
+ if num_augs == 1:
+ return self.simple_test(imgs[0], img_metas[0], **kwargs)
+ else:
+ return self.aug_test(imgs, img_metas, **kwargs)
+
+ @auto_fp16(apply_to=("img",))
+ def forward(self, img, img_metas, return_loss=True, **kwargs):
+ """Calls either :func:`forward_train` or :func:`forward_test` depending
+ on whether ``return_loss`` is ``True``.
+
+ Note this setting will change the expected inputs. When
+ ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor
+ and List[dict]), and when ``resturn_loss=False``, img and img_meta
+ should be double nested (i.e. List[Tensor], List[List[dict]]), with
+ the outer list indicating test time augmentations.
+ """
+ if return_loss:
+ return self.forward_train(img, img_metas, **kwargs)
+ else:
+ return self.forward_test(img, img_metas, **kwargs)
+
+ def train_step(self, data_batch, optimizer, **kwargs):
+ """The iteration step during training.
+
+ This method defines an iteration step during training, except for the
+ back propagation and optimizer updating, which are done in an optimizer
+ hook. Note that in some complicated cases or models, the whole process
+ including back propagation and optimizer updating is also defined in
+ this method, such as GAN.
+
+ Args:
+ data (dict): The output of dataloader.
+ optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of
+ runner is passed to ``train_step()``. This argument is unused
+ and reserved.
+
+ Returns:
+ dict: It should contain at least 3 keys: ``loss``, ``log_vars``,
+ ``num_samples``.
+ ``loss`` is a tensor for back propagation, which can be a
+ weighted sum of multiple losses.
+ ``log_vars`` contains all the variables to be sent to the
+ logger.
+ ``num_samples`` indicates the batch size (when the model is
+ DDP, it means the batch size on each GPU), which is used for
+ averaging the logs.
+ """
+ losses = self(**data_batch)
+
+ # split losses and images
+ real_losses = {}
+ log_imgs = {}
+ for k, v in losses.items():
+ if "img" in k:
+ log_imgs[k] = v
+ else:
+ real_losses[k] = v
+
+ loss, log_vars = self._parse_losses(real_losses)
+
+ outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs)
+
+ return outputs
+
+ def val_step(self, data_batch, **kwargs):
+ """The iteration step during validation.
+
+ This method shares the same signature as :func:`train_step`, but used
+ during val epochs. Note that the evaluation after training epochs is
+ not implemented with this method, but an evaluation hook.
+ """
+ output = self(**data_batch, **kwargs)
+ return output
+
+ @staticmethod
+ def _parse_losses(losses):
+ """Parse the raw outputs (losses) of the network.
+
+ Args:
+ losses (dict): Raw output of the network, which usually contain
+ losses and other necessary information.
+
+ Returns:
+ tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor
+ which may be a weighted sum of all losses, log_vars contains
+ all the variables to be sent to the logger.
+ """
+ log_vars = OrderedDict()
+ for loss_name, loss_value in losses.items():
+ if isinstance(loss_value, torch.Tensor):
+ log_vars[loss_name] = loss_value.mean()
+ elif isinstance(loss_value, list):
+ log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value)
+ else:
+ raise TypeError(f"{loss_name} is not a tensor or list of tensors")
+
+ loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key)
+
+ log_vars["loss"] = loss
+ for loss_name, loss_value in log_vars.items():
+ # reduce loss when distributed training
+ if dist.is_available() and dist.is_initialized():
+ loss_value = loss_value.data.clone()
+ dist.all_reduce(loss_value.div_(dist.get_world_size()))
+ log_vars[loss_name] = loss_value.item()
+
+ return loss, log_vars
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/depther/encoder_decoder.py b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/encoder_decoder.py
new file mode 100644
index 0000000..6b0ec2d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/depther/encoder_decoder.py
@@ -0,0 +1,236 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn.functional as F
+
+from ...models import builder
+from ...models.builder import DEPTHER
+from ...ops import resize
+from .base import BaseDepther
+
+
+def add_prefix(inputs, prefix):
+ """Add prefix for dict.
+
+ Args:
+ inputs (dict): The input dict with str keys.
+ prefix (str): The prefix to add.
+
+ Returns:
+
+ dict: The dict with keys updated with ``prefix``.
+ """
+
+ outputs = dict()
+ for name, value in inputs.items():
+ outputs[f"{prefix}.{name}"] = value
+
+ return outputs
+
+
+@DEPTHER.register_module()
+class DepthEncoderDecoder(BaseDepther):
+ """Encoder Decoder depther.
+
+ EncoderDecoder typically consists of backbone, (neck) and decode_head.
+ """
+
+ def __init__(self, backbone, decode_head, neck=None, train_cfg=None, test_cfg=None, pretrained=None, init_cfg=None):
+ super(DepthEncoderDecoder, self).__init__(init_cfg)
+ if pretrained is not None:
+ assert backbone.get("pretrained") is None, "both backbone and depther set pretrained weight"
+ backbone.pretrained = pretrained
+ self.backbone = builder.build_backbone(backbone)
+ self._init_decode_head(decode_head)
+
+ if neck is not None:
+ self.neck = builder.build_neck(neck)
+
+ self.train_cfg = train_cfg
+ self.test_cfg = test_cfg
+
+ assert self.with_decode_head
+
+ def _init_decode_head(self, decode_head):
+ """Initialize ``decode_head``"""
+ self.decode_head = builder.build_head(decode_head)
+ self.align_corners = self.decode_head.align_corners
+
+ def extract_feat(self, img):
+ """Extract features from images."""
+ x = self.backbone(img)
+ if self.with_neck:
+ x = self.neck(x)
+ return x
+
+ def encode_decode(self, img, img_metas, rescale=True, size=None):
+ """Encode images with backbone and decode into a depth estimation
+ map of the same size as input."""
+ x = self.extract_feat(img)
+ out = self._decode_head_forward_test(x, img_metas)
+ # crop the pred depth to the certain range.
+ out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth)
+ if rescale:
+ if size is None:
+ if img_metas is not None:
+ size = img_metas[0]["ori_shape"][:2]
+ else:
+ size = img.shape[2:]
+ out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners)
+ return out
+
+ def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs):
+ """Run forward function and calculate loss for decode head in
+ training."""
+ losses = dict()
+ loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, self.train_cfg, **kwargs)
+ losses.update(add_prefix(loss_decode, "decode"))
+ return losses
+
+ def _decode_head_forward_test(self, x, img_metas):
+ """Run forward function and calculate loss for decode head in
+ inference."""
+ depth_pred = self.decode_head.forward_test(x, img_metas, self.test_cfg)
+ return depth_pred
+
+ def forward_dummy(self, img):
+ """Dummy forward function."""
+ depth = self.encode_decode(img, None)
+
+ return depth
+
+ def forward_train(self, img, img_metas, depth_gt, **kwargs):
+ """Forward function for training.
+
+ Args:
+ img (Tensor): Input images.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ depth_gt (Tensor): Depth gt
+ used if the architecture supports depth estimation task.
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+
+ x = self.extract_feat(img)
+
+ losses = dict()
+
+ # the last of x saves the info from neck
+ loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs)
+
+ losses.update(loss_decode)
+
+ return losses
+
+ def whole_inference(self, img, img_meta, rescale, size=None):
+ """Inference with full image."""
+ depth_pred = self.encode_decode(img, img_meta, rescale, size=size)
+
+ return depth_pred
+
+ def slide_inference(self, img, img_meta, rescale):
+ """Inference by sliding-window with overlap.
+
+ If h_crop > h_img or w_crop > w_img, the small patch will be used to
+ decode without padding.
+ """
+
+ h_stride, w_stride = self.test_cfg.stride
+ h_crop, w_crop = self.test_cfg.crop_size
+ batch_size, _, h_img, w_img = img.size()
+ h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+ w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+ preds = img.new_zeros((batch_size, 1, h_img, w_img))
+ count_mat = img.new_zeros((batch_size, 1, h_img, w_img))
+ for h_idx in range(h_grids):
+ for w_idx in range(w_grids):
+ y1 = h_idx * h_stride
+ x1 = w_idx * w_stride
+ y2 = min(y1 + h_crop, h_img)
+ x2 = min(x1 + w_crop, w_img)
+ y1 = max(y2 - h_crop, 0)
+ x1 = max(x2 - w_crop, 0)
+ crop_img = img[:, :, y1:y2, x1:x2]
+ depth_pred = self.encode_decode(crop_img, img_meta, rescale)
+ preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2)))
+
+ count_mat[:, :, y1:y2, x1:x2] += 1
+ assert (count_mat == 0).sum() == 0
+ if torch.onnx.is_in_onnx_export():
+ # cast count_mat to constant while exporting to ONNX
+ count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device)
+ preds = preds / count_mat
+ return preds
+
+ def inference(self, img, img_meta, rescale, size=None):
+ """Inference with slide/whole style.
+
+ Args:
+ img (Tensor): The input image of shape (N, 3, H, W).
+ img_meta (dict): Image info dict where each dict has: 'img_shape',
+ 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ rescale (bool): Whether rescale back to original shape.
+
+ Returns:
+ Tensor: The output depth map.
+ """
+
+ assert self.test_cfg.mode in ["slide", "whole"]
+ ori_shape = img_meta[0]["ori_shape"]
+ assert all(_["ori_shape"] == ori_shape for _ in img_meta)
+ if self.test_cfg.mode == "slide":
+ depth_pred = self.slide_inference(img, img_meta, rescale)
+ else:
+ depth_pred = self.whole_inference(img, img_meta, rescale, size=size)
+ output = depth_pred
+ flip = img_meta[0]["flip"]
+ if flip:
+ flip_direction = img_meta[0]["flip_direction"]
+ assert flip_direction in ["horizontal", "vertical"]
+ if flip_direction == "horizontal":
+ output = output.flip(dims=(3,))
+ elif flip_direction == "vertical":
+ output = output.flip(dims=(2,))
+
+ return output
+
+ def simple_test(self, img, img_meta, rescale=True):
+ """Simple test with single image."""
+ depth_pred = self.inference(img, img_meta, rescale)
+ if torch.onnx.is_in_onnx_export():
+ # our inference backend only support 4D output
+ depth_pred = depth_pred.unsqueeze(0)
+ return depth_pred
+ depth_pred = depth_pred.cpu().numpy()
+ # unravel batch dim
+ depth_pred = list(depth_pred)
+ return depth_pred
+
+ def aug_test(self, imgs, img_metas, rescale=True):
+ """Test with augmentations.
+
+ Only rescale=True is supported.
+ """
+ # aug_test rescale all imgs back to ori_shape for now
+ assert rescale
+ # to save memory, we get augmented depth logit inplace
+ depth_pred = self.inference(imgs[0], img_metas[0], rescale)
+ for i in range(1, len(imgs)):
+ cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:])
+ depth_pred += cur_depth_pred
+ depth_pred /= len(imgs)
+ depth_pred = depth_pred.cpu().numpy()
+ # unravel batch dim
+ depth_pred = list(depth_pred)
+ return depth_pred
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/losses/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/__init__.py
new file mode 100644
index 0000000..2f86242
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .gradientloss import GradientLoss
+from .sigloss import SigLoss
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/losses/gradientloss.py b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/gradientloss.py
new file mode 100644
index 0000000..1599878
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/gradientloss.py
@@ -0,0 +1,69 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+
+from ...models.builder import LOSSES
+
+
+@LOSSES.register_module()
+class GradientLoss(nn.Module):
+ """GradientLoss.
+
+ Adapted from https://www.cs.cornell.edu/projects/megadepth/
+
+ Args:
+ valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True.
+ loss_weight (float): Weight of the loss. Default: 1.0.
+ max_depth (int): When filtering invalid gt, set a max threshold. Default: None.
+ """
+
+ def __init__(self, valid_mask=True, loss_weight=1.0, max_depth=None, loss_name="loss_grad"):
+ super(GradientLoss, self).__init__()
+ self.valid_mask = valid_mask
+ self.loss_weight = loss_weight
+ self.max_depth = max_depth
+ self.loss_name = loss_name
+
+ self.eps = 0.001 # avoid grad explode
+
+ def gradientloss(self, input, target):
+ input_downscaled = [input] + [input[:: 2 * i, :: 2 * i] for i in range(1, 4)]
+ target_downscaled = [target] + [target[:: 2 * i, :: 2 * i] for i in range(1, 4)]
+
+ gradient_loss = 0
+ for input, target in zip(input_downscaled, target_downscaled):
+ if self.valid_mask:
+ mask = target > 0
+ if self.max_depth is not None:
+ mask = torch.logical_and(target > 0, target <= self.max_depth)
+ N = torch.sum(mask)
+ else:
+ mask = torch.ones_like(target)
+ N = input.numel()
+ input_log = torch.log(input + self.eps)
+ target_log = torch.log(target + self.eps)
+ log_d_diff = input_log - target_log
+
+ log_d_diff = torch.mul(log_d_diff, mask)
+
+ v_gradient = torch.abs(log_d_diff[0:-2, :] - log_d_diff[2:, :])
+ v_mask = torch.mul(mask[0:-2, :], mask[2:, :])
+ v_gradient = torch.mul(v_gradient, v_mask)
+
+ h_gradient = torch.abs(log_d_diff[:, 0:-2] - log_d_diff[:, 2:])
+ h_mask = torch.mul(mask[:, 0:-2], mask[:, 2:])
+ h_gradient = torch.mul(h_gradient, h_mask)
+
+ gradient_loss += (torch.sum(h_gradient) + torch.sum(v_gradient)) / N
+
+ return gradient_loss
+
+ def forward(self, depth_pred, depth_gt):
+ """Forward function."""
+
+ gradient_loss = self.loss_weight * self.gradientloss(depth_pred, depth_gt)
+ return gradient_loss
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/models/losses/sigloss.py b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/sigloss.py
new file mode 100644
index 0000000..e12fad3
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/models/losses/sigloss.py
@@ -0,0 +1,65 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+
+from ...models.builder import LOSSES
+
+
+@LOSSES.register_module()
+class SigLoss(nn.Module):
+ """SigLoss.
+
+ This follows `AdaBins `_.
+
+ Args:
+ valid_mask (bool): Whether filter invalid gt (gt > 0). Default: True.
+ loss_weight (float): Weight of the loss. Default: 1.0.
+ max_depth (int): When filtering invalid gt, set a max threshold. Default: None.
+ warm_up (bool): A simple warm up stage to help convergence. Default: False.
+ warm_iter (int): The number of warm up stage. Default: 100.
+ """
+
+ def __init__(
+ self, valid_mask=True, loss_weight=1.0, max_depth=None, warm_up=False, warm_iter=100, loss_name="sigloss"
+ ):
+ super(SigLoss, self).__init__()
+ self.valid_mask = valid_mask
+ self.loss_weight = loss_weight
+ self.max_depth = max_depth
+ self.loss_name = loss_name
+
+ self.eps = 0.001 # avoid grad explode
+
+ # HACK: a hack implementation for warmup sigloss
+ self.warm_up = warm_up
+ self.warm_iter = warm_iter
+ self.warm_up_counter = 0
+
+ def sigloss(self, input, target):
+ if self.valid_mask:
+ valid_mask = target > 0
+ if self.max_depth is not None:
+ valid_mask = torch.logical_and(target > 0, target <= self.max_depth)
+ input = input[valid_mask]
+ target = target[valid_mask]
+
+ if self.warm_up:
+ if self.warm_up_counter < self.warm_iter:
+ g = torch.log(input + self.eps) - torch.log(target + self.eps)
+ g = 0.15 * torch.pow(torch.mean(g), 2)
+ self.warm_up_counter += 1
+ return torch.sqrt(g)
+
+ g = torch.log(input + self.eps) - torch.log(target + self.eps)
+ Dg = torch.var(g) + 0.15 * torch.pow(torch.mean(g), 2)
+ return torch.sqrt(Dg)
+
+ def forward(self, depth_pred, depth_gt):
+ """Forward function."""
+
+ loss_depth = self.loss_weight * self.sigloss(depth_pred, depth_gt)
+ return loss_depth
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/ops/__init__.py b/facebookresearch/dinov2/dinov2/eval/depth/ops/__init__.py
new file mode 100644
index 0000000..78181c2
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/ops/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .wrappers import resize
diff --git a/facebookresearch/dinov2/dinov2/eval/depth/ops/wrappers.py b/facebookresearch/dinov2/dinov2/eval/depth/ops/wrappers.py
new file mode 100644
index 0000000..15880ee
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/depth/ops/wrappers.py
@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import warnings
+
+import torch.nn.functional as F
+
+
+def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False):
+ if warning:
+ if size is not None and align_corners:
+ input_h, input_w = tuple(int(x) for x in input.shape[2:])
+ output_h, output_w = tuple(int(x) for x in size)
+ if output_h > input_h or output_w > output_h:
+ if (
+ (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1)
+ and (output_h - 1) % (input_h - 1)
+ and (output_w - 1) % (input_w - 1)
+ ):
+ warnings.warn(
+ f"When align_corners={align_corners}, "
+ "the output would more aligned if "
+ f"input size {(input_h, input_w)} is `x+1` and "
+ f"out size {(output_h, output_w)} is `nx+1`"
+ )
+ return F.interpolate(input, size, scale_factor, mode, align_corners)
diff --git a/facebookresearch/dinov2/dinov2/eval/knn.py b/facebookresearch/dinov2/dinov2/eval/knn.py
new file mode 100644
index 0000000..f3a4845
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/knn.py
@@ -0,0 +1,404 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+from functools import partial
+import json
+import logging
+import os
+import sys
+from typing import List, Optional
+
+import torch
+from torch.nn.functional import one_hot, softmax
+
+import dinov2.distributed as distributed
+from dinov2.data import SamplerType, make_data_loader, make_dataset
+from dinov2.data.transforms import make_classification_eval_transform
+from dinov2.eval.metrics import AccuracyAveraging, build_topk_accuracy_metric
+from dinov2.eval.setup import get_args_parser as get_setup_args_parser
+from dinov2.eval.setup import setup_and_build_model
+from dinov2.eval.utils import ModelWithNormalize, evaluate, extract_features
+
+
+logger = logging.getLogger("dinov2")
+
+
+def get_args_parser(
+ description: Optional[str] = None,
+ parents: Optional[List[argparse.ArgumentParser]] = None,
+ add_help: bool = True,
+):
+ parents = parents or []
+ setup_args_parser = get_setup_args_parser(parents=parents, add_help=False)
+ parents = [setup_args_parser]
+ parser = argparse.ArgumentParser(
+ description=description,
+ parents=parents,
+ add_help=add_help,
+ )
+ parser.add_argument(
+ "--train-dataset",
+ dest="train_dataset_str",
+ type=str,
+ help="Training dataset",
+ )
+ parser.add_argument(
+ "--val-dataset",
+ dest="val_dataset_str",
+ type=str,
+ help="Validation dataset",
+ )
+ parser.add_argument(
+ "--nb_knn",
+ nargs="+",
+ type=int,
+ help="Number of NN to use. 20 is usually working the best.",
+ )
+ parser.add_argument(
+ "--temperature",
+ type=float,
+ help="Temperature used in the voting coefficient",
+ )
+ parser.add_argument(
+ "--gather-on-cpu",
+ action="store_true",
+ help="Whether to gather the train features on cpu, slower"
+ "but useful to avoid OOM for large datasets (e.g. ImageNet22k).",
+ )
+ parser.add_argument(
+ "--batch-size",
+ type=int,
+ help="Batch size.",
+ )
+ parser.add_argument(
+ "--n-per-class-list",
+ nargs="+",
+ type=int,
+ help="Number to take per class",
+ )
+ parser.add_argument(
+ "--n-tries",
+ type=int,
+ help="Number of tries",
+ )
+ parser.set_defaults(
+ train_dataset_str="ImageNet:split=TRAIN",
+ val_dataset_str="ImageNet:split=VAL",
+ nb_knn=[10, 20, 100, 200],
+ temperature=0.07,
+ batch_size=256,
+ n_per_class_list=[-1],
+ n_tries=1,
+ )
+ return parser
+
+
+class KnnModule(torch.nn.Module):
+ """
+ Gets knn of test features from all processes on a chunk of the train features
+
+ Each rank gets a chunk of the train features as well as a chunk of the test features.
+ In `compute_neighbors`, for each rank one after the other, its chunk of test features
+ is sent to all devices, partial knns are computed with each chunk of train features
+ then collated back on the original device.
+ """
+
+ def __init__(self, train_features, train_labels, nb_knn, T, device, num_classes=1000):
+ super().__init__()
+
+ self.global_rank = distributed.get_global_rank()
+ self.global_size = distributed.get_global_size()
+
+ self.device = device
+ self.train_features_rank_T = train_features.chunk(self.global_size)[self.global_rank].T.to(self.device)
+ self.candidates = train_labels.chunk(self.global_size)[self.global_rank].view(1, -1).to(self.device)
+
+ self.nb_knn = nb_knn
+ self.max_k = max(self.nb_knn)
+ self.T = T
+ self.num_classes = num_classes
+
+ def _get_knn_sims_and_labels(self, similarity, train_labels):
+ topk_sims, indices = similarity.topk(self.max_k, largest=True, sorted=True)
+ neighbors_labels = torch.gather(train_labels, 1, indices)
+ return topk_sims, neighbors_labels
+
+ def _similarity_for_rank(self, features_rank, source_rank):
+ # Send the features from `source_rank` to all ranks
+ broadcast_shape = torch.tensor(features_rank.shape).to(self.device)
+ torch.distributed.broadcast(broadcast_shape, source_rank)
+
+ broadcasted = features_rank
+ if self.global_rank != source_rank:
+ broadcasted = torch.zeros(*broadcast_shape, dtype=features_rank.dtype, device=self.device)
+ torch.distributed.broadcast(broadcasted, source_rank)
+
+ # Compute the neighbors for `source_rank` among `train_features_rank_T`
+ similarity_rank = torch.mm(broadcasted, self.train_features_rank_T)
+ candidate_labels = self.candidates.expand(len(similarity_rank), -1)
+ return self._get_knn_sims_and_labels(similarity_rank, candidate_labels)
+
+ def _gather_all_knn_for_rank(self, topk_sims, neighbors_labels, target_rank):
+ # Gather all neighbors for `target_rank`
+ topk_sims_rank = retrieved_rank = None
+ if self.global_rank == target_rank:
+ topk_sims_rank = [torch.zeros_like(topk_sims) for _ in range(self.global_size)]
+ retrieved_rank = [torch.zeros_like(neighbors_labels) for _ in range(self.global_size)]
+
+ torch.distributed.gather(topk_sims, topk_sims_rank, dst=target_rank)
+ torch.distributed.gather(neighbors_labels, retrieved_rank, dst=target_rank)
+
+ if self.global_rank == target_rank:
+ # Perform a second top-k on the k * global_size retrieved neighbors
+ topk_sims_rank = torch.cat(topk_sims_rank, dim=1)
+ retrieved_rank = torch.cat(retrieved_rank, dim=1)
+ results = self._get_knn_sims_and_labels(topk_sims_rank, retrieved_rank)
+ return results
+ return None
+
+ def compute_neighbors(self, features_rank):
+ for rank in range(self.global_size):
+ topk_sims, neighbors_labels = self._similarity_for_rank(features_rank, rank)
+ results = self._gather_all_knn_for_rank(topk_sims, neighbors_labels, rank)
+ if results is not None:
+ topk_sims_rank, neighbors_labels_rank = results
+ return topk_sims_rank, neighbors_labels_rank
+
+ def forward(self, features_rank):
+ """
+ Compute the results on all values of `self.nb_knn` neighbors from the full `self.max_k`
+ """
+ assert all(k <= self.max_k for k in self.nb_knn)
+
+ topk_sims, neighbors_labels = self.compute_neighbors(features_rank)
+ batch_size = neighbors_labels.shape[0]
+ topk_sims_transform = softmax(topk_sims / self.T, 1)
+ matmul = torch.mul(
+ one_hot(neighbors_labels, num_classes=self.num_classes),
+ topk_sims_transform.view(batch_size, -1, 1),
+ )
+ probas_for_k = {k: torch.sum(matmul[:, :k, :], 1) for k in self.nb_knn}
+ return probas_for_k
+
+
+class DictKeysModule(torch.nn.Module):
+ def __init__(self, keys):
+ super().__init__()
+ self.keys = keys
+
+ def forward(self, features_dict, targets):
+ for k in self.keys:
+ features_dict = features_dict[k]
+ return {"preds": features_dict, "target": targets}
+
+
+def create_module_dict(*, module, n_per_class_list, n_tries, nb_knn, train_features, train_labels):
+ modules = {}
+ mapping = create_class_indices_mapping(train_labels)
+ for npc in n_per_class_list:
+ if npc < 0: # Only one try needed when using the full data
+ full_module = module(
+ train_features=train_features,
+ train_labels=train_labels,
+ nb_knn=nb_knn,
+ )
+ modules["full"] = ModuleDictWithForward({"1": full_module})
+ continue
+ all_tries = {}
+ for t in range(n_tries):
+ final_indices = filter_train(mapping, npc, seed=t)
+ k_list = list(set(nb_knn + [npc]))
+ k_list = sorted([el for el in k_list if el <= npc])
+ all_tries[str(t)] = module(
+ train_features=train_features[final_indices],
+ train_labels=train_labels[final_indices],
+ nb_knn=k_list,
+ )
+ modules[f"{npc} per class"] = ModuleDictWithForward(all_tries)
+
+ return ModuleDictWithForward(modules)
+
+
+def filter_train(mapping, n_per_class, seed):
+ torch.manual_seed(seed)
+ final_indices = []
+ for k in mapping.keys():
+ index = torch.randperm(len(mapping[k]))[:n_per_class]
+ final_indices.append(mapping[k][index])
+ return torch.cat(final_indices).squeeze()
+
+
+def create_class_indices_mapping(labels):
+ unique_labels, inverse = torch.unique(labels, return_inverse=True)
+ mapping = {unique_labels[i]: (inverse == i).nonzero() for i in range(len(unique_labels))}
+ return mapping
+
+
+class ModuleDictWithForward(torch.nn.ModuleDict):
+ def forward(self, *args, **kwargs):
+ return {k: module(*args, **kwargs) for k, module in self._modules.items()}
+
+
+def eval_knn(
+ model,
+ train_dataset,
+ val_dataset,
+ accuracy_averaging,
+ nb_knn,
+ temperature,
+ batch_size,
+ num_workers,
+ gather_on_cpu,
+ n_per_class_list=[-1],
+ n_tries=1,
+):
+ model = ModelWithNormalize(model)
+
+ logger.info("Extracting features for train set...")
+ train_features, train_labels = extract_features(
+ model, train_dataset, batch_size, num_workers, gather_on_cpu=gather_on_cpu
+ )
+ logger.info(f"Train features created, shape {train_features.shape}.")
+
+ val_dataloader = make_data_loader(
+ dataset=val_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ sampler_type=SamplerType.DISTRIBUTED,
+ drop_last=False,
+ shuffle=False,
+ persistent_workers=True,
+ )
+ num_classes = train_labels.max() + 1
+ metric_collection = build_topk_accuracy_metric(accuracy_averaging, num_classes=num_classes)
+
+ device = torch.cuda.current_device()
+ partial_module = partial(KnnModule, T=temperature, device=device, num_classes=num_classes)
+ knn_module_dict = create_module_dict(
+ module=partial_module,
+ n_per_class_list=n_per_class_list,
+ n_tries=n_tries,
+ nb_knn=nb_knn,
+ train_features=train_features,
+ train_labels=train_labels,
+ )
+ postprocessors, metrics = {}, {}
+ for n_per_class, knn_module in knn_module_dict.items():
+ for t, knn_try in knn_module.items():
+ postprocessors = {
+ **postprocessors,
+ **{(n_per_class, t, k): DictKeysModule([n_per_class, t, k]) for k in knn_try.nb_knn},
+ }
+ metrics = {**metrics, **{(n_per_class, t, k): metric_collection.clone() for k in knn_try.nb_knn}}
+ model_with_knn = torch.nn.Sequential(model, knn_module_dict)
+
+ # ============ evaluation ... ============
+ logger.info("Start the k-NN classification.")
+ _, results_dict = evaluate(model_with_knn, val_dataloader, postprocessors, metrics, device)
+
+ # Averaging the results over the n tries for each value of n_per_class
+ for n_per_class, knn_module in knn_module_dict.items():
+ first_try = list(knn_module.keys())[0]
+ k_list = knn_module[first_try].nb_knn
+ for k in k_list:
+ keys = results_dict[(n_per_class, first_try, k)].keys() # keys are e.g. `top-1` and `top-5`
+ results_dict[(n_per_class, k)] = {
+ key: torch.mean(torch.stack([results_dict[(n_per_class, t, k)][key] for t in knn_module.keys()]))
+ for key in keys
+ }
+ for t in knn_module.keys():
+ del results_dict[(n_per_class, t, k)]
+
+ return results_dict
+
+
+def eval_knn_with_model(
+ model,
+ output_dir,
+ train_dataset_str="ImageNet:split=TRAIN",
+ val_dataset_str="ImageNet:split=VAL",
+ nb_knn=(10, 20, 100, 200),
+ temperature=0.07,
+ autocast_dtype=torch.float,
+ accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY,
+ transform=None,
+ gather_on_cpu=False,
+ batch_size=256,
+ num_workers=5,
+ n_per_class_list=[-1],
+ n_tries=1,
+):
+ transform = transform or make_classification_eval_transform()
+
+ train_dataset = make_dataset(
+ dataset_str=train_dataset_str,
+ transform=transform,
+ )
+ val_dataset = make_dataset(
+ dataset_str=val_dataset_str,
+ transform=transform,
+ )
+
+ with torch.cuda.amp.autocast(dtype=autocast_dtype):
+ results_dict_knn = eval_knn(
+ model=model,
+ train_dataset=train_dataset,
+ val_dataset=val_dataset,
+ accuracy_averaging=accuracy_averaging,
+ nb_knn=nb_knn,
+ temperature=temperature,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ gather_on_cpu=gather_on_cpu,
+ n_per_class_list=n_per_class_list,
+ n_tries=n_tries,
+ )
+
+ results_dict = {}
+ if distributed.is_main_process():
+ for knn_ in results_dict_knn.keys():
+ top1 = results_dict_knn[knn_]["top-1"].item() * 100.0
+ top5 = results_dict_knn[knn_]["top-5"].item() * 100.0
+ results_dict[f"{knn_} Top 1"] = top1
+ results_dict[f"{knn_} Top 5"] = top5
+ logger.info(f"{knn_} classifier result: Top1: {top1:.2f} Top5: {top5:.2f}")
+
+ metrics_file_path = os.path.join(output_dir, "results_eval_knn.json")
+ with open(metrics_file_path, "a") as f:
+ for k, v in results_dict.items():
+ f.write(json.dumps({k: v}) + "\n")
+
+ if distributed.is_enabled():
+ torch.distributed.barrier()
+ return results_dict
+
+
+def main(args):
+ model, autocast_dtype = setup_and_build_model(args)
+ eval_knn_with_model(
+ model=model,
+ output_dir=args.output_dir,
+ train_dataset_str=args.train_dataset_str,
+ val_dataset_str=args.val_dataset_str,
+ nb_knn=args.nb_knn,
+ temperature=args.temperature,
+ autocast_dtype=autocast_dtype,
+ accuracy_averaging=AccuracyAveraging.MEAN_ACCURACY,
+ transform=None,
+ gather_on_cpu=args.gather_on_cpu,
+ batch_size=args.batch_size,
+ num_workers=5,
+ n_per_class_list=args.n_per_class_list,
+ n_tries=args.n_tries,
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ description = "DINOv2 k-NN evaluation"
+ args_parser = get_args_parser(description=description)
+ args = args_parser.parse_args()
+ sys.exit(main(args))
diff --git a/facebookresearch/dinov2/dinov2/eval/linear.py b/facebookresearch/dinov2/dinov2/eval/linear.py
new file mode 100644
index 0000000..1bd4c5d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/linear.py
@@ -0,0 +1,625 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+from functools import partial
+import json
+import logging
+import os
+import sys
+from typing import List, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel
+from fvcore.common.checkpoint import Checkpointer, PeriodicCheckpointer
+
+from dinov2.data import SamplerType, make_data_loader, make_dataset
+from dinov2.data.transforms import make_classification_eval_transform, make_classification_train_transform
+import dinov2.distributed as distributed
+from dinov2.eval.metrics import MetricType, build_metric
+from dinov2.eval.setup import get_args_parser as get_setup_args_parser
+from dinov2.eval.setup import setup_and_build_model
+from dinov2.eval.utils import ModelWithIntermediateLayers, evaluate
+from dinov2.logging import MetricLogger
+
+
+logger = logging.getLogger("dinov2")
+
+
+def get_args_parser(
+ description: Optional[str] = None,
+ parents: Optional[List[argparse.ArgumentParser]] = None,
+ add_help: bool = True,
+):
+ parents = parents or []
+ setup_args_parser = get_setup_args_parser(parents=parents, add_help=False)
+ parents = [setup_args_parser]
+ parser = argparse.ArgumentParser(
+ description=description,
+ parents=parents,
+ add_help=add_help,
+ )
+ parser.add_argument(
+ "--train-dataset",
+ dest="train_dataset_str",
+ type=str,
+ help="Training dataset",
+ )
+ parser.add_argument(
+ "--val-dataset",
+ dest="val_dataset_str",
+ type=str,
+ help="Validation dataset",
+ )
+ parser.add_argument(
+ "--test-datasets",
+ dest="test_dataset_strs",
+ type=str,
+ nargs="+",
+ help="Test datasets, none to reuse the validation dataset",
+ )
+ parser.add_argument(
+ "--epochs",
+ type=int,
+ help="Number of training epochs",
+ )
+ parser.add_argument(
+ "--batch-size",
+ type=int,
+ help="Batch Size (per GPU)",
+ )
+ parser.add_argument(
+ "--num-workers",
+ type=int,
+ help="Number de Workers",
+ )
+ parser.add_argument(
+ "--epoch-length",
+ type=int,
+ help="Length of an epoch in number of iterations",
+ )
+ parser.add_argument(
+ "--save-checkpoint-frequency",
+ type=int,
+ help="Number of epochs between two named checkpoint saves.",
+ )
+ parser.add_argument(
+ "--eval-period-iterations",
+ type=int,
+ help="Number of iterations between two evaluations.",
+ )
+ parser.add_argument(
+ "--learning-rates",
+ nargs="+",
+ type=float,
+ help="Learning rates to grid search.",
+ )
+ parser.add_argument(
+ "--no-resume",
+ action="store_true",
+ help="Whether to not resume from existing checkpoints",
+ )
+ parser.add_argument(
+ "--val-metric-type",
+ type=MetricType,
+ choices=list(MetricType),
+ help="Validation metric",
+ )
+ parser.add_argument(
+ "--test-metric-types",
+ type=MetricType,
+ choices=list(MetricType),
+ nargs="+",
+ help="Evaluation metric",
+ )
+ parser.add_argument(
+ "--classifier-fpath",
+ type=str,
+ help="Path to a file containing pretrained linear classifiers",
+ )
+ parser.add_argument(
+ "--val-class-mapping-fpath",
+ type=str,
+ help="Path to a file containing a mapping to adjust classifier outputs",
+ )
+ parser.add_argument(
+ "--test-class-mapping-fpaths",
+ nargs="+",
+ type=str,
+ help="Path to a file containing a mapping to adjust classifier outputs",
+ )
+ parser.set_defaults(
+ train_dataset_str="ImageNet:split=TRAIN",
+ val_dataset_str="ImageNet:split=VAL",
+ test_dataset_strs=None,
+ epochs=10,
+ batch_size=128,
+ num_workers=8,
+ epoch_length=1250,
+ save_checkpoint_frequency=20,
+ eval_period_iterations=1250,
+ learning_rates=[1e-5, 2e-5, 5e-5, 1e-4, 2e-4, 5e-4, 1e-3, 2e-3, 5e-3, 1e-2, 2e-2, 5e-2, 0.1],
+ val_metric_type=MetricType.MEAN_ACCURACY,
+ test_metric_types=None,
+ classifier_fpath=None,
+ val_class_mapping_fpath=None,
+ test_class_mapping_fpaths=[None],
+ )
+ return parser
+
+
+def has_ddp_wrapper(m: nn.Module) -> bool:
+ return isinstance(m, DistributedDataParallel)
+
+
+def remove_ddp_wrapper(m: nn.Module) -> nn.Module:
+ return m.module if has_ddp_wrapper(m) else m
+
+
+def _pad_and_collate(batch):
+ maxlen = max(len(targets) for image, targets in batch)
+ padded_batch = [
+ (image, np.pad(targets, (0, maxlen - len(targets)), constant_values=-1)) for image, targets in batch
+ ]
+ return torch.utils.data.default_collate(padded_batch)
+
+
+def create_linear_input(x_tokens_list, use_n_blocks, use_avgpool):
+ intermediate_output = x_tokens_list[-use_n_blocks:]
+ output = torch.cat([class_token for _, class_token in intermediate_output], dim=-1)
+ if use_avgpool:
+ output = torch.cat(
+ (
+ output,
+ torch.mean(intermediate_output[-1][0], dim=1), # patch tokens
+ ),
+ dim=-1,
+ )
+ output = output.reshape(output.shape[0], -1)
+ return output.float()
+
+
+class LinearClassifier(nn.Module):
+ """Linear layer to train on top of frozen features"""
+
+ def __init__(self, out_dim, use_n_blocks, use_avgpool, num_classes=1000):
+ super().__init__()
+ self.out_dim = out_dim
+ self.use_n_blocks = use_n_blocks
+ self.use_avgpool = use_avgpool
+ self.num_classes = num_classes
+ self.linear = nn.Linear(out_dim, num_classes)
+ self.linear.weight.data.normal_(mean=0.0, std=0.01)
+ self.linear.bias.data.zero_()
+
+ def forward(self, x_tokens_list):
+ output = create_linear_input(x_tokens_list, self.use_n_blocks, self.use_avgpool)
+ return self.linear(output)
+
+
+class AllClassifiers(nn.Module):
+ def __init__(self, classifiers_dict):
+ super().__init__()
+ self.classifiers_dict = nn.ModuleDict()
+ self.classifiers_dict.update(classifiers_dict)
+
+ def forward(self, inputs):
+ return {k: v.forward(inputs) for k, v in self.classifiers_dict.items()}
+
+ def __len__(self):
+ return len(self.classifiers_dict)
+
+
+class LinearPostprocessor(nn.Module):
+ def __init__(self, linear_classifier, class_mapping=None):
+ super().__init__()
+ self.linear_classifier = linear_classifier
+ self.register_buffer("class_mapping", None if class_mapping is None else torch.LongTensor(class_mapping))
+
+ def forward(self, samples, targets):
+ preds = self.linear_classifier(samples)
+ return {
+ "preds": preds[:, self.class_mapping] if self.class_mapping is not None else preds,
+ "target": targets,
+ }
+
+
+def scale_lr(learning_rates, batch_size):
+ return learning_rates * (batch_size * distributed.get_global_size()) / 256.0
+
+
+def setup_linear_classifiers(sample_output, n_last_blocks_list, learning_rates, batch_size, num_classes=1000):
+ linear_classifiers_dict = nn.ModuleDict()
+ optim_param_groups = []
+ for n in n_last_blocks_list:
+ for avgpool in [False, True]:
+ for _lr in learning_rates:
+ lr = scale_lr(_lr, batch_size)
+ out_dim = create_linear_input(sample_output, use_n_blocks=n, use_avgpool=avgpool).shape[1]
+ linear_classifier = LinearClassifier(
+ out_dim, use_n_blocks=n, use_avgpool=avgpool, num_classes=num_classes
+ )
+ linear_classifier = linear_classifier.cuda()
+ linear_classifiers_dict[
+ f"classifier_{n}_blocks_avgpool_{avgpool}_lr_{lr:.5f}".replace(".", "_")
+ ] = linear_classifier
+ optim_param_groups.append({"params": linear_classifier.parameters(), "lr": lr})
+
+ linear_classifiers = AllClassifiers(linear_classifiers_dict)
+ if distributed.is_enabled():
+ linear_classifiers = nn.parallel.DistributedDataParallel(linear_classifiers)
+
+ return linear_classifiers, optim_param_groups
+
+
+@torch.no_grad()
+def evaluate_linear_classifiers(
+ feature_model,
+ linear_classifiers,
+ data_loader,
+ metric_type,
+ metrics_file_path,
+ training_num_classes,
+ iteration,
+ prefixstring="",
+ class_mapping=None,
+ best_classifier_on_val=None,
+):
+ logger.info("running validation !")
+
+ num_classes = len(class_mapping) if class_mapping is not None else training_num_classes
+ metric = build_metric(metric_type, num_classes=num_classes)
+ postprocessors = {k: LinearPostprocessor(v, class_mapping) for k, v in linear_classifiers.classifiers_dict.items()}
+ metrics = {k: metric.clone() for k in linear_classifiers.classifiers_dict}
+
+ _, results_dict_temp = evaluate(
+ feature_model,
+ data_loader,
+ postprocessors,
+ metrics,
+ torch.cuda.current_device(),
+ )
+
+ logger.info("")
+ results_dict = {}
+ max_accuracy = 0
+ best_classifier = ""
+ for i, (classifier_string, metric) in enumerate(results_dict_temp.items()):
+ logger.info(f"{prefixstring} -- Classifier: {classifier_string} * {metric}")
+ if (
+ best_classifier_on_val is None and metric["top-1"].item() > max_accuracy
+ ) or classifier_string == best_classifier_on_val:
+ max_accuracy = metric["top-1"].item()
+ best_classifier = classifier_string
+
+ results_dict["best_classifier"] = {"name": best_classifier, "accuracy": max_accuracy}
+
+ logger.info(f"best classifier: {results_dict['best_classifier']}")
+
+ if distributed.is_main_process():
+ with open(metrics_file_path, "a") as f:
+ f.write(f"iter: {iteration}\n")
+ for k, v in results_dict.items():
+ f.write(json.dumps({k: v}) + "\n")
+ f.write("\n")
+
+ return results_dict
+
+
+def eval_linear(
+ *,
+ feature_model,
+ linear_classifiers,
+ train_data_loader,
+ val_data_loader,
+ metrics_file_path,
+ optimizer,
+ scheduler,
+ output_dir,
+ max_iter,
+ checkpoint_period, # In number of iter, creates a new file every period
+ running_checkpoint_period, # Period to update main checkpoint file
+ eval_period,
+ metric_type,
+ training_num_classes,
+ resume=True,
+ classifier_fpath=None,
+ val_class_mapping=None,
+):
+ checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler)
+ start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1
+
+ periodic_checkpointer = PeriodicCheckpointer(checkpointer, checkpoint_period, max_iter=max_iter)
+ iteration = start_iter
+ logger.info("Starting training from iteration {}".format(start_iter))
+ metric_logger = MetricLogger(delimiter=" ")
+ header = "Training"
+
+ for data, labels in metric_logger.log_every(
+ train_data_loader,
+ 10,
+ header,
+ max_iter,
+ start_iter,
+ ):
+ data = data.cuda(non_blocking=True)
+ labels = labels.cuda(non_blocking=True)
+
+ features = feature_model(data)
+ outputs = linear_classifiers(features)
+
+ losses = {f"loss_{k}": nn.CrossEntropyLoss()(v, labels) for k, v in outputs.items()}
+ loss = sum(losses.values())
+
+ # compute the gradients
+ optimizer.zero_grad()
+ loss.backward()
+
+ # step
+ optimizer.step()
+ scheduler.step()
+
+ # log
+ if iteration % 10 == 0:
+ torch.cuda.synchronize()
+ metric_logger.update(loss=loss.item())
+ metric_logger.update(lr=optimizer.param_groups[0]["lr"])
+ print("lr", optimizer.param_groups[0]["lr"])
+
+ if iteration - start_iter > 5:
+ if iteration % running_checkpoint_period == 0:
+ torch.cuda.synchronize()
+ if distributed.is_main_process():
+ logger.info("Checkpointing running_checkpoint")
+ periodic_checkpointer.save("running_checkpoint_linear_eval", iteration=iteration)
+ torch.cuda.synchronize()
+ periodic_checkpointer.step(iteration)
+
+ if eval_period > 0 and (iteration + 1) % eval_period == 0 and iteration != max_iter - 1:
+ _ = evaluate_linear_classifiers(
+ feature_model=feature_model,
+ linear_classifiers=remove_ddp_wrapper(linear_classifiers),
+ data_loader=val_data_loader,
+ metrics_file_path=metrics_file_path,
+ prefixstring=f"ITER: {iteration}",
+ metric_type=metric_type,
+ training_num_classes=training_num_classes,
+ iteration=iteration,
+ class_mapping=val_class_mapping,
+ )
+ torch.cuda.synchronize()
+
+ iteration = iteration + 1
+
+ val_results_dict = evaluate_linear_classifiers(
+ feature_model=feature_model,
+ linear_classifiers=remove_ddp_wrapper(linear_classifiers),
+ data_loader=val_data_loader,
+ metrics_file_path=metrics_file_path,
+ metric_type=metric_type,
+ training_num_classes=training_num_classes,
+ iteration=iteration,
+ class_mapping=val_class_mapping,
+ )
+ return val_results_dict, feature_model, linear_classifiers, iteration
+
+
+def make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type):
+ test_dataset = make_dataset(
+ dataset_str=test_dataset_str,
+ transform=make_classification_eval_transform(),
+ )
+ test_data_loader = make_data_loader(
+ dataset=test_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ sampler_type=SamplerType.DISTRIBUTED,
+ drop_last=False,
+ shuffle=False,
+ persistent_workers=False,
+ collate_fn=_pad_and_collate if metric_type == MetricType.IMAGENET_REAL_ACCURACY else None,
+ )
+ return test_data_loader
+
+
+def test_on_datasets(
+ feature_model,
+ linear_classifiers,
+ test_dataset_strs,
+ batch_size,
+ num_workers,
+ test_metric_types,
+ metrics_file_path,
+ training_num_classes,
+ iteration,
+ best_classifier_on_val,
+ prefixstring="",
+ test_class_mappings=[None],
+):
+ results_dict = {}
+ for test_dataset_str, class_mapping, metric_type in zip(test_dataset_strs, test_class_mappings, test_metric_types):
+ logger.info(f"Testing on {test_dataset_str}")
+ test_data_loader = make_eval_data_loader(test_dataset_str, batch_size, num_workers, metric_type)
+ dataset_results_dict = evaluate_linear_classifiers(
+ feature_model,
+ remove_ddp_wrapper(linear_classifiers),
+ test_data_loader,
+ metric_type,
+ metrics_file_path,
+ training_num_classes,
+ iteration,
+ prefixstring="",
+ class_mapping=class_mapping,
+ best_classifier_on_val=best_classifier_on_val,
+ )
+ results_dict[f"{test_dataset_str}_accuracy"] = 100.0 * dataset_results_dict["best_classifier"]["accuracy"]
+ return results_dict
+
+
+def run_eval_linear(
+ model,
+ output_dir,
+ train_dataset_str,
+ val_dataset_str,
+ batch_size,
+ epochs,
+ epoch_length,
+ num_workers,
+ save_checkpoint_frequency,
+ eval_period_iterations,
+ learning_rates,
+ autocast_dtype,
+ test_dataset_strs=None,
+ resume=True,
+ classifier_fpath=None,
+ val_class_mapping_fpath=None,
+ test_class_mapping_fpaths=[None],
+ val_metric_type=MetricType.MEAN_ACCURACY,
+ test_metric_types=None,
+):
+ seed = 0
+
+ if test_dataset_strs is None:
+ test_dataset_strs = [val_dataset_str]
+ if test_metric_types is None:
+ test_metric_types = [val_metric_type] * len(test_dataset_strs)
+ else:
+ assert len(test_metric_types) == len(test_dataset_strs)
+ assert len(test_dataset_strs) == len(test_class_mapping_fpaths)
+
+ train_transform = make_classification_train_transform()
+ train_dataset = make_dataset(
+ dataset_str=train_dataset_str,
+ transform=train_transform,
+ )
+ training_num_classes = len(torch.unique(torch.Tensor(train_dataset.get_targets().astype(int))))
+ sampler_type = SamplerType.SHARDED_INFINITE
+ # sampler_type = SamplerType.INFINITE
+
+ n_last_blocks_list = [1, 4]
+ n_last_blocks = max(n_last_blocks_list)
+ autocast_ctx = partial(torch.cuda.amp.autocast, enabled=True, dtype=autocast_dtype)
+ feature_model = ModelWithIntermediateLayers(model, n_last_blocks, autocast_ctx)
+ sample_output = feature_model(train_dataset[0][0].unsqueeze(0).cuda())
+
+ linear_classifiers, optim_param_groups = setup_linear_classifiers(
+ sample_output,
+ n_last_blocks_list,
+ learning_rates,
+ batch_size,
+ training_num_classes,
+ )
+
+ optimizer = torch.optim.SGD(optim_param_groups, momentum=0.9, weight_decay=0)
+ max_iter = epochs * epoch_length
+ scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, max_iter, eta_min=0)
+ checkpointer = Checkpointer(linear_classifiers, output_dir, optimizer=optimizer, scheduler=scheduler)
+ start_iter = checkpointer.resume_or_load(classifier_fpath or "", resume=resume).get("iteration", -1) + 1
+ train_data_loader = make_data_loader(
+ dataset=train_dataset,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ shuffle=True,
+ seed=seed,
+ sampler_type=sampler_type,
+ sampler_advance=start_iter,
+ drop_last=True,
+ persistent_workers=True,
+ )
+ val_data_loader = make_eval_data_loader(val_dataset_str, batch_size, num_workers, val_metric_type)
+
+ checkpoint_period = save_checkpoint_frequency * epoch_length
+
+ if val_class_mapping_fpath is not None:
+ logger.info(f"Using class mapping from {val_class_mapping_fpath}")
+ val_class_mapping = np.load(val_class_mapping_fpath)
+ else:
+ val_class_mapping = None
+
+ test_class_mappings = []
+ for class_mapping_fpath in test_class_mapping_fpaths:
+ if class_mapping_fpath is not None and class_mapping_fpath != "None":
+ logger.info(f"Using class mapping from {class_mapping_fpath}")
+ class_mapping = np.load(class_mapping_fpath)
+ else:
+ class_mapping = None
+ test_class_mappings.append(class_mapping)
+
+ metrics_file_path = os.path.join(output_dir, "results_eval_linear.json")
+ val_results_dict, feature_model, linear_classifiers, iteration = eval_linear(
+ feature_model=feature_model,
+ linear_classifiers=linear_classifiers,
+ train_data_loader=train_data_loader,
+ val_data_loader=val_data_loader,
+ metrics_file_path=metrics_file_path,
+ optimizer=optimizer,
+ scheduler=scheduler,
+ output_dir=output_dir,
+ max_iter=max_iter,
+ checkpoint_period=checkpoint_period,
+ running_checkpoint_period=epoch_length,
+ eval_period=eval_period_iterations,
+ metric_type=val_metric_type,
+ training_num_classes=training_num_classes,
+ resume=resume,
+ val_class_mapping=val_class_mapping,
+ classifier_fpath=classifier_fpath,
+ )
+ results_dict = {}
+ if len(test_dataset_strs) > 1 or test_dataset_strs[0] != val_dataset_str:
+ results_dict = test_on_datasets(
+ feature_model,
+ linear_classifiers,
+ test_dataset_strs,
+ batch_size,
+ 0, # num_workers,
+ test_metric_types,
+ metrics_file_path,
+ training_num_classes,
+ iteration,
+ val_results_dict["best_classifier"]["name"],
+ prefixstring="",
+ test_class_mappings=test_class_mappings,
+ )
+ results_dict["best_classifier"] = val_results_dict["best_classifier"]["name"]
+ results_dict[f"{val_dataset_str}_accuracy"] = 100.0 * val_results_dict["best_classifier"]["accuracy"]
+ logger.info("Test Results Dict " + str(results_dict))
+
+ return results_dict
+
+
+def main(args):
+ model, autocast_dtype = setup_and_build_model(args)
+ run_eval_linear(
+ model=model,
+ output_dir=args.output_dir,
+ train_dataset_str=args.train_dataset_str,
+ val_dataset_str=args.val_dataset_str,
+ test_dataset_strs=args.test_dataset_strs,
+ batch_size=args.batch_size,
+ epochs=args.epochs,
+ epoch_length=args.epoch_length,
+ num_workers=args.num_workers,
+ save_checkpoint_frequency=args.save_checkpoint_frequency,
+ eval_period_iterations=args.eval_period_iterations,
+ learning_rates=args.learning_rates,
+ autocast_dtype=autocast_dtype,
+ resume=not args.no_resume,
+ classifier_fpath=args.classifier_fpath,
+ val_metric_type=args.val_metric_type,
+ test_metric_types=args.test_metric_types,
+ val_class_mapping_fpath=args.val_class_mapping_fpath,
+ test_class_mapping_fpaths=args.test_class_mapping_fpaths,
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ description = "DINOv2 linear evaluation"
+ args_parser = get_args_parser(description=description)
+ args = args_parser.parse_args()
+ sys.exit(main(args))
diff --git a/facebookresearch/dinov2/dinov2/eval/log_regression.py b/facebookresearch/dinov2/dinov2/eval/log_regression.py
new file mode 100644
index 0000000..5f36ec1
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/log_regression.py
@@ -0,0 +1,444 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+import gc
+import logging
+import sys
+import time
+from typing import List, Optional
+
+from cuml.linear_model import LogisticRegression
+import torch
+import torch.backends.cudnn as cudnn
+import torch.distributed
+from torch import nn
+from torch.utils.data import TensorDataset
+from torchmetrics import MetricTracker
+
+from dinov2.data import make_dataset
+from dinov2.data.transforms import make_classification_eval_transform
+from dinov2.distributed import get_global_rank, get_global_size
+from dinov2.eval.metrics import MetricType, build_metric
+from dinov2.eval.setup import get_args_parser as get_setup_args_parser
+from dinov2.eval.setup import setup_and_build_model
+from dinov2.eval.utils import evaluate, extract_features
+from dinov2.utils.dtype import as_torch_dtype
+
+
+logger = logging.getLogger("dinov2")
+
+DEFAULT_MAX_ITER = 1_000
+C_POWER_RANGE = torch.linspace(-6, 5, 45)
+_CPU_DEVICE = torch.device("cpu")
+
+
+def get_args_parser(
+ description: Optional[str] = None,
+ parents: Optional[List[argparse.ArgumentParser]] = None,
+ add_help: bool = True,
+):
+ parents = parents or []
+ setup_args_parser = get_setup_args_parser(parents=parents, add_help=False)
+ parents = [setup_args_parser]
+ parser = argparse.ArgumentParser(
+ description=description,
+ parents=parents,
+ add_help=add_help,
+ )
+ parser.add_argument(
+ "--train-dataset",
+ dest="train_dataset_str",
+ type=str,
+ help="Training dataset",
+ )
+ parser.add_argument(
+ "--val-dataset",
+ dest="val_dataset_str",
+ type=str,
+ help="Validation dataset",
+ )
+ parser.add_argument(
+ "--finetune-dataset-str",
+ dest="finetune_dataset_str",
+ type=str,
+ help="Fine-tuning dataset",
+ )
+ parser.add_argument(
+ "--finetune-on-val",
+ action="store_true",
+ help="If there is no finetune dataset, whether to choose the "
+ "hyperparameters on the val set instead of 10%% of the train dataset",
+ )
+ parser.add_argument(
+ "--metric-type",
+ type=MetricType,
+ choices=list(MetricType),
+ help="Metric type",
+ )
+ parser.add_argument(
+ "--train-features-device",
+ type=str,
+ help="Device to gather train features (cpu, cuda, cuda:0, etc.), default: %(default)s",
+ )
+ parser.add_argument(
+ "--train-dtype",
+ type=str,
+ help="Data type to convert the train features to (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--max-train-iters",
+ type=int,
+ help="Maximum number of train iterations (default: %(default)s)",
+ )
+ parser.set_defaults(
+ train_dataset_str="ImageNet:split=TRAIN",
+ val_dataset_str="ImageNet:split=VAL",
+ finetune_dataset_str=None,
+ metric_type=MetricType.MEAN_ACCURACY,
+ train_features_device="cpu",
+ train_dtype="float64",
+ max_train_iters=DEFAULT_MAX_ITER,
+ finetune_on_val=False,
+ )
+ return parser
+
+
+class LogRegModule(nn.Module):
+ def __init__(
+ self,
+ C,
+ max_iter=DEFAULT_MAX_ITER,
+ dtype=torch.float64,
+ device=_CPU_DEVICE,
+ ):
+ super().__init__()
+ self.dtype = dtype
+ self.device = device
+ self.estimator = LogisticRegression(
+ penalty="l2",
+ C=C,
+ max_iter=max_iter,
+ output_type="numpy",
+ tol=1e-12,
+ linesearch_max_iter=50,
+ )
+
+ def forward(self, samples, targets):
+ samples_device = samples.device
+ samples = samples.to(dtype=self.dtype, device=self.device)
+ if self.device == _CPU_DEVICE:
+ samples = samples.numpy()
+ probas = self.estimator.predict_proba(samples)
+ return {"preds": torch.from_numpy(probas).to(samples_device), "target": targets}
+
+ def fit(self, train_features, train_labels):
+ train_features = train_features.to(dtype=self.dtype, device=self.device)
+ train_labels = train_labels.to(dtype=self.dtype, device=self.device)
+ if self.device == _CPU_DEVICE:
+ # both cuML and sklearn only work with numpy arrays on CPU
+ train_features = train_features.numpy()
+ train_labels = train_labels.numpy()
+ self.estimator.fit(train_features, train_labels)
+
+
+def evaluate_model(*, logreg_model, logreg_metric, test_data_loader, device):
+ postprocessors = {"metrics": logreg_model}
+ metrics = {"metrics": logreg_metric}
+ return evaluate(nn.Identity(), test_data_loader, postprocessors, metrics, device)
+
+
+def train_for_C(*, C, max_iter, train_features, train_labels, dtype=torch.float64, device=_CPU_DEVICE):
+ logreg_model = LogRegModule(C, max_iter=max_iter, dtype=dtype, device=device)
+ logreg_model.fit(train_features, train_labels)
+ return logreg_model
+
+
+def train_and_evaluate(
+ *,
+ C,
+ max_iter,
+ train_features,
+ train_labels,
+ logreg_metric,
+ test_data_loader,
+ train_dtype=torch.float64,
+ train_features_device,
+ eval_device,
+):
+ logreg_model = train_for_C(
+ C=C,
+ max_iter=max_iter,
+ train_features=train_features,
+ train_labels=train_labels,
+ dtype=train_dtype,
+ device=train_features_device,
+ )
+ return evaluate_model(
+ logreg_model=logreg_model,
+ logreg_metric=logreg_metric,
+ test_data_loader=test_data_loader,
+ device=eval_device,
+ )
+
+
+def sweep_C_values(
+ *,
+ train_features,
+ train_labels,
+ test_data_loader,
+ metric_type,
+ num_classes,
+ train_dtype=torch.float64,
+ train_features_device=_CPU_DEVICE,
+ max_train_iters=DEFAULT_MAX_ITER,
+):
+ if metric_type == MetricType.PER_CLASS_ACCURACY:
+ # If we want to output per-class accuracy, we select the hyperparameters with mean per class
+ metric_type = MetricType.MEAN_PER_CLASS_ACCURACY
+ logreg_metric = build_metric(metric_type, num_classes=num_classes)
+ metric_tracker = MetricTracker(logreg_metric, maximize=True)
+ ALL_C = 10**C_POWER_RANGE
+ logreg_models = {}
+
+ train_features = train_features.to(dtype=train_dtype, device=train_features_device)
+ train_labels = train_labels.to(device=train_features_device)
+
+ for i in range(get_global_rank(), len(ALL_C), get_global_size()):
+ C = ALL_C[i].item()
+ logger.info(
+ f"Training for C = {C:.5f}, dtype={train_dtype}, "
+ f"features: {train_features.shape}, {train_features.dtype}, "
+ f"labels: {train_labels.shape}, {train_labels.dtype}"
+ )
+ logreg_models[C] = train_for_C(
+ C=C,
+ max_iter=max_train_iters,
+ train_features=train_features,
+ train_labels=train_labels,
+ dtype=train_dtype,
+ device=train_features_device,
+ )
+
+ gather_list = [None for _ in range(get_global_size())]
+ torch.distributed.all_gather_object(gather_list, logreg_models)
+
+ logreg_models_gathered = {}
+ for logreg_dict in gather_list:
+ logreg_models_gathered.update(logreg_dict)
+
+ for i in range(len(ALL_C)):
+ metric_tracker.increment()
+ C = ALL_C[i].item()
+ evals = evaluate_model(
+ logreg_model=logreg_models_gathered[C],
+ logreg_metric=metric_tracker,
+ test_data_loader=test_data_loader,
+ device=torch.cuda.current_device(),
+ )
+ logger.info(f"Trained for C = {C:.5f}, accuracies = {evals}")
+
+ best_stats, which_epoch = metric_tracker.best_metric(return_step=True)
+ best_stats_100 = {k: 100.0 * v for k, v in best_stats.items()}
+ if which_epoch["top-1"] == i:
+ best_C = C
+ logger.info(f"Sweep best {best_stats_100}, best C = {best_C:.6f}")
+
+ return best_stats, best_C
+
+
+def eval_log_regression(
+ *,
+ model,
+ train_dataset,
+ val_dataset,
+ finetune_dataset,
+ metric_type,
+ batch_size,
+ num_workers,
+ finetune_on_val=False,
+ train_dtype=torch.float64,
+ train_features_device=_CPU_DEVICE,
+ max_train_iters=DEFAULT_MAX_ITER,
+):
+ """
+ Implements the "standard" process for log regression evaluation:
+ The value of C is chosen by training on train_dataset and evaluating on
+ finetune_dataset. Then, the final model is trained on a concatenation of
+ train_dataset and finetune_dataset, and is evaluated on val_dataset.
+ If there is no finetune_dataset, the value of C is the one that yields
+ the best results on a random 10% subset of the train dataset
+ """
+
+ start = time.time()
+
+ train_features, train_labels = extract_features(
+ model, train_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE)
+ )
+ val_features, val_labels = extract_features(
+ model, val_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE)
+ )
+ val_data_loader = torch.utils.data.DataLoader(
+ TensorDataset(val_features, val_labels),
+ batch_size=batch_size,
+ drop_last=False,
+ num_workers=0,
+ persistent_workers=False,
+ )
+
+ if finetune_dataset is None and finetune_on_val:
+ logger.info("Choosing hyperparameters on the val dataset")
+ finetune_features, finetune_labels = val_features, val_labels
+ elif finetune_dataset is None and not finetune_on_val:
+ logger.info("Choosing hyperparameters on 10% of the train dataset")
+ torch.manual_seed(0)
+ indices = torch.randperm(len(train_features), device=train_features.device)
+ finetune_index = indices[: len(train_features) // 10]
+ train_index = indices[len(train_features) // 10 :]
+ finetune_features, finetune_labels = train_features[finetune_index], train_labels[finetune_index]
+ train_features, train_labels = train_features[train_index], train_labels[train_index]
+ else:
+ logger.info("Choosing hyperparameters on the finetune dataset")
+ finetune_features, finetune_labels = extract_features(
+ model, finetune_dataset, batch_size, num_workers, gather_on_cpu=(train_features_device == _CPU_DEVICE)
+ )
+ # release the model - free GPU memory
+ del model
+ gc.collect()
+ torch.cuda.empty_cache()
+ finetune_data_loader = torch.utils.data.DataLoader(
+ TensorDataset(finetune_features, finetune_labels),
+ batch_size=batch_size,
+ drop_last=False,
+ )
+
+ if len(train_labels.shape) > 1:
+ num_classes = train_labels.shape[1]
+ else:
+ num_classes = train_labels.max() + 1
+
+ logger.info("Using cuML for logistic regression")
+
+ best_stats, best_C = sweep_C_values(
+ train_features=train_features,
+ train_labels=train_labels,
+ test_data_loader=finetune_data_loader,
+ metric_type=metric_type,
+ num_classes=num_classes,
+ train_dtype=train_dtype,
+ train_features_device=train_features_device,
+ max_train_iters=max_train_iters,
+ )
+
+ if not finetune_on_val:
+ logger.info("Best parameter found, concatenating features")
+ train_features = torch.cat((train_features, finetune_features))
+ train_labels = torch.cat((train_labels, finetune_labels))
+
+ logger.info("Training final model")
+ logreg_metric = build_metric(metric_type, num_classes=num_classes)
+ evals = train_and_evaluate(
+ C=best_C,
+ max_iter=max_train_iters,
+ train_features=train_features,
+ train_labels=train_labels,
+ logreg_metric=logreg_metric.clone(),
+ test_data_loader=val_data_loader,
+ eval_device=torch.cuda.current_device(),
+ train_dtype=train_dtype,
+ train_features_device=train_features_device,
+ )
+
+ best_stats = evals[1]["metrics"]
+
+ best_stats["best_C"] = best_C
+
+ logger.info(f"Log regression evaluation done in {int(time.time() - start)}s")
+ return best_stats
+
+
+def eval_log_regression_with_model(
+ model,
+ train_dataset_str="ImageNet:split=TRAIN",
+ val_dataset_str="ImageNet:split=VAL",
+ finetune_dataset_str=None,
+ autocast_dtype=torch.float,
+ finetune_on_val=False,
+ metric_type=MetricType.MEAN_ACCURACY,
+ train_dtype=torch.float64,
+ train_features_device=_CPU_DEVICE,
+ max_train_iters=DEFAULT_MAX_ITER,
+):
+ cudnn.benchmark = True
+
+ transform = make_classification_eval_transform(resize_size=224)
+ target_transform = None
+
+ train_dataset = make_dataset(dataset_str=train_dataset_str, transform=transform, target_transform=target_transform)
+ val_dataset = make_dataset(dataset_str=val_dataset_str, transform=transform, target_transform=target_transform)
+ if finetune_dataset_str is not None:
+ finetune_dataset = make_dataset(
+ dataset_str=finetune_dataset_str, transform=transform, target_transform=target_transform
+ )
+ else:
+ finetune_dataset = None
+
+ with torch.cuda.amp.autocast(dtype=autocast_dtype):
+ results_dict_logreg = eval_log_regression(
+ model=model,
+ train_dataset=train_dataset,
+ val_dataset=val_dataset,
+ finetune_dataset=finetune_dataset,
+ metric_type=metric_type,
+ batch_size=256,
+ num_workers=0, # 5,
+ finetune_on_val=finetune_on_val,
+ train_dtype=train_dtype,
+ train_features_device=train_features_device,
+ max_train_iters=max_train_iters,
+ )
+
+ results_dict = {
+ "top-1": results_dict_logreg["top-1"].cpu().numpy() * 100.0,
+ "top-5": results_dict_logreg.get("top-5", torch.tensor(0.0)).cpu().numpy() * 100.0,
+ "best_C": results_dict_logreg["best_C"],
+ }
+ logger.info(
+ "\n".join(
+ [
+ "Training of the supervised logistic regression on frozen features completed.\n"
+ "Top-1 test accuracy: {acc:.1f}".format(acc=results_dict["top-1"]),
+ "Top-5 test accuracy: {acc:.1f}".format(acc=results_dict["top-5"]),
+ "obtained for C = {c:.6f}".format(c=results_dict["best_C"]),
+ ]
+ )
+ )
+
+ torch.distributed.barrier()
+ return results_dict
+
+
+def main(args):
+ model, autocast_dtype = setup_and_build_model(args)
+ eval_log_regression_with_model(
+ model=model,
+ train_dataset_str=args.train_dataset_str,
+ val_dataset_str=args.val_dataset_str,
+ finetune_dataset_str=args.finetune_dataset_str,
+ autocast_dtype=autocast_dtype,
+ finetune_on_val=args.finetune_on_val,
+ metric_type=args.metric_type,
+ train_dtype=as_torch_dtype(args.train_dtype),
+ train_features_device=torch.device(args.train_features_device),
+ max_train_iters=args.max_train_iters,
+ )
+ return 0
+
+
+if __name__ == "__main__":
+ description = "DINOv2 logistic regression evaluation"
+ args_parser = get_args_parser(description=description)
+ args = args_parser.parse_args()
+ sys.exit(main(args))
diff --git a/facebookresearch/dinov2/dinov2/eval/metrics.py b/facebookresearch/dinov2/dinov2/eval/metrics.py
new file mode 100644
index 0000000..52be81a
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/metrics.py
@@ -0,0 +1,113 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+import logging
+from typing import Any, Dict, Optional
+
+import torch
+from torch import Tensor
+from torchmetrics import Metric, MetricCollection
+from torchmetrics.classification import MulticlassAccuracy
+from torchmetrics.utilities.data import dim_zero_cat, select_topk
+
+
+logger = logging.getLogger("dinov2")
+
+
+class MetricType(Enum):
+ MEAN_ACCURACY = "mean_accuracy"
+ MEAN_PER_CLASS_ACCURACY = "mean_per_class_accuracy"
+ PER_CLASS_ACCURACY = "per_class_accuracy"
+ IMAGENET_REAL_ACCURACY = "imagenet_real_accuracy"
+
+ @property
+ def accuracy_averaging(self):
+ return getattr(AccuracyAveraging, self.name, None)
+
+ def __str__(self):
+ return self.value
+
+
+class AccuracyAveraging(Enum):
+ MEAN_ACCURACY = "micro"
+ MEAN_PER_CLASS_ACCURACY = "macro"
+ PER_CLASS_ACCURACY = "none"
+
+ def __str__(self):
+ return self.value
+
+
+def build_metric(metric_type: MetricType, *, num_classes: int, ks: Optional[tuple] = None):
+ if metric_type.accuracy_averaging is not None:
+ return build_topk_accuracy_metric(
+ average_type=metric_type.accuracy_averaging,
+ num_classes=num_classes,
+ ks=(1, 5) if ks is None else ks,
+ )
+ elif metric_type == MetricType.IMAGENET_REAL_ACCURACY:
+ return build_topk_imagenet_real_accuracy_metric(
+ num_classes=num_classes,
+ ks=(1, 5) if ks is None else ks,
+ )
+
+ raise ValueError(f"Unknown metric type {metric_type}")
+
+
+def build_topk_accuracy_metric(average_type: AccuracyAveraging, num_classes: int, ks: tuple = (1, 5)):
+ metrics: Dict[str, Metric] = {
+ f"top-{k}": MulticlassAccuracy(top_k=k, num_classes=int(num_classes), average=average_type.value) for k in ks
+ }
+ return MetricCollection(metrics)
+
+
+def build_topk_imagenet_real_accuracy_metric(num_classes: int, ks: tuple = (1, 5)):
+ metrics: Dict[str, Metric] = {f"top-{k}": ImageNetReaLAccuracy(top_k=k, num_classes=int(num_classes)) for k in ks}
+ return MetricCollection(metrics)
+
+
+class ImageNetReaLAccuracy(Metric):
+ is_differentiable: bool = False
+ higher_is_better: Optional[bool] = None
+ full_state_update: bool = False
+
+ def __init__(
+ self,
+ num_classes: int,
+ top_k: int = 1,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.num_classes = num_classes
+ self.top_k = top_k
+ self.add_state("tp", [], dist_reduce_fx="cat")
+
+ def update(self, preds: Tensor, target: Tensor) -> None: # type: ignore
+ # preds [B, D]
+ # target [B, A]
+ # preds_oh [B, D] with 0 and 1
+ # select top K highest probabilities, use one hot representation
+ preds_oh = select_topk(preds, self.top_k)
+ # target_oh [B, D + 1] with 0 and 1
+ target_oh = torch.zeros((preds_oh.shape[0], preds_oh.shape[1] + 1), device=target.device, dtype=torch.int32)
+ target = target.long()
+ # for undefined targets (-1) use a fake value `num_classes`
+ target[target == -1] = self.num_classes
+ # fill targets, use one hot representation
+ target_oh.scatter_(1, target, 1)
+ # target_oh [B, D] (remove the fake target at index `num_classes`)
+ target_oh = target_oh[:, :-1]
+ # tp [B] with 0 and 1
+ tp = (preds_oh * target_oh == 1).sum(dim=1)
+ # at least one match between prediction and target
+ tp.clip_(max=1)
+ # ignore instances where no targets are defined
+ mask = target_oh.sum(dim=1) > 0
+ tp = tp[mask]
+ self.tp.append(tp) # type: ignore
+
+ def compute(self) -> Tensor:
+ tp = dim_zero_cat(self.tp) # type: ignore
+ return tp.float().mean()
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/__init__.py
new file mode 100644
index 0000000..738cc2d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .optimizer import DistOptimizerHook
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/optimizer.py b/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/optimizer.py
new file mode 100644
index 0000000..f593f26
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/hooks/optimizer.py
@@ -0,0 +1,40 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+try:
+ import apex
+except ImportError:
+ print("apex is not installed")
+
+from mmcv.runner import OptimizerHook, HOOKS
+
+
+@HOOKS.register_module()
+class DistOptimizerHook(OptimizerHook):
+ """Optimizer hook for distributed training."""
+
+ def __init__(self, update_interval=1, grad_clip=None, coalesce=True, bucket_size_mb=-1, use_fp16=False):
+ self.grad_clip = grad_clip
+ self.coalesce = coalesce
+ self.bucket_size_mb = bucket_size_mb
+ self.update_interval = update_interval
+ self.use_fp16 = use_fp16
+
+ def before_run(self, runner):
+ runner.optimizer.zero_grad()
+
+ def after_train_iter(self, runner):
+ runner.outputs["loss"] /= self.update_interval
+ if self.use_fp16:
+ # runner.outputs['loss'].backward()
+ with apex.amp.scale_loss(runner.outputs["loss"], runner.optimizer) as scaled_loss:
+ scaled_loss.backward()
+ else:
+ runner.outputs["loss"].backward()
+ if self.every_n_iters(runner, self.update_interval):
+ if self.grad_clip is not None:
+ self.clip_grads(runner.model.parameters())
+ runner.optimizer.step()
+ runner.optimizer.zero_grad()
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/models/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/models/__init__.py
new file mode 100644
index 0000000..88e4563
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/models/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .backbones import * # noqa: F403
+from .decode_heads import * # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/__init__.py
new file mode 100644
index 0000000..520d75b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .vision_transformer import DinoVisionTransformer
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/vision_transformer.py b/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/vision_transformer.py
new file mode 100644
index 0000000..c3e9753
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/models/backbones/vision_transformer.py
@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from mmcv.runner import BaseModule
+from mmseg.models.builder import BACKBONES
+
+
+@BACKBONES.register_module()
+class DinoVisionTransformer(BaseModule):
+ """Vision Transformer."""
+
+ def __init__(
+ self,
+ *args,
+ **kwargs,
+ ):
+ super().__init__()
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/__init__.py
new file mode 100644
index 0000000..c553178
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .linear_head import BNHead
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/linear_head.py b/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/linear_head.py
new file mode 100644
index 0000000..d1f39c6
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/models/decode_heads/linear_head.py
@@ -0,0 +1,90 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+
+from mmseg.models.builder import HEADS
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.ops import resize
+
+
+@HEADS.register_module()
+class BNHead(BaseDecodeHead):
+ """Just a batchnorm."""
+
+ def __init__(self, resize_factors=None, **kwargs):
+ super().__init__(**kwargs)
+ assert self.in_channels == self.channels
+ self.bn = nn.SyncBatchNorm(self.in_channels)
+ self.resize_factors = resize_factors
+
+ def _forward_feature(self, inputs):
+ """Forward function for feature maps before classifying each pixel with
+ ``self.cls_seg`` fc.
+
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+
+ Returns:
+ feats (Tensor): A tensor of shape (batch_size, self.channels,
+ H, W) which is feature map for last layer of decoder head.
+ """
+ # print("inputs", [i.shape for i in inputs])
+ x = self._transform_inputs(inputs)
+ # print("x", x.shape)
+ feats = self.bn(x)
+ # print("feats", feats.shape)
+ return feats
+
+ def _transform_inputs(self, inputs):
+ """Transform inputs for decoder.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ Returns:
+ Tensor: The transformed inputs
+ """
+
+ if self.input_transform == "resize_concat":
+ # accept lists (for cls token)
+ input_list = []
+ for x in inputs:
+ if isinstance(x, list):
+ input_list.extend(x)
+ else:
+ input_list.append(x)
+ inputs = input_list
+ # an image descriptor can be a local descriptor with resolution 1x1
+ for i, x in enumerate(inputs):
+ if len(x.shape) == 2:
+ inputs[i] = x[:, :, None, None]
+ # select indices
+ inputs = [inputs[i] for i in self.in_index]
+ # Resizing shenanigans
+ # print("before", *(x.shape for x in inputs))
+ if self.resize_factors is not None:
+ assert len(self.resize_factors) == len(inputs), (len(self.resize_factors), len(inputs))
+ inputs = [
+ resize(input=x, scale_factor=f, mode="bilinear" if f >= 1 else "area")
+ for x, f in zip(inputs, self.resize_factors)
+ ]
+ # print("after", *(x.shape for x in inputs))
+ upsampled_inputs = [
+ resize(input=x, size=inputs[0].shape[2:], mode="bilinear", align_corners=self.align_corners)
+ for x in inputs
+ ]
+ inputs = torch.cat(upsampled_inputs, dim=1)
+ elif self.input_transform == "multiple_select":
+ inputs = [inputs[i] for i in self.in_index]
+ else:
+ inputs = inputs[self.in_index]
+
+ return inputs
+
+ def forward(self, inputs):
+ """Forward function."""
+ output = self._forward_feature(inputs)
+ output = self.cls_seg(output)
+ return output
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/utils/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation/utils/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/utils/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation/utils/colormaps.py b/facebookresearch/dinov2/dinov2/eval/segmentation/utils/colormaps.py
new file mode 100644
index 0000000..e6ef604
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation/utils/colormaps.py
@@ -0,0 +1,362 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+ADE20K_COLORMAP = [
+ (0, 0, 0),
+ (120, 120, 120),
+ (180, 120, 120),
+ (6, 230, 230),
+ (80, 50, 50),
+ (4, 200, 3),
+ (120, 120, 80),
+ (140, 140, 140),
+ (204, 5, 255),
+ (230, 230, 230),
+ (4, 250, 7),
+ (224, 5, 255),
+ (235, 255, 7),
+ (150, 5, 61),
+ (120, 120, 70),
+ (8, 255, 51),
+ (255, 6, 82),
+ (143, 255, 140),
+ (204, 255, 4),
+ (255, 51, 7),
+ (204, 70, 3),
+ (0, 102, 200),
+ (61, 230, 250),
+ (255, 6, 51),
+ (11, 102, 255),
+ (255, 7, 71),
+ (255, 9, 224),
+ (9, 7, 230),
+ (220, 220, 220),
+ (255, 9, 92),
+ (112, 9, 255),
+ (8, 255, 214),
+ (7, 255, 224),
+ (255, 184, 6),
+ (10, 255, 71),
+ (255, 41, 10),
+ (7, 255, 255),
+ (224, 255, 8),
+ (102, 8, 255),
+ (255, 61, 6),
+ (255, 194, 7),
+ (255, 122, 8),
+ (0, 255, 20),
+ (255, 8, 41),
+ (255, 5, 153),
+ (6, 51, 255),
+ (235, 12, 255),
+ (160, 150, 20),
+ (0, 163, 255),
+ (140, 140, 140),
+ (250, 10, 15),
+ (20, 255, 0),
+ (31, 255, 0),
+ (255, 31, 0),
+ (255, 224, 0),
+ (153, 255, 0),
+ (0, 0, 255),
+ (255, 71, 0),
+ (0, 235, 255),
+ (0, 173, 255),
+ (31, 0, 255),
+ (11, 200, 200),
+ (255, 82, 0),
+ (0, 255, 245),
+ (0, 61, 255),
+ (0, 255, 112),
+ (0, 255, 133),
+ (255, 0, 0),
+ (255, 163, 0),
+ (255, 102, 0),
+ (194, 255, 0),
+ (0, 143, 255),
+ (51, 255, 0),
+ (0, 82, 255),
+ (0, 255, 41),
+ (0, 255, 173),
+ (10, 0, 255),
+ (173, 255, 0),
+ (0, 255, 153),
+ (255, 92, 0),
+ (255, 0, 255),
+ (255, 0, 245),
+ (255, 0, 102),
+ (255, 173, 0),
+ (255, 0, 20),
+ (255, 184, 184),
+ (0, 31, 255),
+ (0, 255, 61),
+ (0, 71, 255),
+ (255, 0, 204),
+ (0, 255, 194),
+ (0, 255, 82),
+ (0, 10, 255),
+ (0, 112, 255),
+ (51, 0, 255),
+ (0, 194, 255),
+ (0, 122, 255),
+ (0, 255, 163),
+ (255, 153, 0),
+ (0, 255, 10),
+ (255, 112, 0),
+ (143, 255, 0),
+ (82, 0, 255),
+ (163, 255, 0),
+ (255, 235, 0),
+ (8, 184, 170),
+ (133, 0, 255),
+ (0, 255, 92),
+ (184, 0, 255),
+ (255, 0, 31),
+ (0, 184, 255),
+ (0, 214, 255),
+ (255, 0, 112),
+ (92, 255, 0),
+ (0, 224, 255),
+ (112, 224, 255),
+ (70, 184, 160),
+ (163, 0, 255),
+ (153, 0, 255),
+ (71, 255, 0),
+ (255, 0, 163),
+ (255, 204, 0),
+ (255, 0, 143),
+ (0, 255, 235),
+ (133, 255, 0),
+ (255, 0, 235),
+ (245, 0, 255),
+ (255, 0, 122),
+ (255, 245, 0),
+ (10, 190, 212),
+ (214, 255, 0),
+ (0, 204, 255),
+ (20, 0, 255),
+ (255, 255, 0),
+ (0, 153, 255),
+ (0, 41, 255),
+ (0, 255, 204),
+ (41, 0, 255),
+ (41, 255, 0),
+ (173, 0, 255),
+ (0, 245, 255),
+ (71, 0, 255),
+ (122, 0, 255),
+ (0, 255, 184),
+ (0, 92, 255),
+ (184, 255, 0),
+ (0, 133, 255),
+ (255, 214, 0),
+ (25, 194, 194),
+ (102, 255, 0),
+ (92, 0, 255),
+]
+
+ADE20K_CLASS_NAMES = [
+ "",
+ "wall",
+ "building;edifice",
+ "sky",
+ "floor;flooring",
+ "tree",
+ "ceiling",
+ "road;route",
+ "bed",
+ "windowpane;window",
+ "grass",
+ "cabinet",
+ "sidewalk;pavement",
+ "person;individual;someone;somebody;mortal;soul",
+ "earth;ground",
+ "door;double;door",
+ "table",
+ "mountain;mount",
+ "plant;flora;plant;life",
+ "curtain;drape;drapery;mantle;pall",
+ "chair",
+ "car;auto;automobile;machine;motorcar",
+ "water",
+ "painting;picture",
+ "sofa;couch;lounge",
+ "shelf",
+ "house",
+ "sea",
+ "mirror",
+ "rug;carpet;carpeting",
+ "field",
+ "armchair",
+ "seat",
+ "fence;fencing",
+ "desk",
+ "rock;stone",
+ "wardrobe;closet;press",
+ "lamp",
+ "bathtub;bathing;tub;bath;tub",
+ "railing;rail",
+ "cushion",
+ "base;pedestal;stand",
+ "box",
+ "column;pillar",
+ "signboard;sign",
+ "chest;of;drawers;chest;bureau;dresser",
+ "counter",
+ "sand",
+ "sink",
+ "skyscraper",
+ "fireplace;hearth;open;fireplace",
+ "refrigerator;icebox",
+ "grandstand;covered;stand",
+ "path",
+ "stairs;steps",
+ "runway",
+ "case;display;case;showcase;vitrine",
+ "pool;table;billiard;table;snooker;table",
+ "pillow",
+ "screen;door;screen",
+ "stairway;staircase",
+ "river",
+ "bridge;span",
+ "bookcase",
+ "blind;screen",
+ "coffee;table;cocktail;table",
+ "toilet;can;commode;crapper;pot;potty;stool;throne",
+ "flower",
+ "book",
+ "hill",
+ "bench",
+ "countertop",
+ "stove;kitchen;stove;range;kitchen;range;cooking;stove",
+ "palm;palm;tree",
+ "kitchen;island",
+ "computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system",
+ "swivel;chair",
+ "boat",
+ "bar",
+ "arcade;machine",
+ "hovel;hut;hutch;shack;shanty",
+ "bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle",
+ "towel",
+ "light;light;source",
+ "truck;motortruck",
+ "tower",
+ "chandelier;pendant;pendent",
+ "awning;sunshade;sunblind",
+ "streetlight;street;lamp",
+ "booth;cubicle;stall;kiosk",
+ "television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box",
+ "airplane;aeroplane;plane",
+ "dirt;track",
+ "apparel;wearing;apparel;dress;clothes",
+ "pole",
+ "land;ground;soil",
+ "bannister;banister;balustrade;balusters;handrail",
+ "escalator;moving;staircase;moving;stairway",
+ "ottoman;pouf;pouffe;puff;hassock",
+ "bottle",
+ "buffet;counter;sideboard",
+ "poster;posting;placard;notice;bill;card",
+ "stage",
+ "van",
+ "ship",
+ "fountain",
+ "conveyer;belt;conveyor;belt;conveyer;conveyor;transporter",
+ "canopy",
+ "washer;automatic;washer;washing;machine",
+ "plaything;toy",
+ "swimming;pool;swimming;bath;natatorium",
+ "stool",
+ "barrel;cask",
+ "basket;handbasket",
+ "waterfall;falls",
+ "tent;collapsible;shelter",
+ "bag",
+ "minibike;motorbike",
+ "cradle",
+ "oven",
+ "ball",
+ "food;solid;food",
+ "step;stair",
+ "tank;storage;tank",
+ "trade;name;brand;name;brand;marque",
+ "microwave;microwave;oven",
+ "pot;flowerpot",
+ "animal;animate;being;beast;brute;creature;fauna",
+ "bicycle;bike;wheel;cycle",
+ "lake",
+ "dishwasher;dish;washer;dishwashing;machine",
+ "screen;silver;screen;projection;screen",
+ "blanket;cover",
+ "sculpture",
+ "hood;exhaust;hood",
+ "sconce",
+ "vase",
+ "traffic;light;traffic;signal;stoplight",
+ "tray",
+ "ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin",
+ "fan",
+ "pier;wharf;wharfage;dock",
+ "crt;screen",
+ "plate",
+ "monitor;monitoring;device",
+ "bulletin;board;notice;board",
+ "shower",
+ "radiator",
+ "glass;drinking;glass",
+ "clock",
+ "flag",
+]
+
+
+VOC2012_COLORMAP = [
+ (0, 0, 0),
+ (128, 0, 0),
+ (0, 128, 0),
+ (128, 128, 0),
+ (0, 0, 128),
+ (128, 0, 128),
+ (0, 128, 128),
+ (128, 128, 128),
+ (64, 0, 0),
+ (192, 0, 0),
+ (64, 128, 0),
+ (192, 128, 0),
+ (64, 0, 128),
+ (192, 0, 128),
+ (64, 128, 128),
+ (192, 128, 128),
+ (0, 64, 0),
+ (128, 64, 0),
+ (0, 192, 0),
+ (128, 192, 0),
+ (0, 64, 128),
+]
+
+
+VOC2012_CLASS_NAMES = [
+ "",
+ "aeroplane",
+ "bicycle",
+ "bird",
+ "boat",
+ "bottle",
+ "bus",
+ "car",
+ "cat",
+ "chair",
+ "cow",
+ "diningtable",
+ "dog",
+ "horse",
+ "motorbike",
+ "person",
+ "pottedplant",
+ "sheep",
+ "sofa",
+ "train",
+ "tvmonitor",
+]
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/__init__.py
new file mode 100644
index 0000000..6c678fd
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .core import * # noqa: F403
+from .models import * # noqa: F403
+from .ops import * # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/__init__.py
new file mode 100644
index 0000000..9259980
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from mmseg.core.evaluation import * # noqa: F403
+from mmseg.core.seg import * # noqa: F403
+
+from .anchor import * # noqa: F403
+from .box import * # noqa: F403
+from .utils import * # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/__init__.py
new file mode 100644
index 0000000..e71ac4d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .point_generator import MlvlPointGenerator # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/builder.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/builder.py
new file mode 100644
index 0000000..6dba90e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/builder.py
@@ -0,0 +1,21 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import warnings
+
+from mmcv.utils import Registry, build_from_cfg
+
+PRIOR_GENERATORS = Registry("Generator for anchors and points")
+
+ANCHOR_GENERATORS = PRIOR_GENERATORS
+
+
+def build_prior_generator(cfg, default_args=None):
+ return build_from_cfg(cfg, PRIOR_GENERATORS, default_args)
+
+
+def build_anchor_generator(cfg, default_args=None):
+ warnings.warn("``build_anchor_generator`` would be deprecated soon, please use " "``build_prior_generator`` ")
+ return build_prior_generator(cfg, default_args=default_args)
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py
new file mode 100644
index 0000000..574d719
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/anchor/point_generator.py
@@ -0,0 +1,205 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import numpy as np
+import torch
+from torch.nn.modules.utils import _pair
+
+from .builder import PRIOR_GENERATORS
+
+
+@PRIOR_GENERATORS.register_module()
+class MlvlPointGenerator:
+ """Standard points generator for multi-level (Mlvl) feature maps in 2D
+ points-based detectors.
+
+ Args:
+ strides (list[int] | list[tuple[int, int]]): Strides of anchors
+ in multiple feature levels in order (w, h).
+ offset (float): The offset of points, the value is normalized with
+ corresponding stride. Defaults to 0.5.
+ """
+
+ def __init__(self, strides, offset=0.5):
+ self.strides = [_pair(stride) for stride in strides]
+ self.offset = offset
+
+ @property
+ def num_levels(self):
+ """int: number of feature levels that the generator will be applied"""
+ return len(self.strides)
+
+ @property
+ def num_base_priors(self):
+ """list[int]: The number of priors (points) at a point
+ on the feature grid"""
+ return [1 for _ in range(len(self.strides))]
+
+ def _meshgrid(self, x, y, row_major=True):
+ yy, xx = torch.meshgrid(y, x)
+ if row_major:
+ # warning .flatten() would cause error in ONNX exporting
+ # have to use reshape here
+ return xx.reshape(-1), yy.reshape(-1)
+
+ else:
+ return yy.reshape(-1), xx.reshape(-1)
+
+ def grid_priors(self, featmap_sizes, dtype=torch.float32, device="cuda", with_stride=False):
+ """Generate grid points of multiple feature levels.
+
+ Args:
+ featmap_sizes (list[tuple]): List of feature map sizes in
+ multiple feature levels, each size arrange as
+ as (h, w).
+ dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32.
+ device (str): The device where the anchors will be put on.
+ with_stride (bool): Whether to concatenate the stride to
+ the last dimension of points.
+
+ Return:
+ list[torch.Tensor]: Points of multiple feature levels.
+ The sizes of each tensor should be (N, 2) when with stride is
+ ``False``, where N = width * height, width and height
+ are the sizes of the corresponding feature level,
+ and the last dimension 2 represent (coord_x, coord_y),
+ otherwise the shape should be (N, 4),
+ and the last dimension 4 represent
+ (coord_x, coord_y, stride_w, stride_h).
+ """
+
+ assert self.num_levels == len(featmap_sizes)
+ multi_level_priors = []
+ for i in range(self.num_levels):
+ priors = self.single_level_grid_priors(
+ featmap_sizes[i], level_idx=i, dtype=dtype, device=device, with_stride=with_stride
+ )
+ multi_level_priors.append(priors)
+ return multi_level_priors
+
+ def single_level_grid_priors(self, featmap_size, level_idx, dtype=torch.float32, device="cuda", with_stride=False):
+ """Generate grid Points of a single level.
+
+ Note:
+ This function is usually called by method ``self.grid_priors``.
+
+ Args:
+ featmap_size (tuple[int]): Size of the feature maps, arrange as
+ (h, w).
+ level_idx (int): The index of corresponding feature map level.
+ dtype (:obj:`dtype`): Dtype of priors. Default: torch.float32.
+ device (str, optional): The device the tensor will be put on.
+ Defaults to 'cuda'.
+ with_stride (bool): Concatenate the stride to the last dimension
+ of points.
+
+ Return:
+ Tensor: Points of single feature levels.
+ The shape of tensor should be (N, 2) when with stride is
+ ``False``, where N = width * height, width and height
+ are the sizes of the corresponding feature level,
+ and the last dimension 2 represent (coord_x, coord_y),
+ otherwise the shape should be (N, 4),
+ and the last dimension 4 represent
+ (coord_x, coord_y, stride_w, stride_h).
+ """
+ feat_h, feat_w = featmap_size
+ stride_w, stride_h = self.strides[level_idx]
+ shift_x = (torch.arange(0, feat_w, device=device) + self.offset) * stride_w
+ # keep featmap_size as Tensor instead of int, so that we
+ # can convert to ONNX correctly
+ shift_x = shift_x.to(dtype)
+
+ shift_y = (torch.arange(0, feat_h, device=device) + self.offset) * stride_h
+ # keep featmap_size as Tensor instead of int, so that we
+ # can convert to ONNX correctly
+ shift_y = shift_y.to(dtype)
+ shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
+ if not with_stride:
+ shifts = torch.stack([shift_xx, shift_yy], dim=-1)
+ else:
+ # use `shape[0]` instead of `len(shift_xx)` for ONNX export
+ stride_w = shift_xx.new_full((shift_xx.shape[0],), stride_w).to(dtype)
+ stride_h = shift_xx.new_full((shift_yy.shape[0],), stride_h).to(dtype)
+ shifts = torch.stack([shift_xx, shift_yy, stride_w, stride_h], dim=-1)
+ all_points = shifts.to(device)
+ return all_points
+
+ def valid_flags(self, featmap_sizes, pad_shape, device="cuda"):
+ """Generate valid flags of points of multiple feature levels.
+
+ Args:
+ featmap_sizes (list(tuple)): List of feature map sizes in
+ multiple feature levels, each size arrange as
+ as (h, w).
+ pad_shape (tuple(int)): The padded shape of the image,
+ arrange as (h, w).
+ device (str): The device where the anchors will be put on.
+
+ Return:
+ list(torch.Tensor): Valid flags of points of multiple levels.
+ """
+ assert self.num_levels == len(featmap_sizes)
+ multi_level_flags = []
+ for i in range(self.num_levels):
+ point_stride = self.strides[i]
+ feat_h, feat_w = featmap_sizes[i]
+ h, w = pad_shape[:2]
+ valid_feat_h = min(int(np.ceil(h / point_stride[1])), feat_h)
+ valid_feat_w = min(int(np.ceil(w / point_stride[0])), feat_w)
+ flags = self.single_level_valid_flags((feat_h, feat_w), (valid_feat_h, valid_feat_w), device=device)
+ multi_level_flags.append(flags)
+ return multi_level_flags
+
+ def single_level_valid_flags(self, featmap_size, valid_size, device="cuda"):
+ """Generate the valid flags of points of a single feature map.
+
+ Args:
+ featmap_size (tuple[int]): The size of feature maps, arrange as
+ as (h, w).
+ valid_size (tuple[int]): The valid size of the feature maps.
+ The size arrange as as (h, w).
+ device (str, optional): The device where the flags will be put on.
+ Defaults to 'cuda'.
+
+ Returns:
+ torch.Tensor: The valid flags of each points in a single level \
+ feature map.
+ """
+ feat_h, feat_w = featmap_size
+ valid_h, valid_w = valid_size
+ assert valid_h <= feat_h and valid_w <= feat_w
+ valid_x = torch.zeros(feat_w, dtype=torch.bool, device=device)
+ valid_y = torch.zeros(feat_h, dtype=torch.bool, device=device)
+ valid_x[:valid_w] = 1
+ valid_y[:valid_h] = 1
+ valid_xx, valid_yy = self._meshgrid(valid_x, valid_y)
+ valid = valid_xx & valid_yy
+ return valid
+
+ def sparse_priors(self, prior_idxs, featmap_size, level_idx, dtype=torch.float32, device="cuda"):
+ """Generate sparse points according to the ``prior_idxs``.
+
+ Args:
+ prior_idxs (Tensor): The index of corresponding anchors
+ in the feature map.
+ featmap_size (tuple[int]): feature map size arrange as (w, h).
+ level_idx (int): The level index of corresponding feature
+ map.
+ dtype (obj:`torch.dtype`): Date type of points. Defaults to
+ ``torch.float32``.
+ device (obj:`torch.device`): The device where the points is
+ located.
+ Returns:
+ Tensor: Anchor with shape (N, 2), N should be equal to
+ the length of ``prior_idxs``. And last dimension
+ 2 represent (coord_x, coord_y).
+ """
+ height, width = featmap_size
+ x = (prior_idxs % width + self.offset) * self.strides[level_idx][0]
+ y = ((prior_idxs // width) % height + self.offset) * self.strides[level_idx][1]
+ prioris = torch.stack([x, y], 1).to(dtype)
+ prioris = prioris.to(device)
+ return prioris
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/__init__.py
new file mode 100644
index 0000000..bf35a61
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .builder import * # noqa: F403
+from .samplers import MaskPseudoSampler # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/builder.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/builder.py
new file mode 100644
index 0000000..9538c0d
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/builder.py
@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from mmcv.utils import Registry, build_from_cfg
+
+BBOX_SAMPLERS = Registry("bbox_sampler")
+BBOX_CODERS = Registry("bbox_coder")
+
+
+def build_sampler(cfg, **default_args):
+ """Builder of box sampler."""
+ return build_from_cfg(cfg, BBOX_SAMPLERS, default_args)
+
+
+def build_bbox_coder(cfg, **default_args):
+ """Builder of box coder."""
+ return build_from_cfg(cfg, BBOX_CODERS, default_args)
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py
new file mode 100644
index 0000000..19c363e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .mask_pseudo_sampler import MaskPseudoSampler # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py
new file mode 100644
index 0000000..c45cec3
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/base_sampler.py
@@ -0,0 +1,92 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from abc import ABCMeta, abstractmethod
+
+import torch
+
+from .sampling_result import SamplingResult
+
+
+class BaseSampler(metaclass=ABCMeta):
+ """Base class of samplers."""
+
+ def __init__(self, num, pos_fraction, neg_pos_ub=-1, add_gt_as_proposals=True, **kwargs):
+ self.num = num
+ self.pos_fraction = pos_fraction
+ self.neg_pos_ub = neg_pos_ub
+ self.add_gt_as_proposals = add_gt_as_proposals
+ self.pos_sampler = self
+ self.neg_sampler = self
+
+ @abstractmethod
+ def _sample_pos(self, assign_result, num_expected, **kwargs):
+ """Sample positive samples."""
+ pass
+
+ @abstractmethod
+ def _sample_neg(self, assign_result, num_expected, **kwargs):
+ """Sample negative samples."""
+ pass
+
+ def sample(self, assign_result, bboxes, gt_bboxes, gt_labels=None, **kwargs):
+ """Sample positive and negative bboxes.
+
+ This is a simple implementation of bbox sampling given candidates,
+ assigning results and ground truth bboxes.
+
+ Args:
+ assign_result (:obj:`AssignResult`): Bbox assigning results.
+ bboxes (Tensor): Boxes to be sampled from.
+ gt_bboxes (Tensor): Ground truth bboxes.
+ gt_labels (Tensor, optional): Class labels of ground truth bboxes.
+
+ Returns:
+ :obj:`SamplingResult`: Sampling result.
+
+ Example:
+ >>> from mmdet.core.bbox import RandomSampler
+ >>> from mmdet.core.bbox import AssignResult
+ >>> from mmdet.core.bbox.demodata import ensure_rng, random_boxes
+ >>> rng = ensure_rng(None)
+ >>> assign_result = AssignResult.random(rng=rng)
+ >>> bboxes = random_boxes(assign_result.num_preds, rng=rng)
+ >>> gt_bboxes = random_boxes(assign_result.num_gts, rng=rng)
+ >>> gt_labels = None
+ >>> self = RandomSampler(num=32, pos_fraction=0.5, neg_pos_ub=-1,
+ >>> add_gt_as_proposals=False)
+ >>> self = self.sample(assign_result, bboxes, gt_bboxes, gt_labels)
+ """
+ if len(bboxes.shape) < 2:
+ bboxes = bboxes[None, :]
+
+ bboxes = bboxes[:, :4]
+
+ gt_flags = bboxes.new_zeros((bboxes.shape[0],), dtype=torch.uint8)
+ if self.add_gt_as_proposals and len(gt_bboxes) > 0:
+ if gt_labels is None:
+ raise ValueError("gt_labels must be given when add_gt_as_proposals is True")
+ bboxes = torch.cat([gt_bboxes, bboxes], dim=0)
+ assign_result.add_gt_(gt_labels)
+ gt_ones = bboxes.new_ones(gt_bboxes.shape[0], dtype=torch.uint8)
+ gt_flags = torch.cat([gt_ones, gt_flags])
+
+ num_expected_pos = int(self.num * self.pos_fraction)
+ pos_inds = self.pos_sampler._sample_pos(assign_result, num_expected_pos, bboxes=bboxes, **kwargs)
+ # We found that sampled indices have duplicated items occasionally.
+ # (may be a bug of PyTorch)
+ pos_inds = pos_inds.unique()
+ num_sampled_pos = pos_inds.numel()
+ num_expected_neg = self.num - num_sampled_pos
+ if self.neg_pos_ub >= 0:
+ _pos = max(1, num_sampled_pos)
+ neg_upper_bound = int(self.neg_pos_ub * _pos)
+ if num_expected_neg > neg_upper_bound:
+ num_expected_neg = neg_upper_bound
+ neg_inds = self.neg_sampler._sample_neg(assign_result, num_expected_neg, bboxes=bboxes, **kwargs)
+ neg_inds = neg_inds.unique()
+
+ sampling_result = SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags)
+ return sampling_result
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py
new file mode 100644
index 0000000..3e67ea6
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_pseudo_sampler.py
@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py
+
+import torch
+
+from ..builder import BBOX_SAMPLERS
+from .base_sampler import BaseSampler
+from .mask_sampling_result import MaskSamplingResult
+
+
+@BBOX_SAMPLERS.register_module()
+class MaskPseudoSampler(BaseSampler):
+ """A pseudo sampler that does not do sampling actually."""
+
+ def __init__(self, **kwargs):
+ pass
+
+ def _sample_pos(self, **kwargs):
+ """Sample positive samples."""
+ raise NotImplementedError
+
+ def _sample_neg(self, **kwargs):
+ """Sample negative samples."""
+ raise NotImplementedError
+
+ def sample(self, assign_result, masks, gt_masks, **kwargs):
+ """Directly returns the positive and negative indices of samples.
+
+ Args:
+ assign_result (:obj:`AssignResult`): Assigned results
+ masks (torch.Tensor): Bounding boxes
+ gt_masks (torch.Tensor): Ground truth boxes
+ Returns:
+ :obj:`SamplingResult`: sampler results
+ """
+ pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+ neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+ gt_flags = masks.new_zeros(masks.shape[0], dtype=torch.uint8)
+ sampling_result = MaskSamplingResult(pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags)
+ return sampling_result
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py
new file mode 100644
index 0000000..270ffd3
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/mask_sampling_result.py
@@ -0,0 +1,63 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/ZwwWayne/K-Net/blob/main/knet/det/mask_pseudo_sampler.py
+
+import torch
+
+from .sampling_result import SamplingResult
+
+
+class MaskSamplingResult(SamplingResult):
+ """Mask sampling result."""
+
+ def __init__(self, pos_inds, neg_inds, masks, gt_masks, assign_result, gt_flags):
+ self.pos_inds = pos_inds
+ self.neg_inds = neg_inds
+ self.pos_masks = masks[pos_inds]
+ self.neg_masks = masks[neg_inds]
+ self.pos_is_gt = gt_flags[pos_inds]
+
+ self.num_gts = gt_masks.shape[0]
+ self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+
+ if gt_masks.numel() == 0:
+ # hack for index error case
+ assert self.pos_assigned_gt_inds.numel() == 0
+ self.pos_gt_masks = torch.empty_like(gt_masks)
+ else:
+ self.pos_gt_masks = gt_masks[self.pos_assigned_gt_inds, :]
+
+ if assign_result.labels is not None:
+ self.pos_gt_labels = assign_result.labels[pos_inds]
+ else:
+ self.pos_gt_labels = None
+
+ @property
+ def masks(self):
+ """torch.Tensor: concatenated positive and negative boxes"""
+ return torch.cat([self.pos_masks, self.neg_masks])
+
+ def __nice__(self):
+ data = self.info.copy()
+ data["pos_masks"] = data.pop("pos_masks").shape
+ data["neg_masks"] = data.pop("neg_masks").shape
+ parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())]
+ body = " " + ",\n ".join(parts)
+ return "{\n" + body + "\n}"
+
+ @property
+ def info(self):
+ """Returns a dictionary of info about the object."""
+ return {
+ "pos_inds": self.pos_inds,
+ "neg_inds": self.neg_inds,
+ "pos_masks": self.pos_masks,
+ "neg_masks": self.neg_masks,
+ "pos_is_gt": self.pos_is_gt,
+ "num_gts": self.num_gts,
+ "pos_assigned_gt_inds": self.pos_assigned_gt_inds,
+ }
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py
new file mode 100644
index 0000000..aaee3fe
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/box/samplers/sampling_result.py
@@ -0,0 +1,152 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+
+
+class SamplingResult:
+ """Bbox sampling result.
+
+ Example:
+ >>> # xdoctest: +IGNORE_WANT
+ >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA
+ >>> self = SamplingResult.random(rng=10)
+ >>> print(f'self = {self}')
+ self =
+ """
+
+ def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags):
+ self.pos_inds = pos_inds
+ self.neg_inds = neg_inds
+ self.pos_bboxes = bboxes[pos_inds]
+ self.neg_bboxes = bboxes[neg_inds]
+ self.pos_is_gt = gt_flags[pos_inds]
+
+ self.num_gts = gt_bboxes.shape[0]
+ self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
+
+ if gt_bboxes.numel() == 0:
+ # hack for index error case
+ assert self.pos_assigned_gt_inds.numel() == 0
+ self.pos_gt_bboxes = torch.empty_like(gt_bboxes).view(-1, 4)
+ else:
+ if len(gt_bboxes.shape) < 2:
+ gt_bboxes = gt_bboxes.view(-1, 4)
+
+ self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds.long(), :]
+
+ if assign_result.labels is not None:
+ self.pos_gt_labels = assign_result.labels[pos_inds]
+ else:
+ self.pos_gt_labels = None
+
+ @property
+ def bboxes(self):
+ """torch.Tensor: concatenated positive and negative boxes"""
+ return torch.cat([self.pos_bboxes, self.neg_bboxes])
+
+ def to(self, device):
+ """Change the device of the data inplace.
+
+ Example:
+ >>> self = SamplingResult.random()
+ >>> print(f'self = {self.to(None)}')
+ >>> # xdoctest: +REQUIRES(--gpu)
+ >>> print(f'self = {self.to(0)}')
+ """
+ _dict = self.__dict__
+ for key, value in _dict.items():
+ if isinstance(value, torch.Tensor):
+ _dict[key] = value.to(device)
+ return self
+
+ def __nice__(self):
+ data = self.info.copy()
+ data["pos_bboxes"] = data.pop("pos_bboxes").shape
+ data["neg_bboxes"] = data.pop("neg_bboxes").shape
+ parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())]
+ body = " " + ",\n ".join(parts)
+ return "{\n" + body + "\n}"
+
+ @property
+ def info(self):
+ """Returns a dictionary of info about the object."""
+ return {
+ "pos_inds": self.pos_inds,
+ "neg_inds": self.neg_inds,
+ "pos_bboxes": self.pos_bboxes,
+ "neg_bboxes": self.neg_bboxes,
+ "pos_is_gt": self.pos_is_gt,
+ "num_gts": self.num_gts,
+ "pos_assigned_gt_inds": self.pos_assigned_gt_inds,
+ }
+
+ @classmethod
+ def random(cls, rng=None, **kwargs):
+ """
+ Args:
+ rng (None | int | numpy.random.RandomState): seed or state.
+ kwargs (keyword arguments):
+ - num_preds: number of predicted boxes
+ - num_gts: number of true boxes
+ - p_ignore (float): probability of a predicted box assigned to \
+ an ignored truth.
+ - p_assigned (float): probability of a predicted box not being \
+ assigned.
+ - p_use_label (float | bool): with labels or not.
+
+ Returns:
+ :obj:`SamplingResult`: Randomly generated sampling result.
+
+ Example:
+ >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA
+ >>> self = SamplingResult.random()
+ >>> print(self.__dict__)
+ """
+ from mmdet.core.bbox import demodata
+ from mmdet.core.bbox.assigners.assign_result import AssignResult
+ from mmdet.core.bbox.samplers.random_sampler import RandomSampler
+
+ rng = demodata.ensure_rng(rng)
+
+ # make probabalistic?
+ num = 32
+ pos_fraction = 0.5
+ neg_pos_ub = -1
+
+ assign_result = AssignResult.random(rng=rng, **kwargs)
+
+ # Note we could just compute an assignment
+ bboxes = demodata.random_boxes(assign_result.num_preds, rng=rng)
+ gt_bboxes = demodata.random_boxes(assign_result.num_gts, rng=rng)
+
+ if rng.rand() > 0.2:
+ # sometimes algorithms squeeze their data, be robust to that
+ gt_bboxes = gt_bboxes.squeeze()
+ bboxes = bboxes.squeeze()
+
+ if assign_result.labels is None:
+ gt_labels = None
+ else:
+ gt_labels = None
+
+ if gt_labels is None:
+ add_gt_as_proposals = False
+ else:
+ add_gt_as_proposals = True # make probabalistic?
+
+ sampler = RandomSampler(
+ num, pos_fraction, neg_pos_ub=neg_pos_ub, add_gt_as_proposals=add_gt_as_proposals, rng=rng
+ )
+ self = sampler.sample(assign_result, bboxes, gt_bboxes, gt_labels)
+ return self
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/__init__.py
new file mode 100644
index 0000000..6cdc9e1
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .dist_utils import reduce_mean
+from .misc import add_prefix, multi_apply
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py
new file mode 100644
index 0000000..7dfed42
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/dist_utils.py
@@ -0,0 +1,15 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch.distributed as dist
+
+
+def reduce_mean(tensor):
+ """ "Obtain the mean of tensor on different GPUs."""
+ if not (dist.is_available() and dist.is_initialized()):
+ return tensor
+ tensor = tensor.clone()
+ dist.all_reduce(tensor.div_(dist.get_world_size()), op=dist.ReduceOp.SUM)
+ return tensor
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/misc.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/misc.py
new file mode 100644
index 0000000..e07579e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/core/utils/misc.py
@@ -0,0 +1,47 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from functools import partial
+
+
+def multi_apply(func, *args, **kwargs):
+ """Apply function to a list of arguments.
+
+ Note:
+ This function applies the ``func`` to multiple inputs and
+ map the multiple outputs of the ``func`` into different
+ list. Each list contains the same type of outputs corresponding
+ to different inputs.
+
+ Args:
+ func (Function): A function that will be applied to a list of
+ arguments
+
+ Returns:
+ tuple(list): A tuple containing multiple list, each list contains \
+ a kind of returned results by the function
+ """
+ pfunc = partial(func, **kwargs) if kwargs else func
+ map_results = map(pfunc, *args)
+ return tuple(map(list, zip(*map_results)))
+
+
+def add_prefix(inputs, prefix):
+ """Add prefix for dict.
+
+ Args:
+ inputs (dict): The input dict with str keys.
+ prefix (str): The prefix to add.
+
+ Returns:
+
+ dict: The dict with keys updated with ``prefix``.
+ """
+
+ outputs = dict()
+ for name, value in inputs.items():
+ outputs[f"{prefix}.{name}"] = value
+
+ return outputs
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/__init__.py
new file mode 100644
index 0000000..ed89bb0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .backbones import * # noqa: F403
+from .builder import MASK_ASSIGNERS, MATCH_COST, TRANSFORMER, build_assigner, build_match_cost
+from .decode_heads import * # noqa: F403
+from .losses import * # noqa: F403
+from .plugins import * # noqa: F403
+from .segmentors import * # noqa: F403
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/__init__.py
new file mode 100644
index 0000000..c4bf73b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .vit_adapter import ViTAdapter
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py
new file mode 100644
index 0000000..26bfdf8
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/adapter_modules.py
@@ -0,0 +1,442 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from functools import partial
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as cp
+
+from ...ops.modules import MSDeformAttn
+from .drop_path import DropPath
+
+
+def get_reference_points(spatial_shapes, device):
+ reference_points_list = []
+ for lvl, (H_, W_) in enumerate(spatial_shapes):
+ ref_y, ref_x = torch.meshgrid(
+ torch.linspace(0.5, H_ - 0.5, H_, dtype=torch.float32, device=device),
+ torch.linspace(0.5, W_ - 0.5, W_, dtype=torch.float32, device=device),
+ )
+ ref_y = ref_y.reshape(-1)[None] / H_
+ ref_x = ref_x.reshape(-1)[None] / W_
+ ref = torch.stack((ref_x, ref_y), -1)
+ reference_points_list.append(ref)
+ reference_points = torch.cat(reference_points_list, 1)
+ reference_points = reference_points[:, :, None]
+ return reference_points
+
+
+def deform_inputs(x, patch_size):
+ bs, c, h, w = x.shape
+ spatial_shapes = torch.as_tensor(
+ [(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], dtype=torch.long, device=x.device
+ )
+ level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1]))
+ reference_points = get_reference_points([(h // patch_size, w // patch_size)], x.device)
+ deform_inputs1 = [reference_points, spatial_shapes, level_start_index]
+
+ spatial_shapes = torch.as_tensor([(h // patch_size, w // patch_size)], dtype=torch.long, device=x.device)
+ level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1]))
+ reference_points = get_reference_points([(h // 8, w // 8), (h // 16, w // 16), (h // 32, w // 32)], x.device)
+ deform_inputs2 = [reference_points, spatial_shapes, level_start_index]
+
+ return deform_inputs1, deform_inputs2
+
+
+class ConvFFN(nn.Module):
+ def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.0):
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.fc1 = nn.Linear(in_features, hidden_features)
+ self.dwconv = DWConv(hidden_features)
+ self.act = act_layer()
+ self.fc2 = nn.Linear(hidden_features, out_features)
+ self.drop = nn.Dropout(drop)
+
+ def forward(self, x, H, W):
+ x = self.fc1(x)
+ x = self.dwconv(x, H, W)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
+
+
+class DWConv(nn.Module):
+ def __init__(self, dim=768):
+ super().__init__()
+ self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim)
+
+ def forward(self, x, H, W):
+ B, N, C = x.shape
+ n = N // 21
+ x1 = x[:, 0 : 16 * n, :].transpose(1, 2).view(B, C, H * 2, W * 2).contiguous()
+ x2 = x[:, 16 * n : 20 * n, :].transpose(1, 2).view(B, C, H, W).contiguous()
+ x3 = x[:, 20 * n :, :].transpose(1, 2).view(B, C, H // 2, W // 2).contiguous()
+ x1 = self.dwconv(x1).flatten(2).transpose(1, 2)
+ x2 = self.dwconv(x2).flatten(2).transpose(1, 2)
+ x3 = self.dwconv(x3).flatten(2).transpose(1, 2)
+ x = torch.cat([x1, x2, x3], dim=1)
+ return x
+
+
+class Extractor(nn.Module):
+ def __init__(
+ self,
+ dim,
+ num_heads=6,
+ n_points=4,
+ n_levels=1,
+ deform_ratio=1.0,
+ with_cffn=True,
+ cffn_ratio=0.25,
+ drop=0.0,
+ drop_path=0.0,
+ norm_layer=partial(nn.LayerNorm, eps=1e-6),
+ with_cp=False,
+ ):
+ super().__init__()
+ self.query_norm = norm_layer(dim)
+ self.feat_norm = norm_layer(dim)
+ self.attn = MSDeformAttn(
+ d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio
+ )
+ self.with_cffn = with_cffn
+ self.with_cp = with_cp
+ if with_cffn:
+ self.ffn = ConvFFN(in_features=dim, hidden_features=int(dim * cffn_ratio), drop=drop)
+ self.ffn_norm = norm_layer(dim)
+ self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+ def forward(self, query, reference_points, feat, spatial_shapes, level_start_index, H, W):
+ def _inner_forward(query, feat):
+
+ attn = self.attn(
+ self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None
+ )
+ query = query + attn
+
+ if self.with_cffn:
+ query = query + self.drop_path(self.ffn(self.ffn_norm(query), H, W))
+ return query
+
+ if self.with_cp and query.requires_grad:
+ query = cp.checkpoint(_inner_forward, query, feat)
+ else:
+ query = _inner_forward(query, feat)
+
+ return query
+
+
+class Injector(nn.Module):
+ def __init__(
+ self,
+ dim,
+ num_heads=6,
+ n_points=4,
+ n_levels=1,
+ deform_ratio=1.0,
+ norm_layer=partial(nn.LayerNorm, eps=1e-6),
+ init_values=0.0,
+ with_cp=False,
+ ):
+ super().__init__()
+ self.with_cp = with_cp
+ self.query_norm = norm_layer(dim)
+ self.feat_norm = norm_layer(dim)
+ self.attn = MSDeformAttn(
+ d_model=dim, n_levels=n_levels, n_heads=num_heads, n_points=n_points, ratio=deform_ratio
+ )
+ self.gamma = nn.Parameter(init_values * torch.ones((dim)), requires_grad=True)
+
+ def forward(self, query, reference_points, feat, spatial_shapes, level_start_index):
+ def _inner_forward(query, feat):
+
+ attn = self.attn(
+ self.query_norm(query), reference_points, self.feat_norm(feat), spatial_shapes, level_start_index, None
+ )
+ return query + self.gamma * attn
+
+ if self.with_cp and query.requires_grad:
+ query = cp.checkpoint(_inner_forward, query, feat)
+ else:
+ query = _inner_forward(query, feat)
+
+ return query
+
+
+class InteractionBlock(nn.Module):
+ def __init__(
+ self,
+ dim,
+ num_heads=6,
+ n_points=4,
+ norm_layer=partial(nn.LayerNorm, eps=1e-6),
+ drop=0.0,
+ drop_path=0.0,
+ with_cffn=True,
+ cffn_ratio=0.25,
+ init_values=0.0,
+ deform_ratio=1.0,
+ extra_extractor=False,
+ with_cp=False,
+ ):
+ super().__init__()
+
+ self.injector = Injector(
+ dim=dim,
+ n_levels=3,
+ num_heads=num_heads,
+ init_values=init_values,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ deform_ratio=deform_ratio,
+ with_cp=with_cp,
+ )
+ self.extractor = Extractor(
+ dim=dim,
+ n_levels=1,
+ num_heads=num_heads,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ deform_ratio=deform_ratio,
+ with_cffn=with_cffn,
+ cffn_ratio=cffn_ratio,
+ drop=drop,
+ drop_path=drop_path,
+ with_cp=with_cp,
+ )
+ if extra_extractor:
+ self.extra_extractors = nn.Sequential(
+ *[
+ Extractor(
+ dim=dim,
+ num_heads=num_heads,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ with_cffn=with_cffn,
+ cffn_ratio=cffn_ratio,
+ deform_ratio=deform_ratio,
+ drop=drop,
+ drop_path=drop_path,
+ with_cp=with_cp,
+ )
+ for _ in range(2)
+ ]
+ )
+ else:
+ self.extra_extractors = None
+
+ def forward(self, x, c, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks):
+ x = self.injector(
+ query=x,
+ reference_points=deform_inputs1[0],
+ feat=c,
+ spatial_shapes=deform_inputs1[1],
+ level_start_index=deform_inputs1[2],
+ )
+ for idx, blk in enumerate(blocks):
+ x = blk(x, H_toks, W_toks)
+ c = self.extractor(
+ query=c,
+ reference_points=deform_inputs2[0],
+ feat=x,
+ spatial_shapes=deform_inputs2[1],
+ level_start_index=deform_inputs2[2],
+ H=H_c,
+ W=W_c,
+ )
+ if self.extra_extractors is not None:
+ for extractor in self.extra_extractors:
+ c = extractor(
+ query=c,
+ reference_points=deform_inputs2[0],
+ feat=x,
+ spatial_shapes=deform_inputs2[1],
+ level_start_index=deform_inputs2[2],
+ H=H_c,
+ W=W_c,
+ )
+ return x, c
+
+
+class InteractionBlockWithCls(nn.Module):
+ def __init__(
+ self,
+ dim,
+ num_heads=6,
+ n_points=4,
+ norm_layer=partial(nn.LayerNorm, eps=1e-6),
+ drop=0.0,
+ drop_path=0.0,
+ with_cffn=True,
+ cffn_ratio=0.25,
+ init_values=0.0,
+ deform_ratio=1.0,
+ extra_extractor=False,
+ with_cp=False,
+ ):
+ super().__init__()
+
+ self.injector = Injector(
+ dim=dim,
+ n_levels=3,
+ num_heads=num_heads,
+ init_values=init_values,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ deform_ratio=deform_ratio,
+ with_cp=with_cp,
+ )
+ self.extractor = Extractor(
+ dim=dim,
+ n_levels=1,
+ num_heads=num_heads,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ deform_ratio=deform_ratio,
+ with_cffn=with_cffn,
+ cffn_ratio=cffn_ratio,
+ drop=drop,
+ drop_path=drop_path,
+ with_cp=with_cp,
+ )
+ if extra_extractor:
+ self.extra_extractors = nn.Sequential(
+ *[
+ Extractor(
+ dim=dim,
+ num_heads=num_heads,
+ n_points=n_points,
+ norm_layer=norm_layer,
+ with_cffn=with_cffn,
+ cffn_ratio=cffn_ratio,
+ deform_ratio=deform_ratio,
+ drop=drop,
+ drop_path=drop_path,
+ with_cp=with_cp,
+ )
+ for _ in range(2)
+ ]
+ )
+ else:
+ self.extra_extractors = None
+
+ def forward(self, x, c, cls, blocks, deform_inputs1, deform_inputs2, H_c, W_c, H_toks, W_toks):
+ x = self.injector(
+ query=x,
+ reference_points=deform_inputs1[0],
+ feat=c,
+ spatial_shapes=deform_inputs1[1],
+ level_start_index=deform_inputs1[2],
+ )
+ x = torch.cat((cls, x), dim=1)
+ for idx, blk in enumerate(blocks):
+ x = blk(x, H_toks, W_toks)
+ cls, x = (
+ x[
+ :,
+ :1,
+ ],
+ x[
+ :,
+ 1:,
+ ],
+ )
+ c = self.extractor(
+ query=c,
+ reference_points=deform_inputs2[0],
+ feat=x,
+ spatial_shapes=deform_inputs2[1],
+ level_start_index=deform_inputs2[2],
+ H=H_c,
+ W=W_c,
+ )
+ if self.extra_extractors is not None:
+ for extractor in self.extra_extractors:
+ c = extractor(
+ query=c,
+ reference_points=deform_inputs2[0],
+ feat=x,
+ spatial_shapes=deform_inputs2[1],
+ level_start_index=deform_inputs2[2],
+ H=H_c,
+ W=W_c,
+ )
+ return x, c, cls
+
+
+class SpatialPriorModule(nn.Module):
+ def __init__(self, inplanes=64, embed_dim=384, with_cp=False):
+ super().__init__()
+ self.with_cp = with_cp
+
+ self.stem = nn.Sequential(
+ *[
+ nn.Conv2d(3, inplanes, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.SyncBatchNorm(inplanes),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.SyncBatchNorm(inplanes),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(inplanes, inplanes, kernel_size=3, stride=1, padding=1, bias=False),
+ nn.SyncBatchNorm(inplanes),
+ nn.ReLU(inplace=True),
+ nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
+ ]
+ )
+ self.conv2 = nn.Sequential(
+ *[
+ nn.Conv2d(inplanes, 2 * inplanes, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.SyncBatchNorm(2 * inplanes),
+ nn.ReLU(inplace=True),
+ ]
+ )
+ self.conv3 = nn.Sequential(
+ *[
+ nn.Conv2d(2 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.SyncBatchNorm(4 * inplanes),
+ nn.ReLU(inplace=True),
+ ]
+ )
+ self.conv4 = nn.Sequential(
+ *[
+ nn.Conv2d(4 * inplanes, 4 * inplanes, kernel_size=3, stride=2, padding=1, bias=False),
+ nn.SyncBatchNorm(4 * inplanes),
+ nn.ReLU(inplace=True),
+ ]
+ )
+ self.fc1 = nn.Conv2d(inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True)
+ self.fc2 = nn.Conv2d(2 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True)
+ self.fc3 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True)
+ self.fc4 = nn.Conv2d(4 * inplanes, embed_dim, kernel_size=1, stride=1, padding=0, bias=True)
+
+ def forward(self, x):
+ def _inner_forward(x):
+ c1 = self.stem(x)
+ c2 = self.conv2(c1)
+ c3 = self.conv3(c2)
+ c4 = self.conv4(c3)
+ c1 = self.fc1(c1)
+ c2 = self.fc2(c2)
+ c3 = self.fc3(c3)
+ c4 = self.fc4(c4)
+
+ bs, dim, _, _ = c1.shape
+ # c1 = c1.view(bs, dim, -1).transpose(1, 2) # 4s
+ c2 = c2.view(bs, dim, -1).transpose(1, 2) # 8s
+ c3 = c3.view(bs, dim, -1).transpose(1, 2) # 16s
+ c4 = c4.view(bs, dim, -1).transpose(1, 2) # 32s
+
+ return c1, c2, c3, c4
+
+ if self.with_cp and x.requires_grad:
+ outs = cp.checkpoint(_inner_forward, x)
+ else:
+ outs = _inner_forward(x)
+ return outs
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py
new file mode 100644
index 0000000..864eb87
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/drop_path.py
@@ -0,0 +1,32 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py
+
+from torch import nn
+
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+ if drop_prob == 0.0 or not training:
+ return x
+ keep_prob = 1 - drop_prob
+ shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets
+ random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+ if keep_prob > 0.0:
+ random_tensor.div_(keep_prob)
+ return x * random_tensor
+
+
+class DropPath(nn.Module):
+ """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+ def __init__(self, drop_prob: float = 0.0):
+ super(DropPath, self).__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, x):
+ return drop_path(x, self.drop_prob, self.training)
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit.py
new file mode 100644
index 0000000..8a14757
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit.py
@@ -0,0 +1,552 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+"""Vision Transformer (ViT) in PyTorch.
+
+A PyTorch implement of Vision Transformers as described in:
+
+'An Image Is Worth 16 x 16 Words: Transformers for Image Recognition at Scale'
+ - https://arxiv.org/abs/2010.11929
+
+`How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers`
+ - https://arxiv.org/abs/2106.10270
+
+The official jax code is released and available at https://github.com/google-research/vision_transformer
+
+DeiT model defs and weights from https://github.com/facebookresearch/deit,
+paper `DeiT: Data-efficient Image Transformers` - https://arxiv.org/abs/2012.12877
+
+Acknowledgments:
+* The paper authors for releasing code and weights, thanks!
+* I fixed my class token impl based on Phil Wang's https://github.com/lucidrains/vit-pytorch ... check it out
+for some einops/einsum fun
+* Simple transformer style inspired by Andrej Karpathy's https://github.com/karpathy/minGPT
+* Bert reference code checks against Huggingface Transformers and Tensorflow Bert
+
+Hacked together by / Copyright 2021 Ross Wightman
+"""
+import logging
+import math
+from functools import partial
+from itertools import repeat
+from typing import Callable, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.runner import BaseModule, load_checkpoint
+from mmseg.ops import resize
+from mmseg.utils import get_root_logger
+from torch import Tensor
+
+from .drop_path import DropPath
+
+
+def to_2tuple(x):
+ return tuple(repeat(x, 2))
+
+
+class Mlp(nn.Module):
+ def __init__(
+ self,
+ in_features: int,
+ hidden_features: Optional[int] = None,
+ out_features: Optional[int] = None,
+ act_layer: Callable[..., nn.Module] = nn.GELU,
+ drop: float = 0.0,
+ bias: bool = True,
+ ) -> None:
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+ self.act = act_layer()
+ self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+ self.drop = nn.Dropout(drop)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.fc1(x)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
+
+
+class SwiGLUFFN(nn.Module):
+ def __init__(
+ self,
+ in_features: int,
+ hidden_features: Optional[int] = None,
+ out_features: Optional[int] = None,
+ act_layer: Callable[..., nn.Module] = None,
+ drop: float = 0.0,
+ ) -> None:
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ swiglu_hidden_features = int(2 * hidden_features / 3)
+ align_as = 8
+ swiglu_hidden_features = (swiglu_hidden_features + align_as - 1) // align_as * align_as
+ self.w1 = nn.Linear(in_features, swiglu_hidden_features)
+ self.w2 = nn.Linear(in_features, swiglu_hidden_features)
+ self.w3 = nn.Linear(swiglu_hidden_features, out_features)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x1 = self.w1(x)
+ x2 = self.w2(x)
+ hidden = F.silu(x1) * x2
+ return self.w3(hidden)
+
+
+class PatchEmbed(nn.Module):
+ """2D Image to Patch Embedding."""
+
+ def __init__(
+ self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, norm_layer=None, flatten=True, bias=True
+ ):
+ super().__init__()
+ img_size = to_2tuple(img_size)
+ patch_size = to_2tuple(patch_size)
+ self.img_size = img_size
+ self.patch_size = patch_size
+ self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1])
+ self.num_patches = self.grid_size[0] * self.grid_size[1]
+ self.flatten = flatten
+
+ self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias)
+ self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+ def forward(self, x):
+ x = self.proj(x)
+ _, _, H, W = x.shape
+ if self.flatten:
+ x = x.flatten(2).transpose(1, 2) # BCHW -> BNC
+ x = self.norm(x)
+ return x, H, W
+
+
+class Attention(nn.Module):
+ def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0):
+ super().__init__()
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = head_dim**-0.5
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop)
+
+ def forward(self, x, H, W):
+ B, N, C = x.shape
+ qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+ q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple)
+
+ attn = (q @ k.transpose(-2, -1)) * self.scale
+ attn = attn.softmax(dim=-1)
+ attn = self.attn_drop(attn)
+
+ x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
+
+
+class MemEffAttention(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ num_heads: int = 8,
+ qkv_bias: bool = False,
+ attn_drop: float = 0.0,
+ proj_drop: float = 0.0,
+ ) -> None:
+ super().__init__()
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = head_dim**-0.5
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop)
+
+ def forward(self, x: Tensor, H, W) -> Tensor:
+ from xformers.ops import memory_efficient_attention, unbind
+
+ B, N, C = x.shape
+ qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+ q, k, v = unbind(qkv, 2)
+
+ x = memory_efficient_attention(q, k, v)
+ x = x.reshape([B, N, C])
+
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
+
+
+def window_partition(x, window_size):
+ """
+ Args:
+ x: (B, H, W, C)
+ window_size (int): window size
+ Returns:
+ windows: (num_windows*B, window_size, window_size, C)
+ """
+ B, H, W, C = x.shape
+ x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+ windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+ return windows
+
+
+def window_reverse(windows, window_size, H, W):
+ """
+ Args:
+ windows: (num_windows*B, window_size, window_size, C)
+ window_size (int): Window size
+ H (int): Height of image
+ W (int): Width of image
+ Returns:
+ x: (B, H, W, C)
+ """
+ B = int(windows.shape[0] / (H * W / window_size / window_size))
+ x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+ x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+ return x
+
+
+class WindowedAttention(nn.Module):
+ def __init__(
+ self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0, window_size=14, pad_mode="constant"
+ ):
+ super().__init__()
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = head_dim**-0.5
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim)
+ self.proj_drop = nn.Dropout(proj_drop)
+ self.window_size = window_size
+ self.pad_mode = pad_mode
+
+ def forward(self, x, H, W):
+ B, N, C = x.shape
+ N_ = self.window_size * self.window_size
+ H_ = math.ceil(H / self.window_size) * self.window_size
+ W_ = math.ceil(W / self.window_size) * self.window_size
+
+ qkv = self.qkv(x) # [B, N, C]
+ qkv = qkv.transpose(1, 2).reshape(B, C * 3, H, W) # [B, C, H, W]
+ qkv = F.pad(qkv, [0, W_ - W, 0, H_ - H], mode=self.pad_mode)
+
+ qkv = F.unfold(
+ qkv, kernel_size=(self.window_size, self.window_size), stride=(self.window_size, self.window_size)
+ )
+ B, C_kw_kw, L = qkv.shape # L - the num of windows
+ qkv = qkv.reshape(B, C * 3, N_, L).permute(0, 3, 2, 1) # [B, L, N_, C]
+ qkv = qkv.reshape(B, L, N_, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5)
+ q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple)
+
+ # q,k,v [B, L, num_head, N_, C/num_head]
+ attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_]
+ # if self.mask:
+ # attn = attn * mask
+ attn = attn.softmax(dim=-1)
+ attn = self.attn_drop(attn) # [B, L, num_head, N_, N_]
+ # attn @ v = [B, L, num_head, N_, C/num_head]
+ x = (attn @ v).permute(0, 2, 4, 3, 1).reshape(B, C_kw_kw // 3, L)
+
+ x = F.fold(
+ x,
+ output_size=(H_, W_),
+ kernel_size=(self.window_size, self.window_size),
+ stride=(self.window_size, self.window_size),
+ ) # [B, C, H_, W_]
+ x = x[:, :, :H, :W].reshape(B, C, N).transpose(-1, -2)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
+
+
+# class WindowedAttention(nn.Module):
+# def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0., window_size=14, pad_mode="constant"):
+# super().__init__()
+# self.num_heads = num_heads
+# head_dim = dim // num_heads
+# self.scale = head_dim ** -0.5
+#
+# self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+# self.attn_drop = nn.Dropout(attn_drop)
+# self.proj = nn.Linear(dim, dim)
+# self.proj_drop = nn.Dropout(proj_drop)
+# self.window_size = window_size
+# self.pad_mode = pad_mode
+#
+# def forward(self, x, H, W):
+# B, N, C = x.shape
+#
+# N_ = self.window_size * self.window_size
+# H_ = math.ceil(H / self.window_size) * self.window_size
+# W_ = math.ceil(W / self.window_size) * self.window_size
+# x = x.view(B, H, W, C)
+# x = F.pad(x, [0, 0, 0, W_ - W, 0, H_- H], mode=self.pad_mode)
+#
+# x = window_partition(x, window_size=self.window_size)# nW*B, window_size, window_size, C
+# x = x.view(-1, N_, C)
+#
+# qkv = self.qkv(x).view(-1, N_, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+# q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple)
+# attn = (q @ k.transpose(-2, -1)) * self.scale # [B, L, num_head, N_, N_]
+# attn = attn.softmax(dim=-1)
+# attn = self.attn_drop(attn) # [B, L, num_head, N_, N_]
+# x = (attn @ v).transpose(1, 2).reshape(-1, self.window_size, self.window_size, C)
+#
+# x = window_reverse(x, self.window_size, H_, W_)
+# x = x[:, :H, :W, :].reshape(B, N, C).contiguous()
+# x = self.proj(x)
+# x = self.proj_drop(x)
+# return x
+
+
+class Block(nn.Module):
+ def __init__(
+ self,
+ dim,
+ num_heads,
+ mlp_ratio=4.0,
+ qkv_bias=False,
+ drop=0.0,
+ attn_drop=0.0,
+ drop_path=0.0,
+ act_layer=nn.GELU,
+ norm_layer=nn.LayerNorm,
+ windowed=False,
+ window_size=14,
+ pad_mode="constant",
+ layer_scale=False,
+ with_cp=False,
+ ffn_layer=Mlp,
+ memeff=False,
+ ):
+ super().__init__()
+ self.with_cp = with_cp
+ self.norm1 = norm_layer(dim)
+ if windowed:
+ self.attn = WindowedAttention(
+ dim,
+ num_heads=num_heads,
+ qkv_bias=qkv_bias,
+ attn_drop=attn_drop,
+ proj_drop=drop,
+ window_size=window_size,
+ pad_mode=pad_mode,
+ )
+ elif memeff:
+ self.attn = MemEffAttention(
+ dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop
+ )
+ else:
+ self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop)
+ # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
+ self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+ self.norm2 = norm_layer(dim)
+ mlp_hidden_dim = int(dim * mlp_ratio)
+ self.mlp = ffn_layer(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+ self.layer_scale = layer_scale
+ if layer_scale:
+ self.gamma1 = nn.Parameter(torch.ones((dim)), requires_grad=True)
+ self.gamma2 = nn.Parameter(torch.ones((dim)), requires_grad=True)
+
+ def forward(self, x, H, W):
+ def _inner_forward(x):
+ if self.layer_scale:
+ x = x + self.drop_path(self.gamma1 * self.attn(self.norm1(x), H, W))
+ x = x + self.drop_path(self.gamma2 * self.mlp(self.norm2(x)))
+ else:
+ x = x + self.drop_path(self.attn(self.norm1(x), H, W))
+ x = x + self.drop_path(self.mlp(self.norm2(x)))
+ return x
+
+ if self.with_cp and x.requires_grad:
+ x = cp.checkpoint(_inner_forward, x)
+ else:
+ x = _inner_forward(x)
+
+ return x
+
+
+class TIMMVisionTransformer(BaseModule):
+ """Vision Transformer.
+
+ A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
+ - https://arxiv.org/abs/2010.11929
+
+ Includes distillation token & head support for `DeiT: Data-efficient Image Transformers`
+ - https://arxiv.org/abs/2012.12877
+ """
+
+ def __init__(
+ self,
+ img_size=224,
+ patch_size=16,
+ in_chans=3,
+ num_classes=1000,
+ embed_dim=768,
+ depth=12,
+ num_heads=12,
+ mlp_ratio=4.0,
+ qkv_bias=True,
+ drop_rate=0.0,
+ attn_drop_rate=0.0,
+ drop_path_rate=0.0,
+ layer_scale=True,
+ embed_layer=PatchEmbed,
+ norm_layer=partial(nn.LayerNorm, eps=1e-6),
+ act_layer=nn.GELU,
+ window_attn=False,
+ window_size=14,
+ pretrained=None,
+ with_cp=False,
+ pre_norm=False,
+ ffn_type="mlp",
+ memeff=False,
+ ):
+ """
+ Args:
+ img_size (int, tuple): input image size
+ patch_size (int, tuple): patch size
+ in_chans (int): number of input channels
+ num_classes (int): number of classes for classification head
+ embed_dim (int): embedding dimension
+ depth (int): depth of transformer
+ num_heads (int): number of attention heads
+ mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+ qkv_bias (bool): enable bias for qkv if True
+ drop_rate (float): dropout rate
+ attn_drop_rate (float): attention dropout rate
+ drop_path_rate (float): stochastic depth rate
+ embed_layer (nn.Module): patch embedding layer
+ norm_layer: (nn.Module): normalization layer
+ pretrained: (str): pretrained path
+ """
+ super().__init__()
+ self.num_classes = num_classes
+ self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
+ self.num_tokens = 1
+ norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
+ act_layer = act_layer or nn.GELU
+ self.norm_layer = norm_layer
+ self.act_layer = act_layer
+ self.pretrain_size = img_size
+ self.drop_path_rate = drop_path_rate
+ self.drop_rate = drop_rate
+ self.patch_size = patch_size
+
+ window_attn = [window_attn] * depth if not isinstance(window_attn, list) else window_attn
+ window_size = [window_size] * depth if not isinstance(window_size, list) else window_size
+ logging.info("window attention:", window_attn)
+ logging.info("window size:", window_size)
+ logging.info("layer scale:", layer_scale)
+
+ self.patch_embed = embed_layer(
+ img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, bias=not pre_norm
+ )
+ num_patches = self.patch_embed.num_patches
+
+ self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+ self.pos_drop = nn.Dropout(p=drop_rate)
+
+ ffn_types = {"mlp": Mlp, "swiglu": SwiGLUFFN}
+
+ dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule
+ self.blocks = nn.Sequential(
+ *[
+ Block(
+ dim=embed_dim,
+ num_heads=num_heads,
+ mlp_ratio=mlp_ratio,
+ qkv_bias=qkv_bias,
+ drop=drop_rate,
+ attn_drop=attn_drop_rate,
+ drop_path=dpr[i],
+ norm_layer=norm_layer,
+ act_layer=act_layer,
+ windowed=window_attn[i],
+ window_size=window_size[i],
+ layer_scale=layer_scale,
+ with_cp=with_cp,
+ ffn_layer=ffn_types[ffn_type],
+ memeff=memeff,
+ )
+ for i in range(depth)
+ ]
+ )
+
+ # self.norm = norm_layer(embed_dim)
+ self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+ # For CLIP
+ if pre_norm:
+ norm_pre = norm_layer(embed_dim)
+ self.norm_pre = norm_pre
+ else:
+ self.norm_pre = nn.Identity()
+ self.init_weights(pretrained)
+
+ def init_weights(self, pretrained=None):
+ if isinstance(pretrained, str):
+ logger = get_root_logger()
+ load_checkpoint(self, pretrained, map_location="cpu", strict=False, logger=logger)
+
+ def forward_features(self, x):
+ x, H, W = self.patch_embed(x)
+ cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks
+ x = torch.cat((cls_token, x), dim=1)
+ x = self.pos_drop(x + self.pos_embed)
+
+ # For CLIP
+ x = self.norm_pre(x)
+
+ for blk in self.blocks:
+ x = blk(x, H, W)
+ x = self.norm(x)
+ return x
+
+ def forward(self, x):
+ x = self.forward_features(x)
+ return x
+
+ @staticmethod
+ def resize_pos_embed(pos_embed, input_shpae, pos_shape, mode):
+ """Resize pos_embed weights.
+
+ Resize pos_embed using bicubic interpolate method.
+ Args:
+ pos_embed (torch.Tensor): Position embedding weights.
+ input_shpae (tuple): Tuple for (downsampled input image height,
+ downsampled input image width).
+ pos_shape (tuple): The resolution of downsampled origin training
+ image.
+ mode (str): Algorithm used for upsampling:
+ ``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
+ ``'trilinear'``. Default: ``'nearest'``
+ Return:
+ torch.Tensor: The resized pos_embed of shape [B, L_new, C]
+ """
+ assert pos_embed.ndim == 3, "shape of pos_embed must be [B, L, C]"
+ pos_h, pos_w = pos_shape
+ # keep dim for easy deployment
+ cls_token_weight = pos_embed[:, 0:1]
+ pos_embed_weight = pos_embed[:, (-1 * pos_h * pos_w) :]
+ pos_embed_weight = pos_embed_weight.reshape(1, pos_h, pos_w, pos_embed.shape[2]).permute(0, 3, 1, 2)
+ pos_embed_weight = resize(pos_embed_weight, size=input_shpae, align_corners=False, mode=mode)
+ pos_embed_weight = torch.flatten(pos_embed_weight, 2).transpose(1, 2)
+ pos_embed = torch.cat((cls_token_weight, pos_embed_weight), dim=1)
+ return pos_embed
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py
new file mode 100644
index 0000000..ebc4f0f
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/backbones/vit_adapter.py
@@ -0,0 +1,217 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmseg.models.builder import BACKBONES
+from torch.nn.init import normal_
+
+from ...ops.modules import MSDeformAttn
+from .adapter_modules import InteractionBlock, InteractionBlockWithCls, SpatialPriorModule, deform_inputs
+from .vit import TIMMVisionTransformer
+
+
+@BACKBONES.register_module()
+class ViTAdapter(TIMMVisionTransformer):
+ def __init__(
+ self,
+ pretrain_size=224,
+ num_heads=12,
+ conv_inplane=64,
+ n_points=4,
+ deform_num_heads=6,
+ init_values=0.0,
+ interaction_indexes=None,
+ with_cffn=True,
+ cffn_ratio=0.25,
+ deform_ratio=1.0,
+ add_vit_feature=True,
+ pretrained=None,
+ use_extra_extractor=True,
+ freeze_vit=False,
+ use_cls=True,
+ with_cp=False,
+ *args,
+ **kwargs
+ ):
+
+ super().__init__(num_heads=num_heads, pretrained=pretrained, with_cp=with_cp, *args, **kwargs)
+ if freeze_vit:
+ for param in self.parameters():
+ param.requires_grad = False
+
+ # self.num_classes = 80
+ self.use_cls = use_cls
+ if not self.use_cls:
+ self.cls_token = None
+ self.num_block = len(self.blocks)
+ self.pretrain_size = (pretrain_size, pretrain_size)
+ self.interaction_indexes = interaction_indexes
+ self.add_vit_feature = add_vit_feature
+ embed_dim = self.embed_dim
+
+ block_fn = InteractionBlockWithCls if use_cls else InteractionBlock
+
+ self.level_embed = nn.Parameter(torch.zeros(3, embed_dim))
+ self.spm = SpatialPriorModule(inplanes=conv_inplane, embed_dim=embed_dim, with_cp=False)
+ self.interactions = nn.Sequential(
+ *[
+ block_fn(
+ dim=embed_dim,
+ num_heads=deform_num_heads,
+ n_points=n_points,
+ init_values=init_values,
+ drop_path=self.drop_path_rate,
+ norm_layer=self.norm_layer,
+ with_cffn=with_cffn,
+ cffn_ratio=cffn_ratio,
+ deform_ratio=deform_ratio,
+ extra_extractor=((True if i == len(interaction_indexes) - 1 else False) and use_extra_extractor),
+ with_cp=with_cp,
+ )
+ for i in range(len(interaction_indexes))
+ ]
+ )
+ self.up = nn.ConvTranspose2d(embed_dim, embed_dim, 2, 2)
+ self.norm1 = nn.SyncBatchNorm(embed_dim)
+ self.norm2 = nn.SyncBatchNorm(embed_dim)
+ self.norm3 = nn.SyncBatchNorm(embed_dim)
+ self.norm4 = nn.SyncBatchNorm(embed_dim)
+
+ self.up.apply(self._init_weights)
+ self.spm.apply(self._init_weights)
+ self.interactions.apply(self._init_weights)
+ self.apply(self._init_deform_weights)
+ normal_(self.level_embed)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ torch.nn.init.trunc_normal_(m.weight, std=0.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.LayerNorm) or isinstance(m, nn.BatchNorm2d):
+ nn.init.constant_(m.bias, 0)
+ nn.init.constant_(m.weight, 1.0)
+ elif isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ fan_out //= m.groups
+ m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+ if m.bias is not None:
+ m.bias.data.zero_()
+
+ def _get_pos_embed(self, pos_embed, H, W):
+ pos_embed = pos_embed.reshape(
+ 1, self.pretrain_size[0] // self.patch_size, self.pretrain_size[1] // self.patch_size, -1
+ ).permute(0, 3, 1, 2)
+ pos_embed = (
+ F.interpolate(pos_embed, size=(H, W), mode="bicubic", align_corners=False)
+ .reshape(1, -1, H * W)
+ .permute(0, 2, 1)
+ )
+ return pos_embed
+
+ def _init_deform_weights(self, m):
+ if isinstance(m, MSDeformAttn):
+ m._reset_parameters()
+
+ def _add_level_embed(self, c2, c3, c4):
+ c2 = c2 + self.level_embed[0]
+ c3 = c3 + self.level_embed[1]
+ c4 = c4 + self.level_embed[2]
+ return c2, c3, c4
+
+ def forward(self, x):
+ deform_inputs1, deform_inputs2 = deform_inputs(x, self.patch_size)
+
+ # SPM forward
+ c1, c2, c3, c4 = self.spm(x)
+ c2, c3, c4 = self._add_level_embed(c2, c3, c4)
+ c = torch.cat([c2, c3, c4], dim=1)
+
+ # Patch Embedding forward
+ H_c, W_c = x.shape[2] // 16, x.shape[3] // 16
+ x, H_toks, W_toks = self.patch_embed(x)
+ # print("H_toks, W_toks =", H_toks, W_toks)
+ bs, n, dim = x.shape
+ pos_embed = self._get_pos_embed(self.pos_embed[:, 1:], H_toks, W_toks)
+ if self.use_cls:
+ cls_token = self.cls_token.expand(x.shape[0], -1, -1) # stole cls_tokens impl from Phil Wang, thanks
+ x = torch.cat((cls_token, x), dim=1)
+ pos_embed = torch.cat((self.pos_embed[:, :1], pos_embed), dim=1)
+ x = self.pos_drop(x + pos_embed)
+ # For CLIP
+ x = self.norm_pre(x)
+
+ # Interaction
+ if self.use_cls:
+ cls, x = (
+ x[
+ :,
+ :1,
+ ],
+ x[
+ :,
+ 1:,
+ ],
+ )
+ outs = list()
+ for i, layer in enumerate(self.interactions):
+ indexes = self.interaction_indexes[i]
+ if self.use_cls:
+ x, c, cls = layer(
+ x,
+ c,
+ cls,
+ self.blocks[indexes[0] : indexes[-1] + 1],
+ deform_inputs1,
+ deform_inputs2,
+ H_c,
+ W_c,
+ H_toks,
+ W_toks,
+ )
+ else:
+ x, c = layer(
+ x,
+ c,
+ self.blocks[indexes[0] : indexes[-1] + 1],
+ deform_inputs1,
+ deform_inputs2,
+ H_c,
+ W_c,
+ H_toks,
+ W_toks,
+ )
+ outs.append(x.transpose(1, 2).view(bs, dim, H_toks, W_toks).contiguous())
+
+ # Split & Reshape
+ c2 = c[:, 0 : c2.size(1), :]
+ c3 = c[:, c2.size(1) : c2.size(1) + c3.size(1), :]
+ c4 = c[:, c2.size(1) + c3.size(1) :, :]
+
+ c2 = c2.transpose(1, 2).view(bs, dim, H_c * 2, W_c * 2).contiguous()
+ c3 = c3.transpose(1, 2).view(bs, dim, H_c, W_c).contiguous()
+ c4 = c4.transpose(1, 2).view(bs, dim, H_c // 2, W_c // 2).contiguous()
+ c1 = self.up(c2) + c1
+
+ if self.add_vit_feature:
+ x1, x2, x3, x4 = outs
+
+ x1 = F.interpolate(x1, size=(4 * H_c, 4 * W_c), mode="bilinear", align_corners=False)
+ x2 = F.interpolate(x2, size=(2 * H_c, 2 * W_c), mode="bilinear", align_corners=False)
+ x3 = F.interpolate(x3, size=(1 * H_c, 1 * W_c), mode="bilinear", align_corners=False)
+ x4 = F.interpolate(x4, size=(H_c // 2, W_c // 2), mode="bilinear", align_corners=False)
+ # print(c1.shape, c2.shape, c3.shape, c4.shape, x1.shape, x2.shape, x3.shape, x4.shape, H_c, H_toks)
+ c1, c2, c3, c4 = c1 + x1, c2 + x2, c3 + x3, c4 + x4
+
+ # Final Norm
+ f1 = self.norm1(c1)
+ f2 = self.norm2(c2)
+ f3 = self.norm3(c3)
+ f4 = self.norm4(c4)
+ return [f1, f2, f3, f4]
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/builder.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/builder.py
new file mode 100644
index 0000000..d7cf7b9
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/builder.py
@@ -0,0 +1,25 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from mmcv.utils import Registry
+
+TRANSFORMER = Registry("Transformer")
+MASK_ASSIGNERS = Registry("mask_assigner")
+MATCH_COST = Registry("match_cost")
+
+
+def build_match_cost(cfg):
+ """Build Match Cost."""
+ return MATCH_COST.build(cfg)
+
+
+def build_assigner(cfg):
+ """Build Assigner."""
+ return MASK_ASSIGNERS.build(cfg)
+
+
+def build_transformer(cfg):
+ """Build Transformer."""
+ return TRANSFORMER.build(cfg)
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py
new file mode 100644
index 0000000..01f08b8
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .mask2former_head import Mask2FormerHead
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py
new file mode 100644
index 0000000..d1705fc
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/decode_heads/mask2former_head.py
@@ -0,0 +1,544 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import copy
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init
+from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence
+from mmcv.ops import point_sample
+from mmcv.runner import ModuleList, force_fp32
+from mmseg.models.builder import HEADS, build_loss
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+
+from ...core import build_sampler, multi_apply, reduce_mean
+from ..builder import build_assigner
+from ..utils import get_uncertain_point_coords_with_randomness
+
+
+@HEADS.register_module()
+class Mask2FormerHead(BaseDecodeHead):
+ """Implements the Mask2Former head.
+
+ See `Masked-attention Mask Transformer for Universal Image
+ Segmentation `_ for details.
+
+ Args:
+ in_channels (list[int]): Number of channels in the input feature map.
+ feat_channels (int): Number of channels for features.
+ out_channels (int): Number of channels for output.
+ num_things_classes (int): Number of things.
+ num_stuff_classes (int): Number of stuff.
+ num_queries (int): Number of query in Transformer decoder.
+ pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel
+ decoder. Defaults to None.
+ enforce_decoder_input_project (bool, optional): Whether to add
+ a layer to change the embed_dim of tranformer encoder in
+ pixel decoder to the embed_dim of transformer decoder.
+ Defaults to False.
+ transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for
+ transformer decoder. Defaults to None.
+ positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for
+ transformer decoder position encoding. Defaults to None.
+ loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification
+ loss. Defaults to None.
+ loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss.
+ Defaults to None.
+ loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss.
+ Defaults to None.
+ train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of
+ Mask2Former head.
+ test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of
+ Mask2Former head.
+ init_cfg (dict or list[dict], optional): Initialization config dict.
+ Defaults to None.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ feat_channels,
+ out_channels,
+ num_things_classes=80,
+ num_stuff_classes=53,
+ num_queries=100,
+ num_transformer_feat_level=3,
+ pixel_decoder=None,
+ enforce_decoder_input_project=False,
+ transformer_decoder=None,
+ positional_encoding=None,
+ loss_cls=None,
+ loss_mask=None,
+ loss_dice=None,
+ train_cfg=None,
+ test_cfg=None,
+ init_cfg=None,
+ **kwargs,
+ ):
+ super(Mask2FormerHead, self).__init__(
+ in_channels=in_channels,
+ channels=feat_channels,
+ num_classes=(num_things_classes + num_stuff_classes),
+ init_cfg=init_cfg,
+ input_transform="multiple_select",
+ **kwargs,
+ )
+ self.num_things_classes = num_things_classes
+ self.num_stuff_classes = num_stuff_classes
+ self.num_classes = self.num_things_classes + self.num_stuff_classes
+ self.num_queries = num_queries
+ self.num_transformer_feat_level = num_transformer_feat_level
+ self.num_heads = transformer_decoder.transformerlayers.attn_cfgs.num_heads
+ self.num_transformer_decoder_layers = transformer_decoder.num_layers
+ assert pixel_decoder.encoder.transformerlayers.attn_cfgs.num_levels == num_transformer_feat_level
+ pixel_decoder_ = copy.deepcopy(pixel_decoder)
+ pixel_decoder_.update(in_channels=in_channels, feat_channels=feat_channels, out_channels=out_channels)
+ self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1]
+ self.transformer_decoder = build_transformer_layer_sequence(transformer_decoder)
+ self.decoder_embed_dims = self.transformer_decoder.embed_dims
+
+ self.decoder_input_projs = ModuleList()
+ # from low resolution to high resolution
+ for _ in range(num_transformer_feat_level):
+ if self.decoder_embed_dims != feat_channels or enforce_decoder_input_project:
+ self.decoder_input_projs.append(Conv2d(feat_channels, self.decoder_embed_dims, kernel_size=1))
+ else:
+ self.decoder_input_projs.append(nn.Identity())
+ self.decoder_positional_encoding = build_positional_encoding(positional_encoding)
+ self.query_embed = nn.Embedding(self.num_queries, feat_channels)
+ self.query_feat = nn.Embedding(self.num_queries, feat_channels)
+ # from low resolution to high resolution
+ self.level_embed = nn.Embedding(self.num_transformer_feat_level, feat_channels)
+
+ self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1)
+ self.mask_embed = nn.Sequential(
+ nn.Linear(feat_channels, feat_channels),
+ nn.ReLU(inplace=True),
+ nn.Linear(feat_channels, feat_channels),
+ nn.ReLU(inplace=True),
+ nn.Linear(feat_channels, out_channels),
+ )
+ self.conv_seg = None # fix a bug here (conv_seg is not used)
+
+ self.test_cfg = test_cfg
+ self.train_cfg = train_cfg
+ if train_cfg:
+ self.assigner = build_assigner(self.train_cfg.assigner)
+ self.sampler = build_sampler(self.train_cfg.sampler, context=self)
+ self.num_points = self.train_cfg.get("num_points", 12544)
+ self.oversample_ratio = self.train_cfg.get("oversample_ratio", 3.0)
+ self.importance_sample_ratio = self.train_cfg.get("importance_sample_ratio", 0.75)
+
+ self.class_weight = loss_cls.class_weight
+ self.loss_cls = build_loss(loss_cls)
+ self.loss_mask = build_loss(loss_mask)
+ self.loss_dice = build_loss(loss_dice)
+
+ def init_weights(self):
+ for m in self.decoder_input_projs:
+ if isinstance(m, Conv2d):
+ caffe2_xavier_init(m, bias=0)
+
+ self.pixel_decoder.init_weights()
+
+ for p in self.transformer_decoder.parameters():
+ if p.dim() > 1:
+ nn.init.xavier_normal_(p)
+
+ def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas):
+ """Compute classification and mask targets for all images for a decoder
+ layer.
+
+ Args:
+ cls_scores_list (list[Tensor]): Mask score logits from a single
+ decoder layer for all images. Each with shape [num_queries,
+ cls_out_channels].
+ mask_preds_list (list[Tensor]): Mask logits from a single decoder
+ layer for all images. Each with shape [num_queries, h, w].
+ gt_labels_list (list[Tensor]): Ground truth class indices for all
+ images. Each with shape (n, ), n is the sum of number of stuff
+ type and number of instance in a image.
+ gt_masks_list (list[Tensor]): Ground truth mask for each image,
+ each with shape (n, h, w).
+ img_metas (list[dict]): List of image meta information.
+
+ Returns:
+ tuple[list[Tensor]]: a tuple containing the following targets.
+
+ - labels_list (list[Tensor]): Labels of all images.
+ Each with shape [num_queries, ].
+ - label_weights_list (list[Tensor]): Label weights of all
+ images.Each with shape [num_queries, ].
+ - mask_targets_list (list[Tensor]): Mask targets of all images.
+ Each with shape [num_queries, h, w].
+ - mask_weights_list (list[Tensor]): Mask weights of all images.
+ Each with shape [num_queries, ].
+ - num_total_pos (int): Number of positive samples in all
+ images.
+ - num_total_neg (int): Number of negative samples in all
+ images.
+ """
+ (
+ labels_list,
+ label_weights_list,
+ mask_targets_list,
+ mask_weights_list,
+ pos_inds_list,
+ neg_inds_list,
+ ) = multi_apply(
+ self._get_target_single, cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas
+ )
+
+ num_total_pos = sum((inds.numel() for inds in pos_inds_list))
+ num_total_neg = sum((inds.numel() for inds in neg_inds_list))
+ return (labels_list, label_weights_list, mask_targets_list, mask_weights_list, num_total_pos, num_total_neg)
+
+ def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, img_metas):
+ """Compute classification and mask targets for one image.
+
+ Args:
+ cls_score (Tensor): Mask score logits from a single decoder layer
+ for one image. Shape (num_queries, cls_out_channels).
+ mask_pred (Tensor): Mask logits for a single decoder layer for one
+ image. Shape (num_queries, h, w).
+ gt_labels (Tensor): Ground truth class indices for one image with
+ shape (num_gts, ).
+ gt_masks (Tensor): Ground truth mask for each image, each with
+ shape (num_gts, h, w).
+ img_metas (dict): Image informtation.
+
+ Returns:
+ tuple[Tensor]: A tuple containing the following for one image.
+
+ - labels (Tensor): Labels of each image. \
+ shape (num_queries, ).
+ - label_weights (Tensor): Label weights of each image. \
+ shape (num_queries, ).
+ - mask_targets (Tensor): Mask targets of each image. \
+ shape (num_queries, h, w).
+ - mask_weights (Tensor): Mask weights of each image. \
+ shape (num_queries, ).
+ - pos_inds (Tensor): Sampled positive indices for each \
+ image.
+ - neg_inds (Tensor): Sampled negative indices for each \
+ image.
+ """
+ # sample points
+ num_queries = cls_score.shape[0]
+ num_gts = gt_labels.shape[0]
+
+ point_coords = torch.rand((1, self.num_points, 2), device=cls_score.device)
+ # shape (num_queries, num_points)
+ mask_points_pred = point_sample(mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, 1)).squeeze(1)
+ # shape (num_gts, num_points)
+ gt_points_masks = point_sample(gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, 1)).squeeze(1)
+
+ # assign and sample
+ assign_result = self.assigner.assign(cls_score, mask_points_pred, gt_labels, gt_points_masks, img_metas)
+ sampling_result = self.sampler.sample(assign_result, mask_pred, gt_masks)
+ pos_inds = sampling_result.pos_inds
+ neg_inds = sampling_result.neg_inds
+
+ # label target
+ labels = gt_labels.new_full((self.num_queries,), self.num_classes, dtype=torch.long)
+ labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds]
+ label_weights = gt_labels.new_ones((self.num_queries,))
+
+ # mask target
+ mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds]
+ mask_weights = mask_pred.new_zeros((self.num_queries,))
+ mask_weights[pos_inds] = 1.0
+
+ return (labels, label_weights, mask_targets, mask_weights, pos_inds, neg_inds)
+
+ def loss_single(self, cls_scores, mask_preds, gt_labels_list, gt_masks_list, img_metas):
+ """Loss function for outputs from a single decoder layer.
+
+ Args:
+ cls_scores (Tensor): Mask score logits from a single decoder layer
+ for all images. Shape (batch_size, num_queries,
+ cls_out_channels). Note `cls_out_channels` should includes
+ background.
+ mask_preds (Tensor): Mask logits for a pixel decoder for all
+ images. Shape (batch_size, num_queries, h, w).
+ gt_labels_list (list[Tensor]): Ground truth class indices for each
+ image, each with shape (num_gts, ).
+ gt_masks_list (list[Tensor]): Ground truth mask for each image,
+ each with shape (num_gts, h, w).
+ img_metas (list[dict]): List of image meta information.
+
+ Returns:
+ tuple[Tensor]: Loss components for outputs from a single \
+ decoder layer.
+ """
+ num_imgs = cls_scores.size(0)
+ cls_scores_list = [cls_scores[i] for i in range(num_imgs)]
+ mask_preds_list = [mask_preds[i] for i in range(num_imgs)]
+ (
+ labels_list,
+ label_weights_list,
+ mask_targets_list,
+ mask_weights_list,
+ num_total_pos,
+ num_total_neg,
+ ) = self.get_targets(cls_scores_list, mask_preds_list, gt_labels_list, gt_masks_list, img_metas)
+ # shape (batch_size, num_queries)
+ labels = torch.stack(labels_list, dim=0)
+ # shape (batch_size, num_queries)
+ label_weights = torch.stack(label_weights_list, dim=0)
+ # shape (num_total_gts, h, w)
+ mask_targets = torch.cat(mask_targets_list, dim=0)
+ # shape (batch_size, num_queries)
+ mask_weights = torch.stack(mask_weights_list, dim=0)
+
+ # classfication loss
+ # shape (batch_size * num_queries, )
+ cls_scores = cls_scores.flatten(0, 1)
+ labels = labels.flatten(0, 1)
+ label_weights = label_weights.flatten(0, 1)
+
+ class_weight = cls_scores.new_tensor(self.class_weight)
+ loss_cls = self.loss_cls(cls_scores, labels, label_weights, avg_factor=class_weight[labels].sum())
+
+ num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos]))
+ num_total_masks = max(num_total_masks, 1)
+
+ # extract positive ones
+ # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w)
+ mask_preds = mask_preds[mask_weights > 0]
+
+ if mask_targets.shape[0] == 0:
+ # zero match
+ loss_dice = mask_preds.sum()
+ loss_mask = mask_preds.sum()
+ return loss_cls, loss_mask, loss_dice
+
+ with torch.no_grad():
+ points_coords = get_uncertain_point_coords_with_randomness(
+ mask_preds.unsqueeze(1), None, self.num_points, self.oversample_ratio, self.importance_sample_ratio
+ )
+ # shape (num_total_gts, h, w) -> (num_total_gts, num_points)
+ mask_point_targets = point_sample(mask_targets.unsqueeze(1).float(), points_coords).squeeze(1)
+ # shape (num_queries, h, w) -> (num_queries, num_points)
+ mask_point_preds = point_sample(mask_preds.unsqueeze(1), points_coords).squeeze(1)
+
+ # dice loss
+ loss_dice = self.loss_dice(mask_point_preds, mask_point_targets, avg_factor=num_total_masks)
+
+ # mask loss
+ # shape (num_queries, num_points) -> (num_queries * num_points, )
+ mask_point_preds = mask_point_preds.reshape(-1, 1)
+ # shape (num_total_gts, num_points) -> (num_total_gts * num_points, )
+ mask_point_targets = mask_point_targets.reshape(-1)
+ loss_mask = self.loss_mask(mask_point_preds, mask_point_targets, avg_factor=num_total_masks * self.num_points)
+
+ return loss_cls, loss_mask, loss_dice
+
+ @force_fp32(apply_to=("all_cls_scores", "all_mask_preds"))
+ def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, gt_masks_list, img_metas):
+ """Loss function.
+
+ Args:
+ all_cls_scores (Tensor): Classification scores for all decoder
+ layers with shape [num_decoder, batch_size, num_queries,
+ cls_out_channels].
+ all_mask_preds (Tensor): Mask scores for all decoder layers with
+ shape [num_decoder, batch_size, num_queries, h, w].
+ gt_labels_list (list[Tensor]): Ground truth class indices for each
+ image with shape (n, ). n is the sum of number of stuff type
+ and number of instance in a image.
+ gt_masks_list (list[Tensor]): Ground truth mask for each image with
+ shape (n, h, w).
+ img_metas (list[dict]): List of image meta information.
+
+ Returns:
+ dict[str, Tensor]: A dictionary of loss components.
+ """
+ num_dec_layers = len(all_cls_scores)
+ all_gt_labels_list = [gt_labels_list for _ in range(num_dec_layers)]
+ all_gt_masks_list = [gt_masks_list for _ in range(num_dec_layers)]
+ img_metas_list = [img_metas for _ in range(num_dec_layers)]
+ losses_cls, losses_mask, losses_dice = multi_apply(
+ self.loss_single, all_cls_scores, all_mask_preds, all_gt_labels_list, all_gt_masks_list, img_metas_list
+ )
+
+ loss_dict = dict()
+ # loss from the last decoder layer
+ loss_dict["loss_cls"] = losses_cls[-1]
+ loss_dict["loss_mask"] = losses_mask[-1]
+ loss_dict["loss_dice"] = losses_dice[-1]
+ # loss from other decoder layers
+ num_dec_layer = 0
+ for loss_cls_i, loss_mask_i, loss_dice_i in zip(losses_cls[:-1], losses_mask[:-1], losses_dice[:-1]):
+ loss_dict[f"d{num_dec_layer}.loss_cls"] = loss_cls_i
+ loss_dict[f"d{num_dec_layer}.loss_mask"] = loss_mask_i
+ loss_dict[f"d{num_dec_layer}.loss_dice"] = loss_dice_i
+ num_dec_layer += 1
+ return loss_dict
+
+ def forward_head(self, decoder_out, mask_feature, attn_mask_target_size):
+ """Forward for head part which is called after every decoder layer.
+
+ Args:
+ decoder_out (Tensor): in shape (num_queries, batch_size, c).
+ mask_feature (Tensor): in shape (batch_size, c, h, w).
+ attn_mask_target_size (tuple[int, int]): target attention
+ mask size.
+
+ Returns:
+ tuple: A tuple contain three elements.
+
+ - cls_pred (Tensor): Classification scores in shape \
+ (batch_size, num_queries, cls_out_channels). \
+ Note `cls_out_channels` should includes background.
+ - mask_pred (Tensor): Mask scores in shape \
+ (batch_size, num_queries,h, w).
+ - attn_mask (Tensor): Attention mask in shape \
+ (batch_size * num_heads, num_queries, h, w).
+ """
+ decoder_out = self.transformer_decoder.post_norm(decoder_out)
+ decoder_out = decoder_out.transpose(0, 1)
+ # shape (num_queries, batch_size, c)
+ cls_pred = self.cls_embed(decoder_out)
+ # shape (num_queries, batch_size, c)
+ mask_embed = self.mask_embed(decoder_out)
+ # shape (num_queries, batch_size, h, w)
+ mask_pred = torch.einsum("bqc,bchw->bqhw", mask_embed, mask_feature)
+ attn_mask = F.interpolate(mask_pred, attn_mask_target_size, mode="bilinear", align_corners=False)
+ # shape (num_queries, batch_size, h, w) ->
+ # (batch_size * num_head, num_queries, h, w)
+ attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat((1, self.num_heads, 1, 1)).flatten(0, 1)
+ attn_mask = attn_mask.sigmoid() < 0.5
+ attn_mask = attn_mask.detach()
+
+ return cls_pred, mask_pred, attn_mask
+
+ def forward(self, feats, img_metas):
+ """Forward function.
+
+ Args:
+ feats (list[Tensor]): Multi scale Features from the
+ upstream network, each is a 4D-tensor.
+ img_metas (list[dict]): List of image information.
+
+ Returns:
+ tuple: A tuple contains two elements.
+
+ - cls_pred_list (list[Tensor)]: Classification logits \
+ for each decoder layer. Each is a 3D-tensor with shape \
+ (batch_size, num_queries, cls_out_channels). \
+ Note `cls_out_channels` should includes background.
+ - mask_pred_list (list[Tensor]): Mask logits for each \
+ decoder layer. Each with shape (batch_size, num_queries, \
+ h, w).
+ """
+ batch_size = len(img_metas)
+ mask_features, multi_scale_memorys = self.pixel_decoder(feats)
+ # multi_scale_memorys (from low resolution to high resolution)
+ decoder_inputs = []
+ decoder_positional_encodings = []
+ for i in range(self.num_transformer_feat_level):
+ decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i])
+ # shape (batch_size, c, h, w) -> (h*w, batch_size, c)
+ decoder_input = decoder_input.flatten(2).permute(2, 0, 1)
+ level_embed = self.level_embed.weight[i].view(1, 1, -1)
+ decoder_input = decoder_input + level_embed
+ # shape (batch_size, c, h, w) -> (h*w, batch_size, c)
+ mask = decoder_input.new_zeros((batch_size,) + multi_scale_memorys[i].shape[-2:], dtype=torch.bool)
+ decoder_positional_encoding = self.decoder_positional_encoding(mask)
+ decoder_positional_encoding = decoder_positional_encoding.flatten(2).permute(2, 0, 1)
+ decoder_inputs.append(decoder_input)
+ decoder_positional_encodings.append(decoder_positional_encoding)
+ # shape (num_queries, c) -> (num_queries, batch_size, c)
+ query_feat = self.query_feat.weight.unsqueeze(1).repeat((1, batch_size, 1))
+ query_embed = self.query_embed.weight.unsqueeze(1).repeat((1, batch_size, 1))
+
+ cls_pred_list = []
+ mask_pred_list = []
+ cls_pred, mask_pred, attn_mask = self.forward_head(query_feat, mask_features, multi_scale_memorys[0].shape[-2:])
+ cls_pred_list.append(cls_pred)
+ mask_pred_list.append(mask_pred)
+
+ for i in range(self.num_transformer_decoder_layers):
+ level_idx = i % self.num_transformer_feat_level
+ # if a mask is all True(all background), then set it all False.
+ attn_mask[torch.where(attn_mask.sum(-1) == attn_mask.shape[-1])] = False
+
+ # cross_attn + self_attn
+ layer = self.transformer_decoder.layers[i]
+ attn_masks = [attn_mask, None]
+ query_feat = layer(
+ query=query_feat,
+ key=decoder_inputs[level_idx],
+ value=decoder_inputs[level_idx],
+ query_pos=query_embed,
+ key_pos=decoder_positional_encodings[level_idx],
+ attn_masks=attn_masks,
+ query_key_padding_mask=None,
+ # here we do not apply masking on padded region
+ key_padding_mask=None,
+ )
+ cls_pred, mask_pred, attn_mask = self.forward_head(
+ query_feat, mask_features, multi_scale_memorys[(i + 1) % self.num_transformer_feat_level].shape[-2:]
+ )
+
+ cls_pred_list.append(cls_pred)
+ mask_pred_list.append(mask_pred)
+
+ return cls_pred_list, mask_pred_list
+
+ def forward_train(self, x, img_metas, gt_semantic_seg, gt_labels, gt_masks):
+ """Forward function for training mode.
+
+ Args:
+ x (list[Tensor]): Multi-level features from the upstream network,
+ each is a 4D-tensor.
+ img_metas (list[Dict]): List of image information.
+ gt_semantic_seg (list[tensor]):Each element is the ground truth
+ of semantic segmentation with the shape (N, H, W).
+ train_cfg (dict): The training config, which not been used in
+ maskformer.
+ gt_labels (list[Tensor]): Each element is ground truth labels of
+ each box, shape (num_gts,).
+ gt_masks (list[BitmapMasks]): Each element is masks of instances
+ of a image, shape (num_gts, h, w).
+
+ Returns:
+ losses (dict[str, Tensor]): a dictionary of loss components
+ """
+
+ # forward
+ all_cls_scores, all_mask_preds = self(x, img_metas)
+
+ # loss
+ losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, img_metas)
+
+ return losses
+
+ def forward_test(self, inputs, img_metas, test_cfg):
+ """Test segment without test-time aumengtation.
+
+ Only the output of last decoder layers was used.
+
+ Args:
+ inputs (list[Tensor]): Multi-level features from the
+ upstream network, each is a 4D-tensor.
+ img_metas (list[dict]): List of image information.
+ test_cfg (dict): Testing config.
+
+ Returns:
+ seg_mask (Tensor): Predicted semantic segmentation logits.
+ """
+ all_cls_scores, all_mask_preds = self(inputs, img_metas)
+ cls_score, mask_pred = all_cls_scores[-1], all_mask_preds[-1]
+ ori_h, ori_w, _ = img_metas[0]["ori_shape"]
+
+ # semantic inference
+ cls_score = F.softmax(cls_score, dim=-1)[..., :-1]
+ mask_pred = mask_pred.sigmoid()
+ seg_mask = torch.einsum("bqc,bqhw->bchw", cls_score, mask_pred)
+ return seg_mask
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/__init__.py
new file mode 100644
index 0000000..229a887
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .cross_entropy_loss import CrossEntropyLoss, binary_cross_entropy, cross_entropy, mask_cross_entropy
+from .dice_loss import DiceLoss
+from .match_costs import ClassificationCost, CrossEntropyLossCost, DiceCost
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py
new file mode 100644
index 0000000..0a1f9dd
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py
@@ -0,0 +1,279 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import warnings
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmseg.models.builder import LOSSES
+from mmseg.models.losses.utils import get_class_weight, weight_reduce_loss
+
+
+def cross_entropy(
+ pred,
+ label,
+ weight=None,
+ class_weight=None,
+ reduction="mean",
+ avg_factor=None,
+ ignore_index=-100,
+ avg_non_ignore=False,
+):
+ """cross_entropy. The wrapper function for :func:`F.cross_entropy`
+
+ Args:
+ pred (torch.Tensor): The prediction with shape (N, 1).
+ label (torch.Tensor): The learning label of the prediction.
+ weight (torch.Tensor, optional): Sample-wise loss weight.
+ Default: None.
+ class_weight (list[float], optional): The weight for each class.
+ Default: None.
+ reduction (str, optional): The method used to reduce the loss.
+ Options are 'none', 'mean' and 'sum'. Default: 'mean'.
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Default: None.
+ ignore_index (int): Specifies a target value that is ignored and
+ does not contribute to the input gradients. When
+ ``avg_non_ignore `` is ``True``, and the ``reduction`` is
+ ``''mean''``, the loss is averaged over non-ignored targets.
+ Defaults: -100.
+ avg_non_ignore (bool): The flag decides to whether the loss is
+ only averaged over non-ignored targets. Default: False.
+ `New in version 0.23.0.`
+ """
+
+ # class_weight is a manual rescaling weight given to each class.
+ # If given, has to be a Tensor of size C element-wise losses
+ loss = F.cross_entropy(pred, label, weight=class_weight, reduction="none", ignore_index=ignore_index)
+
+ # apply weights and do the reduction
+ # average loss over non-ignored elements
+ # pytorch's official cross_entropy average loss over non-ignored elements
+ # refer to https://github.com/pytorch/pytorch/blob/56b43f4fec1f76953f15a627694d4bba34588969/torch/nn/functional.py#L2660 # noqa
+ if (avg_factor is None) and avg_non_ignore and reduction == "mean":
+ avg_factor = label.numel() - (label == ignore_index).sum().item()
+ if weight is not None:
+ weight = weight.float()
+ loss = weight_reduce_loss(loss, weight=weight, reduction=reduction, avg_factor=avg_factor)
+
+ return loss
+
+
+def _expand_onehot_labels(labels, label_weights, target_shape, ignore_index):
+ """Expand onehot labels to match the size of prediction."""
+ bin_labels = labels.new_zeros(target_shape)
+ valid_mask = (labels >= 0) & (labels != ignore_index)
+ inds = torch.nonzero(valid_mask, as_tuple=True)
+
+ if inds[0].numel() > 0:
+ if labels.dim() == 3:
+ bin_labels[inds[0], labels[valid_mask], inds[1], inds[2]] = 1
+ else:
+ bin_labels[inds[0], labels[valid_mask]] = 1
+
+ valid_mask = valid_mask.unsqueeze(1).expand(target_shape).float()
+
+ if label_weights is None:
+ bin_label_weights = valid_mask
+ else:
+ bin_label_weights = label_weights.unsqueeze(1).expand(target_shape)
+ bin_label_weights = bin_label_weights * valid_mask
+
+ return bin_labels, bin_label_weights, valid_mask
+
+
+def binary_cross_entropy(
+ pred,
+ label,
+ weight=None,
+ reduction="mean",
+ avg_factor=None,
+ class_weight=None,
+ ignore_index=-100,
+ avg_non_ignore=False,
+ **kwargs,
+):
+ """Calculate the binary CrossEntropy loss.
+
+ Args:
+ pred (torch.Tensor): The prediction with shape (N, 1).
+ label (torch.Tensor): The learning label of the prediction.
+ Note: In bce loss, label < 0 is invalid.
+ weight (torch.Tensor, optional): Sample-wise loss weight.
+ reduction (str, optional): The method used to reduce the loss.
+ Options are "none", "mean" and "sum".
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Defaults to None.
+ class_weight (list[float], optional): The weight for each class.
+ ignore_index (int): The label index to be ignored. Default: -100.
+ avg_non_ignore (bool): The flag decides to whether the loss is
+ only averaged over non-ignored targets. Default: False.
+ `New in version 0.23.0.`
+
+ Returns:
+ torch.Tensor: The calculated loss
+ """
+ if pred.size(1) == 1:
+ # For binary class segmentation, the shape of pred is
+ # [N, 1, H, W] and that of label is [N, H, W].
+ assert label.max() <= 1, "For pred with shape [N, 1, H, W], its label must have at " "most 2 classes"
+ pred = pred.squeeze()
+ if pred.dim() != label.dim():
+ assert (pred.dim() == 2 and label.dim() == 1) or (pred.dim() == 4 and label.dim() == 3), (
+ "Only pred shape [N, C], label shape [N] or pred shape [N, C, " "H, W], label shape [N, H, W] are supported"
+ )
+ # `weight` returned from `_expand_onehot_labels`
+ # has been treated for valid (non-ignore) pixels
+ label, weight, valid_mask = _expand_onehot_labels(label, weight, pred.shape, ignore_index)
+ else:
+ # should mask out the ignored elements
+ valid_mask = ((label >= 0) & (label != ignore_index)).float()
+ if weight is not None:
+ weight = weight * valid_mask
+ else:
+ weight = valid_mask
+ # average loss over non-ignored and valid elements
+ if reduction == "mean" and avg_factor is None and avg_non_ignore:
+ avg_factor = valid_mask.sum().item()
+
+ loss = F.binary_cross_entropy_with_logits(pred, label.float(), pos_weight=class_weight, reduction="none")
+ # do the reduction for the weighted loss
+ loss = weight_reduce_loss(loss, weight, reduction=reduction, avg_factor=avg_factor)
+
+ return loss
+
+
+def mask_cross_entropy(
+ pred, target, label, reduction="mean", avg_factor=None, class_weight=None, ignore_index=None, **kwargs
+):
+ """Calculate the CrossEntropy loss for masks.
+
+ Args:
+ pred (torch.Tensor): The prediction with shape (N, C), C is the number
+ of classes.
+ target (torch.Tensor): The learning label of the prediction.
+ label (torch.Tensor): ``label`` indicates the class label of the mask'
+ corresponding object. This will be used to select the mask in the
+ of the class which the object belongs to when the mask prediction
+ if not class-agnostic.
+ reduction (str, optional): The method used to reduce the loss.
+ Options are "none", "mean" and "sum".
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Defaults to None.
+ class_weight (list[float], optional): The weight for each class.
+ ignore_index (None): Placeholder, to be consistent with other loss.
+ Default: None.
+
+ Returns:
+ torch.Tensor: The calculated loss
+ """
+ assert ignore_index is None, "BCE loss does not support ignore_index"
+ assert reduction == "mean" and avg_factor is None
+ num_rois = pred.size()[0]
+ inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device)
+ pred_slice = pred[inds, label].squeeze(1)
+ return F.binary_cross_entropy_with_logits(pred_slice, target, weight=class_weight, reduction="mean")[None]
+
+
+@LOSSES.register_module(force=True)
+class CrossEntropyLoss(nn.Module):
+ """CrossEntropyLoss.
+
+ Args:
+ use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+ of softmax. Defaults to False.
+ use_mask (bool, optional): Whether to use mask cross entropy loss.
+ Defaults to False.
+ reduction (str, optional): . Defaults to 'mean'.
+ Options are "none", "mean" and "sum".
+ class_weight (list[float] | str, optional): Weight of each class. If in
+ str format, read them from a file. Defaults to None.
+ loss_weight (float, optional): Weight of the loss. Defaults to 1.0.
+ loss_name (str, optional): Name of the loss item. If you want this loss
+ item to be included into the backward graph, `loss_` must be the
+ prefix of the name. Defaults to 'loss_ce'.
+ avg_non_ignore (bool): The flag decides to whether the loss is
+ only averaged over non-ignored targets. Default: False.
+ `New in version 0.23.0.`
+ """
+
+ def __init__(
+ self,
+ use_sigmoid=False,
+ use_mask=False,
+ reduction="mean",
+ class_weight=None,
+ loss_weight=1.0,
+ loss_name="loss_ce",
+ avg_non_ignore=False,
+ ):
+ super(CrossEntropyLoss, self).__init__()
+ assert (use_sigmoid is False) or (use_mask is False)
+ self.use_sigmoid = use_sigmoid
+ self.use_mask = use_mask
+ self.reduction = reduction
+ self.loss_weight = loss_weight
+ self.class_weight = get_class_weight(class_weight)
+ self.avg_non_ignore = avg_non_ignore
+ if not self.avg_non_ignore and self.reduction == "mean":
+ warnings.warn(
+ "Default ``avg_non_ignore`` is False, if you would like to "
+ "ignore the certain label and average loss over non-ignore "
+ "labels, which is the same with PyTorch official "
+ "cross_entropy, set ``avg_non_ignore=True``."
+ )
+
+ if self.use_sigmoid:
+ self.cls_criterion = binary_cross_entropy
+ elif self.use_mask:
+ self.cls_criterion = mask_cross_entropy
+ else:
+ self.cls_criterion = cross_entropy
+ self._loss_name = loss_name
+
+ def extra_repr(self):
+ """Extra repr."""
+ s = f"avg_non_ignore={self.avg_non_ignore}"
+ return s
+
+ def forward(
+ self, cls_score, label, weight=None, avg_factor=None, reduction_override=None, ignore_index=-100, **kwargs
+ ):
+ """Forward function."""
+ assert reduction_override in (None, "none", "mean", "sum")
+ reduction = reduction_override if reduction_override else self.reduction
+ if self.class_weight is not None:
+ class_weight = cls_score.new_tensor(self.class_weight)
+ else:
+ class_weight = None
+ # Note: for BCE loss, label < 0 is invalid.
+ loss_cls = self.loss_weight * self.cls_criterion(
+ cls_score,
+ label,
+ weight,
+ class_weight=class_weight,
+ reduction=reduction,
+ avg_factor=avg_factor,
+ avg_non_ignore=self.avg_non_ignore,
+ ignore_index=ignore_index,
+ **kwargs,
+ )
+ return loss_cls
+
+ @property
+ def loss_name(self):
+ """Loss Name.
+
+ This function must be implemented and will return the name of this
+ loss function. This name will be used to combine different loss items
+ by simple sum operation. In addition, if you want this loss item to be
+ included into the backward graph, `loss_` must be the prefix of the
+ name.
+
+ Returns:
+ str: The name of this loss item.
+ """
+ return self._loss_name
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py
new file mode 100644
index 0000000..1bc5ba8
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/dice_loss.py
@@ -0,0 +1,153 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+from mmseg.models.builder import LOSSES
+from mmseg.models.losses.utils import weight_reduce_loss
+
+
+def dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None):
+ """Calculate dice loss, which is proposed in
+ `V-Net: Fully Convolutional Neural Networks for Volumetric
+ Medical Image Segmentation `_.
+
+ Args:
+ pred (torch.Tensor): The prediction, has a shape (n, *)
+ target (torch.Tensor): The learning label of the prediction,
+ shape (n, *), same shape of pred.
+ weight (torch.Tensor, optional): The weight of loss for each
+ prediction, has a shape (n,). Defaults to None.
+ eps (float): Avoid dividing by zero. Default: 1e-3.
+ reduction (str, optional): The method used to reduce the loss into
+ a scalar. Defaults to 'mean'.
+ Options are "none", "mean" and "sum".
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Defaults to None.
+ """
+
+ input = pred.flatten(1)
+ target = target.flatten(1).float()
+
+ a = torch.sum(input * target, 1)
+ b = torch.sum(input * input, 1) + eps
+ c = torch.sum(target * target, 1) + eps
+ d = (2 * a) / (b + c)
+ loss = 1 - d
+ if weight is not None:
+ assert weight.ndim == loss.ndim
+ assert len(weight) == len(pred)
+ loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+ return loss
+
+
+def naive_dice_loss(pred, target, weight=None, eps=1e-3, reduction="mean", avg_factor=None):
+ """Calculate naive dice loss, the coefficient in the denominator is the
+ first power instead of the second power.
+
+ Args:
+ pred (torch.Tensor): The prediction, has a shape (n, *)
+ target (torch.Tensor): The learning label of the prediction,
+ shape (n, *), same shape of pred.
+ weight (torch.Tensor, optional): The weight of loss for each
+ prediction, has a shape (n,). Defaults to None.
+ eps (float): Avoid dividing by zero. Default: 1e-3.
+ reduction (str, optional): The method used to reduce the loss into
+ a scalar. Defaults to 'mean'.
+ Options are "none", "mean" and "sum".
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Defaults to None.
+ """
+ input = pred.flatten(1)
+ target = target.flatten(1).float()
+
+ a = torch.sum(input * target, 1)
+ b = torch.sum(input, 1)
+ c = torch.sum(target, 1)
+ d = (2 * a + eps) / (b + c + eps)
+ loss = 1 - d
+ if weight is not None:
+ assert weight.ndim == loss.ndim
+ assert len(weight) == len(pred)
+ loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
+ return loss
+
+
+@LOSSES.register_module(force=True)
+class DiceLoss(nn.Module):
+ def __init__(self, use_sigmoid=True, activate=True, reduction="mean", naive_dice=False, loss_weight=1.0, eps=1e-3):
+ """Dice Loss, there are two forms of dice loss is supported:
+
+ - the one proposed in `V-Net: Fully Convolutional Neural
+ Networks for Volumetric Medical Image Segmentation
+ `_.
+ - the dice loss in which the power of the number in the
+ denominator is the first power instead of the second
+ power.
+
+ Args:
+ use_sigmoid (bool, optional): Whether to the prediction is
+ used for sigmoid or softmax. Defaults to True.
+ activate (bool): Whether to activate the predictions inside,
+ this will disable the inside sigmoid operation.
+ Defaults to True.
+ reduction (str, optional): The method used
+ to reduce the loss. Options are "none",
+ "mean" and "sum". Defaults to 'mean'.
+ naive_dice (bool, optional): If false, use the dice
+ loss defined in the V-Net paper, otherwise, use the
+ naive dice loss in which the power of the number in the
+ denominator is the first power instead of the second
+ power.Defaults to False.
+ loss_weight (float, optional): Weight of loss. Defaults to 1.0.
+ eps (float): Avoid dividing by zero. Defaults to 1e-3.
+ """
+
+ super(DiceLoss, self).__init__()
+ self.use_sigmoid = use_sigmoid
+ self.reduction = reduction
+ self.naive_dice = naive_dice
+ self.loss_weight = loss_weight
+ self.eps = eps
+ self.activate = activate
+
+ def forward(self, pred, target, weight=None, reduction_override=None, avg_factor=None):
+ """Forward function.
+
+ Args:
+ pred (torch.Tensor): The prediction, has a shape (n, *).
+ target (torch.Tensor): The label of the prediction,
+ shape (n, *), same shape of pred.
+ weight (torch.Tensor, optional): The weight of loss for each
+ prediction, has a shape (n,). Defaults to None.
+ avg_factor (int, optional): Average factor that is used to average
+ the loss. Defaults to None.
+ reduction_override (str, optional): The reduction method used to
+ override the original reduction method of the loss.
+ Options are "none", "mean" and "sum".
+
+ Returns:
+ torch.Tensor: The calculated loss
+ """
+
+ assert reduction_override in (None, "none", "mean", "sum")
+ reduction = reduction_override if reduction_override else self.reduction
+
+ if self.activate:
+ if self.use_sigmoid:
+ pred = pred.sigmoid()
+ else:
+ raise NotImplementedError
+
+ if self.naive_dice:
+ loss = self.loss_weight * naive_dice_loss(
+ pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor
+ )
+ else:
+ loss = self.loss_weight * dice_loss(
+ pred, target, weight, eps=self.eps, reduction=reduction, avg_factor=avg_factor
+ )
+
+ return loss
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/match_costs.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/match_costs.py
new file mode 100644
index 0000000..4917d2a
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/losses/match_costs.py
@@ -0,0 +1,153 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn.functional as F
+
+from ..builder import MATCH_COST
+
+
+@MATCH_COST.register_module()
+class ClassificationCost:
+ """ClsSoftmaxCost.Borrow from
+ mmdet.core.bbox.match_costs.match_cost.ClassificationCost.
+
+ Args:
+ weight (int | float, optional): loss_weight
+
+ Examples:
+ >>> import torch
+ >>> self = ClassificationCost()
+ >>> cls_pred = torch.rand(4, 3)
+ >>> gt_labels = torch.tensor([0, 1, 2])
+ >>> factor = torch.tensor([10, 8, 10, 8])
+ >>> self(cls_pred, gt_labels)
+ tensor([[-0.3430, -0.3525, -0.3045],
+ [-0.3077, -0.2931, -0.3992],
+ [-0.3664, -0.3455, -0.2881],
+ [-0.3343, -0.2701, -0.3956]])
+ """
+
+ def __init__(self, weight=1.0):
+ self.weight = weight
+
+ def __call__(self, cls_pred, gt_labels):
+ """
+ Args:
+ cls_pred (Tensor): Predicted classification logits, shape
+ [num_query, num_class].
+ gt_labels (Tensor): Label of `gt_bboxes`, shape (num_gt,).
+
+ Returns:
+ torch.Tensor: cls_cost value with weight
+ """
+ # Following the official DETR repo, contrary to the loss that
+ # NLL is used, we approximate it in 1 - cls_score[gt_label].
+ # The 1 is a constant that doesn't change the matching,
+ # so it can be omitted.
+ cls_score = cls_pred.softmax(-1)
+ cls_cost = -cls_score[:, gt_labels]
+ return cls_cost * self.weight
+
+
+@MATCH_COST.register_module()
+class DiceCost:
+ """Cost of mask assignments based on dice losses.
+
+ Args:
+ weight (int | float, optional): loss_weight. Defaults to 1.
+ pred_act (bool, optional): Whether to apply sigmoid to mask_pred.
+ Defaults to False.
+ eps (float, optional): default 1e-12.
+ """
+
+ def __init__(self, weight=1.0, pred_act=False, eps=1e-3):
+ self.weight = weight
+ self.pred_act = pred_act
+ self.eps = eps
+
+ def binary_mask_dice_loss(self, mask_preds, gt_masks):
+ """
+ Args:
+ mask_preds (Tensor): Mask prediction in shape (N1, H, W).
+ gt_masks (Tensor): Ground truth in shape (N2, H, W)
+ store 0 or 1, 0 for negative class and 1 for
+ positive class.
+
+ Returns:
+ Tensor: Dice cost matrix in shape (N1, N2).
+ """
+ mask_preds = mask_preds.reshape((mask_preds.shape[0], -1))
+ gt_masks = gt_masks.reshape((gt_masks.shape[0], -1)).float()
+ numerator = 2 * torch.einsum("nc,mc->nm", mask_preds, gt_masks)
+ denominator = mask_preds.sum(-1)[:, None] + gt_masks.sum(-1)[None, :]
+ loss = 1 - (numerator + self.eps) / (denominator + self.eps)
+ return loss
+
+ def __call__(self, mask_preds, gt_masks):
+ """
+ Args:
+ mask_preds (Tensor): Mask prediction logits in shape (N1, H, W).
+ gt_masks (Tensor): Ground truth in shape (N2, H, W).
+
+ Returns:
+ Tensor: Dice cost matrix in shape (N1, N2).
+ """
+ if self.pred_act:
+ mask_preds = mask_preds.sigmoid()
+ dice_cost = self.binary_mask_dice_loss(mask_preds, gt_masks)
+ return dice_cost * self.weight
+
+
+@MATCH_COST.register_module()
+class CrossEntropyLossCost:
+ """CrossEntropyLossCost.
+
+ Args:
+ weight (int | float, optional): loss weight. Defaults to 1.
+ use_sigmoid (bool, optional): Whether the prediction uses sigmoid
+ of softmax. Defaults to True.
+ """
+
+ def __init__(self, weight=1.0, use_sigmoid=True):
+ assert use_sigmoid, "use_sigmoid = False is not supported yet."
+ self.weight = weight
+ self.use_sigmoid = use_sigmoid
+
+ def _binary_cross_entropy(self, cls_pred, gt_labels):
+ """
+ Args:
+ cls_pred (Tensor): The prediction with shape (num_query, 1, *) or
+ (num_query, *).
+ gt_labels (Tensor): The learning label of prediction with
+ shape (num_gt, *).
+ Returns:
+ Tensor: Cross entropy cost matrix in shape (num_query, num_gt).
+ """
+ cls_pred = cls_pred.flatten(1).float()
+ gt_labels = gt_labels.flatten(1).float()
+ n = cls_pred.shape[1]
+ pos = F.binary_cross_entropy_with_logits(cls_pred, torch.ones_like(cls_pred), reduction="none")
+ neg = F.binary_cross_entropy_with_logits(cls_pred, torch.zeros_like(cls_pred), reduction="none")
+ cls_cost = torch.einsum("nc,mc->nm", pos, gt_labels) + torch.einsum("nc,mc->nm", neg, 1 - gt_labels)
+ cls_cost = cls_cost / n
+
+ return cls_cost
+
+ def __call__(self, cls_pred, gt_labels):
+ """
+ Args:
+ cls_pred (Tensor): Predicted classification logits.
+ gt_labels (Tensor): Labels.
+ Returns:
+ Tensor: Cross entropy cost matrix with weight in
+ shape (num_query, num_gt).
+ """
+ if self.use_sigmoid:
+ cls_cost = self._binary_cross_entropy(cls_pred, gt_labels)
+ else:
+ raise NotImplementedError
+
+ return cls_cost * self.weight
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/__init__.py
new file mode 100644
index 0000000..81a60db
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .msdeformattn_pixel_decoder import MSDeformAttnPixelDecoder
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py
new file mode 100644
index 0000000..db19471
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/plugins/msdeformattn_pixel_decoder.py
@@ -0,0 +1,242 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmcv.cnn import PLUGIN_LAYERS, Conv2d, ConvModule, caffe2_xavier_init, normal_init, xavier_init
+from mmcv.cnn.bricks.transformer import build_positional_encoding, build_transformer_layer_sequence
+from mmcv.runner import BaseModule, ModuleList
+
+from ...core.anchor import MlvlPointGenerator
+from ..utils.transformer import MultiScaleDeformableAttention
+
+
+@PLUGIN_LAYERS.register_module()
+class MSDeformAttnPixelDecoder(BaseModule):
+ """Pixel decoder with multi-scale deformable attention.
+
+ Args:
+ in_channels (list[int] | tuple[int]): Number of channels in the
+ input feature maps.
+ strides (list[int] | tuple[int]): Output strides of feature from
+ backbone.
+ feat_channels (int): Number of channels for feature.
+ out_channels (int): Number of channels for output.
+ num_outs (int): Number of output scales.
+ norm_cfg (:obj:`mmcv.ConfigDict` | dict): Config for normalization.
+ Defaults to dict(type='GN', num_groups=32).
+ act_cfg (:obj:`mmcv.ConfigDict` | dict): Config for activation.
+ Defaults to dict(type='ReLU').
+ encoder (:obj:`mmcv.ConfigDict` | dict): Config for transformer
+ encoder. Defaults to `DetrTransformerEncoder`.
+ positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for
+ transformer encoder position encoding. Defaults to
+ dict(type='SinePositionalEncoding', num_feats=128,
+ normalize=True).
+ init_cfg (:obj:`mmcv.ConfigDict` | dict): Initialization config dict.
+ """
+
+ def __init__(
+ self,
+ in_channels=[256, 512, 1024, 2048],
+ strides=[4, 8, 16, 32],
+ feat_channels=256,
+ out_channels=256,
+ num_outs=3,
+ norm_cfg=dict(type="GN", num_groups=32),
+ act_cfg=dict(type="ReLU"),
+ encoder=dict(
+ type="DetrTransformerEncoder",
+ num_layers=6,
+ transformerlayers=dict(
+ type="BaseTransformerLayer",
+ attn_cfgs=dict(
+ type="MultiScaleDeformableAttention",
+ embed_dims=256,
+ num_heads=8,
+ num_levels=3,
+ num_points=4,
+ im2col_step=64,
+ dropout=0.0,
+ batch_first=False,
+ norm_cfg=None,
+ init_cfg=None,
+ ),
+ feedforward_channels=1024,
+ ffn_dropout=0.0,
+ operation_order=("self_attn", "norm", "ffn", "norm"),
+ ),
+ init_cfg=None,
+ ),
+ positional_encoding=dict(type="SinePositionalEncoding", num_feats=128, normalize=True),
+ init_cfg=None,
+ ):
+ super().__init__(init_cfg=init_cfg)
+ self.strides = strides
+ self.num_input_levels = len(in_channels)
+ self.num_encoder_levels = encoder.transformerlayers.attn_cfgs.num_levels
+ assert self.num_encoder_levels >= 1, "num_levels in attn_cfgs must be at least one"
+ input_conv_list = []
+ # from top to down (low to high resolution)
+ for i in range(self.num_input_levels - 1, self.num_input_levels - self.num_encoder_levels - 1, -1):
+ input_conv = ConvModule(
+ in_channels[i], feat_channels, kernel_size=1, norm_cfg=norm_cfg, act_cfg=None, bias=True
+ )
+ input_conv_list.append(input_conv)
+ self.input_convs = ModuleList(input_conv_list)
+
+ self.encoder = build_transformer_layer_sequence(encoder)
+ self.postional_encoding = build_positional_encoding(positional_encoding)
+ # high resolution to low resolution
+ self.level_encoding = nn.Embedding(self.num_encoder_levels, feat_channels)
+
+ # fpn-like structure
+ self.lateral_convs = ModuleList()
+ self.output_convs = ModuleList()
+ self.use_bias = norm_cfg is None
+ # from top to down (low to high resolution)
+ # fpn for the rest features that didn't pass in encoder
+ for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1):
+ lateral_conv = ConvModule(
+ in_channels[i], feat_channels, kernel_size=1, bias=self.use_bias, norm_cfg=norm_cfg, act_cfg=None
+ )
+ output_conv = ConvModule(
+ feat_channels,
+ feat_channels,
+ kernel_size=3,
+ stride=1,
+ padding=1,
+ bias=self.use_bias,
+ norm_cfg=norm_cfg,
+ act_cfg=act_cfg,
+ )
+ self.lateral_convs.append(lateral_conv)
+ self.output_convs.append(output_conv)
+
+ self.mask_feature = Conv2d(feat_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+ self.num_outs = num_outs
+ self.point_generator = MlvlPointGenerator(strides)
+
+ def init_weights(self):
+ """Initialize weights."""
+ for i in range(0, self.num_encoder_levels):
+ xavier_init(self.input_convs[i].conv, gain=1, bias=0, distribution="uniform")
+
+ for i in range(0, self.num_input_levels - self.num_encoder_levels):
+ caffe2_xavier_init(self.lateral_convs[i].conv, bias=0)
+ caffe2_xavier_init(self.output_convs[i].conv, bias=0)
+
+ caffe2_xavier_init(self.mask_feature, bias=0)
+
+ normal_init(self.level_encoding, mean=0, std=1)
+ for p in self.encoder.parameters():
+ if p.dim() > 1:
+ nn.init.xavier_normal_(p)
+
+ # init_weights defined in MultiScaleDeformableAttention
+ for layer in self.encoder.layers:
+ for attn in layer.attentions:
+ if isinstance(attn, MultiScaleDeformableAttention):
+ attn.init_weights()
+
+ def forward(self, feats):
+ """
+ Args:
+ feats (list[Tensor]): Feature maps of each level. Each has
+ shape of (batch_size, c, h, w).
+
+ Returns:
+ tuple: A tuple containing the following:
+
+ - mask_feature (Tensor): shape (batch_size, c, h, w).
+ - multi_scale_features (list[Tensor]): Multi scale \
+ features, each in shape (batch_size, c, h, w).
+ """
+ # generate padding mask for each level, for each image
+ batch_size = feats[0].shape[0]
+ encoder_input_list = []
+ padding_mask_list = []
+ level_positional_encoding_list = []
+ spatial_shapes = []
+ reference_points_list = []
+ for i in range(self.num_encoder_levels):
+ level_idx = self.num_input_levels - i - 1
+ feat = feats[level_idx]
+ feat_projected = self.input_convs[i](feat)
+ h, w = feat.shape[-2:]
+
+ # no padding
+ padding_mask_resized = feat.new_zeros((batch_size,) + feat.shape[-2:], dtype=torch.bool)
+ pos_embed = self.postional_encoding(padding_mask_resized)
+ level_embed = self.level_encoding.weight[i]
+ level_pos_embed = level_embed.view(1, -1, 1, 1) + pos_embed
+ # (h_i * w_i, 2)
+ reference_points = self.point_generator.single_level_grid_priors(
+ feat.shape[-2:], level_idx, device=feat.device
+ )
+ # normalize
+ factor = feat.new_tensor([[w, h]]) * self.strides[level_idx]
+ reference_points = reference_points / factor
+
+ # shape (batch_size, c, h_i, w_i) -> (h_i * w_i, batch_size, c)
+ feat_projected = feat_projected.flatten(2).permute(2, 0, 1)
+ level_pos_embed = level_pos_embed.flatten(2).permute(2, 0, 1)
+ padding_mask_resized = padding_mask_resized.flatten(1)
+
+ encoder_input_list.append(feat_projected)
+ padding_mask_list.append(padding_mask_resized)
+ level_positional_encoding_list.append(level_pos_embed)
+ spatial_shapes.append(feat.shape[-2:])
+ reference_points_list.append(reference_points)
+ # shape (batch_size, total_num_query),
+ # total_num_query=sum([., h_i * w_i,.])
+ padding_masks = torch.cat(padding_mask_list, dim=1)
+ # shape (total_num_query, batch_size, c)
+ encoder_inputs = torch.cat(encoder_input_list, dim=0)
+ level_positional_encodings = torch.cat(level_positional_encoding_list, dim=0)
+ device = encoder_inputs.device
+ # shape (num_encoder_levels, 2), from low
+ # resolution to high resolution
+ spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=device)
+ # shape (0, h_0*w_0, h_0*w_0+h_1*w_1, ...)
+ level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1]))
+ reference_points = torch.cat(reference_points_list, dim=0)
+ reference_points = reference_points[None, :, None].repeat(batch_size, 1, self.num_encoder_levels, 1)
+ valid_radios = reference_points.new_ones((batch_size, self.num_encoder_levels, 2))
+ # shape (num_total_query, batch_size, c)
+ memory = self.encoder(
+ query=encoder_inputs,
+ key=None,
+ value=None,
+ query_pos=level_positional_encodings,
+ key_pos=None,
+ attn_masks=None,
+ key_padding_mask=None,
+ query_key_padding_mask=padding_masks,
+ spatial_shapes=spatial_shapes,
+ reference_points=reference_points,
+ level_start_index=level_start_index,
+ valid_radios=valid_radios,
+ )
+ # (num_total_query, batch_size, c) -> (batch_size, c, num_total_query)
+ memory = memory.permute(1, 2, 0)
+
+ # from low resolution to high resolution
+ num_query_per_level = [e[0] * e[1] for e in spatial_shapes]
+ outs = torch.split(memory, num_query_per_level, dim=-1)
+ outs = [x.reshape(batch_size, -1, spatial_shapes[i][0], spatial_shapes[i][1]) for i, x in enumerate(outs)]
+
+ for i in range(self.num_input_levels - self.num_encoder_levels - 1, -1, -1):
+ x = feats[i]
+ cur_feat = self.lateral_convs[i](x)
+ y = cur_feat + F.interpolate(outs[-1], size=cur_feat.shape[-2:], mode="bilinear", align_corners=False)
+ y = self.output_convs[i](y)
+ outs.append(y)
+ multi_scale_features = outs[: self.num_outs]
+
+ mask_feature = self.mask_feature(outs[-1])
+ return mask_feature, multi_scale_features
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py
new file mode 100644
index 0000000..adf0062
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/__init__.py
@@ -0,0 +1,6 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .encoder_decoder_mask2former import EncoderDecoderMask2Former
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py
new file mode 100644
index 0000000..cfe572c
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/segmentors/encoder_decoder_mask2former.py
@@ -0,0 +1,271 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mmseg.core import add_prefix
+from mmseg.models import builder
+from mmseg.models.builder import SEGMENTORS
+from mmseg.models.segmentors.base import BaseSegmentor
+from mmseg.ops import resize
+
+
+@SEGMENTORS.register_module()
+class EncoderDecoderMask2Former(BaseSegmentor):
+ """Encoder Decoder segmentors.
+
+ EncoderDecoder typically consists of backbone, decode_head, auxiliary_head.
+ Note that auxiliary_head is only used for deep supervision during training,
+ which could be dumped during inference.
+ """
+
+ def __init__(
+ self,
+ backbone,
+ decode_head,
+ neck=None,
+ auxiliary_head=None,
+ train_cfg=None,
+ test_cfg=None,
+ pretrained=None,
+ init_cfg=None,
+ ):
+ super(EncoderDecoderMask2Former, self).__init__(init_cfg)
+ if pretrained is not None:
+ assert backbone.get("pretrained") is None, "both backbone and segmentor set pretrained weight"
+ backbone.pretrained = pretrained
+ self.backbone = builder.build_backbone(backbone)
+ if neck is not None:
+ self.neck = builder.build_neck(neck)
+ decode_head.update(train_cfg=train_cfg)
+ decode_head.update(test_cfg=test_cfg)
+ self._init_decode_head(decode_head)
+ self._init_auxiliary_head(auxiliary_head)
+
+ self.train_cfg = train_cfg
+ self.test_cfg = test_cfg
+
+ assert self.with_decode_head
+
+ def _init_decode_head(self, decode_head):
+ """Initialize ``decode_head``"""
+ self.decode_head = builder.build_head(decode_head)
+ self.align_corners = self.decode_head.align_corners
+ self.num_classes = self.decode_head.num_classes
+
+ def _init_auxiliary_head(self, auxiliary_head):
+ """Initialize ``auxiliary_head``"""
+ if auxiliary_head is not None:
+ if isinstance(auxiliary_head, list):
+ self.auxiliary_head = nn.ModuleList()
+ for head_cfg in auxiliary_head:
+ self.auxiliary_head.append(builder.build_head(head_cfg))
+ else:
+ self.auxiliary_head = builder.build_head(auxiliary_head)
+
+ def extract_feat(self, img):
+ """Extract features from images."""
+ x = self.backbone(img)
+ if self.with_neck:
+ x = self.neck(x)
+ return x
+
+ def encode_decode(self, img, img_metas):
+ """Encode images with backbone and decode into a semantic segmentation
+ map of the same size as input."""
+ x = self.extract_feat(img)
+ out = self._decode_head_forward_test(x, img_metas)
+ out = resize(input=out, size=img.shape[2:], mode="bilinear", align_corners=self.align_corners)
+ return out
+
+ def _decode_head_forward_train(self, x, img_metas, gt_semantic_seg, **kwargs):
+ """Run forward function and calculate loss for decode head in
+ training."""
+ losses = dict()
+ loss_decode = self.decode_head.forward_train(x, img_metas, gt_semantic_seg, **kwargs)
+
+ losses.update(add_prefix(loss_decode, "decode"))
+ return losses
+
+ def _decode_head_forward_test(self, x, img_metas):
+ """Run forward function and calculate loss for decode head in
+ inference."""
+ seg_logits = self.decode_head.forward_test(x, img_metas, self.test_cfg)
+ return seg_logits
+
+ def _auxiliary_head_forward_train(self, x, img_metas, gt_semantic_seg):
+ """Run forward function and calculate loss for auxiliary head in
+ training."""
+ losses = dict()
+ if isinstance(self.auxiliary_head, nn.ModuleList):
+ for idx, aux_head in enumerate(self.auxiliary_head):
+ loss_aux = aux_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg)
+ losses.update(add_prefix(loss_aux, f"aux_{idx}"))
+ else:
+ loss_aux = self.auxiliary_head.forward_train(x, img_metas, gt_semantic_seg, self.train_cfg)
+ losses.update(add_prefix(loss_aux, "aux"))
+
+ return losses
+
+ def forward_dummy(self, img):
+ """Dummy forward function."""
+ seg_logit = self.encode_decode(img, None)
+
+ return seg_logit
+
+ def forward_train(self, img, img_metas, gt_semantic_seg, **kwargs):
+ """Forward function for training.
+
+ Args:
+ img (Tensor): Input images.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `mmseg/datasets/pipelines/formatting.py:Collect`.
+ gt_semantic_seg (Tensor): Semantic segmentation masks
+ used if the architecture supports semantic segmentation task.
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+
+ x = self.extract_feat(img)
+
+ losses = dict()
+
+ loss_decode = self._decode_head_forward_train(x, img_metas, gt_semantic_seg, **kwargs)
+ losses.update(loss_decode)
+
+ if self.with_auxiliary_head:
+ loss_aux = self._auxiliary_head_forward_train(x, img_metas, gt_semantic_seg)
+ losses.update(loss_aux)
+
+ return losses
+
+ def slide_inference(self, img, img_meta, rescale):
+ """Inference by sliding-window with overlap.
+
+ If h_crop > h_img or w_crop > w_img, the small patch will be used to
+ decode without padding.
+ """
+
+ h_stride, w_stride = self.test_cfg.stride
+ h_crop, w_crop = self.test_cfg.crop_size
+ batch_size, _, h_img, w_img = img.size()
+ num_classes = self.num_classes
+ h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+ w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+ preds = img.new_zeros((batch_size, num_classes, h_img, w_img))
+ count_mat = img.new_zeros((batch_size, 1, h_img, w_img))
+ for h_idx in range(h_grids):
+ for w_idx in range(w_grids):
+ y1 = h_idx * h_stride
+ x1 = w_idx * w_stride
+ y2 = min(y1 + h_crop, h_img)
+ x2 = min(x1 + w_crop, w_img)
+ y1 = max(y2 - h_crop, 0)
+ x1 = max(x2 - w_crop, 0)
+ crop_img = img[:, :, y1:y2, x1:x2]
+ crop_seg_logit = self.encode_decode(crop_img, img_meta)
+ preds += F.pad(crop_seg_logit, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2)))
+
+ count_mat[:, :, y1:y2, x1:x2] += 1
+ assert (count_mat == 0).sum() == 0
+ if torch.onnx.is_in_onnx_export():
+ # cast count_mat to constant while exporting to ONNX
+ count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device)
+ preds = preds / count_mat
+ if rescale:
+ preds = resize(
+ preds,
+ size=img_meta[0]["ori_shape"][:2],
+ mode="bilinear",
+ align_corners=self.align_corners,
+ warning=False,
+ )
+ return preds
+
+ def whole_inference(self, img, img_meta, rescale):
+ """Inference with full image."""
+
+ seg_logit = self.encode_decode(img, img_meta)
+ if rescale:
+ # support dynamic shape for onnx
+ if torch.onnx.is_in_onnx_export():
+ size = img.shape[2:]
+ else:
+ size = img_meta[0]["ori_shape"][:2]
+ seg_logit = resize(seg_logit, size=size, mode="bilinear", align_corners=self.align_corners, warning=False)
+
+ return seg_logit
+
+ def inference(self, img, img_meta, rescale):
+ """Inference with slide/whole style.
+
+ Args:
+ img (Tensor): The input image of shape (N, 3, H, W).
+ img_meta (dict): Image info dict where each dict has: 'img_shape',
+ 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `mmseg/datasets/pipelines/formatting.py:Collect`.
+ rescale (bool): Whether rescale back to original shape.
+
+ Returns:
+ Tensor: The output segmentation map.
+ """
+
+ assert self.test_cfg.mode in ["slide", "whole"]
+ ori_shape = img_meta[0]["ori_shape"]
+ assert all(_["ori_shape"] == ori_shape for _ in img_meta)
+ if self.test_cfg.mode == "slide":
+ seg_logit = self.slide_inference(img, img_meta, rescale)
+ else:
+ seg_logit = self.whole_inference(img, img_meta, rescale)
+ output = F.softmax(seg_logit, dim=1)
+ flip = img_meta[0]["flip"]
+ if flip:
+ flip_direction = img_meta[0]["flip_direction"]
+ assert flip_direction in ["horizontal", "vertical"]
+ if flip_direction == "horizontal":
+ output = output.flip(dims=(3,))
+ elif flip_direction == "vertical":
+ output = output.flip(dims=(2,))
+
+ return output
+
+ def simple_test(self, img, img_meta, rescale=True):
+ """Simple test with single image."""
+ seg_logit = self.inference(img, img_meta, rescale)
+ seg_pred = seg_logit.argmax(dim=1)
+ if torch.onnx.is_in_onnx_export():
+ # our inference backend only support 4D output
+ seg_pred = seg_pred.unsqueeze(0)
+ return seg_pred
+ seg_pred = seg_pred.cpu().numpy()
+ # unravel batch dim
+ seg_pred = list(seg_pred)
+ return seg_pred
+
+ def aug_test(self, imgs, img_metas, rescale=True):
+ """Test with augmentations.
+
+ Only rescale=True is supported.
+ """
+ # aug_test rescale all imgs back to ori_shape for now
+ assert rescale
+ # to save memory, we get augmented seg logit inplace
+ seg_logit = self.inference(imgs[0], img_metas[0], rescale)
+ for i in range(1, len(imgs)):
+ cur_seg_logit = self.inference(imgs[i], img_metas[i], rescale)
+ seg_logit += cur_seg_logit
+ seg_logit /= len(imgs)
+ seg_pred = seg_logit.argmax(dim=1)
+ seg_pred = seg_pred.cpu().numpy()
+ # unravel batch dim
+ seg_pred = list(seg_pred)
+ return seg_pred
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/__init__.py
new file mode 100644
index 0000000..e7fdc16
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .assigner import MaskHungarianAssigner
+from .point_sample import get_uncertain_point_coords_with_randomness
+from .positional_encoding import LearnedPositionalEncoding, SinePositionalEncoding
+from .transformer import DetrTransformerDecoder, DetrTransformerDecoderLayer, DynamicConv, Transformer
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/assigner.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/assigner.py
new file mode 100644
index 0000000..3cb08fc
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/assigner.py
@@ -0,0 +1,157 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from abc import ABCMeta, abstractmethod
+
+import torch
+
+from ..builder import MASK_ASSIGNERS, build_match_cost
+
+try:
+ from scipy.optimize import linear_sum_assignment
+except ImportError:
+ linear_sum_assignment = None
+
+
+class AssignResult(metaclass=ABCMeta):
+ """Collection of assign results."""
+
+ def __init__(self, num_gts, gt_inds, labels):
+ self.num_gts = num_gts
+ self.gt_inds = gt_inds
+ self.labels = labels
+
+ @property
+ def info(self):
+ info = {
+ "num_gts": self.num_gts,
+ "gt_inds": self.gt_inds,
+ "labels": self.labels,
+ }
+ return info
+
+
+class BaseAssigner(metaclass=ABCMeta):
+ """Base assigner that assigns boxes to ground truth boxes."""
+
+ @abstractmethod
+ def assign(self, masks, gt_masks, gt_masks_ignore=None, gt_labels=None):
+ """Assign boxes to either a ground truth boxes or a negative boxes."""
+ pass
+
+
+@MASK_ASSIGNERS.register_module()
+class MaskHungarianAssigner(BaseAssigner):
+ """Computes one-to-one matching between predictions and ground truth for
+ mask.
+
+ This class computes an assignment between the targets and the predictions
+ based on the costs. The costs are weighted sum of three components:
+ classification cost, regression L1 cost and regression iou cost. The
+ targets don't include the no_object, so generally there are more
+ predictions than targets. After the one-to-one matching, the un-matched
+ are treated as backgrounds. Thus each query prediction will be assigned
+ with `0` or a positive integer indicating the ground truth index:
+
+ - 0: negative sample, no assigned gt
+ - positive integer: positive sample, index (1-based) of assigned gt
+
+ Args:
+ cls_cost (obj:`mmcv.ConfigDict`|dict): Classification cost config.
+ mask_cost (obj:`mmcv.ConfigDict`|dict): Mask cost config.
+ dice_cost (obj:`mmcv.ConfigDict`|dict): Dice cost config.
+ """
+
+ def __init__(
+ self,
+ cls_cost=dict(type="ClassificationCost", weight=1.0),
+ dice_cost=dict(type="DiceCost", weight=1.0),
+ mask_cost=dict(type="MaskFocalCost", weight=1.0),
+ ):
+ self.cls_cost = build_match_cost(cls_cost)
+ self.dice_cost = build_match_cost(dice_cost)
+ self.mask_cost = build_match_cost(mask_cost)
+
+ def assign(self, cls_pred, mask_pred, gt_labels, gt_masks, img_meta, gt_masks_ignore=None, eps=1e-7):
+ """Computes one-to-one matching based on the weighted costs.
+
+ This method assign each query prediction to a ground truth or
+ background. The `assigned_gt_inds` with -1 means don't care,
+ 0 means negative sample, and positive number is the index (1-based)
+ of assigned gt.
+ The assignment is done in the following steps, the order matters.
+
+ 1. assign every prediction to -1
+ 2. compute the weighted costs
+ 3. do Hungarian matching on CPU based on the costs
+ 4. assign all to 0 (background) first, then for each matched pair
+ between predictions and gts, treat this prediction as foreground
+ and assign the corresponding gt index (plus 1) to it.
+
+ Args:
+ mask_pred (Tensor): Predicted mask, shape [num_query, h, w]
+ cls_pred (Tensor): Predicted classification logits, shape
+ [num_query, num_class].
+ gt_masks (Tensor): Ground truth mask, shape [num_gt, h, w].
+ gt_labels (Tensor): Label of `gt_masks`, shape (num_gt,).
+ img_meta (dict): Meta information for current image.
+ gt_masks_ignore (Tensor, optional): Ground truth masks that are
+ labelled as `ignored`. Default None.
+ eps (int | float, optional): A value added to the denominator for
+ numerical stability. Default 1e-7.
+
+ Returns:
+ :obj:`AssignResult`: The assigned result.
+ """
+ assert gt_masks_ignore is None, "Only case when gt_masks_ignore is None is supported."
+ num_gts, num_queries = gt_labels.shape[0], cls_pred.shape[0]
+
+ # 1. assign -1 by default
+ assigned_gt_inds = cls_pred.new_full((num_queries,), -1, dtype=torch.long)
+ assigned_labels = cls_pred.new_full((num_queries,), -1, dtype=torch.long)
+ if num_gts == 0 or num_queries == 0:
+ # No ground truth or boxes, return empty assignment
+ if num_gts == 0:
+ # No ground truth, assign all to background
+ assigned_gt_inds[:] = 0
+ return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels)
+
+ # 2. compute the weighted costs
+ # classification and maskcost.
+ if self.cls_cost.weight != 0 and cls_pred is not None:
+ cls_cost = self.cls_cost(cls_pred, gt_labels)
+ else:
+ cls_cost = 0
+
+ if self.mask_cost.weight != 0:
+ # mask_pred shape = [nq, h, w]
+ # gt_mask shape = [ng, h, w]
+ # mask_cost shape = [nq, ng]
+ mask_cost = self.mask_cost(mask_pred, gt_masks)
+ else:
+ mask_cost = 0
+
+ if self.dice_cost.weight != 0:
+ dice_cost = self.dice_cost(mask_pred, gt_masks)
+ else:
+ dice_cost = 0
+ cost = cls_cost + mask_cost + dice_cost
+
+ # 3. do Hungarian matching on CPU using linear_sum_assignment
+ cost = cost.detach().cpu()
+ if linear_sum_assignment is None:
+ raise ImportError('Please run "pip install scipy" ' "to install scipy first.")
+
+ matched_row_inds, matched_col_inds = linear_sum_assignment(cost)
+ matched_row_inds = torch.from_numpy(matched_row_inds).to(cls_pred.device)
+ matched_col_inds = torch.from_numpy(matched_col_inds).to(cls_pred.device)
+
+ # 4. assign backgrounds and foregrounds
+ # assign all indices to backgrounds first
+ assigned_gt_inds[:] = 0
+ # assign foregrounds based on matching results
+ assigned_gt_inds[matched_row_inds] = matched_col_inds + 1
+ assigned_labels[matched_row_inds] = gt_labels[matched_col_inds]
+ return AssignResult(num_gts, assigned_gt_inds, labels=assigned_labels)
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/point_sample.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/point_sample.py
new file mode 100644
index 0000000..9f11340
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/point_sample.py
@@ -0,0 +1,86 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+from mmcv.ops import point_sample
+
+
+def get_uncertainty(mask_pred, labels):
+ """Estimate uncertainty based on pred logits.
+
+ We estimate uncertainty as L1 distance between 0.0 and the logits
+ prediction in 'mask_pred' for the foreground class in `classes`.
+
+ Args:
+ mask_pred (Tensor): mask predication logits, shape (num_rois,
+ num_classes, mask_height, mask_width).
+
+ labels (list[Tensor]): Either predicted or ground truth label for
+ each predicted mask, of length num_rois.
+
+ Returns:
+ scores (Tensor): Uncertainty scores with the most uncertain
+ locations having the highest uncertainty score,
+ shape (num_rois, 1, mask_height, mask_width)
+ """
+ if mask_pred.shape[1] == 1:
+ gt_class_logits = mask_pred.clone()
+ else:
+ inds = torch.arange(mask_pred.shape[0], device=mask_pred.device)
+ gt_class_logits = mask_pred[inds, labels].unsqueeze(1)
+ return -torch.abs(gt_class_logits)
+
+
+def get_uncertain_point_coords_with_randomness(
+ mask_pred, labels, num_points, oversample_ratio, importance_sample_ratio
+):
+ """Get ``num_points`` most uncertain points with random points during
+ train.
+
+ Sample points in [0, 1] x [0, 1] coordinate space based on their
+ uncertainty. The uncertainties are calculated for each point using
+ 'get_uncertainty()' function that takes point's logit prediction as
+ input.
+
+ Args:
+ mask_pred (Tensor): A tensor of shape (num_rois, num_classes,
+ mask_height, mask_width) for class-specific or class-agnostic
+ prediction.
+ labels (list): The ground truth class for each instance.
+ num_points (int): The number of points to sample.
+ oversample_ratio (int): Oversampling parameter.
+ importance_sample_ratio (float): Ratio of points that are sampled
+ via importnace sampling.
+
+ Returns:
+ point_coords (Tensor): A tensor of shape (num_rois, num_points, 2)
+ that contains the coordinates sampled points.
+ """
+ assert oversample_ratio >= 1
+ assert 0 <= importance_sample_ratio <= 1
+ batch_size = mask_pred.shape[0]
+ num_sampled = int(num_points * oversample_ratio)
+ point_coords = torch.rand(batch_size, num_sampled, 2, device=mask_pred.device)
+ point_logits = point_sample(mask_pred, point_coords)
+ # It is crucial to calculate uncertainty based on the sampled
+ # prediction value for the points. Calculating uncertainties of the
+ # coarse predictions first and sampling them for points leads to
+ # incorrect results. To illustrate this: assume uncertainty func(
+ # logits)=-abs(logits), a sampled point between two coarse
+ # predictions with -1 and 1 logits has 0 logits, and therefore 0
+ # uncertainty value. However, if we calculate uncertainties for the
+ # coarse predictions first, both will have -1 uncertainty,
+ # and sampled point will get -1 uncertainty.
+ point_uncertainties = get_uncertainty(point_logits, labels)
+ num_uncertain_points = int(importance_sample_ratio * num_points)
+ num_random_points = num_points - num_uncertain_points
+ idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+ shift = num_sampled * torch.arange(batch_size, dtype=torch.long, device=mask_pred.device)
+ idx += shift[:, None]
+ point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(batch_size, num_uncertain_points, 2)
+ if num_random_points > 0:
+ rand_roi_coords = torch.rand(batch_size, num_random_points, 2, device=mask_pred.device)
+ point_coords = torch.cat((point_coords, rand_roi_coords), dim=1)
+ return point_coords
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py
new file mode 100644
index 0000000..bf5d6fa
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/positional_encoding.py
@@ -0,0 +1,152 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+
+import torch
+import torch.nn as nn
+from mmcv.cnn.bricks.transformer import POSITIONAL_ENCODING
+from mmcv.runner import BaseModule
+
+
+@POSITIONAL_ENCODING.register_module()
+class SinePositionalEncoding(BaseModule):
+ """Position encoding with sine and cosine functions.
+
+ See `End-to-End Object Detection with Transformers
+ `_ for details.
+
+ Args:
+ num_feats (int): The feature dimension for each position
+ along x-axis or y-axis. Note the final returned dimension
+ for each position is 2 times of this value.
+ temperature (int, optional): The temperature used for scaling
+ the position embedding. Defaults to 10000.
+ normalize (bool, optional): Whether to normalize the position
+ embedding. Defaults to False.
+ scale (float, optional): A scale factor that scales the position
+ embedding. The scale will be used only when `normalize` is True.
+ Defaults to 2*pi.
+ eps (float, optional): A value added to the denominator for
+ numerical stability. Defaults to 1e-6.
+ offset (float): offset add to embed when do the normalization.
+ Defaults to 0.
+ init_cfg (dict or list[dict], optional): Initialization config dict.
+ Default: None
+ """
+
+ def __init__(
+ self, num_feats, temperature=10000, normalize=False, scale=2 * math.pi, eps=1e-6, offset=0.0, init_cfg=None
+ ):
+ super(SinePositionalEncoding, self).__init__(init_cfg)
+ if normalize:
+ assert isinstance(scale, (float, int)), (
+ "when normalize is set," "scale should be provided and in float or int type, " f"found {type(scale)}"
+ )
+ self.num_feats = num_feats
+ self.temperature = temperature
+ self.normalize = normalize
+ self.scale = scale
+ self.eps = eps
+ self.offset = offset
+
+ def forward(self, mask):
+ """Forward function for `SinePositionalEncoding`.
+
+ Args:
+ mask (Tensor): ByteTensor mask. Non-zero values representing
+ ignored positions, while zero values means valid positions
+ for this image. Shape [bs, h, w].
+
+ Returns:
+ pos (Tensor): Returned position embedding with shape
+ [bs, num_feats*2, h, w].
+ """
+ # For convenience of exporting to ONNX, it's required to convert
+ # `masks` from bool to int.
+ mask = mask.to(torch.int)
+ not_mask = 1 - mask # logical_not
+ y_embed = not_mask.cumsum(1, dtype=torch.float32)
+ x_embed = not_mask.cumsum(2, dtype=torch.float32)
+ if self.normalize:
+ y_embed = (y_embed + self.offset) / (y_embed[:, -1:, :] + self.eps) * self.scale
+ x_embed = (x_embed + self.offset) / (x_embed[:, :, -1:] + self.eps) * self.scale
+ dim_t = torch.arange(self.num_feats, dtype=torch.float32, device=mask.device)
+ dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_feats)
+ pos_x = x_embed[:, :, :, None] / dim_t
+ pos_y = y_embed[:, :, :, None] / dim_t
+ # use `view` instead of `flatten` for dynamically exporting to ONNX
+ B, H, W = mask.size()
+ pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1)
+ pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).view(B, H, W, -1)
+ pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+ return pos
+
+ def __repr__(self):
+ """str: a string that describes the module"""
+ repr_str = self.__class__.__name__
+ repr_str += f"(num_feats={self.num_feats}, "
+ repr_str += f"temperature={self.temperature}, "
+ repr_str += f"normalize={self.normalize}, "
+ repr_str += f"scale={self.scale}, "
+ repr_str += f"eps={self.eps})"
+ return repr_str
+
+
+@POSITIONAL_ENCODING.register_module()
+class LearnedPositionalEncoding(BaseModule):
+ """Position embedding with learnable embedding weights.
+
+ Args:
+ num_feats (int): The feature dimension for each position
+ along x-axis or y-axis. The final returned dimension for
+ each position is 2 times of this value.
+ row_num_embed (int, optional): The dictionary size of row embeddings.
+ Default 50.
+ col_num_embed (int, optional): The dictionary size of col embeddings.
+ Default 50.
+ init_cfg (dict or list[dict], optional): Initialization config dict.
+ """
+
+ def __init__(self, num_feats, row_num_embed=50, col_num_embed=50, init_cfg=dict(type="Uniform", layer="Embedding")):
+ super(LearnedPositionalEncoding, self).__init__(init_cfg)
+ self.row_embed = nn.Embedding(row_num_embed, num_feats)
+ self.col_embed = nn.Embedding(col_num_embed, num_feats)
+ self.num_feats = num_feats
+ self.row_num_embed = row_num_embed
+ self.col_num_embed = col_num_embed
+
+ def forward(self, mask):
+ """Forward function for `LearnedPositionalEncoding`.
+
+ Args:
+ mask (Tensor): ByteTensor mask. Non-zero values representing
+ ignored positions, while zero values means valid positions
+ for this image. Shape [bs, h, w].
+
+ Returns:
+ pos (Tensor): Returned position embedding with shape
+ [bs, num_feats*2, h, w].
+ """
+ h, w = mask.shape[-2:]
+ x = torch.arange(w, device=mask.device)
+ y = torch.arange(h, device=mask.device)
+ x_embed = self.col_embed(x)
+ y_embed = self.row_embed(y)
+ pos = (
+ torch.cat((x_embed.unsqueeze(0).repeat(h, 1, 1), y_embed.unsqueeze(1).repeat(1, w, 1)), dim=-1)
+ .permute(2, 0, 1)
+ .unsqueeze(0)
+ .repeat(mask.shape[0], 1, 1, 1)
+ )
+ return pos
+
+ def __repr__(self):
+ """str: a string that describes the module"""
+ repr_str = self.__class__.__name__
+ repr_str += f"(num_feats={self.num_feats}, "
+ repr_str += f"row_num_embed={self.row_num_embed}, "
+ repr_str += f"col_num_embed={self.col_num_embed})"
+ return repr_str
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/transformer.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/transformer.py
new file mode 100644
index 0000000..8befe60
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/models/utils/transformer.py
@@ -0,0 +1,989 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+import warnings
+from typing import Sequence
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from mmcv.cnn import Linear, build_activation_layer, build_norm_layer, xavier_init
+from mmcv.cnn.bricks.drop import build_dropout
+from mmcv.cnn.bricks.registry import FEEDFORWARD_NETWORK, TRANSFORMER_LAYER, TRANSFORMER_LAYER_SEQUENCE
+from mmcv.cnn.bricks.transformer import BaseTransformerLayer, TransformerLayerSequence, build_transformer_layer_sequence
+from mmcv.runner.base_module import BaseModule, Sequential
+from mmcv.utils import deprecated_api_warning, to_2tuple
+from torch.nn.init import normal_
+
+from ..builder import TRANSFORMER
+
+try:
+ from mmcv.ops.multi_scale_deform_attn import MultiScaleDeformableAttention
+
+except ImportError:
+ warnings.warn(
+ "`MultiScaleDeformableAttention` in MMCV has been moved to "
+ "`mmcv.ops.multi_scale_deform_attn`, please update your MMCV"
+ )
+ from mmcv.cnn.bricks.transformer import MultiScaleDeformableAttention
+
+
+class AdaptivePadding(nn.Module):
+ """Applies padding to input (if needed) so that input can get fully covered
+ by filter you specified. It support two modes "same" and "corner". The
+ "same" mode is same with "SAME" padding mode in TensorFlow, pad zero around
+ input. The "corner" mode would pad zero to bottom right.
+
+ Args:
+ kernel_size (int | tuple): Size of the kernel:
+ stride (int | tuple): Stride of the filter. Default: 1:
+ dilation (int | tuple): Spacing between kernel elements.
+ Default: 1
+ padding (str): Support "same" and "corner", "corner" mode
+ would pad zero to bottom right, and "same" mode would
+ pad zero around input. Default: "corner".
+ Example:
+ >>> kernel_size = 16
+ >>> stride = 16
+ >>> dilation = 1
+ >>> input = torch.rand(1, 1, 15, 17)
+ >>> adap_pad = AdaptivePadding(
+ >>> kernel_size=kernel_size,
+ >>> stride=stride,
+ >>> dilation=dilation,
+ >>> padding="corner")
+ >>> out = adap_pad(input)
+ >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+ >>> input = torch.rand(1, 1, 16, 17)
+ >>> out = adap_pad(input)
+ >>> assert (out.shape[2], out.shape[3]) == (16, 32)
+ """
+
+ def __init__(self, kernel_size=1, stride=1, dilation=1, padding="corner"):
+
+ super(AdaptivePadding, self).__init__()
+
+ assert padding in ("same", "corner")
+
+ kernel_size = to_2tuple(kernel_size)
+ stride = to_2tuple(stride)
+ padding = to_2tuple(padding)
+ dilation = to_2tuple(dilation)
+
+ self.padding = padding
+ self.kernel_size = kernel_size
+ self.stride = stride
+ self.dilation = dilation
+
+ def get_pad_shape(self, input_shape):
+ input_h, input_w = input_shape
+ kernel_h, kernel_w = self.kernel_size
+ stride_h, stride_w = self.stride
+ output_h = math.ceil(input_h / stride_h)
+ output_w = math.ceil(input_w / stride_w)
+ pad_h = max((output_h - 1) * stride_h + (kernel_h - 1) * self.dilation[0] + 1 - input_h, 0)
+ pad_w = max((output_w - 1) * stride_w + (kernel_w - 1) * self.dilation[1] + 1 - input_w, 0)
+ return pad_h, pad_w
+
+ def forward(self, x):
+ pad_h, pad_w = self.get_pad_shape(x.size()[-2:])
+ if pad_h > 0 or pad_w > 0:
+ if self.padding == "corner":
+ x = F.pad(x, [0, pad_w, 0, pad_h])
+ elif self.padding == "same":
+ x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
+ return x
+
+
+class PatchMerging(BaseModule):
+ """Merge patch feature map.
+
+ This layer groups feature map by kernel_size, and applies norm and linear
+ layers to the grouped feature map. Our implementation uses `nn.Unfold` to
+ merge patch, which is about 25% faster than original implementation.
+ Instead, we need to modify pretrained models for compatibility.
+
+ Args:
+ in_channels (int): The num of input channels.
+ to gets fully covered by filter and stride you specified..
+ Default: True.
+ out_channels (int): The num of output channels.
+ kernel_size (int | tuple, optional): the kernel size in the unfold
+ layer. Defaults to 2.
+ stride (int | tuple, optional): the stride of the sliding blocks in the
+ unfold layer. Default: None. (Would be set as `kernel_size`)
+ padding (int | tuple | string ): The padding length of
+ embedding conv. When it is a string, it means the mode
+ of adaptive padding, support "same" and "corner" now.
+ Default: "corner".
+ dilation (int | tuple, optional): dilation parameter in the unfold
+ layer. Default: 1.
+ bias (bool, optional): Whether to add bias in linear layer or not.
+ Defaults: False.
+ norm_cfg (dict, optional): Config dict for normalization layer.
+ Default: dict(type='LN').
+ init_cfg (dict, optional): The extra config for initialization.
+ Default: None.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ kernel_size=2,
+ stride=None,
+ padding="corner",
+ dilation=1,
+ bias=False,
+ norm_cfg=dict(type="LN"),
+ init_cfg=None,
+ ):
+ super().__init__(init_cfg=init_cfg)
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ if stride:
+ stride = stride
+ else:
+ stride = kernel_size
+
+ kernel_size = to_2tuple(kernel_size)
+ stride = to_2tuple(stride)
+ dilation = to_2tuple(dilation)
+
+ if isinstance(padding, str):
+ self.adap_padding = AdaptivePadding(
+ kernel_size=kernel_size, stride=stride, dilation=dilation, padding=padding
+ )
+ # disable the padding of unfold
+ padding = 0
+ else:
+ self.adap_padding = None
+
+ padding = to_2tuple(padding)
+ self.sampler = nn.Unfold(kernel_size=kernel_size, dilation=dilation, padding=padding, stride=stride)
+
+ sample_dim = kernel_size[0] * kernel_size[1] * in_channels
+
+ if norm_cfg is not None:
+ self.norm = build_norm_layer(norm_cfg, sample_dim)[1]
+ else:
+ self.norm = None
+
+ self.reduction = nn.Linear(sample_dim, out_channels, bias=bias)
+
+ def forward(self, x, input_size):
+ """
+ Args:
+ x (Tensor): Has shape (B, H*W, C_in).
+ input_size (tuple[int]): The spatial shape of x, arrange as (H, W).
+ Default: None.
+
+ Returns:
+ tuple: Contains merged results and its spatial shape.
+
+ - x (Tensor): Has shape (B, Merged_H * Merged_W, C_out)
+ - out_size (tuple[int]): Spatial shape of x, arrange as
+ (Merged_H, Merged_W).
+ """
+ B, L, C = x.shape
+ assert isinstance(input_size, Sequence), f"Expect " f"input_size is " f"`Sequence` " f"but get {input_size}"
+
+ H, W = input_size
+ assert L == H * W, "input feature has wrong size"
+
+ x = x.view(B, H, W, C).permute([0, 3, 1, 2]) # B, C, H, W
+ # Use nn.Unfold to merge patch. About 25% faster than original method,
+ # but need to modify pretrained model for compatibility
+
+ if self.adap_padding:
+ x = self.adap_padding(x)
+ H, W = x.shape[-2:]
+
+ x = self.sampler(x)
+ # if kernel_size=2 and stride=2, x should has shape (B, 4*C, H/2*W/2)
+
+ out_h = (
+ H + 2 * self.sampler.padding[0] - self.sampler.dilation[0] * (self.sampler.kernel_size[0] - 1) - 1
+ ) // self.sampler.stride[0] + 1
+ out_w = (
+ W + 2 * self.sampler.padding[1] - self.sampler.dilation[1] * (self.sampler.kernel_size[1] - 1) - 1
+ ) // self.sampler.stride[1] + 1
+
+ output_size = (out_h, out_w)
+ x = x.transpose(1, 2) # B, H/2*W/2, 4*C
+ x = self.norm(x) if self.norm else x
+ x = self.reduction(x)
+ return x, output_size
+
+
+def inverse_sigmoid(x, eps=1e-5):
+ """Inverse function of sigmoid.
+
+ Args:
+ x (Tensor): The tensor to do the
+ inverse.
+ eps (float): EPS avoid numerical
+ overflow. Defaults 1e-5.
+ Returns:
+ Tensor: The x has passed the inverse
+ function of sigmoid, has same
+ shape with input.
+ """
+ x = x.clamp(min=0, max=1)
+ x1 = x.clamp(min=eps)
+ x2 = (1 - x).clamp(min=eps)
+ return torch.log(x1 / x2)
+
+
+@FEEDFORWARD_NETWORK.register_module(force=True)
+class FFN(BaseModule):
+ """Implements feed-forward networks (FFNs) with identity connection.
+ Args:
+ embed_dims (int): The feature dimension. Same as
+ `MultiheadAttention`. Defaults: 256.
+ feedforward_channels (int): The hidden dimension of FFNs.
+ Defaults: 1024.
+ num_fcs (int, optional): The number of fully-connected layers in
+ FFNs. Default: 2.
+ act_cfg (dict, optional): The activation config for FFNs.
+ Default: dict(type='ReLU')
+ ffn_drop (float, optional): Probability of an element to be
+ zeroed in FFN. Default 0.0.
+ add_identity (bool, optional): Whether to add the
+ identity connection. Default: `True`.
+ dropout_layer (obj:`ConfigDict`): The dropout_layer used
+ when adding the shortcut.
+ init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+ Default: None.
+ """
+
+ @deprecated_api_warning({"dropout": "ffn_drop", "add_residual": "add_identity"}, cls_name="FFN")
+ def __init__(
+ self,
+ embed_dims=256,
+ feedforward_channels=1024,
+ num_fcs=2,
+ act_cfg=dict(type="ReLU", inplace=True),
+ ffn_drop=0.0,
+ dropout_layer=None,
+ add_identity=True,
+ init_cfg=None,
+ with_cp=False,
+ **kwargs,
+ ):
+ super().__init__(init_cfg)
+ assert num_fcs >= 2, "num_fcs should be no less " f"than 2. got {num_fcs}."
+ self.embed_dims = embed_dims
+ self.feedforward_channels = feedforward_channels
+ self.num_fcs = num_fcs
+ self.act_cfg = act_cfg
+ self.activate = build_activation_layer(act_cfg)
+ self.with_cp = with_cp
+ layers = []
+ in_channels = embed_dims
+ for _ in range(num_fcs - 1):
+ layers.append(Sequential(Linear(in_channels, feedforward_channels), self.activate, nn.Dropout(ffn_drop)))
+ in_channels = feedforward_channels
+ layers.append(Linear(feedforward_channels, embed_dims))
+ layers.append(nn.Dropout(ffn_drop))
+ self.layers = Sequential(*layers)
+ self.dropout_layer = build_dropout(dropout_layer) if dropout_layer else torch.nn.Identity()
+ self.add_identity = add_identity
+
+ @deprecated_api_warning({"residual": "identity"}, cls_name="FFN")
+ def forward(self, x, identity=None):
+ """Forward function for `FFN`.
+ The function would add x to the output tensor if residue is None.
+ """
+
+ if self.with_cp and x.requires_grad:
+ out = cp.checkpoint(self.layers, x)
+ else:
+ out = self.layers(x)
+
+ if not self.add_identity:
+ return self.dropout_layer(out)
+ if identity is None:
+ identity = x
+ return identity + self.dropout_layer(out)
+
+
+@TRANSFORMER_LAYER.register_module()
+class DetrTransformerDecoderLayer(BaseTransformerLayer):
+ """Implements decoder layer in DETR transformer.
+
+ Args:
+ attn_cfgs (list[`mmcv.ConfigDict`] | list[dict] | dict )):
+ Configs for self_attention or cross_attention, the order
+ should be consistent with it in `operation_order`. If it is
+ a dict, it would be expand to the number of attention in
+ `operation_order`.
+ feedforward_channels (int): The hidden dimension for FFNs.
+ ffn_dropout (float): Probability of an element to be zeroed
+ in ffn. Default 0.0.
+ operation_order (tuple[str]): The execution order of operation
+ in transformer. Such as ('self_attn', 'norm', 'ffn', 'norm').
+ Default：None
+ act_cfg (dict): The activation config for FFNs. Default: `LN`
+ norm_cfg (dict): Config dict for normalization layer.
+ Default: `LN`.
+ ffn_num_fcs (int): The number of fully-connected layers in FFNs.
+ Default：2.
+ """
+
+ def __init__(
+ self,
+ attn_cfgs,
+ feedforward_channels,
+ ffn_dropout=0.0,
+ operation_order=None,
+ act_cfg=dict(type="ReLU", inplace=True),
+ norm_cfg=dict(type="LN"),
+ ffn_num_fcs=2,
+ **kwargs,
+ ):
+ super(DetrTransformerDecoderLayer, self).__init__(
+ attn_cfgs=attn_cfgs,
+ feedforward_channels=feedforward_channels,
+ ffn_dropout=ffn_dropout,
+ operation_order=operation_order,
+ act_cfg=act_cfg,
+ norm_cfg=norm_cfg,
+ ffn_num_fcs=ffn_num_fcs,
+ **kwargs,
+ )
+ assert len(operation_order) == 6
+ assert set(operation_order) == set(["self_attn", "norm", "cross_attn", "ffn"])
+
+
+@TRANSFORMER_LAYER_SEQUENCE.register_module()
+class DetrTransformerEncoder(TransformerLayerSequence):
+ """TransformerEncoder of DETR.
+
+ Args:
+ post_norm_cfg (dict): Config of last normalization layer. Default：
+ `LN`. Only used when `self.pre_norm` is `True`
+ """
+
+ def __init__(self, *args, post_norm_cfg=dict(type="LN"), **kwargs):
+ super(DetrTransformerEncoder, self).__init__(*args, **kwargs)
+ if post_norm_cfg is not None:
+ self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1] if self.pre_norm else None
+ else:
+ assert not self.pre_norm, f"Use prenorm in " f"{self.__class__.__name__}," f"Please specify post_norm_cfg"
+ self.post_norm = None
+
+ def forward(self, *args, **kwargs):
+ """Forward function for `TransformerCoder`.
+
+ Returns:
+ Tensor: forwarded results with shape [num_query, bs, embed_dims].
+ """
+ x = super(DetrTransformerEncoder, self).forward(*args, **kwargs)
+ if self.post_norm is not None:
+ x = self.post_norm(x)
+ return x
+
+
+@TRANSFORMER_LAYER_SEQUENCE.register_module()
+class DetrTransformerDecoder(TransformerLayerSequence):
+ """Implements the decoder in DETR transformer.
+
+ Args:
+ return_intermediate (bool): Whether to return intermediate outputs.
+ post_norm_cfg (dict): Config of last normalization layer. Default：
+ `LN`.
+ """
+
+ def __init__(self, *args, post_norm_cfg=dict(type="LN"), return_intermediate=False, **kwargs):
+
+ super(DetrTransformerDecoder, self).__init__(*args, **kwargs)
+ self.return_intermediate = return_intermediate
+ if post_norm_cfg is not None:
+ self.post_norm = build_norm_layer(post_norm_cfg, self.embed_dims)[1]
+ else:
+ self.post_norm = None
+
+ def forward(self, query, *args, **kwargs):
+ """Forward function for `TransformerDecoder`.
+
+ Args:
+ query (Tensor): Input query with shape
+ `(num_query, bs, embed_dims)`.
+
+ Returns:
+ Tensor: Results with shape [1, num_query, bs, embed_dims] when
+ return_intermediate is `False`, otherwise it has shape
+ [num_layers, num_query, bs, embed_dims].
+ """
+ if not self.return_intermediate:
+ x = super().forward(query, *args, **kwargs)
+ if self.post_norm:
+ x = self.post_norm(x)[None]
+ return x
+
+ intermediate = []
+ for layer in self.layers:
+ query = layer(query, *args, **kwargs)
+ if self.return_intermediate:
+ if self.post_norm is not None:
+ intermediate.append(self.post_norm(query))
+ else:
+ intermediate.append(query)
+ return torch.stack(intermediate)
+
+
+@TRANSFORMER.register_module()
+class Transformer(BaseModule):
+ """Implements the DETR transformer.
+
+ Following the official DETR implementation, this module copy-paste
+ from torch.nn.Transformer with modifications:
+
+ * positional encodings are passed in MultiheadAttention
+ * extra LN at the end of encoder is removed
+ * decoder returns a stack of activations from all decoding layers
+
+ See `paper: End-to-End Object Detection with Transformers
+ `_ for details.
+
+ Args:
+ encoder (`mmcv.ConfigDict` | Dict): Config of
+ TransformerEncoder. Defaults to None.
+ decoder ((`mmcv.ConfigDict` | Dict)): Config of
+ TransformerDecoder. Defaults to None
+ init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+ Defaults to None.
+ """
+
+ def __init__(self, encoder=None, decoder=None, init_cfg=None):
+ super(Transformer, self).__init__(init_cfg=init_cfg)
+ self.encoder = build_transformer_layer_sequence(encoder)
+ self.decoder = build_transformer_layer_sequence(decoder)
+ self.embed_dims = self.encoder.embed_dims
+
+ def init_weights(self):
+ # follow the official DETR to init parameters
+ for m in self.modules():
+ if hasattr(m, "weight") and m.weight.dim() > 1:
+ xavier_init(m, distribution="uniform")
+ self._is_init = True
+
+ def forward(self, x, mask, query_embed, pos_embed):
+ """Forward function for `Transformer`.
+
+ Args:
+ x (Tensor): Input query with shape [bs, c, h, w] where
+ c = embed_dims.
+ mask (Tensor): The key_padding_mask used for encoder and decoder,
+ with shape [bs, h, w].
+ query_embed (Tensor): The query embedding for decoder, with shape
+ [num_query, c].
+ pos_embed (Tensor): The positional encoding for encoder and
+ decoder, with the same shape as `x`.
+
+ Returns:
+ tuple[Tensor]: results of decoder containing the following tensor.
+
+ - out_dec: Output from decoder. If return_intermediate_dec \
+ is True output has shape [num_dec_layers, bs,
+ num_query, embed_dims], else has shape [1, bs, \
+ num_query, embed_dims].
+ - memory: Output results from encoder, with shape \
+ [bs, embed_dims, h, w].
+ """
+ bs, c, h, w = x.shape
+ # use `view` instead of `flatten` for dynamically exporting to ONNX
+ x = x.view(bs, c, -1).permute(2, 0, 1) # [bs, c, h, w] -> [h*w, bs, c]
+ pos_embed = pos_embed.view(bs, c, -1).permute(2, 0, 1)
+ query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) # [num_query, dim] -> [num_query, bs, dim]
+ mask = mask.view(bs, -1) # [bs, h, w] -> [bs, h*w]
+ memory = self.encoder(query=x, key=None, value=None, query_pos=pos_embed, query_key_padding_mask=mask)
+ target = torch.zeros_like(query_embed)
+ # out_dec: [num_layers, num_query, bs, dim]
+ out_dec = self.decoder(
+ query=target, key=memory, value=memory, key_pos=pos_embed, query_pos=query_embed, key_padding_mask=mask
+ )
+ out_dec = out_dec.transpose(1, 2)
+ memory = memory.permute(1, 2, 0).reshape(bs, c, h, w)
+ return out_dec, memory
+
+
+@TRANSFORMER_LAYER_SEQUENCE.register_module()
+class DeformableDetrTransformerDecoder(TransformerLayerSequence):
+ """Implements the decoder in DETR transformer.
+
+ Args:
+ return_intermediate (bool): Whether to return intermediate outputs.
+ coder_norm_cfg (dict): Config of last normalization layer. Default：
+ `LN`.
+ """
+
+ def __init__(self, *args, return_intermediate=False, **kwargs):
+
+ super(DeformableDetrTransformerDecoder, self).__init__(*args, **kwargs)
+ self.return_intermediate = return_intermediate
+
+ def forward(self, query, *args, reference_points=None, valid_ratios=None, reg_branches=None, **kwargs):
+ """Forward function for `TransformerDecoder`.
+
+ Args:
+ query (Tensor): Input query with shape
+ `(num_query, bs, embed_dims)`.
+ reference_points (Tensor): The reference
+ points of offset. has shape
+ (bs, num_query, 4) when as_two_stage,
+ otherwise has shape ((bs, num_query, 2).
+ valid_ratios (Tensor): The radios of valid
+ points on the feature map, has shape
+ (bs, num_levels, 2)
+ reg_branch: (obj:`nn.ModuleList`): Used for
+ refining the regression results. Only would
+ be passed when with_box_refine is True,
+ otherwise would be passed a `None`.
+
+ Returns:
+ Tensor: Results with shape [1, num_query, bs, embed_dims] when
+ return_intermediate is `False`, otherwise it has shape
+ [num_layers, num_query, bs, embed_dims].
+ """
+ output = query
+ intermediate = []
+ intermediate_reference_points = []
+ for lid, layer in enumerate(self.layers):
+ if reference_points.shape[-1] == 4:
+ reference_points_input = (
+ reference_points[:, :, None] * torch.cat([valid_ratios, valid_ratios], -1)[:, None]
+ )
+ else:
+ assert reference_points.shape[-1] == 2
+ reference_points_input = reference_points[:, :, None] * valid_ratios[:, None]
+ output = layer(output, *args, reference_points=reference_points_input, **kwargs)
+ output = output.permute(1, 0, 2)
+
+ if reg_branches is not None:
+ tmp = reg_branches[lid](output)
+ if reference_points.shape[-1] == 4:
+ new_reference_points = tmp + inverse_sigmoid(reference_points)
+ new_reference_points = new_reference_points.sigmoid()
+ else:
+ assert reference_points.shape[-1] == 2
+ new_reference_points = tmp
+ new_reference_points[..., :2] = tmp[..., :2] + inverse_sigmoid(reference_points)
+ new_reference_points = new_reference_points.sigmoid()
+ reference_points = new_reference_points.detach()
+
+ output = output.permute(1, 0, 2)
+ if self.return_intermediate:
+ intermediate.append(output)
+ intermediate_reference_points.append(reference_points)
+
+ if self.return_intermediate:
+ return torch.stack(intermediate), torch.stack(intermediate_reference_points)
+
+ return output, reference_points
+
+
+@TRANSFORMER.register_module()
+class DeformableDetrTransformer(Transformer):
+ """Implements the DeformableDETR transformer.
+
+ Args:
+ as_two_stage (bool): Generate query from encoder features.
+ Default: False.
+ num_feature_levels (int): Number of feature maps from FPN:
+ Default: 4.
+ two_stage_num_proposals (int): Number of proposals when set
+ `as_two_stage` as True. Default: 300.
+ """
+
+ def __init__(self, as_two_stage=False, num_feature_levels=4, two_stage_num_proposals=300, **kwargs):
+ super(DeformableDetrTransformer, self).__init__(**kwargs)
+ self.as_two_stage = as_two_stage
+ self.num_feature_levels = num_feature_levels
+ self.two_stage_num_proposals = two_stage_num_proposals
+ self.embed_dims = self.encoder.embed_dims
+ self.init_layers()
+
+ def init_layers(self):
+ """Initialize layers of the DeformableDetrTransformer."""
+ self.level_embeds = nn.Parameter(torch.Tensor(self.num_feature_levels, self.embed_dims))
+
+ if self.as_two_stage:
+ self.enc_output = nn.Linear(self.embed_dims, self.embed_dims)
+ self.enc_output_norm = nn.LayerNorm(self.embed_dims)
+ self.pos_trans = nn.Linear(self.embed_dims * 2, self.embed_dims * 2)
+ self.pos_trans_norm = nn.LayerNorm(self.embed_dims * 2)
+ else:
+ self.reference_points = nn.Linear(self.embed_dims, 2)
+
+ def init_weights(self):
+ """Initialize the transformer weights."""
+ for p in self.parameters():
+ if p.dim() > 1:
+ nn.init.xavier_uniform_(p)
+ for m in self.modules():
+ if isinstance(m, MultiScaleDeformableAttention):
+ m.init_weights()
+ if not self.as_two_stage:
+ xavier_init(self.reference_points, distribution="uniform", bias=0.0)
+ normal_(self.level_embeds)
+
+ def gen_encoder_output_proposals(self, memory, memory_padding_mask, spatial_shapes):
+ """Generate proposals from encoded memory.
+
+ Args:
+ memory (Tensor) : The output of encoder,
+ has shape (bs, num_key, embed_dim). num_key is
+ equal the number of points on feature map from
+ all level.
+ memory_padding_mask (Tensor): Padding mask for memory.
+ has shape (bs, num_key).
+ spatial_shapes (Tensor): The shape of all feature maps.
+ has shape (num_level, 2).
+
+ Returns:
+ tuple: A tuple of feature map and bbox prediction.
+
+ - output_memory (Tensor): The input of decoder, \
+ has shape (bs, num_key, embed_dim). num_key is \
+ equal the number of points on feature map from \
+ all levels.
+ - output_proposals (Tensor): The normalized proposal \
+ after a inverse sigmoid, has shape \
+ (bs, num_keys, 4).
+ """
+
+ N, S, C = memory.shape
+ proposals = []
+ _cur = 0
+ for lvl, (H, W) in enumerate(spatial_shapes):
+ mask_flatten_ = memory_padding_mask[:, _cur : (_cur + H * W)].view(N, H, W, 1)
+ valid_H = torch.sum(~mask_flatten_[:, :, 0, 0], 1)
+ valid_W = torch.sum(~mask_flatten_[:, 0, :, 0], 1)
+
+ grid_y, grid_x = torch.meshgrid(
+ torch.linspace(0, H - 1, H, dtype=torch.float32, device=memory.device),
+ torch.linspace(0, W - 1, W, dtype=torch.float32, device=memory.device),
+ )
+ grid = torch.cat([grid_x.unsqueeze(-1), grid_y.unsqueeze(-1)], -1)
+
+ scale = torch.cat([valid_W.unsqueeze(-1), valid_H.unsqueeze(-1)], 1).view(N, 1, 1, 2)
+ grid = (grid.unsqueeze(0).expand(N, -1, -1, -1) + 0.5) / scale
+ wh = torch.ones_like(grid) * 0.05 * (2.0**lvl)
+ proposal = torch.cat((grid, wh), -1).view(N, -1, 4)
+ proposals.append(proposal)
+ _cur += H * W
+ output_proposals = torch.cat(proposals, 1)
+ output_proposals_valid = ((output_proposals > 0.01) & (output_proposals < 0.99)).all(-1, keepdim=True)
+ output_proposals = torch.log(output_proposals / (1 - output_proposals))
+ output_proposals = output_proposals.masked_fill(memory_padding_mask.unsqueeze(-1), float("inf"))
+ output_proposals = output_proposals.masked_fill(~output_proposals_valid, float("inf"))
+
+ output_memory = memory
+ output_memory = output_memory.masked_fill(memory_padding_mask.unsqueeze(-1), float(0))
+ output_memory = output_memory.masked_fill(~output_proposals_valid, float(0))
+ output_memory = self.enc_output_norm(self.enc_output(output_memory))
+ return output_memory, output_proposals
+
+ @staticmethod
+ def get_reference_points(spatial_shapes, valid_ratios, device):
+ """Get the reference points used in decoder.
+
+ Args:
+ spatial_shapes (Tensor): The shape of all
+ feature maps, has shape (num_level, 2).
+ valid_ratios (Tensor): The radios of valid
+ points on the feature map, has shape
+ (bs, num_levels, 2)
+ device (obj:`device`): The device where
+ reference_points should be.
+
+ Returns:
+ Tensor: reference points used in decoder, has \
+ shape (bs, num_keys, num_levels, 2).
+ """
+ reference_points_list = []
+ for lvl, (H, W) in enumerate(spatial_shapes):
+ ref_y, ref_x = torch.meshgrid(
+ torch.linspace(0.5, H - 0.5, H, dtype=torch.float32, device=device),
+ torch.linspace(0.5, W - 0.5, W, dtype=torch.float32, device=device),
+ )
+ ref_y = ref_y.reshape(-1)[None] / (valid_ratios[:, None, lvl, 1] * H)
+ ref_x = ref_x.reshape(-1)[None] / (valid_ratios[:, None, lvl, 0] * W)
+ ref = torch.stack((ref_x, ref_y), -1)
+ reference_points_list.append(ref)
+ reference_points = torch.cat(reference_points_list, 1)
+ reference_points = reference_points[:, :, None] * valid_ratios[:, None]
+ return reference_points
+
+ def get_valid_ratio(self, mask):
+ """Get the valid radios of feature maps of all level."""
+ _, H, W = mask.shape
+ valid_H = torch.sum(~mask[:, :, 0], 1)
+ valid_W = torch.sum(~mask[:, 0, :], 1)
+ valid_ratio_h = valid_H.float() / H
+ valid_ratio_w = valid_W.float() / W
+ valid_ratio = torch.stack([valid_ratio_w, valid_ratio_h], -1)
+ return valid_ratio
+
+ def get_proposal_pos_embed(self, proposals, num_pos_feats=128, temperature=10000):
+ """Get the position embedding of proposal."""
+ scale = 2 * math.pi
+ dim_t = torch.arange(num_pos_feats, dtype=torch.float32, device=proposals.device)
+ dim_t = temperature ** (2 * (dim_t // 2) / num_pos_feats)
+ # N, L, 4
+ proposals = proposals.sigmoid() * scale
+ # N, L, 4, 128
+ pos = proposals[:, :, :, None] / dim_t
+ # N, L, 4, 64, 2
+ pos = torch.stack((pos[:, :, :, 0::2].sin(), pos[:, :, :, 1::2].cos()), dim=4).flatten(2)
+ return pos
+
+ def forward(
+ self, mlvl_feats, mlvl_masks, query_embed, mlvl_pos_embeds, reg_branches=None, cls_branches=None, **kwargs
+ ):
+ """Forward function for `Transformer`.
+
+ Args:
+ mlvl_feats (list(Tensor)): Input queries from
+ different level. Each element has shape
+ [bs, embed_dims, h, w].
+ mlvl_masks (list(Tensor)): The key_padding_mask from
+ different level used for encoder and decoder,
+ each element has shape [bs, h, w].
+ query_embed (Tensor): The query embedding for decoder,
+ with shape [num_query, c].
+ mlvl_pos_embeds (list(Tensor)): The positional encoding
+ of feats from different level, has the shape
+ [bs, embed_dims, h, w].
+ reg_branches (obj:`nn.ModuleList`): Regression heads for
+ feature maps from each decoder layer. Only would
+ be passed when
+ `with_box_refine` is True. Default to None.
+ cls_branches (obj:`nn.ModuleList`): Classification heads
+ for feature maps from each decoder layer. Only would
+ be passed when `as_two_stage`
+ is True. Default to None.
+
+
+ Returns:
+ tuple[Tensor]: results of decoder containing the following tensor.
+
+ - inter_states: Outputs from decoder. If
+ return_intermediate_dec is True output has shape \
+ (num_dec_layers, bs, num_query, embed_dims), else has \
+ shape (1, bs, num_query, embed_dims).
+ - init_reference_out: The initial value of reference \
+ points, has shape (bs, num_queries, 4).
+ - inter_references_out: The internal value of reference \
+ points in decoder, has shape \
+ (num_dec_layers, bs,num_query, embed_dims)
+ - enc_outputs_class: The classification score of \
+ proposals generated from \
+ encoder's feature maps, has shape \
+ (batch, h*w, num_classes). \
+ Only would be returned when `as_two_stage` is True, \
+ otherwise None.
+ - enc_outputs_coord_unact: The regression results \
+ generated from encoder's feature maps., has shape \
+ (batch, h*w, 4). Only would \
+ be returned when `as_two_stage` is True, \
+ otherwise None.
+ """
+ assert self.as_two_stage or query_embed is not None
+
+ feat_flatten = []
+ mask_flatten = []
+ lvl_pos_embed_flatten = []
+ spatial_shapes = []
+ for lvl, (feat, mask, pos_embed) in enumerate(zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)):
+ bs, c, h, w = feat.shape
+ spatial_shape = (h, w)
+ spatial_shapes.append(spatial_shape)
+ feat = feat.flatten(2).transpose(1, 2)
+ mask = mask.flatten(1)
+ pos_embed = pos_embed.flatten(2).transpose(1, 2)
+ lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(1, 1, -1)
+ lvl_pos_embed_flatten.append(lvl_pos_embed)
+ feat_flatten.append(feat)
+ mask_flatten.append(mask)
+ feat_flatten = torch.cat(feat_flatten, 1)
+ mask_flatten = torch.cat(mask_flatten, 1)
+ lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
+ spatial_shapes = torch.as_tensor(spatial_shapes, dtype=torch.long, device=feat_flatten.device)
+ level_start_index = torch.cat((spatial_shapes.new_zeros((1,)), spatial_shapes.prod(1).cumsum(0)[:-1]))
+ valid_ratios = torch.stack([self.get_valid_ratio(m) for m in mlvl_masks], 1)
+
+ reference_points = self.get_reference_points(spatial_shapes, valid_ratios, device=feat.device)
+
+ feat_flatten = feat_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims)
+ lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(1, 0, 2) # (H*W, bs, embed_dims)
+ memory = self.encoder(
+ query=feat_flatten,
+ key=None,
+ value=None,
+ query_pos=lvl_pos_embed_flatten,
+ query_key_padding_mask=mask_flatten,
+ spatial_shapes=spatial_shapes,
+ reference_points=reference_points,
+ level_start_index=level_start_index,
+ valid_ratios=valid_ratios,
+ **kwargs,
+ )
+
+ memory = memory.permute(1, 0, 2)
+ bs, _, c = memory.shape
+ if self.as_two_stage:
+ output_memory, output_proposals = self.gen_encoder_output_proposals(memory, mask_flatten, spatial_shapes)
+ enc_outputs_class = cls_branches[self.decoder.num_layers](output_memory)
+ enc_outputs_coord_unact = reg_branches[self.decoder.num_layers](output_memory) + output_proposals
+
+ topk = self.two_stage_num_proposals
+ topk_proposals = torch.topk(enc_outputs_class[..., 0], topk, dim=1)[1]
+ topk_coords_unact = torch.gather(enc_outputs_coord_unact, 1, topk_proposals.unsqueeze(-1).repeat(1, 1, 4))
+ topk_coords_unact = topk_coords_unact.detach()
+ reference_points = topk_coords_unact.sigmoid()
+ init_reference_out = reference_points
+ pos_trans_out = self.pos_trans_norm(self.pos_trans(self.get_proposal_pos_embed(topk_coords_unact)))
+ query_pos, query = torch.split(pos_trans_out, c, dim=2)
+ else:
+ query_pos, query = torch.split(query_embed, c, dim=1)
+ query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1)
+ query = query.unsqueeze(0).expand(bs, -1, -1)
+ reference_points = self.reference_points(query_pos).sigmoid()
+ init_reference_out = reference_points
+
+ # decoder
+ query = query.permute(1, 0, 2)
+ memory = memory.permute(1, 0, 2)
+ query_pos = query_pos.permute(1, 0, 2)
+ inter_states, inter_references = self.decoder(
+ query=query,
+ key=None,
+ value=memory,
+ query_pos=query_pos,
+ key_padding_mask=mask_flatten,
+ reference_points=reference_points,
+ spatial_shapes=spatial_shapes,
+ level_start_index=level_start_index,
+ valid_ratios=valid_ratios,
+ reg_branches=reg_branches,
+ **kwargs,
+ )
+
+ inter_references_out = inter_references
+ if self.as_two_stage:
+ return inter_states, init_reference_out, inter_references_out, enc_outputs_class, enc_outputs_coord_unact
+ return inter_states, init_reference_out, inter_references_out, None, None
+
+
+@TRANSFORMER.register_module()
+class DynamicConv(BaseModule):
+ """Implements Dynamic Convolution.
+
+ This module generate parameters for each sample and
+ use bmm to implement 1*1 convolution. Code is modified
+ from the `official github repo `_ .
+
+ Args:
+ in_channels (int): The input feature channel.
+ Defaults to 256.
+ feat_channels (int): The inner feature channel.
+ Defaults to 64.
+ out_channels (int, optional): The output feature channel.
+ When not specified, it will be set to `in_channels`
+ by default
+ input_feat_shape (int): The shape of input feature.
+ Defaults to 7.
+ with_proj (bool): Project two-dimentional feature to
+ one-dimentional feature. Default to True.
+ act_cfg (dict): The activation config for DynamicConv.
+ norm_cfg (dict): Config dict for normalization layer. Default
+ layer normalization.
+ init_cfg (obj:`mmcv.ConfigDict`): The Config for initialization.
+ Default: None.
+ """
+
+ def __init__(
+ self,
+ in_channels=256,
+ feat_channels=64,
+ out_channels=None,
+ input_feat_shape=7,
+ with_proj=True,
+ act_cfg=dict(type="ReLU", inplace=True),
+ norm_cfg=dict(type="LN"),
+ init_cfg=None,
+ ):
+ super(DynamicConv, self).__init__(init_cfg)
+ self.in_channels = in_channels
+ self.feat_channels = feat_channels
+ self.out_channels_raw = out_channels
+ self.input_feat_shape = input_feat_shape
+ self.with_proj = with_proj
+ self.act_cfg = act_cfg
+ self.norm_cfg = norm_cfg
+ self.out_channels = out_channels if out_channels else in_channels
+
+ self.num_params_in = self.in_channels * self.feat_channels
+ self.num_params_out = self.out_channels * self.feat_channels
+ self.dynamic_layer = nn.Linear(self.in_channels, self.num_params_in + self.num_params_out)
+
+ self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1]
+ self.norm_out = build_norm_layer(norm_cfg, self.out_channels)[1]
+
+ self.activation = build_activation_layer(act_cfg)
+
+ num_output = self.out_channels * input_feat_shape**2
+ if self.with_proj:
+ self.fc_layer = nn.Linear(num_output, self.out_channels)
+ self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1]
+
+ def forward(self, param_feature, input_feature):
+ """Forward function for `DynamicConv`.
+
+ Args:
+ param_feature (Tensor): The feature can be used
+ to generate the parameter, has shape
+ (num_all_proposals, in_channels).
+ input_feature (Tensor): Feature that
+ interact with parameters, has shape
+ (num_all_proposals, in_channels, H, W).
+
+ Returns:
+ Tensor: The output feature has shape
+ (num_all_proposals, out_channels).
+ """
+ input_feature = input_feature.flatten(2).permute(2, 0, 1)
+
+ input_feature = input_feature.permute(1, 0, 2)
+ parameters = self.dynamic_layer(param_feature)
+
+ param_in = parameters[:, : self.num_params_in].view(-1, self.in_channels, self.feat_channels)
+ param_out = parameters[:, -self.num_params_out :].view(-1, self.feat_channels, self.out_channels)
+
+ # input_feature has shape (num_all_proposals, H*W, in_channels)
+ # param_in has shape (num_all_proposals, in_channels, feat_channels)
+ # feature has shape (num_all_proposals, H*W, feat_channels)
+ features = torch.bmm(input_feature, param_in)
+ features = self.norm_in(features)
+ features = self.activation(features)
+
+ # param_out has shape (batch_size, feat_channels, out_channels)
+ features = torch.bmm(features, param_out)
+ features = self.norm_out(features)
+ features = self.activation(features)
+
+ if self.with_proj:
+ features = features.flatten(1)
+ features = self.fc_layer(features)
+ features = self.fc_norm(features)
+ features = self.activation(features)
+
+ return features
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/__init__.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/__init__.py
new file mode 100644
index 0000000..49aa8fe
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/fundamentalvision/Deformable-DETR/tree/main/models/ops/modules
+# https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/tree/pytorch_1.0.0
+
+from .ms_deform_attn import MSDeformAttn
diff --git a/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py
new file mode 100644
index 0000000..d8b4fa2
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/segmentation_m2f/ops/modules/ms_deform_attn.py
@@ -0,0 +1,185 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+import warnings
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.autograd import Function
+from torch.cuda.amp import custom_fwd
+from torch.nn.init import constant_, xavier_uniform_
+
+
+class MSDeformAttnFunction(Function):
+ @staticmethod
+ @custom_fwd(cast_inputs=torch.float32)
+ def forward(
+ ctx, value, value_spatial_shapes, value_level_start_index, sampling_locations, attention_weights, im2col_step
+ ):
+ output = ms_deform_attn_core_pytorch(
+ value,
+ value_spatial_shapes,
+ # value_level_start_index,
+ sampling_locations,
+ attention_weights,
+ )
+ return output
+
+
+def ms_deform_attn_core_pytorch(value, value_spatial_shapes, sampling_locations, attention_weights):
+ # for debug and test only,
+ # need to use cuda version instead
+ N_, S_, M_, D_ = value.shape
+ _, Lq_, M_, L_, P_, _ = sampling_locations.shape
+ value_list = value.split([H_ * W_ for H_, W_ in value_spatial_shapes], dim=1)
+ sampling_grids = 2 * sampling_locations - 1
+ sampling_value_list = []
+ for lid_, (H_, W_) in enumerate(value_spatial_shapes):
+ # N_, H_*W_, M_, D_ -> N_, H_*W_, M_*D_ -> N_, M_*D_, H_*W_ -> N_*M_, D_, H_, W_
+ value_l_ = value_list[lid_].flatten(2).transpose(1, 2).reshape(N_ * M_, D_, H_, W_)
+ # N_, Lq_, M_, P_, 2 -> N_, M_, Lq_, P_, 2 -> N_*M_, Lq_, P_, 2
+ sampling_grid_l_ = sampling_grids[:, :, :, lid_].transpose(1, 2).flatten(0, 1)
+ # N_*M_, D_, Lq_, P_
+ sampling_value_l_ = F.grid_sample(
+ value_l_, sampling_grid_l_, mode="bilinear", padding_mode="zeros", align_corners=False
+ )
+ sampling_value_list.append(sampling_value_l_)
+ # (N_, Lq_, M_, L_, P_) -> (N_, M_, Lq_, L_, P_) -> (N_, M_, 1, Lq_, L_*P_)
+ attention_weights = attention_weights.transpose(1, 2).reshape(N_ * M_, 1, Lq_, L_ * P_)
+ output = (torch.stack(sampling_value_list, dim=-2).flatten(-2) * attention_weights).sum(-1).view(N_, M_ * D_, Lq_)
+ return output.transpose(1, 2).contiguous()
+
+
+def _is_power_of_2(n):
+ if (not isinstance(n, int)) or (n < 0):
+ raise ValueError("invalid input for _is_power_of_2: {} (type: {})".format(n, type(n)))
+ return (n & (n - 1) == 0) and n != 0
+
+
+class MSDeformAttn(nn.Module):
+ def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4, ratio=1.0):
+ """Multi-Scale Deformable Attention Module.
+
+ :param d_model hidden dimension
+ :param n_levels number of feature levels
+ :param n_heads number of attention heads
+ :param n_points number of sampling points per attention head per feature level
+ """
+ super().__init__()
+ if d_model % n_heads != 0:
+ raise ValueError("d_model must be divisible by n_heads, " "but got {} and {}".format(d_model, n_heads))
+ _d_per_head = d_model // n_heads
+ # you'd better set _d_per_head to a power of 2
+ # which is more efficient in our CUDA implementation
+ if not _is_power_of_2(_d_per_head):
+ warnings.warn(
+ "You'd better set d_model in MSDeformAttn to make "
+ "the dimension of each attention head a power of 2 "
+ "which is more efficient in our CUDA implementation."
+ )
+
+ self.im2col_step = 64
+
+ self.d_model = d_model
+ self.n_levels = n_levels
+ self.n_heads = n_heads
+ self.n_points = n_points
+ self.ratio = ratio
+ self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2)
+ self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points)
+ self.value_proj = nn.Linear(d_model, int(d_model * ratio))
+ self.output_proj = nn.Linear(int(d_model * ratio), d_model)
+
+ self._reset_parameters()
+
+ def _reset_parameters(self):
+ constant_(self.sampling_offsets.weight.data, 0.0)
+ thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads)
+ grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
+ grid_init = (
+ (grid_init / grid_init.abs().max(-1, keepdim=True)[0])
+ .view(self.n_heads, 1, 1, 2)
+ .repeat(1, self.n_levels, self.n_points, 1)
+ )
+ for i in range(self.n_points):
+ grid_init[:, :, i, :] *= i + 1
+
+ with torch.no_grad():
+ self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1))
+ constant_(self.attention_weights.weight.data, 0.0)
+ constant_(self.attention_weights.bias.data, 0.0)
+ xavier_uniform_(self.value_proj.weight.data)
+ constant_(self.value_proj.bias.data, 0.0)
+ xavier_uniform_(self.output_proj.weight.data)
+ constant_(self.output_proj.bias.data, 0.0)
+
+ def forward(
+ self,
+ query,
+ reference_points,
+ input_flatten,
+ input_spatial_shapes,
+ input_level_start_index,
+ input_padding_mask=None,
+ ):
+ """
+ :param query (N, Length_{query}, C)
+ :param reference_points (N, Length_{query}, n_levels, 2), range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area
+ or (N, Length_{query}, n_levels, 4), add additional (w, h) to form reference boxes
+ :param input_flatten (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l, C)
+ :param input_spatial_shapes (n_levels, 2), [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})]
+ :param input_level_start_index (n_levels, ), [0, H_0*W_0, H_0*W_0+H_1*W_1, H_0*W_0+H_1*W_1+H_2*W_2, ..., H_0*W_0+H_1*W_1+...+H_{L-1}*W_{L-1}]
+ :param input_padding_mask (N, \\sum_{l=0}^{L-1} H_l \\cdot W_l), True for padding elements, False for non-padding elements
+
+ :return output (N, Length_{query}, C)
+ """
+ # print(query.shape)
+ # print(reference_points.shape)
+ # print(input_flatten.shape)
+ # print(input_spatial_shapes.shape)
+ # print(input_level_start_index.shape)
+ # print(input_spatial_shapes)
+ # print(input_level_start_index)
+
+ N, Len_q, _ = query.shape
+ N, Len_in, _ = input_flatten.shape
+ assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == Len_in
+
+ value = self.value_proj(input_flatten)
+ if input_padding_mask is not None:
+ value = value.masked_fill(input_padding_mask[..., None], float(0))
+
+ value = value.view(N, Len_in, self.n_heads, int(self.ratio * self.d_model) // self.n_heads)
+ sampling_offsets = self.sampling_offsets(query).view(N, Len_q, self.n_heads, self.n_levels, self.n_points, 2)
+ attention_weights = self.attention_weights(query).view(N, Len_q, self.n_heads, self.n_levels * self.n_points)
+ attention_weights = F.softmax(attention_weights, -1).view(N, Len_q, self.n_heads, self.n_levels, self.n_points)
+
+ if reference_points.shape[-1] == 2:
+ offset_normalizer = torch.stack([input_spatial_shapes[..., 1], input_spatial_shapes[..., 0]], -1)
+ sampling_locations = (
+ reference_points[:, :, None, :, None, :]
+ + sampling_offsets / offset_normalizer[None, None, None, :, None, :]
+ )
+ elif reference_points.shape[-1] == 4:
+ sampling_locations = (
+ reference_points[:, :, None, :, None, :2]
+ + sampling_offsets / self.n_points * reference_points[:, :, None, :, None, 2:] * 0.5
+ )
+ else:
+ raise ValueError(
+ "Last dim of reference_points must be 2 or 4, but get {} instead.".format(reference_points.shape[-1])
+ )
+ output = MSDeformAttnFunction.apply(
+ value,
+ input_spatial_shapes,
+ input_level_start_index,
+ sampling_locations,
+ attention_weights,
+ self.im2col_step,
+ )
+ output = self.output_proj(output)
+ return output
diff --git a/facebookresearch/dinov2/dinov2/eval/setup.py b/facebookresearch/dinov2/dinov2/eval/setup.py
new file mode 100644
index 0000000..959128c
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/setup.py
@@ -0,0 +1,75 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+from typing import Any, List, Optional, Tuple
+
+import torch
+import torch.backends.cudnn as cudnn
+
+from dinov2.models import build_model_from_cfg
+from dinov2.utils.config import setup
+import dinov2.utils.utils as dinov2_utils
+
+
+def get_args_parser(
+ description: Optional[str] = None,
+ parents: Optional[List[argparse.ArgumentParser]] = None,
+ add_help: bool = True,
+):
+ parser = argparse.ArgumentParser(
+ description=description,
+ parents=parents or [],
+ add_help=add_help,
+ )
+ parser.add_argument(
+ "--config-file",
+ type=str,
+ help="Model configuration file",
+ )
+ parser.add_argument(
+ "--pretrained-weights",
+ type=str,
+ help="Pretrained model weights",
+ )
+ parser.add_argument(
+ "--output-dir",
+ default="",
+ type=str,
+ help="Output directory to write results and logs",
+ )
+ parser.add_argument(
+ "--opts",
+ help="Extra configuration options",
+ default=[],
+ nargs="+",
+ )
+ return parser
+
+
+def get_autocast_dtype(config):
+ teacher_dtype_str = config.compute_precision.teacher.backbone.mixed_precision.param_dtype
+ if teacher_dtype_str == "fp16":
+ return torch.half
+ elif teacher_dtype_str == "bf16":
+ return torch.bfloat16
+ else:
+ return torch.float
+
+
+def build_model_for_eval(config, pretrained_weights):
+ model, _ = build_model_from_cfg(config, only_teacher=True)
+ dinov2_utils.load_pretrained_weights(model, pretrained_weights, "teacher")
+ model.eval()
+ model.cuda()
+ return model
+
+
+def setup_and_build_model(args) -> Tuple[Any, torch.dtype]:
+ cudnn.benchmark = True
+ config = setup(args)
+ model = build_model_for_eval(config, args.pretrained_weights)
+ autocast_dtype = get_autocast_dtype(config)
+ return model, autocast_dtype
diff --git a/facebookresearch/dinov2/dinov2/eval/utils.py b/facebookresearch/dinov2/dinov2/eval/utils.py
new file mode 100644
index 0000000..c50576b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/eval/utils.py
@@ -0,0 +1,146 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+from typing import Dict, Optional
+
+import torch
+from torch import nn
+from torchmetrics import MetricCollection
+
+from dinov2.data import DatasetWithEnumeratedTargets, SamplerType, make_data_loader
+import dinov2.distributed as distributed
+from dinov2.logging import MetricLogger
+
+
+logger = logging.getLogger("dinov2")
+
+
+class ModelWithNormalize(torch.nn.Module):
+ def __init__(self, model):
+ super().__init__()
+ self.model = model
+
+ def forward(self, samples):
+ return nn.functional.normalize(self.model(samples), dim=1, p=2)
+
+
+class ModelWithIntermediateLayers(nn.Module):
+ def __init__(self, feature_model, n_last_blocks, autocast_ctx):
+ super().__init__()
+ self.feature_model = feature_model
+ self.feature_model.eval()
+ self.n_last_blocks = n_last_blocks
+ self.autocast_ctx = autocast_ctx
+
+ def forward(self, images):
+ with torch.inference_mode():
+ with self.autocast_ctx():
+ features = self.feature_model.get_intermediate_layers(
+ images, self.n_last_blocks, return_class_token=True
+ )
+ return features
+
+
+@torch.inference_mode()
+def evaluate(
+ model: nn.Module,
+ data_loader,
+ postprocessors: Dict[str, nn.Module],
+ metrics: Dict[str, MetricCollection],
+ device: torch.device,
+ criterion: Optional[nn.Module] = None,
+):
+ model.eval()
+ if criterion is not None:
+ criterion.eval()
+
+ for metric in metrics.values():
+ metric = metric.to(device)
+
+ metric_logger = MetricLogger(delimiter=" ")
+ header = "Test:"
+
+ for samples, targets, *_ in metric_logger.log_every(data_loader, 10, header):
+ outputs = model(samples.to(device))
+ targets = targets.to(device)
+
+ if criterion is not None:
+ loss = criterion(outputs, targets)
+ metric_logger.update(loss=loss.item())
+
+ for k, metric in metrics.items():
+ metric_inputs = postprocessors[k](outputs, targets)
+ metric.update(**metric_inputs)
+
+ metric_logger.synchronize_between_processes()
+ logger.info(f"Averaged stats: {metric_logger}")
+
+ stats = {k: metric.compute() for k, metric in metrics.items()}
+ metric_logger_stats = {k: meter.global_avg for k, meter in metric_logger.meters.items()}
+ return metric_logger_stats, stats
+
+
+def all_gather_and_flatten(tensor_rank):
+ tensor_all_ranks = torch.empty(
+ distributed.get_global_size(),
+ *tensor_rank.shape,
+ dtype=tensor_rank.dtype,
+ device=tensor_rank.device,
+ )
+ tensor_list = list(tensor_all_ranks.unbind(0))
+ torch.distributed.all_gather(tensor_list, tensor_rank.contiguous())
+ return tensor_all_ranks.flatten(end_dim=1)
+
+
+def extract_features(model, dataset, batch_size, num_workers, gather_on_cpu=False):
+ dataset_with_enumerated_targets = DatasetWithEnumeratedTargets(dataset)
+ sample_count = len(dataset_with_enumerated_targets)
+ data_loader = make_data_loader(
+ dataset=dataset_with_enumerated_targets,
+ batch_size=batch_size,
+ num_workers=num_workers,
+ sampler_type=SamplerType.DISTRIBUTED,
+ drop_last=False,
+ shuffle=False,
+ )
+ return extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu)
+
+
+@torch.inference_mode()
+def extract_features_with_dataloader(model, data_loader, sample_count, gather_on_cpu=False):
+ gather_device = torch.device("cpu") if gather_on_cpu else torch.device("cuda")
+ metric_logger = MetricLogger(delimiter=" ")
+ features, all_labels = None, None
+ for samples, (index, labels_rank) in metric_logger.log_every(data_loader, 10):
+ samples = samples.cuda(non_blocking=True)
+ labels_rank = labels_rank.cuda(non_blocking=True)
+ index = index.cuda(non_blocking=True)
+ features_rank = model(samples).float()
+
+ # init storage feature matrix
+ if features is None:
+ features = torch.zeros(sample_count, features_rank.shape[-1], device=gather_device)
+ labels_shape = list(labels_rank.shape)
+ labels_shape[0] = sample_count
+ all_labels = torch.full(labels_shape, fill_value=-1, device=gather_device)
+ logger.info(f"Storing features into tensor of shape {features.shape}")
+
+ # share indexes, features and labels between processes
+ index_all = all_gather_and_flatten(index).to(gather_device)
+ features_all_ranks = all_gather_and_flatten(features_rank).to(gather_device)
+ labels_all_ranks = all_gather_and_flatten(labels_rank).to(gather_device)
+
+ # update storage feature matrix
+ if len(index_all) > 0:
+ features.index_copy_(0, index_all, features_all_ranks)
+ all_labels.index_copy_(0, index_all, labels_all_ranks)
+
+ logger.info(f"Features shape: {tuple(features.shape)}")
+ logger.info(f"Labels shape: {tuple(all_labels.shape)}")
+
+ assert torch.all(all_labels > -1)
+
+ return features, all_labels
diff --git a/facebookresearch/dinov2/dinov2/fsdp/__init__.py b/facebookresearch/dinov2/dinov2/fsdp/__init__.py
new file mode 100644
index 0000000..ed45448
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/fsdp/__init__.py
@@ -0,0 +1,157 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import os
+from typing import Any
+
+import torch
+import dinov2.distributed as distributed
+from functools import partial
+from fvcore.common.checkpoint import Checkpointer
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.distributed.fsdp import ShardingStrategy
+from torch.distributed.fsdp import MixedPrecision
+from torch.distributed.fsdp import StateDictType
+from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler
+from torch.distributed.fsdp.wrap import ModuleWrapPolicy
+from torch.distributed.fsdp._runtime_utils import _reshard
+
+
+def get_fsdp_wrapper(model_cfg, modules_to_wrap=set()):
+ sharding_strategy_dict = {
+ "NO_SHARD": ShardingStrategy.NO_SHARD,
+ "SHARD_GRAD_OP": ShardingStrategy.SHARD_GRAD_OP,
+ "FULL_SHARD": ShardingStrategy.FULL_SHARD,
+ }
+
+ dtype_dict = {
+ "fp32": torch.float32,
+ "fp16": torch.float16,
+ "bf16": torch.bfloat16,
+ }
+
+ mixed_precision_config = MixedPrecision(
+ param_dtype=dtype_dict[model_cfg.mixed_precision.param_dtype],
+ reduce_dtype=dtype_dict[model_cfg.mixed_precision.reduce_dtype],
+ buffer_dtype=dtype_dict[model_cfg.mixed_precision.buffer_dtype],
+ )
+
+ sharding_strategy_config = sharding_strategy_dict[model_cfg.sharding_strategy]
+
+ local_rank = distributed.get_local_rank()
+
+ fsdp_wrapper = partial(
+ FSDP,
+ sharding_strategy=sharding_strategy_config,
+ mixed_precision=mixed_precision_config,
+ device_id=local_rank,
+ sync_module_states=True,
+ use_orig_params=True,
+ auto_wrap_policy=ModuleWrapPolicy(modules_to_wrap),
+ )
+ return fsdp_wrapper
+
+
+def is_fsdp(x):
+ return isinstance(x, FSDP)
+
+
+def is_sharded_fsdp(x):
+ return is_fsdp(x) and x.sharding_strategy is not ShardingStrategy.NO_SHARD
+
+
+def free_if_fsdp(x):
+ if is_sharded_fsdp(x):
+ handles = x._handles
+ true_list = [True for h in handles]
+ _reshard(x, handles, true_list)
+
+
+def get_fsdp_modules(x):
+ return FSDP.fsdp_modules(x)
+
+
+def reshard_fsdp_model(x):
+ for m in get_fsdp_modules(x):
+ free_if_fsdp(m)
+
+
+def rankstr():
+ return f"rank_{distributed.get_global_rank()}"
+
+
+class FSDPCheckpointer(Checkpointer):
+ def save(self, name: str, **kwargs: Any) -> None:
+ """
+ Dump model and checkpointables to a file.
+
+ Args:
+ name (str): name of the file.
+ kwargs (dict): extra arbitrary data to save.
+ """
+ if not self.save_dir or not self.save_to_disk:
+ return
+
+ data = {}
+ with FSDP.state_dict_type(self.model, StateDictType.LOCAL_STATE_DICT):
+ data["model"] = self.model.state_dict()
+
+ # data["model"] = self.model.state_dict()
+ for key, obj in self.checkpointables.items():
+ data[key] = obj.state_dict()
+ data.update(kwargs)
+
+ basename = f"{name}.{rankstr()}.pth"
+ save_file = os.path.join(self.save_dir, basename)
+ assert os.path.basename(save_file) == basename, basename
+ self.logger.info("Saving checkpoint to {}".format(save_file))
+ with self.path_manager.open(save_file, "wb") as f:
+ torch.save(data, f)
+ self.tag_last_checkpoint(basename)
+
+ def load(self, *args, **kwargs):
+ with FSDP.state_dict_type(self.model, StateDictType.LOCAL_STATE_DICT):
+ return super().load(*args, **kwargs)
+
+ def has_checkpoint(self) -> bool:
+ """
+ Returns:
+ bool: whether a checkpoint exists in the target directory.
+ """
+ save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}")
+ return self.path_manager.exists(save_file)
+
+ def get_checkpoint_file(self) -> str:
+ """
+ Returns:
+ str: The latest checkpoint file in target directory.
+ """
+ save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}")
+ try:
+ with self.path_manager.open(save_file, "r") as f:
+ last_saved = f.read().strip()
+ except IOError:
+ # if file doesn't exist, maybe because it has just been
+ # deleted by a separate process
+ return ""
+ # pyre-fixme[6]: For 2nd param expected `Union[PathLike[str], str]` but got
+ # `Union[bytes, str]`.
+ return os.path.join(self.save_dir, last_saved)
+
+ def tag_last_checkpoint(self, last_filename_basename: str) -> None:
+ """
+ Tag the last checkpoint.
+
+ Args:
+ last_filename_basename (str): the basename of the last filename.
+ """
+ if distributed.is_enabled():
+ torch.distributed.barrier()
+ save_file = os.path.join(self.save_dir, f"last_checkpoint.{rankstr()}")
+ with self.path_manager.open(save_file, "w") as f:
+ f.write(last_filename_basename) # pyre-ignore
+
+
+ShardedGradScaler = ShardedGradScaler
diff --git a/facebookresearch/dinov2/dinov2/hub/__init__.py b/facebookresearch/dinov2/dinov2/hub/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/hub/backbones.py b/facebookresearch/dinov2/dinov2/hub/backbones.py
new file mode 100644
index 0000000..f36f2e0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/backbones.py
@@ -0,0 +1,165 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+from typing import Union
+
+import torch
+
+from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name
+
+
+class Weights(Enum):
+ LVD142M = "LVD142M"
+
+
+def _make_dinov2_model(
+ *,
+ arch_name: str = "vit_large",
+ img_size: int = 518,
+ patch_size: int = 14,
+ init_values: float = 1.0,
+ ffn_layer: str = "mlp",
+ block_chunks: int = 0,
+ num_register_tokens: int = 0,
+ interpolate_antialias: bool = False,
+ interpolate_offset: float = 0.1,
+ pretrained: bool = True,
+ weights: str="",
+ #weights: Union[Weights, str] = Weights.LVD142M,
+ **kwargs,
+):
+ from ..models import vision_transformer as vits
+
+ # if isinstance(weights, str):
+ # try:
+ # weights = Weights[weights]
+ # except KeyError:
+ # raise AssertionError(f"Unsupported weights: {weights}")
+
+ model_base_name = _make_dinov2_model_name(arch_name, patch_size)
+ vit_kwargs = dict(
+ img_size=img_size,
+ patch_size=patch_size,
+ init_values=init_values,
+ ffn_layer=ffn_layer,
+ block_chunks=block_chunks,
+ num_register_tokens=num_register_tokens,
+ interpolate_antialias=interpolate_antialias,
+ interpolate_offset=interpolate_offset,
+ )
+ vit_kwargs.update(**kwargs)
+ model = vits.__dict__[arch_name](**vit_kwargs)
+
+ if pretrained:
+ model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens)
+ try:
+ state_dict = torch.load(weights, map_location="cpu")
+ except:
+ weights=Weights.LVD142M
+ if isinstance(weights, str):
+ try:
+ weights = Weights[weights]
+ except KeyError:
+ raise AssertionError(f"Unsupported weights: {weights}")
+ url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_pretrain.pth"
+ state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu")
+ model.load_state_dict(state_dict, strict=True)
+ return model
+
+
+def dinov2_vits14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-S/14 model (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitb14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-B/14 model (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitl14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-L/14 model (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitg14(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-g/14 model (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(
+ arch_name="vit_giant2",
+ ffn_layer="swiglufused",
+ weights=weights,
+ pretrained=pretrained,
+ **kwargs,
+ )
+
+
+def dinov2_vits14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-S/14 model with registers (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(
+ arch_name="vit_small",
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitb14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-B/14 model with registers (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(
+ arch_name="vit_base",
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitl14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-L/14 model with registers (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(
+ arch_name="vit_large",
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitg14_reg(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.LVD142M, **kwargs):
+ """
+ DINOv2 ViT-g/14 model with registers (optionally) pretrained on the LVD-142M dataset.
+ """
+ return _make_dinov2_model(
+ arch_name="vit_giant2",
+ ffn_layer="swiglufused",
+ weights=weights,
+ pretrained=pretrained,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
diff --git a/facebookresearch/dinov2/dinov2/hub/classifiers.py b/facebookresearch/dinov2/dinov2/hub/classifiers.py
new file mode 100644
index 0000000..3f0841e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/classifiers.py
@@ -0,0 +1,268 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+from typing import Union
+
+import torch
+import torch.nn as nn
+
+from .backbones import _make_dinov2_model
+from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name
+
+
+class Weights(Enum):
+ IMAGENET1K = "IMAGENET1K"
+
+
+def _make_dinov2_linear_classification_head(
+ *,
+ arch_name: str = "vit_large",
+ patch_size: int = 14,
+ embed_dim: int = 1024,
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ num_register_tokens: int = 0,
+ **kwargs,
+):
+ if layers not in (1, 4):
+ raise AssertionError(f"Unsupported number of layers: {layers}")
+ if isinstance(weights, str):
+ try:
+ weights = Weights[weights]
+ except KeyError:
+ raise AssertionError(f"Unsupported weights: {weights}")
+
+ linear_head = nn.Linear((1 + layers) * embed_dim, 1_000)
+
+ if pretrained:
+ model_base_name = _make_dinov2_model_name(arch_name, patch_size)
+ model_full_name = _make_dinov2_model_name(arch_name, patch_size, num_register_tokens)
+ layers_str = str(layers) if layers == 4 else ""
+ url = _DINOV2_BASE_URL + f"/{model_base_name}/{model_full_name}_linear{layers_str}_head.pth"
+ state_dict = torch.hub.load_state_dict_from_url(url, map_location="cpu")
+ linear_head.load_state_dict(state_dict, strict=True)
+
+ return linear_head
+
+
+class _LinearClassifierWrapper(nn.Module):
+ def __init__(self, *, backbone: nn.Module, linear_head: nn.Module, layers: int = 4):
+ super().__init__()
+ self.backbone = backbone
+ self.linear_head = linear_head
+ self.layers = layers
+
+ def forward(self, x):
+ if self.layers == 1:
+ x = self.backbone.forward_features(x)
+ cls_token = x["x_norm_clstoken"]
+ patch_tokens = x["x_norm_patchtokens"]
+ # fmt: off
+ linear_input = torch.cat([
+ cls_token,
+ patch_tokens.mean(dim=1),
+ ], dim=1)
+ # fmt: on
+ elif self.layers == 4:
+ x = self.backbone.get_intermediate_layers(x, n=4, return_class_token=True)
+ # fmt: off
+ linear_input = torch.cat([
+ x[0][1],
+ x[1][1],
+ x[2][1],
+ x[3][1],
+ x[3][0].mean(dim=1),
+ ], dim=1)
+ # fmt: on
+ else:
+ assert False, f"Unsupported number of layers: {self.layers}"
+ return self.linear_head(linear_input)
+
+
+def _make_dinov2_linear_classifier(
+ *,
+ arch_name: str = "vit_large",
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ num_register_tokens: int = 0,
+ interpolate_antialias: bool = False,
+ interpolate_offset: float = 0.1,
+ **kwargs,
+):
+ backbone = _make_dinov2_model(
+ arch_name=arch_name,
+ pretrained=pretrained,
+ num_register_tokens=num_register_tokens,
+ interpolate_antialias=interpolate_antialias,
+ interpolate_offset=interpolate_offset,
+ **kwargs,
+ )
+
+ embed_dim = backbone.embed_dim
+ patch_size = backbone.patch_size
+ linear_head = _make_dinov2_linear_classification_head(
+ arch_name=arch_name,
+ patch_size=patch_size,
+ embed_dim=embed_dim,
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=num_register_tokens,
+ )
+
+ return _LinearClassifierWrapper(backbone=backbone, linear_head=linear_head, layers=layers)
+
+
+def dinov2_vits14_lc(
+ *,
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ **kwargs,
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_small",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ **kwargs,
+ )
+
+
+def dinov2_vitb14_lc(
+ *,
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ **kwargs,
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_base",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ **kwargs,
+ )
+
+
+def dinov2_vitl14_lc(
+ *,
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ **kwargs,
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_large",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ **kwargs,
+ )
+
+
+def dinov2_vitg14_lc(
+ *,
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.IMAGENET1K,
+ **kwargs,
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_giant2",
+ layers=layers,
+ ffn_layer="swiglufused",
+ pretrained=pretrained,
+ weights=weights,
+ **kwargs,
+ )
+
+
+def dinov2_vits14_reg_lc(
+ *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-S/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_small",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitb14_reg_lc(
+ *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-B/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_base",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitl14_reg_lc(
+ *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-L/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_large",
+ layers=layers,
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
+
+
+def dinov2_vitg14_reg_lc(
+ *, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.IMAGENET1K, **kwargs
+):
+ """
+ Linear classifier (1 or 4 layers) on top of a DINOv2 ViT-g/14 backbone with registers (optionally) pretrained on the LVD-142M dataset and trained on ImageNet-1k.
+ """
+ return _make_dinov2_linear_classifier(
+ arch_name="vit_giant2",
+ layers=layers,
+ ffn_layer="swiglufused",
+ pretrained=pretrained,
+ weights=weights,
+ num_register_tokens=4,
+ interpolate_antialias=True,
+ interpolate_offset=0.0,
+ **kwargs,
+ )
diff --git a/facebookresearch/dinov2/dinov2/hub/depth/__init__.py b/facebookresearch/dinov2/dinov2/hub/depth/__init__.py
new file mode 100644
index 0000000..91716e5
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/depth/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .decode_heads import BNHead, DPTHead
+from .encoder_decoder import DepthEncoderDecoder
diff --git a/facebookresearch/dinov2/dinov2/hub/depth/decode_heads.py b/facebookresearch/dinov2/dinov2/hub/depth/decode_heads.py
new file mode 100644
index 0000000..f455acc
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/depth/decode_heads.py
@@ -0,0 +1,747 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import copy
+from functools import partial
+import math
+import warnings
+
+import torch
+import torch.nn as nn
+
+from .ops import resize
+
+
+# XXX: (Untested) replacement for mmcv.imdenormalize()
+def _imdenormalize(img, mean, std, to_bgr=True):
+ import numpy as np
+
+ mean = mean.reshape(1, -1).astype(np.float64)
+ std = std.reshape(1, -1).astype(np.float64)
+ img = (img * std) + mean
+ if to_bgr:
+ img = img[::-1]
+ return img
+
+
+class DepthBaseDecodeHead(nn.Module):
+ """Base class for BaseDecodeHead.
+
+ Args:
+ in_channels (List): Input channels.
+ channels (int): Channels after modules, before conv_depth.
+ conv_layer (nn.Module): Conv layers. Default: None.
+ act_layer (nn.Module): Activation layers. Default: nn.ReLU.
+ loss_decode (dict): Config of decode loss.
+ Default: ().
+ sampler (dict|None): The config of depth map sampler.
+ Default: None.
+ align_corners (bool): align_corners argument of F.interpolate.
+ Default: False.
+ min_depth (int): Min depth in dataset setting.
+ Default: 1e-3.
+ max_depth (int): Max depth in dataset setting.
+ Default: None.
+ norm_layer (dict|None): Norm layers.
+ Default: None.
+ classify (bool): Whether predict depth in a cls.-reg. manner.
+ Default: False.
+ n_bins (int): The number of bins used in cls. step.
+ Default: 256.
+ bins_strategy (str): The discrete strategy used in cls. step.
+ Default: 'UD'.
+ norm_strategy (str): The norm strategy on cls. probability
+ distribution. Default: 'linear'
+ scale_up (str): Whether predict depth in a scale-up manner.
+ Default: False.
+ """
+
+ def __init__(
+ self,
+ in_channels,
+ conv_layer=None,
+ act_layer=nn.ReLU,
+ channels=96,
+ loss_decode=(),
+ sampler=None,
+ align_corners=False,
+ min_depth=1e-3,
+ max_depth=None,
+ norm_layer=None,
+ classify=False,
+ n_bins=256,
+ bins_strategy="UD",
+ norm_strategy="linear",
+ scale_up=False,
+ ):
+ super(DepthBaseDecodeHead, self).__init__()
+
+ self.in_channels = in_channels
+ self.channels = channels
+ self.conf_layer = conv_layer
+ self.act_layer = act_layer
+ self.loss_decode = loss_decode
+ self.align_corners = align_corners
+ self.min_depth = min_depth
+ self.max_depth = max_depth
+ self.norm_layer = norm_layer
+ self.classify = classify
+ self.n_bins = n_bins
+ self.scale_up = scale_up
+
+ if self.classify:
+ assert bins_strategy in ["UD", "SID"], "Support bins_strategy: UD, SID"
+ assert norm_strategy in ["linear", "softmax", "sigmoid"], "Support norm_strategy: linear, softmax, sigmoid"
+
+ self.bins_strategy = bins_strategy
+ self.norm_strategy = norm_strategy
+ self.softmax = nn.Softmax(dim=1)
+ self.conv_depth = nn.Conv2d(channels, n_bins, kernel_size=3, padding=1, stride=1)
+ else:
+ self.conv_depth = nn.Conv2d(channels, 1, kernel_size=3, padding=1, stride=1)
+
+ self.relu = nn.ReLU()
+ self.sigmoid = nn.Sigmoid()
+
+ def forward(self, inputs, img_metas):
+ """Placeholder of forward function."""
+ pass
+
+ def forward_train(self, img, inputs, img_metas, depth_gt):
+ """Forward function for training.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ depth_gt (Tensor): GT depth
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+ depth_pred = self.forward(inputs, img_metas)
+ losses = self.losses(depth_pred, depth_gt)
+
+ log_imgs = self.log_images(img[0], depth_pred[0], depth_gt[0], img_metas[0])
+ losses.update(**log_imgs)
+
+ return losses
+
+ def forward_test(self, inputs, img_metas):
+ """Forward function for testing.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+
+ Returns:
+ Tensor: Output depth map.
+ """
+ return self.forward(inputs, img_metas)
+
+ def depth_pred(self, feat):
+ """Prediction each pixel."""
+ if self.classify:
+ logit = self.conv_depth(feat)
+
+ if self.bins_strategy == "UD":
+ bins = torch.linspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device)
+ elif self.bins_strategy == "SID":
+ bins = torch.logspace(self.min_depth, self.max_depth, self.n_bins, device=feat.device)
+
+ # following Adabins, default linear
+ if self.norm_strategy == "linear":
+ logit = torch.relu(logit)
+ eps = 0.1
+ logit = logit + eps
+ logit = logit / logit.sum(dim=1, keepdim=True)
+ elif self.norm_strategy == "softmax":
+ logit = torch.softmax(logit, dim=1)
+ elif self.norm_strategy == "sigmoid":
+ logit = torch.sigmoid(logit)
+ logit = logit / logit.sum(dim=1, keepdim=True)
+
+ output = torch.einsum("ikmn,k->imn", [logit, bins]).unsqueeze(dim=1)
+
+ else:
+ if self.scale_up:
+ output = self.sigmoid(self.conv_depth(feat)) * self.max_depth
+ else:
+ output = self.relu(self.conv_depth(feat)) + self.min_depth
+ return output
+
+ def losses(self, depth_pred, depth_gt):
+ """Compute depth loss."""
+ loss = dict()
+ depth_pred = resize(
+ input=depth_pred, size=depth_gt.shape[2:], mode="bilinear", align_corners=self.align_corners, warning=False
+ )
+ if not isinstance(self.loss_decode, nn.ModuleList):
+ losses_decode = [self.loss_decode]
+ else:
+ losses_decode = self.loss_decode
+ for loss_decode in losses_decode:
+ if loss_decode.loss_name not in loss:
+ loss[loss_decode.loss_name] = loss_decode(depth_pred, depth_gt)
+ else:
+ loss[loss_decode.loss_name] += loss_decode(depth_pred, depth_gt)
+ return loss
+
+ def log_images(self, img_path, depth_pred, depth_gt, img_meta):
+ import numpy as np
+
+ show_img = copy.deepcopy(img_path.detach().cpu().permute(1, 2, 0))
+ show_img = show_img.numpy().astype(np.float32)
+ show_img = _imdenormalize(
+ show_img,
+ img_meta["img_norm_cfg"]["mean"],
+ img_meta["img_norm_cfg"]["std"],
+ img_meta["img_norm_cfg"]["to_rgb"],
+ )
+ show_img = np.clip(show_img, 0, 255)
+ show_img = show_img.astype(np.uint8)
+ show_img = show_img[:, :, ::-1]
+ show_img = show_img.transpose(0, 2, 1)
+ show_img = show_img.transpose(1, 0, 2)
+
+ depth_pred = depth_pred / torch.max(depth_pred)
+ depth_gt = depth_gt / torch.max(depth_gt)
+
+ depth_pred_color = copy.deepcopy(depth_pred.detach().cpu())
+ depth_gt_color = copy.deepcopy(depth_gt.detach().cpu())
+
+ return {"img_rgb": show_img, "img_depth_pred": depth_pred_color, "img_depth_gt": depth_gt_color}
+
+
+class BNHead(DepthBaseDecodeHead):
+ """Just a batchnorm."""
+
+ def __init__(self, input_transform="resize_concat", in_index=(0, 1, 2, 3), upsample=1, **kwargs):
+ super().__init__(**kwargs)
+ self.input_transform = input_transform
+ self.in_index = in_index
+ self.upsample = upsample
+ # self.bn = nn.SyncBatchNorm(self.in_channels)
+ if self.classify:
+ self.conv_depth = nn.Conv2d(self.channels, self.n_bins, kernel_size=1, padding=0, stride=1)
+ else:
+ self.conv_depth = nn.Conv2d(self.channels, 1, kernel_size=1, padding=0, stride=1)
+
+ def _transform_inputs(self, inputs):
+ """Transform inputs for decoder.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ Returns:
+ Tensor: The transformed inputs
+ """
+
+ if "concat" in self.input_transform:
+ inputs = [inputs[i] for i in self.in_index]
+ if "resize" in self.input_transform:
+ inputs = [
+ resize(
+ input=x,
+ size=[s * self.upsample for s in inputs[0].shape[2:]],
+ mode="bilinear",
+ align_corners=self.align_corners,
+ )
+ for x in inputs
+ ]
+ inputs = torch.cat(inputs, dim=1)
+ elif self.input_transform == "multiple_select":
+ inputs = [inputs[i] for i in self.in_index]
+ else:
+ inputs = inputs[self.in_index]
+
+ return inputs
+
+ def _forward_feature(self, inputs, img_metas=None, **kwargs):
+ """Forward function for feature maps before classifying each pixel with
+ ``self.cls_seg`` fc.
+ Args:
+ inputs (list[Tensor]): List of multi-level img features.
+ Returns:
+ feats (Tensor): A tensor of shape (batch_size, self.channels,
+ H, W) which is feature map for last layer of decoder head.
+ """
+ # accept lists (for cls token)
+ inputs = list(inputs)
+ for i, x in enumerate(inputs):
+ if len(x) == 2:
+ x, cls_token = x[0], x[1]
+ if len(x.shape) == 2:
+ x = x[:, :, None, None]
+ cls_token = cls_token[:, :, None, None].expand_as(x)
+ inputs[i] = torch.cat((x, cls_token), 1)
+ else:
+ x = x[0]
+ if len(x.shape) == 2:
+ x = x[:, :, None, None]
+ inputs[i] = x
+ x = self._transform_inputs(inputs)
+ # feats = self.bn(x)
+ return x
+
+ def forward(self, inputs, img_metas=None, **kwargs):
+ """Forward function."""
+ output = self._forward_feature(inputs, img_metas=img_metas, **kwargs)
+ output = self.depth_pred(output)
+ return output
+
+
+class ConvModule(nn.Module):
+ """A conv block that bundles conv/norm/activation layers.
+
+ This block simplifies the usage of convolution layers, which are commonly
+ used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU).
+ It is based upon three build methods: `build_conv_layer()`,
+ `build_norm_layer()` and `build_activation_layer()`.
+
+ Besides, we add some additional features in this module.
+ 1. Automatically set `bias` of the conv layer.
+ 2. Spectral norm is supported.
+ 3. More padding modes are supported. Before PyTorch 1.5, nn.Conv2d only
+ supports zero and circular padding, and we add "reflect" padding mode.
+
+ Args:
+ in_channels (int): Number of channels in the input feature map.
+ Same as that in ``nn._ConvNd``.
+ out_channels (int): Number of channels produced by the convolution.
+ Same as that in ``nn._ConvNd``.
+ kernel_size (int | tuple[int]): Size of the convolving kernel.
+ Same as that in ``nn._ConvNd``.
+ stride (int | tuple[int]): Stride of the convolution.
+ Same as that in ``nn._ConvNd``.
+ padding (int | tuple[int]): Zero-padding added to both sides of
+ the input. Same as that in ``nn._ConvNd``.
+ dilation (int | tuple[int]): Spacing between kernel elements.
+ Same as that in ``nn._ConvNd``.
+ groups (int): Number of blocked connections from input channels to
+ output channels. Same as that in ``nn._ConvNd``.
+ bias (bool | str): If specified as `auto`, it will be decided by the
+ norm_layer. Bias will be set as True if `norm_layer` is None, otherwise
+ False. Default: "auto".
+ conv_layer (nn.Module): Convolution layer. Default: None,
+ which means using conv2d.
+ norm_layer (nn.Module): Normalization layer. Default: None.
+ act_layer (nn.Module): Activation layer. Default: nn.ReLU.
+ inplace (bool): Whether to use inplace mode for activation.
+ Default: True.
+ with_spectral_norm (bool): Whether use spectral norm in conv module.
+ Default: False.
+ padding_mode (str): If the `padding_mode` has not been supported by
+ current `Conv2d` in PyTorch, we will use our own padding layer
+ instead. Currently, we support ['zeros', 'circular'] with official
+ implementation and ['reflect'] with our own implementation.
+ Default: 'zeros'.
+ order (tuple[str]): The order of conv/norm/activation layers. It is a
+ sequence of "conv", "norm" and "act". Common examples are
+ ("conv", "norm", "act") and ("act", "conv", "norm").
+ Default: ('conv', 'norm', 'act').
+ """
+
+ _abbr_ = "conv_block"
+
+ def __init__(
+ self,
+ in_channels,
+ out_channels,
+ kernel_size,
+ stride=1,
+ padding=0,
+ dilation=1,
+ groups=1,
+ bias="auto",
+ conv_layer=nn.Conv2d,
+ norm_layer=None,
+ act_layer=nn.ReLU,
+ inplace=True,
+ with_spectral_norm=False,
+ padding_mode="zeros",
+ order=("conv", "norm", "act"),
+ ):
+ super(ConvModule, self).__init__()
+ official_padding_mode = ["zeros", "circular"]
+ self.conv_layer = conv_layer
+ self.norm_layer = norm_layer
+ self.act_layer = act_layer
+ self.inplace = inplace
+ self.with_spectral_norm = with_spectral_norm
+ self.with_explicit_padding = padding_mode not in official_padding_mode
+ self.order = order
+ assert isinstance(self.order, tuple) and len(self.order) == 3
+ assert set(order) == set(["conv", "norm", "act"])
+
+ self.with_norm = norm_layer is not None
+ self.with_activation = act_layer is not None
+ # if the conv layer is before a norm layer, bias is unnecessary.
+ if bias == "auto":
+ bias = not self.with_norm
+ self.with_bias = bias
+
+ if self.with_explicit_padding:
+ if padding_mode == "zeros":
+ padding_layer = nn.ZeroPad2d
+ else:
+ raise AssertionError(f"Unsupported padding mode: {padding_mode}")
+ self.pad = padding_layer(padding)
+
+ # reset padding to 0 for conv module
+ conv_padding = 0 if self.with_explicit_padding else padding
+ # build convolution layer
+ self.conv = self.conv_layer(
+ in_channels,
+ out_channels,
+ kernel_size,
+ stride=stride,
+ padding=conv_padding,
+ dilation=dilation,
+ groups=groups,
+ bias=bias,
+ )
+ # export the attributes of self.conv to a higher level for convenience
+ self.in_channels = self.conv.in_channels
+ self.out_channels = self.conv.out_channels
+ self.kernel_size = self.conv.kernel_size
+ self.stride = self.conv.stride
+ self.padding = padding
+ self.dilation = self.conv.dilation
+ self.transposed = self.conv.transposed
+ self.output_padding = self.conv.output_padding
+ self.groups = self.conv.groups
+
+ if self.with_spectral_norm:
+ self.conv = nn.utils.spectral_norm(self.conv)
+
+ # build normalization layers
+ if self.with_norm:
+ # norm layer is after conv layer
+ if order.index("norm") > order.index("conv"):
+ norm_channels = out_channels
+ else:
+ norm_channels = in_channels
+ norm = partial(norm_layer, num_features=norm_channels)
+ self.add_module("norm", norm)
+ if self.with_bias:
+ from torch.nnModules.batchnorm import _BatchNorm
+ from torch.nnModules.instancenorm import _InstanceNorm
+
+ if isinstance(norm, (_BatchNorm, _InstanceNorm)):
+ warnings.warn("Unnecessary conv bias before batch/instance norm")
+ else:
+ self.norm_name = None
+
+ # build activation layer
+ if self.with_activation:
+ # nn.Tanh has no 'inplace' argument
+ # (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.HSigmoid, nn.Swish, nn.GELU)
+ if not isinstance(act_layer, (nn.Tanh, nn.PReLU, nn.Sigmoid, nn.GELU)):
+ act_layer = partial(act_layer, inplace=inplace)
+ self.activate = act_layer()
+
+ # Use msra init by default
+ self.init_weights()
+
+ @property
+ def norm(self):
+ if self.norm_name:
+ return getattr(self, self.norm_name)
+ else:
+ return None
+
+ def init_weights(self):
+ # 1. It is mainly for customized conv layers with their own
+ # initialization manners by calling their own ``init_weights()``,
+ # and we do not want ConvModule to override the initialization.
+ # 2. For customized conv layers without their own initialization
+ # manners (that is, they don't have their own ``init_weights()``)
+ # and PyTorch's conv layers, they will be initialized by
+ # this method with default ``kaiming_init``.
+ # Note: For PyTorch's conv layers, they will be overwritten by our
+ # initialization implementation using default ``kaiming_init``.
+ if not hasattr(self.conv, "init_weights"):
+ if self.with_activation and isinstance(self.act_layer, nn.LeakyReLU):
+ nonlinearity = "leaky_relu"
+ a = 0.01 # XXX: default negative_slope
+ else:
+ nonlinearity = "relu"
+ a = 0
+ if hasattr(self.conv, "weight") and self.conv.weight is not None:
+ nn.init.kaiming_normal_(self.conv.weight, a=a, mode="fan_out", nonlinearity=nonlinearity)
+ if hasattr(self.conv, "bias") and self.conv.bias is not None:
+ nn.init.constant_(self.conv.bias, 0)
+ if self.with_norm:
+ if hasattr(self.norm, "weight") and self.norm.weight is not None:
+ nn.init.constant_(self.norm.weight, 1)
+ if hasattr(self.norm, "bias") and self.norm.bias is not None:
+ nn.init.constant_(self.norm.bias, 0)
+
+ def forward(self, x, activate=True, norm=True):
+ for layer in self.order:
+ if layer == "conv":
+ if self.with_explicit_padding:
+ x = self.pad(x)
+ x = self.conv(x)
+ elif layer == "norm" and norm and self.with_norm:
+ x = self.norm(x)
+ elif layer == "act" and activate and self.with_activation:
+ x = self.activate(x)
+ return x
+
+
+class Interpolate(nn.Module):
+ def __init__(self, scale_factor, mode, align_corners=False):
+ super(Interpolate, self).__init__()
+ self.interp = nn.functional.interpolate
+ self.scale_factor = scale_factor
+ self.mode = mode
+ self.align_corners = align_corners
+
+ def forward(self, x):
+ x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners)
+ return x
+
+
+class HeadDepth(nn.Module):
+ def __init__(self, features):
+ super(HeadDepth, self).__init__()
+ self.head = nn.Sequential(
+ nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
+ Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
+ nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
+ )
+
+ def forward(self, x):
+ x = self.head(x)
+ return x
+
+
+class ReassembleBlocks(nn.Module):
+ """ViTPostProcessBlock, process cls_token in ViT backbone output and
+ rearrange the feature vector to feature map.
+ Args:
+ in_channels (int): ViT feature channels. Default: 768.
+ out_channels (List): output channels of each stage.
+ Default: [96, 192, 384, 768].
+ readout_type (str): Type of readout operation. Default: 'ignore'.
+ patch_size (int): The patch size. Default: 16.
+ """
+
+ def __init__(self, in_channels=768, out_channels=[96, 192, 384, 768], readout_type="ignore", patch_size=16):
+ super(ReassembleBlocks, self).__init__()
+
+ assert readout_type in ["ignore", "add", "project"]
+ self.readout_type = readout_type
+ self.patch_size = patch_size
+
+ self.projects = nn.ModuleList(
+ [
+ ConvModule(
+ in_channels=in_channels,
+ out_channels=out_channel,
+ kernel_size=1,
+ act_layer=None,
+ )
+ for out_channel in out_channels
+ ]
+ )
+
+ self.resize_layers = nn.ModuleList(
+ [
+ nn.ConvTranspose2d(
+ in_channels=out_channels[0], out_channels=out_channels[0], kernel_size=4, stride=4, padding=0
+ ),
+ nn.ConvTranspose2d(
+ in_channels=out_channels[1], out_channels=out_channels[1], kernel_size=2, stride=2, padding=0
+ ),
+ nn.Identity(),
+ nn.Conv2d(
+ in_channels=out_channels[3], out_channels=out_channels[3], kernel_size=3, stride=2, padding=1
+ ),
+ ]
+ )
+ if self.readout_type == "project":
+ self.readout_projects = nn.ModuleList()
+ for _ in range(len(self.projects)):
+ self.readout_projects.append(nn.Sequential(nn.Linear(2 * in_channels, in_channels), nn.GELU()))
+
+ def forward(self, inputs):
+ assert isinstance(inputs, list)
+ out = []
+ for i, x in enumerate(inputs):
+ assert len(x) == 2
+ x, cls_token = x[0], x[1]
+ feature_shape = x.shape
+ if self.readout_type == "project":
+ x = x.flatten(2).permute((0, 2, 1))
+ readout = cls_token.unsqueeze(1).expand_as(x)
+ x = self.readout_projects[i](torch.cat((x, readout), -1))
+ x = x.permute(0, 2, 1).reshape(feature_shape)
+ elif self.readout_type == "add":
+ x = x.flatten(2) + cls_token.unsqueeze(-1)
+ x = x.reshape(feature_shape)
+ else:
+ pass
+ x = self.projects[i](x)
+ x = self.resize_layers[i](x)
+ out.append(x)
+ return out
+
+
+class PreActResidualConvUnit(nn.Module):
+ """ResidualConvUnit, pre-activate residual unit.
+ Args:
+ in_channels (int): number of channels in the input feature map.
+ act_layer (nn.Module): activation layer.
+ norm_layer (nn.Module): norm layer.
+ stride (int): stride of the first block. Default: 1
+ dilation (int): dilation rate for convs layers. Default: 1.
+ """
+
+ def __init__(self, in_channels, act_layer, norm_layer, stride=1, dilation=1):
+ super(PreActResidualConvUnit, self).__init__()
+
+ self.conv1 = ConvModule(
+ in_channels,
+ in_channels,
+ 3,
+ stride=stride,
+ padding=dilation,
+ dilation=dilation,
+ norm_layer=norm_layer,
+ act_layer=act_layer,
+ bias=False,
+ order=("act", "conv", "norm"),
+ )
+
+ self.conv2 = ConvModule(
+ in_channels,
+ in_channels,
+ 3,
+ padding=1,
+ norm_layer=norm_layer,
+ act_layer=act_layer,
+ bias=False,
+ order=("act", "conv", "norm"),
+ )
+
+ def forward(self, inputs):
+ inputs_ = inputs.clone()
+ x = self.conv1(inputs)
+ x = self.conv2(x)
+ return x + inputs_
+
+
+class FeatureFusionBlock(nn.Module):
+ """FeatureFusionBlock, merge feature map from different stages.
+ Args:
+ in_channels (int): Input channels.
+ act_layer (nn.Module): activation layer for ResidualConvUnit.
+ norm_layer (nn.Module): normalization layer.
+ expand (bool): Whether expand the channels in post process block.
+ Default: False.
+ align_corners (bool): align_corner setting for bilinear upsample.
+ Default: True.
+ """
+
+ def __init__(self, in_channels, act_layer, norm_layer, expand=False, align_corners=True):
+ super(FeatureFusionBlock, self).__init__()
+
+ self.in_channels = in_channels
+ self.expand = expand
+ self.align_corners = align_corners
+
+ self.out_channels = in_channels
+ if self.expand:
+ self.out_channels = in_channels // 2
+
+ self.project = ConvModule(self.in_channels, self.out_channels, kernel_size=1, act_layer=None, bias=True)
+
+ self.res_conv_unit1 = PreActResidualConvUnit(
+ in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer
+ )
+ self.res_conv_unit2 = PreActResidualConvUnit(
+ in_channels=self.in_channels, act_layer=act_layer, norm_layer=norm_layer
+ )
+
+ def forward(self, *inputs):
+ x = inputs[0]
+ if len(inputs) == 2:
+ if x.shape != inputs[1].shape:
+ res = resize(inputs[1], size=(x.shape[2], x.shape[3]), mode="bilinear", align_corners=False)
+ else:
+ res = inputs[1]
+ x = x + self.res_conv_unit1(res)
+ x = self.res_conv_unit2(x)
+ x = resize(x, scale_factor=2, mode="bilinear", align_corners=self.align_corners)
+ x = self.project(x)
+ return x
+
+
+class DPTHead(DepthBaseDecodeHead):
+ """Vision Transformers for Dense Prediction.
+ This head is implemented of `DPT `_.
+ Args:
+ embed_dims (int): The embed dimension of the ViT backbone.
+ Default: 768.
+ post_process_channels (List): Out channels of post process conv
+ layers. Default: [96, 192, 384, 768].
+ readout_type (str): Type of readout operation. Default: 'ignore'.
+ patch_size (int): The patch size. Default: 16.
+ expand_channels (bool): Whether expand the channels in post process
+ block. Default: False.
+ """
+
+ def __init__(
+ self,
+ embed_dims=768,
+ post_process_channels=[96, 192, 384, 768],
+ readout_type="ignore",
+ patch_size=16,
+ expand_channels=False,
+ **kwargs,
+ ):
+ super(DPTHead, self).__init__(**kwargs)
+
+ self.in_channels = self.in_channels
+ self.expand_channels = expand_channels
+ self.reassemble_blocks = ReassembleBlocks(embed_dims, post_process_channels, readout_type, patch_size)
+
+ self.post_process_channels = [
+ channel * math.pow(2, i) if expand_channels else channel for i, channel in enumerate(post_process_channels)
+ ]
+ self.convs = nn.ModuleList()
+ for channel in self.post_process_channels:
+ self.convs.append(ConvModule(channel, self.channels, kernel_size=3, padding=1, act_layer=None, bias=False))
+ self.fusion_blocks = nn.ModuleList()
+ for _ in range(len(self.convs)):
+ self.fusion_blocks.append(FeatureFusionBlock(self.channels, self.act_layer, self.norm_layer))
+ self.fusion_blocks[0].res_conv_unit1 = None
+ self.project = ConvModule(self.channels, self.channels, kernel_size=3, padding=1, norm_layer=self.norm_layer)
+ self.num_fusion_blocks = len(self.fusion_blocks)
+ self.num_reassemble_blocks = len(self.reassemble_blocks.resize_layers)
+ self.num_post_process_channels = len(self.post_process_channels)
+ assert self.num_fusion_blocks == self.num_reassemble_blocks
+ assert self.num_reassemble_blocks == self.num_post_process_channels
+ self.conv_depth = HeadDepth(self.channels)
+
+ def forward(self, inputs, img_metas):
+ assert len(inputs) == self.num_reassemble_blocks
+ x = [inp for inp in inputs]
+ x = self.reassemble_blocks(x)
+ x = [self.convs[i](feature) for i, feature in enumerate(x)]
+ out = self.fusion_blocks[0](x[-1])
+ for i in range(1, len(self.fusion_blocks)):
+ out = self.fusion_blocks[i](out, x[-(i + 1)])
+ out = self.project(out)
+ out = self.depth_pred(out)
+ return out
diff --git a/facebookresearch/dinov2/dinov2/hub/depth/encoder_decoder.py b/facebookresearch/dinov2/dinov2/hub/depth/encoder_decoder.py
new file mode 100644
index 0000000..eb29ced
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/depth/encoder_decoder.py
@@ -0,0 +1,351 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from collections import OrderedDict
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .ops import resize
+
+
+def add_prefix(inputs, prefix):
+ """Add prefix for dict.
+
+ Args:
+ inputs (dict): The input dict with str keys.
+ prefix (str): The prefix to add.
+
+ Returns:
+
+ dict: The dict with keys updated with ``prefix``.
+ """
+
+ outputs = dict()
+ for name, value in inputs.items():
+ outputs[f"{prefix}.{name}"] = value
+
+ return outputs
+
+
+class DepthEncoderDecoder(nn.Module):
+ """Encoder Decoder depther.
+
+ EncoderDecoder typically consists of backbone and decode_head.
+ """
+
+ def __init__(self, backbone, decode_head):
+ super(DepthEncoderDecoder, self).__init__()
+
+ self.backbone = backbone
+ self.decode_head = decode_head
+ self.align_corners = self.decode_head.align_corners
+
+ def extract_feat(self, img):
+ """Extract features from images."""
+ return self.backbone(img)
+
+ def encode_decode(self, img, img_metas, rescale=True, size=None):
+ """Encode images with backbone and decode into a depth estimation
+ map of the same size as input."""
+ x = self.extract_feat(img)
+ out = self._decode_head_forward_test(x, img_metas)
+ # crop the pred depth to the certain range.
+ out = torch.clamp(out, min=self.decode_head.min_depth, max=self.decode_head.max_depth)
+ if rescale:
+ if size is None:
+ if img_metas is not None:
+ size = img_metas[0]["ori_shape"][:2]
+ else:
+ size = img.shape[2:]
+ out = resize(input=out, size=size, mode="bilinear", align_corners=self.align_corners)
+ return out
+
+ def _decode_head_forward_train(self, img, x, img_metas, depth_gt, **kwargs):
+ """Run forward function and calculate loss for decode head in
+ training."""
+ losses = dict()
+ loss_decode = self.decode_head.forward_train(img, x, img_metas, depth_gt, **kwargs)
+ losses.update(add_prefix(loss_decode, "decode"))
+ return losses
+
+ def _decode_head_forward_test(self, x, img_metas):
+ """Run forward function and calculate loss for decode head in
+ inference."""
+ depth_pred = self.decode_head.forward_test(x, img_metas)
+ return depth_pred
+
+ def forward_dummy(self, img):
+ """Dummy forward function."""
+ depth = self.encode_decode(img, None)
+
+ return depth
+
+ def forward_train(self, img, img_metas, depth_gt, **kwargs):
+ """Forward function for training.
+
+ Args:
+ img (Tensor): Input images.
+ img_metas (list[dict]): List of image info dict where each dict
+ has: 'img_shape', 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ depth_gt (Tensor): Depth gt
+ used if the architecture supports depth estimation task.
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+
+ x = self.extract_feat(img)
+
+ losses = dict()
+
+ # the last of x saves the info from neck
+ loss_decode = self._decode_head_forward_train(img, x, img_metas, depth_gt, **kwargs)
+
+ losses.update(loss_decode)
+
+ return losses
+
+ def whole_inference(self, img, img_meta, rescale, size=None):
+ """Inference with full image."""
+ return self.encode_decode(img, img_meta, rescale, size=size)
+
+ def slide_inference(self, img, img_meta, rescale, stride, crop_size):
+ """Inference by sliding-window with overlap.
+
+ If h_crop > h_img or w_crop > w_img, the small patch will be used to
+ decode without padding.
+ """
+
+ h_stride, w_stride = stride
+ h_crop, w_crop = crop_size
+ batch_size, _, h_img, w_img = img.size()
+ h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1
+ w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1
+ preds = img.new_zeros((batch_size, 1, h_img, w_img))
+ count_mat = img.new_zeros((batch_size, 1, h_img, w_img))
+ for h_idx in range(h_grids):
+ for w_idx in range(w_grids):
+ y1 = h_idx * h_stride
+ x1 = w_idx * w_stride
+ y2 = min(y1 + h_crop, h_img)
+ x2 = min(x1 + w_crop, w_img)
+ y1 = max(y2 - h_crop, 0)
+ x1 = max(x2 - w_crop, 0)
+ crop_img = img[:, :, y1:y2, x1:x2]
+ depth_pred = self.encode_decode(crop_img, img_meta, rescale)
+ preds += F.pad(depth_pred, (int(x1), int(preds.shape[3] - x2), int(y1), int(preds.shape[2] - y2)))
+
+ count_mat[:, :, y1:y2, x1:x2] += 1
+ assert (count_mat == 0).sum() == 0
+ if torch.onnx.is_in_onnx_export():
+ # cast count_mat to constant while exporting to ONNX
+ count_mat = torch.from_numpy(count_mat.cpu().detach().numpy()).to(device=img.device)
+ preds = preds / count_mat
+ return preds
+
+ def inference(self, img, img_meta, rescale, size=None, mode="whole"):
+ """Inference with slide/whole style.
+
+ Args:
+ img (Tensor): The input image of shape (N, 3, H, W).
+ img_meta (dict): Image info dict where each dict has: 'img_shape',
+ 'scale_factor', 'flip', and may also contain
+ 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+ For details on the values of these keys see
+ `depth/datasets/pipelines/formatting.py:Collect`.
+ rescale (bool): Whether rescale back to original shape.
+
+ Returns:
+ Tensor: The output depth map.
+ """
+
+ assert mode in ["slide", "whole"]
+ ori_shape = img_meta[0]["ori_shape"]
+ assert all(_["ori_shape"] == ori_shape for _ in img_meta)
+ if mode == "slide":
+ depth_pred = self.slide_inference(img, img_meta, rescale)
+ else:
+ depth_pred = self.whole_inference(img, img_meta, rescale, size=size)
+ output = depth_pred
+ flip = img_meta[0]["flip"]
+ if flip:
+ flip_direction = img_meta[0]["flip_direction"]
+ assert flip_direction in ["horizontal", "vertical"]
+ if flip_direction == "horizontal":
+ output = output.flip(dims=(3,))
+ elif flip_direction == "vertical":
+ output = output.flip(dims=(2,))
+
+ return output
+
+ def simple_test(self, img, img_meta, rescale=True):
+ """Simple test with single image."""
+ depth_pred = self.inference(img, img_meta, rescale)
+ if torch.onnx.is_in_onnx_export():
+ # our inference backend only support 4D output
+ depth_pred = depth_pred.unsqueeze(0)
+ return depth_pred
+ depth_pred = depth_pred.cpu().numpy()
+ # unravel batch dim
+ depth_pred = list(depth_pred)
+ return depth_pred
+
+ def aug_test(self, imgs, img_metas, rescale=True):
+ """Test with augmentations.
+
+ Only rescale=True is supported.
+ """
+ # aug_test rescale all imgs back to ori_shape for now
+ assert rescale
+ # to save memory, we get augmented depth logit inplace
+ depth_pred = self.inference(imgs[0], img_metas[0], rescale)
+ for i in range(1, len(imgs)):
+ cur_depth_pred = self.inference(imgs[i], img_metas[i], rescale, size=depth_pred.shape[-2:])
+ depth_pred += cur_depth_pred
+ depth_pred /= len(imgs)
+ depth_pred = depth_pred.cpu().numpy()
+ # unravel batch dim
+ depth_pred = list(depth_pred)
+ return depth_pred
+
+ def forward_test(self, imgs, img_metas, **kwargs):
+ """
+ Args:
+ imgs (List[Tensor]): the outer list indicates test-time
+ augmentations and inner Tensor should have a shape NxCxHxW,
+ which contains all images in the batch.
+ img_metas (List[List[dict]]): the outer list indicates test-time
+ augs (multiscale, flip, etc.) and the inner list indicates
+ images in a batch.
+ """
+ for var, name in [(imgs, "imgs"), (img_metas, "img_metas")]:
+ if not isinstance(var, list):
+ raise TypeError(f"{name} must be a list, but got " f"{type(var)}")
+ num_augs = len(imgs)
+ if num_augs != len(img_metas):
+ raise ValueError(f"num of augmentations ({len(imgs)}) != " f"num of image meta ({len(img_metas)})")
+ # all images in the same aug batch all of the same ori_shape and pad
+ # shape
+ for img_meta in img_metas:
+ ori_shapes = [_["ori_shape"] for _ in img_meta]
+ assert all(shape == ori_shapes[0] for shape in ori_shapes)
+ img_shapes = [_["img_shape"] for _ in img_meta]
+ assert all(shape == img_shapes[0] for shape in img_shapes)
+ pad_shapes = [_["pad_shape"] for _ in img_meta]
+ assert all(shape == pad_shapes[0] for shape in pad_shapes)
+
+ if num_augs == 1:
+ return self.simple_test(imgs[0], img_metas[0], **kwargs)
+ else:
+ return self.aug_test(imgs, img_metas, **kwargs)
+
+ def forward(self, img, img_metas, return_loss=True, **kwargs):
+ """Calls either :func:`forward_train` or :func:`forward_test` depending
+ on whether ``return_loss`` is ``True``.
+
+ Note this setting will change the expected inputs. When
+ ``return_loss=True``, img and img_meta are single-nested (i.e. Tensor
+ and List[dict]), and when ``resturn_loss=False``, img and img_meta
+ should be double nested (i.e. List[Tensor], List[List[dict]]), with
+ the outer list indicating test time augmentations.
+ """
+ if return_loss:
+ return self.forward_train(img, img_metas, **kwargs)
+ else:
+ return self.forward_test(img, img_metas, **kwargs)
+
+ def train_step(self, data_batch, optimizer, **kwargs):
+ """The iteration step during training.
+
+ This method defines an iteration step during training, except for the
+ back propagation and optimizer updating, which are done in an optimizer
+ hook. Note that in some complicated cases or models, the whole process
+ including back propagation and optimizer updating is also defined in
+ this method, such as GAN.
+
+ Args:
+ data (dict): The output of dataloader.
+ optimizer (:obj:`torch.optim.Optimizer` | dict): The optimizer of
+ runner is passed to ``train_step()``. This argument is unused
+ and reserved.
+
+ Returns:
+ dict: It should contain at least 3 keys: ``loss``, ``log_vars``,
+ ``num_samples``.
+ ``loss`` is a tensor for back propagation, which can be a
+ weighted sum of multiple losses.
+ ``log_vars`` contains all the variables to be sent to the
+ logger.
+ ``num_samples`` indicates the batch size (when the model is
+ DDP, it means the batch size on each GPU), which is used for
+ averaging the logs.
+ """
+ losses = self(**data_batch)
+
+ # split losses and images
+ real_losses = {}
+ log_imgs = {}
+ for k, v in losses.items():
+ if "img" in k:
+ log_imgs[k] = v
+ else:
+ real_losses[k] = v
+
+ loss, log_vars = self._parse_losses(real_losses)
+
+ outputs = dict(loss=loss, log_vars=log_vars, num_samples=len(data_batch["img_metas"]), log_imgs=log_imgs)
+
+ return outputs
+
+ def val_step(self, data_batch, **kwargs):
+ """The iteration step during validation.
+
+ This method shares the same signature as :func:`train_step`, but used
+ during val epochs. Note that the evaluation after training epochs is
+ not implemented with this method, but an evaluation hook.
+ """
+ output = self(**data_batch, **kwargs)
+ return output
+
+ @staticmethod
+ def _parse_losses(losses):
+ import torch.distributed as dist
+
+ """Parse the raw outputs (losses) of the network.
+
+ Args:
+ losses (dict): Raw output of the network, which usually contain
+ losses and other necessary information.
+
+ Returns:
+ tuple[Tensor, dict]: (loss, log_vars), loss is the loss tensor
+ which may be a weighted sum of all losses, log_vars contains
+ all the variables to be sent to the logger.
+ """
+ log_vars = OrderedDict()
+ for loss_name, loss_value in losses.items():
+ if isinstance(loss_value, torch.Tensor):
+ log_vars[loss_name] = loss_value.mean()
+ elif isinstance(loss_value, list):
+ log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value)
+ else:
+ raise TypeError(f"{loss_name} is not a tensor or list of tensors")
+
+ loss = sum(_value for _key, _value in log_vars.items() if "loss" in _key)
+
+ log_vars["loss"] = loss
+ for loss_name, loss_value in log_vars.items():
+ # reduce loss when distributed training
+ if dist.is_available() and dist.is_initialized():
+ loss_value = loss_value.data.clone()
+ dist.all_reduce(loss_value.div_(dist.get_world_size()))
+ log_vars[loss_name] = loss_value.item()
+
+ return loss, log_vars
diff --git a/facebookresearch/dinov2/dinov2/hub/depth/ops.py b/facebookresearch/dinov2/dinov2/hub/depth/ops.py
new file mode 100644
index 0000000..15880ee
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/depth/ops.py
@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import warnings
+
+import torch.nn.functional as F
+
+
+def resize(input, size=None, scale_factor=None, mode="nearest", align_corners=None, warning=False):
+ if warning:
+ if size is not None and align_corners:
+ input_h, input_w = tuple(int(x) for x in input.shape[2:])
+ output_h, output_w = tuple(int(x) for x in size)
+ if output_h > input_h or output_w > output_h:
+ if (
+ (output_h > 1 and output_w > 1 and input_h > 1 and input_w > 1)
+ and (output_h - 1) % (input_h - 1)
+ and (output_w - 1) % (input_w - 1)
+ ):
+ warnings.warn(
+ f"When align_corners={align_corners}, "
+ "the output would more aligned if "
+ f"input size {(input_h, input_w)} is `x+1` and "
+ f"out size {(output_h, output_w)} is `nx+1`"
+ )
+ return F.interpolate(input, size, scale_factor, mode, align_corners)
diff --git a/facebookresearch/dinov2/dinov2/hub/depthers.py b/facebookresearch/dinov2/dinov2/hub/depthers.py
new file mode 100644
index 0000000..f88b7e9
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/depthers.py
@@ -0,0 +1,246 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+from functools import partial
+from typing import Optional, Tuple, Union
+
+import torch
+
+from .backbones import _make_dinov2_model
+from .depth import BNHead, DepthEncoderDecoder, DPTHead
+from .utils import _DINOV2_BASE_URL, _make_dinov2_model_name, CenterPadding
+
+
+class Weights(Enum):
+ NYU = "NYU"
+ KITTI = "KITTI"
+
+
+def _get_depth_range(pretrained: bool, weights: Weights = Weights.NYU) -> Tuple[float, float]:
+ if not pretrained: # Default
+ return (0.001, 10.0)
+
+ # Pretrained, set according to the training dataset for the provided weights
+ if weights == Weights.KITTI:
+ return (0.001, 80.0)
+
+ if weights == Weights.NYU:
+ return (0.001, 10.0)
+
+ return (0.001, 10.0)
+
+
+def _make_dinov2_linear_depth_head(
+ *,
+ embed_dim: int,
+ layers: int,
+ min_depth: float,
+ max_depth: float,
+ **kwargs,
+):
+ if layers not in (1, 4):
+ raise AssertionError(f"Unsupported number of layers: {layers}")
+
+ if layers == 1:
+ in_index = [0]
+ else:
+ assert layers == 4
+ in_index = [0, 1, 2, 3]
+
+ return BNHead(
+ classify=True,
+ n_bins=256,
+ bins_strategy="UD",
+ norm_strategy="linear",
+ upsample=4,
+ in_channels=[embed_dim] * len(in_index),
+ in_index=in_index,
+ input_transform="resize_concat",
+ channels=embed_dim * len(in_index) * 2,
+ align_corners=False,
+ min_depth=0.001,
+ max_depth=80,
+ loss_decode=(),
+ )
+
+
+def _make_dinov2_linear_depther(
+ *,
+ arch_name: str = "vit_large",
+ layers: int = 4,
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.NYU,
+ depth_range: Optional[Tuple[float, float]] = None,
+ **kwargs,
+):
+ if layers not in (1, 4):
+ raise AssertionError(f"Unsupported number of layers: {layers}")
+ if isinstance(weights, str):
+ try:
+ weights = Weights[weights]
+ except KeyError:
+ raise AssertionError(f"Unsupported weights: {weights}")
+
+ if depth_range is None:
+ depth_range = _get_depth_range(pretrained, weights)
+ min_depth, max_depth = depth_range
+
+ backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs)
+
+ embed_dim = backbone.embed_dim
+ patch_size = backbone.patch_size
+ model_name = _make_dinov2_model_name(arch_name, patch_size)
+ linear_depth_head = _make_dinov2_linear_depth_head(
+ embed_dim=embed_dim,
+ layers=layers,
+ min_depth=min_depth,
+ max_depth=max_depth,
+ )
+
+ layer_count = {
+ "vit_small": 12,
+ "vit_base": 12,
+ "vit_large": 24,
+ "vit_giant2": 40,
+ }[arch_name]
+
+ if layers == 4:
+ out_index = {
+ "vit_small": [2, 5, 8, 11],
+ "vit_base": [2, 5, 8, 11],
+ "vit_large": [4, 11, 17, 23],
+ "vit_giant2": [9, 19, 29, 39],
+ }[arch_name]
+ else:
+ assert layers == 1
+ out_index = [layer_count - 1]
+
+ model = DepthEncoderDecoder(backbone=backbone, decode_head=linear_depth_head)
+ model.backbone.forward = partial(
+ backbone.get_intermediate_layers,
+ n=out_index,
+ reshape=True,
+ return_class_token=True,
+ norm=False,
+ )
+ model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(patch_size)(x[0]))
+
+ if pretrained:
+ layers_str = str(layers) if layers == 4 else ""
+ weights_str = weights.value.lower()
+ url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_linear{layers_str}_head.pth"
+ checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu")
+ if "state_dict" in checkpoint:
+ state_dict = checkpoint["state_dict"]
+ model.load_state_dict(state_dict, strict=False)
+
+ return model
+
+
+def dinov2_vits14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_linear_depther(
+ arch_name="vit_small", layers=layers, pretrained=pretrained, weights=weights, **kwargs
+ )
+
+
+def dinov2_vitb14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_linear_depther(
+ arch_name="vit_base", layers=layers, pretrained=pretrained, weights=weights, **kwargs
+ )
+
+
+def dinov2_vitl14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_linear_depther(
+ arch_name="vit_large", layers=layers, pretrained=pretrained, weights=weights, **kwargs
+ )
+
+
+def dinov2_vitg14_ld(*, layers: int = 4, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_linear_depther(
+ arch_name="vit_giant2", layers=layers, ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs
+ )
+
+
+def _make_dinov2_dpt_depth_head(*, embed_dim: int, min_depth: float, max_depth: float):
+ return DPTHead(
+ in_channels=[embed_dim] * 4,
+ channels=256,
+ embed_dims=embed_dim,
+ post_process_channels=[embed_dim // 2 ** (3 - i) for i in range(4)],
+ readout_type="project",
+ min_depth=min_depth,
+ max_depth=max_depth,
+ loss_decode=(),
+ )
+
+
+def _make_dinov2_dpt_depther(
+ *,
+ arch_name: str = "vit_large",
+ pretrained: bool = True,
+ weights: Union[Weights, str] = Weights.NYU,
+ depth_range: Optional[Tuple[float, float]] = None,
+ **kwargs,
+):
+ if isinstance(weights, str):
+ try:
+ weights = Weights[weights]
+ except KeyError:
+ raise AssertionError(f"Unsupported weights: {weights}")
+
+ if depth_range is None:
+ depth_range = _get_depth_range(pretrained, weights)
+ min_depth, max_depth = depth_range
+
+ backbone = _make_dinov2_model(arch_name=arch_name, pretrained=pretrained, **kwargs)
+
+ model_name = _make_dinov2_model_name(arch_name, backbone.patch_size)
+ dpt_depth_head = _make_dinov2_dpt_depth_head(embed_dim=backbone.embed_dim, min_depth=min_depth, max_depth=max_depth)
+
+ out_index = {
+ "vit_small": [2, 5, 8, 11],
+ "vit_base": [2, 5, 8, 11],
+ "vit_large": [4, 11, 17, 23],
+ "vit_giant2": [9, 19, 29, 39],
+ }[arch_name]
+
+ model = DepthEncoderDecoder(backbone=backbone, decode_head=dpt_depth_head)
+ model.backbone.forward = partial(
+ backbone.get_intermediate_layers,
+ n=out_index,
+ reshape=True,
+ return_class_token=True,
+ norm=False,
+ )
+ model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone.patch_size)(x[0]))
+
+ if pretrained:
+ weights_str = weights.value.lower()
+ url = _DINOV2_BASE_URL + f"/{model_name}/{model_name}_{weights_str}_dpt_head.pth"
+ checkpoint = torch.hub.load_state_dict_from_url(url, map_location="cpu")
+ if "state_dict" in checkpoint:
+ state_dict = checkpoint["state_dict"]
+ model.load_state_dict(state_dict, strict=False)
+
+ return model
+
+
+def dinov2_vits14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_dpt_depther(arch_name="vit_small", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitb14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_dpt_depther(arch_name="vit_base", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitl14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_dpt_depther(arch_name="vit_large", pretrained=pretrained, weights=weights, **kwargs)
+
+
+def dinov2_vitg14_dd(*, pretrained: bool = True, weights: Union[Weights, str] = Weights.NYU, **kwargs):
+ return _make_dinov2_dpt_depther(
+ arch_name="vit_giant2", ffn_layer="swiglufused", pretrained=pretrained, weights=weights, **kwargs
+ )
diff --git a/facebookresearch/dinov2/dinov2/hub/utils.py b/facebookresearch/dinov2/dinov2/hub/utils.py
new file mode 100644
index 0000000..9c66414
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/hub/utils.py
@@ -0,0 +1,39 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import itertools
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+_DINOV2_BASE_URL = "https://dl.fbaipublicfiles.com/dinov2"
+
+
+def _make_dinov2_model_name(arch_name: str, patch_size: int, num_register_tokens: int = 0) -> str:
+ compact_arch_name = arch_name.replace("_", "")[:4]
+ registers_suffix = f"_reg{num_register_tokens}" if num_register_tokens else ""
+ return f"dinov2_{compact_arch_name}{patch_size}{registers_suffix}"
+
+
+class CenterPadding(nn.Module):
+ def __init__(self, multiple):
+ super().__init__()
+ self.multiple = multiple
+
+ def _get_pad(self, size):
+ new_size = math.ceil(size / self.multiple) * self.multiple
+ pad_size = new_size - size
+ pad_size_left = pad_size // 2
+ pad_size_right = pad_size - pad_size_left
+ return pad_size_left, pad_size_right
+
+ @torch.inference_mode()
+ def forward(self, x):
+ pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1]))
+ output = F.pad(x, pads)
+ return output
diff --git a/facebookresearch/dinov2/dinov2/layers/__init__.py b/facebookresearch/dinov2/dinov2/layers/__init__.py
new file mode 100644
index 0000000..05a0b61
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/__init__.py
@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .dino_head import DINOHead
+from .mlp import Mlp
+from .patch_embed import PatchEmbed
+from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused
+from .block import NestedTensorBlock
+from .attention import MemEffAttention
diff --git a/facebookresearch/dinov2/dinov2/layers/attention.py b/facebookresearch/dinov2/dinov2/layers/attention.py
new file mode 100644
index 0000000..0fb76ef
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/attention.py
@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+import logging
+import os
+import warnings
+
+from torch import Tensor
+from torch import nn
+
+
+logger = logging.getLogger("dinov2")
+
+
+XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None
+try:
+ if XFORMERS_ENABLED:
+ from xformers.ops import memory_efficient_attention, unbind
+
+ XFORMERS_AVAILABLE = True
+ warnings.warn("xFormers is available (Attention)")
+ else:
+ warnings.warn("xFormers is disabled (Attention)")
+ raise ImportError
+except ImportError:
+ XFORMERS_AVAILABLE = False
+ warnings.warn("xFormers is not available (Attention)")
+
+
+class Attention(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ num_heads: int = 8,
+ qkv_bias: bool = False,
+ proj_bias: bool = True,
+ attn_drop: float = 0.0,
+ proj_drop: float = 0.0,
+ ) -> None:
+ super().__init__()
+ self.num_heads = num_heads
+ head_dim = dim // num_heads
+ self.scale = head_dim**-0.5
+
+ self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+ self.attn_drop = nn.Dropout(attn_drop)
+ self.proj = nn.Linear(dim, dim, bias=proj_bias)
+ self.proj_drop = nn.Dropout(proj_drop)
+
+ def forward(self, x: Tensor) -> Tensor:
+ B, N, C = x.shape
+ qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+
+ q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
+ attn = q @ k.transpose(-2, -1)
+
+ attn = attn.softmax(dim=-1)
+ attn = self.attn_drop(attn)
+
+ x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
+
+
+class MemEffAttention(Attention):
+ def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+ if not XFORMERS_AVAILABLE:
+ if attn_bias is not None:
+ raise AssertionError("xFormers is required for using nested tensors")
+ return super().forward(x)
+
+ B, N, C = x.shape
+ qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+ q, k, v = unbind(qkv, 2)
+
+ x = memory_efficient_attention(q, k, v, attn_bias=attn_bias)
+ x = x.reshape([B, N, C])
+
+ x = self.proj(x)
+ x = self.proj_drop(x)
+ return x
diff --git a/facebookresearch/dinov2/dinov2/layers/block.py b/facebookresearch/dinov2/dinov2/layers/block.py
new file mode 100644
index 0000000..930787b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/block.py
@@ -0,0 +1,260 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+import logging
+import os
+from typing import Callable, List, Any, Tuple, Dict
+import warnings
+
+import torch
+from torch import nn, Tensor
+
+from .attention import Attention, MemEffAttention
+from .drop_path import DropPath
+from .layer_scale import LayerScale
+from .mlp import Mlp
+
+
+logger = logging.getLogger("dinov2")
+
+
+XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None
+try:
+ if XFORMERS_ENABLED:
+ from xformers.ops import fmha, scaled_index_add, index_select_cat
+
+ XFORMERS_AVAILABLE = True
+ warnings.warn("xFormers is available (Block)")
+ else:
+ warnings.warn("xFormers is disabled (Block)")
+ raise ImportError
+except ImportError:
+ XFORMERS_AVAILABLE = False
+
+ warnings.warn("xFormers is not available (Block)")
+
+
+class Block(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ num_heads: int,
+ mlp_ratio: float = 4.0,
+ qkv_bias: bool = False,
+ proj_bias: bool = True,
+ ffn_bias: bool = True,
+ drop: float = 0.0,
+ attn_drop: float = 0.0,
+ init_values=None,
+ drop_path: float = 0.0,
+ act_layer: Callable[..., nn.Module] = nn.GELU,
+ norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+ attn_class: Callable[..., nn.Module] = Attention,
+ ffn_layer: Callable[..., nn.Module] = Mlp,
+ ) -> None:
+ super().__init__()
+ # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}")
+ self.norm1 = norm_layer(dim)
+ self.attn = attn_class(
+ dim,
+ num_heads=num_heads,
+ qkv_bias=qkv_bias,
+ proj_bias=proj_bias,
+ attn_drop=attn_drop,
+ proj_drop=drop,
+ )
+ self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+ self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+ self.norm2 = norm_layer(dim)
+ mlp_hidden_dim = int(dim * mlp_ratio)
+ self.mlp = ffn_layer(
+ in_features=dim,
+ hidden_features=mlp_hidden_dim,
+ act_layer=act_layer,
+ drop=drop,
+ bias=ffn_bias,
+ )
+ self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+ self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+ self.sample_drop_ratio = drop_path
+
+ def forward(self, x: Tensor) -> Tensor:
+ def attn_residual_func(x: Tensor) -> Tensor:
+ return self.ls1(self.attn(self.norm1(x)))
+
+ def ffn_residual_func(x: Tensor) -> Tensor:
+ return self.ls2(self.mlp(self.norm2(x)))
+
+ if self.training and self.sample_drop_ratio > 0.1:
+ # the overhead is compensated only for a drop path rate larger than 0.1
+ x = drop_add_residual_stochastic_depth(
+ x,
+ residual_func=attn_residual_func,
+ sample_drop_ratio=self.sample_drop_ratio,
+ )
+ x = drop_add_residual_stochastic_depth(
+ x,
+ residual_func=ffn_residual_func,
+ sample_drop_ratio=self.sample_drop_ratio,
+ )
+ elif self.training and self.sample_drop_ratio > 0.0:
+ x = x + self.drop_path1(attn_residual_func(x))
+ x = x + self.drop_path1(ffn_residual_func(x)) # FIXME: drop_path2
+ else:
+ x = x + attn_residual_func(x)
+ x = x + ffn_residual_func(x)
+ return x
+
+
+def drop_add_residual_stochastic_depth(
+ x: Tensor,
+ residual_func: Callable[[Tensor], Tensor],
+ sample_drop_ratio: float = 0.0,
+) -> Tensor:
+ # 1) extract subset using permutation
+ b, n, d = x.shape
+ sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+ brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+ x_subset = x[brange]
+
+ # 2) apply residual_func to get residual
+ residual = residual_func(x_subset)
+
+ x_flat = x.flatten(1)
+ residual = residual.flatten(1)
+
+ residual_scale_factor = b / sample_subset_size
+
+ # 3) add the residual
+ x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+ return x_plus_residual.view_as(x)
+
+
+def get_branges_scales(x, sample_drop_ratio=0.0):
+ b, n, d = x.shape
+ sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+ brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+ residual_scale_factor = b / sample_subset_size
+ return brange, residual_scale_factor
+
+
+def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None):
+ if scaling_vector is None:
+ x_flat = x.flatten(1)
+ residual = residual.flatten(1)
+ x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+ else:
+ x_plus_residual = scaled_index_add(
+ x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor
+ )
+ return x_plus_residual
+
+
+attn_bias_cache: Dict[Tuple, Any] = {}
+
+
+def get_attn_bias_and_cat(x_list, branges=None):
+ """
+ this will perform the index select, cat the tensors, and provide the attn_bias from cache
+ """
+ batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list]
+ all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list))
+ if all_shapes not in attn_bias_cache.keys():
+ seqlens = []
+ for b, x in zip(batch_sizes, x_list):
+ for _ in range(b):
+ seqlens.append(x.shape[1])
+ attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens)
+ attn_bias._batch_sizes = batch_sizes
+ attn_bias_cache[all_shapes] = attn_bias
+
+ if branges is not None:
+ cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1])
+ else:
+ tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list)
+ cat_tensors = torch.cat(tensors_bs1, dim=1)
+
+ return attn_bias_cache[all_shapes], cat_tensors
+
+
+def drop_add_residual_stochastic_depth_list(
+ x_list: List[Tensor],
+ residual_func: Callable[[Tensor, Any], Tensor],
+ sample_drop_ratio: float = 0.0,
+ scaling_vector=None,
+) -> Tensor:
+ # 1) generate random set of indices for dropping samples in the batch
+ branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list]
+ branges = [s[0] for s in branges_scales]
+ residual_scale_factors = [s[1] for s in branges_scales]
+
+ # 2) get attention bias and index+concat the tensors
+ attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges)
+
+ # 3) apply residual_func to get residual, and split the result
+ residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias)) # type: ignore
+
+ outputs = []
+ for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors):
+ outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x))
+ return outputs
+
+
+class NestedTensorBlock(Block):
+ def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
+ """
+ x_list contains a list of tensors to nest together and run
+ """
+ assert isinstance(self.attn, MemEffAttention)
+
+ if self.training and self.sample_drop_ratio > 0.0:
+
+ def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+ return self.attn(self.norm1(x), attn_bias=attn_bias)
+
+ def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+ return self.mlp(self.norm2(x))
+
+ x_list = drop_add_residual_stochastic_depth_list(
+ x_list,
+ residual_func=attn_residual_func,
+ sample_drop_ratio=self.sample_drop_ratio,
+ scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None,
+ )
+ x_list = drop_add_residual_stochastic_depth_list(
+ x_list,
+ residual_func=ffn_residual_func,
+ sample_drop_ratio=self.sample_drop_ratio,
+ scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None,
+ )
+ return x_list
+ else:
+
+ def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+ return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias))
+
+ def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+ return self.ls2(self.mlp(self.norm2(x)))
+
+ attn_bias, x = get_attn_bias_and_cat(x_list)
+ x = x + attn_residual_func(x, attn_bias=attn_bias)
+ x = x + ffn_residual_func(x)
+ return attn_bias.split(x)
+
+ def forward(self, x_or_x_list):
+ if isinstance(x_or_x_list, Tensor):
+ return super().forward(x_or_x_list)
+ elif isinstance(x_or_x_list, list):
+ if not XFORMERS_AVAILABLE:
+ raise AssertionError("xFormers is required for using nested tensors")
+ return self.forward_nested(x_or_x_list)
+ else:
+ raise AssertionError
diff --git a/facebookresearch/dinov2/dinov2/layers/dino_head.py b/facebookresearch/dinov2/dinov2/layers/dino_head.py
new file mode 100644
index 0000000..0ace8ff
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/dino_head.py
@@ -0,0 +1,58 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+from torch.nn.init import trunc_normal_
+from torch.nn.utils import weight_norm
+
+
+class DINOHead(nn.Module):
+ def __init__(
+ self,
+ in_dim,
+ out_dim,
+ use_bn=False,
+ nlayers=3,
+ hidden_dim=2048,
+ bottleneck_dim=256,
+ mlp_bias=True,
+ ):
+ super().__init__()
+ nlayers = max(nlayers, 1)
+ self.mlp = _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=hidden_dim, use_bn=use_bn, bias=mlp_bias)
+ self.apply(self._init_weights)
+ self.last_layer = weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False))
+ self.last_layer.weight_g.data.fill_(1)
+
+ def _init_weights(self, m):
+ if isinstance(m, nn.Linear):
+ trunc_normal_(m.weight, std=0.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+
+ def forward(self, x):
+ x = self.mlp(x)
+ eps = 1e-6 if x.dtype == torch.float16 else 1e-12
+ x = nn.functional.normalize(x, dim=-1, p=2, eps=eps)
+ x = self.last_layer(x)
+ return x
+
+
+def _build_mlp(nlayers, in_dim, bottleneck_dim, hidden_dim=None, use_bn=False, bias=True):
+ if nlayers == 1:
+ return nn.Linear(in_dim, bottleneck_dim, bias=bias)
+ else:
+ layers = [nn.Linear(in_dim, hidden_dim, bias=bias)]
+ if use_bn:
+ layers.append(nn.BatchNorm1d(hidden_dim))
+ layers.append(nn.GELU())
+ for _ in range(nlayers - 2):
+ layers.append(nn.Linear(hidden_dim, hidden_dim, bias=bias))
+ if use_bn:
+ layers.append(nn.BatchNorm1d(hidden_dim))
+ layers.append(nn.GELU())
+ layers.append(nn.Linear(hidden_dim, bottleneck_dim, bias=bias))
+ return nn.Sequential(*layers)
diff --git a/facebookresearch/dinov2/dinov2/layers/drop_path.py b/facebookresearch/dinov2/dinov2/layers/drop_path.py
new file mode 100644
index 0000000..1d640e0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/drop_path.py
@@ -0,0 +1,34 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/drop.py
+
+
+from torch import nn
+
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+ if drop_prob == 0.0 or not training:
+ return x
+ keep_prob = 1 - drop_prob
+ shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets
+ random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+ if keep_prob > 0.0:
+ random_tensor.div_(keep_prob)
+ output = x * random_tensor
+ return output
+
+
+class DropPath(nn.Module):
+ """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+ def __init__(self, drop_prob=None):
+ super(DropPath, self).__init__()
+ self.drop_prob = drop_prob
+
+ def forward(self, x):
+ return drop_path(x, self.drop_prob, self.training)
diff --git a/facebookresearch/dinov2/dinov2/layers/layer_scale.py b/facebookresearch/dinov2/dinov2/layers/layer_scale.py
new file mode 100644
index 0000000..51df0d7
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/layer_scale.py
@@ -0,0 +1,27 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# Modified from: https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/vision_transformer.py#L103-L110
+
+from typing import Union
+
+import torch
+from torch import Tensor
+from torch import nn
+
+
+class LayerScale(nn.Module):
+ def __init__(
+ self,
+ dim: int,
+ init_values: Union[float, Tensor] = 1e-5,
+ inplace: bool = False,
+ ) -> None:
+ super().__init__()
+ self.inplace = inplace
+ self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+ def forward(self, x: Tensor) -> Tensor:
+ return x.mul_(self.gamma) if self.inplace else x * self.gamma
diff --git a/facebookresearch/dinov2/dinov2/layers/mlp.py b/facebookresearch/dinov2/dinov2/layers/mlp.py
new file mode 100644
index 0000000..bbf9432
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/mlp.py
@@ -0,0 +1,40 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/mlp.py
+
+
+from typing import Callable, Optional
+
+from torch import Tensor, nn
+
+
+class Mlp(nn.Module):
+ def __init__(
+ self,
+ in_features: int,
+ hidden_features: Optional[int] = None,
+ out_features: Optional[int] = None,
+ act_layer: Callable[..., nn.Module] = nn.GELU,
+ drop: float = 0.0,
+ bias: bool = True,
+ ) -> None:
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+ self.act = act_layer()
+ self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+ self.drop = nn.Dropout(drop)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.fc1(x)
+ x = self.act(x)
+ x = self.drop(x)
+ x = self.fc2(x)
+ x = self.drop(x)
+ return x
diff --git a/facebookresearch/dinov2/dinov2/layers/patch_embed.py b/facebookresearch/dinov2/dinov2/layers/patch_embed.py
new file mode 100644
index 0000000..8b7c080
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/patch_embed.py
@@ -0,0 +1,88 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
+
+from typing import Callable, Optional, Tuple, Union
+
+from torch import Tensor
+import torch.nn as nn
+
+
+def make_2tuple(x):
+ if isinstance(x, tuple):
+ assert len(x) == 2
+ return x
+
+ assert isinstance(x, int)
+ return (x, x)
+
+
+class PatchEmbed(nn.Module):
+ """
+ 2D image to patch embedding: (B,C,H,W) -> (B,N,D)
+
+ Args:
+ img_size: Image size.
+ patch_size: Patch token size.
+ in_chans: Number of input image channels.
+ embed_dim: Number of linear projection output channels.
+ norm_layer: Normalization layer.
+ """
+
+ def __init__(
+ self,
+ img_size: Union[int, Tuple[int, int]] = 224,
+ patch_size: Union[int, Tuple[int, int]] = 16,
+ in_chans: int = 3,
+ embed_dim: int = 768,
+ norm_layer: Optional[Callable] = None,
+ flatten_embedding: bool = True,
+ ) -> None:
+ super().__init__()
+
+ image_HW = make_2tuple(img_size)
+ patch_HW = make_2tuple(patch_size)
+ patch_grid_size = (
+ image_HW[0] // patch_HW[0],
+ image_HW[1] // patch_HW[1],
+ )
+
+ self.img_size = image_HW
+ self.patch_size = patch_HW
+ self.patches_resolution = patch_grid_size
+ self.num_patches = patch_grid_size[0] * patch_grid_size[1]
+
+ self.in_chans = in_chans
+ self.embed_dim = embed_dim
+
+ self.flatten_embedding = flatten_embedding
+
+ self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW)
+ self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+ def forward(self, x: Tensor) -> Tensor:
+ _, _, H, W = x.shape
+ patch_H, patch_W = self.patch_size
+
+ assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}"
+ assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}"
+
+ x = self.proj(x) # B C H W
+ H, W = x.size(2), x.size(3)
+ x = x.flatten(2).transpose(1, 2) # B HW C
+ x = self.norm(x)
+ if not self.flatten_embedding:
+ x = x.reshape(-1, H, W, self.embed_dim) # B H W C
+ return x
+
+ def flops(self) -> float:
+ Ho, Wo = self.patches_resolution
+ flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+ if self.norm is not None:
+ flops += Ho * Wo * self.embed_dim
+ return flops
diff --git a/facebookresearch/dinov2/dinov2/layers/swiglu_ffn.py b/facebookresearch/dinov2/dinov2/layers/swiglu_ffn.py
new file mode 100644
index 0000000..5e9dafa
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/layers/swiglu_ffn.py
@@ -0,0 +1,72 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import os
+from typing import Callable, Optional
+import warnings
+
+from torch import Tensor, nn
+import torch.nn.functional as F
+
+
+class SwiGLUFFN(nn.Module):
+ def __init__(
+ self,
+ in_features: int,
+ hidden_features: Optional[int] = None,
+ out_features: Optional[int] = None,
+ act_layer: Callable[..., nn.Module] = None,
+ drop: float = 0.0,
+ bias: bool = True,
+ ) -> None:
+ super().__init__()
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias)
+ self.w3 = nn.Linear(hidden_features, out_features, bias=bias)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x12 = self.w12(x)
+ x1, x2 = x12.chunk(2, dim=-1)
+ hidden = F.silu(x1) * x2
+ return self.w3(hidden)
+
+
+XFORMERS_ENABLED = os.environ.get("XFORMERS_DISABLED") is None
+try:
+ if XFORMERS_ENABLED:
+ from xformers.ops import SwiGLU
+
+ XFORMERS_AVAILABLE = True
+ warnings.warn("xFormers is available (SwiGLU)")
+ else:
+ warnings.warn("xFormers is disabled (SwiGLU)")
+ raise ImportError
+except ImportError:
+ SwiGLU = SwiGLUFFN
+ XFORMERS_AVAILABLE = False
+
+ warnings.warn("xFormers is not available (SwiGLU)")
+
+
+class SwiGLUFFNFused(SwiGLU):
+ def __init__(
+ self,
+ in_features: int,
+ hidden_features: Optional[int] = None,
+ out_features: Optional[int] = None,
+ act_layer: Callable[..., nn.Module] = None,
+ drop: float = 0.0,
+ bias: bool = True,
+ ) -> None:
+ out_features = out_features or in_features
+ hidden_features = hidden_features or in_features
+ hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+ super().__init__(
+ in_features=in_features,
+ hidden_features=hidden_features,
+ out_features=out_features,
+ bias=bias,
+ )
diff --git a/facebookresearch/dinov2/dinov2/logging/__init__.py b/facebookresearch/dinov2/dinov2/logging/__init__.py
new file mode 100644
index 0000000..04a7f02
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/logging/__init__.py
@@ -0,0 +1,102 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import functools
+import logging
+import os
+import sys
+from typing import Optional
+
+import dinov2.distributed as distributed
+from .helpers import MetricLogger, SmoothedValue
+
+
+# So that calling _configure_logger multiple times won't add many handlers
+@functools.lru_cache()
+def _configure_logger(
+ name: Optional[str] = None,
+ *,
+ level: int = logging.DEBUG,
+ output: Optional[str] = None,
+):
+ """
+ Configure a logger.
+
+ Adapted from Detectron2.
+
+ Args:
+ name: The name of the logger to configure.
+ level: The logging level to use.
+ output: A file name or a directory to save log. If None, will not save log file.
+ If ends with ".txt" or ".log", assumed to be a file name.
+ Otherwise, logs will be saved to `output/log.txt`.
+
+ Returns:
+ The configured logger.
+ """
+
+ logger = logging.getLogger(name)
+ logger.setLevel(level)
+ logger.propagate = False
+
+ # Loosely match Google glog format:
+ # [IWEF]yyyymmdd hh:mm:ss.uuuuuu threadid file:line] msg
+ # but use a shorter timestamp and include the logger name:
+ # [IWEF]yyyymmdd hh:mm:ss logger threadid file:line] msg
+ fmt_prefix = "%(levelname).1s%(asctime)s %(process)s %(name)s %(filename)s:%(lineno)s] "
+ fmt_message = "%(message)s"
+ fmt = fmt_prefix + fmt_message
+ datefmt = "%Y%m%d %H:%M:%S"
+ formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
+
+ # stdout logging for main worker only
+ if distributed.is_main_process():
+ handler = logging.StreamHandler(stream=sys.stdout)
+ handler.setLevel(logging.DEBUG)
+ handler.setFormatter(formatter)
+ logger.addHandler(handler)
+
+ # file logging for all workers
+ if output:
+ if os.path.splitext(output)[-1] in (".txt", ".log"):
+ filename = output
+ else:
+ filename = os.path.join(output, "logs", "log.txt")
+
+ if not distributed.is_main_process():
+ global_rank = distributed.get_global_rank()
+ filename = filename + ".rank{}".format(global_rank)
+
+ os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+ handler = logging.StreamHandler(open(filename, "a"))
+ handler.setLevel(logging.DEBUG)
+ handler.setFormatter(formatter)
+ logger.addHandler(handler)
+
+ return logger
+
+
+def setup_logging(
+ output: Optional[str] = None,
+ *,
+ name: Optional[str] = None,
+ level: int = logging.DEBUG,
+ capture_warnings: bool = True,
+) -> None:
+ """
+ Setup logging.
+
+ Args:
+ output: A file name or a directory to save log files. If None, log
+ files will not be saved. If output ends with ".txt" or ".log", it
+ is assumed to be a file name.
+ Otherwise, logs will be saved to `output/log.txt`.
+ name: The name of the logger to configure, by default the root logger.
+ level: The logging level to use.
+ capture_warnings: Whether warnings should be captured as logs.
+ """
+ logging.captureWarnings(capture_warnings)
+ _configure_logger(name, level=level, output=output)
diff --git a/facebookresearch/dinov2/dinov2/logging/helpers.py b/facebookresearch/dinov2/dinov2/logging/helpers.py
new file mode 100644
index 0000000..c6e70bb
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/logging/helpers.py
@@ -0,0 +1,194 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from collections import defaultdict, deque
+import datetime
+import json
+import logging
+import time
+
+import torch
+
+import dinov2.distributed as distributed
+
+
+logger = logging.getLogger("dinov2")
+
+
+class MetricLogger(object):
+ def __init__(self, delimiter="\t", output_file=None):
+ self.meters = defaultdict(SmoothedValue)
+ self.delimiter = delimiter
+ self.output_file = output_file
+
+ def update(self, **kwargs):
+ for k, v in kwargs.items():
+ if isinstance(v, torch.Tensor):
+ v = v.item()
+ assert isinstance(v, (float, int))
+ self.meters[k].update(v)
+
+ def __getattr__(self, attr):
+ if attr in self.meters:
+ return self.meters[attr]
+ if attr in self.__dict__:
+ return self.__dict__[attr]
+ raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr))
+
+ def __str__(self):
+ loss_str = []
+ for name, meter in self.meters.items():
+ loss_str.append("{}: {}".format(name, str(meter)))
+ return self.delimiter.join(loss_str)
+
+ def synchronize_between_processes(self):
+ for meter in self.meters.values():
+ meter.synchronize_between_processes()
+
+ def add_meter(self, name, meter):
+ self.meters[name] = meter
+
+ def dump_in_output_file(self, iteration, iter_time, data_time):
+ if self.output_file is None or not distributed.is_main_process():
+ return
+ dict_to_dump = dict(
+ iteration=iteration,
+ iter_time=iter_time,
+ data_time=data_time,
+ )
+ dict_to_dump.update({k: v.median for k, v in self.meters.items()})
+ with open(self.output_file, "a") as f:
+ f.write(json.dumps(dict_to_dump) + "\n")
+ pass
+
+ def log_every(self, iterable, print_freq, header=None, n_iterations=None, start_iteration=0):
+ i = start_iteration
+ if not header:
+ header = ""
+ start_time = time.time()
+ end = time.time()
+ iter_time = SmoothedValue(fmt="{avg:.6f}")
+ data_time = SmoothedValue(fmt="{avg:.6f}")
+
+ if n_iterations is None:
+ n_iterations = len(iterable)
+
+ space_fmt = ":" + str(len(str(n_iterations))) + "d"
+
+ log_list = [
+ header,
+ "[{0" + space_fmt + "}/{1}]",
+ "eta: {eta}",
+ "{meters}",
+ "time: {time}",
+ "data: {data}",
+ ]
+ if torch.cuda.is_available():
+ log_list += ["max mem: {memory:.0f}"]
+
+ log_msg = self.delimiter.join(log_list)
+ MB = 1024.0 * 1024.0
+ for obj in iterable:
+ data_time.update(time.time() - end)
+ yield obj
+ iter_time.update(time.time() - end)
+ if i % print_freq == 0 or i == n_iterations - 1:
+ self.dump_in_output_file(iteration=i, iter_time=iter_time.avg, data_time=data_time.avg)
+ eta_seconds = iter_time.global_avg * (n_iterations - i)
+ eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+ if torch.cuda.is_available():
+ logger.info(
+ log_msg.format(
+ i,
+ n_iterations,
+ eta=eta_string,
+ meters=str(self),
+ time=str(iter_time),
+ data=str(data_time),
+ memory=torch.cuda.max_memory_allocated() / MB,
+ )
+ )
+ else:
+ logger.info(
+ log_msg.format(
+ i,
+ n_iterations,
+ eta=eta_string,
+ meters=str(self),
+ time=str(iter_time),
+ data=str(data_time),
+ )
+ )
+ i += 1
+ end = time.time()
+ if i >= n_iterations:
+ break
+ total_time = time.time() - start_time
+ total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+ logger.info("{} Total time: {} ({:.6f} s / it)".format(header, total_time_str, total_time / n_iterations))
+
+
+class SmoothedValue:
+ """Track a series of values and provide access to smoothed values over a
+ window or the global series average.
+ """
+
+ def __init__(self, window_size=20, fmt=None):
+ if fmt is None:
+ fmt = "{median:.4f} ({global_avg:.4f})"
+ self.deque = deque(maxlen=window_size)
+ self.total = 0.0
+ self.count = 0
+ self.fmt = fmt
+
+ def update(self, value, num=1):
+ self.deque.append(value)
+ self.count += num
+ self.total += value * num
+
+ def synchronize_between_processes(self):
+ """
+ Distributed synchronization of the metric
+ Warning: does not synchronize the deque!
+ """
+ if not distributed.is_enabled():
+ return
+ t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
+ torch.distributed.barrier()
+ torch.distributed.all_reduce(t)
+ t = t.tolist()
+ self.count = int(t[0])
+ self.total = t[1]
+
+ @property
+ def median(self):
+ d = torch.tensor(list(self.deque))
+ return d.median().item()
+
+ @property
+ def avg(self):
+ d = torch.tensor(list(self.deque), dtype=torch.float32)
+ return d.mean().item()
+
+ @property
+ def global_avg(self):
+ return self.total / self.count
+
+ @property
+ def max(self):
+ return max(self.deque)
+
+ @property
+ def value(self):
+ return self.deque[-1]
+
+ def __str__(self):
+ return self.fmt.format(
+ median=self.median,
+ avg=self.avg,
+ global_avg=self.global_avg,
+ max=self.max,
+ value=self.value,
+ )
diff --git a/facebookresearch/dinov2/dinov2/loss/__init__.py b/facebookresearch/dinov2/dinov2/loss/__init__.py
new file mode 100644
index 0000000..d6b0115
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/loss/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .dino_clstoken_loss import DINOLoss
+from .ibot_patch_loss import iBOTPatchLoss
+from .koleo_loss import KoLeoLoss
diff --git a/facebookresearch/dinov2/dinov2/loss/dino_clstoken_loss.py b/facebookresearch/dinov2/dinov2/loss/dino_clstoken_loss.py
new file mode 100644
index 0000000..c31808e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/loss/dino_clstoken_loss.py
@@ -0,0 +1,99 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from torch import nn
+
+
+class DINOLoss(nn.Module):
+ def __init__(
+ self,
+ out_dim,
+ student_temp=0.1,
+ center_momentum=0.9,
+ ):
+ super().__init__()
+ self.student_temp = student_temp
+ self.center_momentum = center_momentum
+ self.register_buffer("center", torch.zeros(1, out_dim))
+ self.updated = True
+ self.reduce_handle = None
+ self.len_teacher_output = None
+ self.async_batch_center = None
+
+ @torch.no_grad()
+ def softmax_center_teacher(self, teacher_output, teacher_temp):
+ self.apply_center_update()
+ # teacher centering and sharpening
+ return F.softmax((teacher_output - self.center) / teacher_temp, dim=-1)
+
+ @torch.no_grad()
+ def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_iterations=3):
+ teacher_output = teacher_output.float()
+ world_size = dist.get_world_size() if dist.is_initialized() else 1
+ Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper
+ B = Q.shape[1] * world_size # number of samples to assign
+ K = Q.shape[0] # how many prototypes
+
+ # make the matrix sums to 1
+ sum_Q = torch.sum(Q)
+ if dist.is_initialized():
+ dist.all_reduce(sum_Q)
+ Q /= sum_Q
+
+ for it in range(n_iterations):
+ # normalize each row: total weight per prototype must be 1/K
+ sum_of_rows = torch.sum(Q, dim=1, keepdim=True)
+ if dist.is_initialized():
+ dist.all_reduce(sum_of_rows)
+ Q /= sum_of_rows
+ Q /= K
+
+ # normalize each column: total weight per sample must be 1/B
+ Q /= torch.sum(Q, dim=0, keepdim=True)
+ Q /= B
+
+ Q *= B # the columns must sum to 1 so that Q is an assignment
+ return Q.t()
+
+ def forward(self, student_output_list, teacher_out_softmaxed_centered_list):
+ """
+ Cross-entropy between softmax outputs of the teacher and student networks.
+ """
+ # TODO: Use cross_entropy_distribution here
+ total_loss = 0
+ for s in student_output_list:
+ lsm = F.log_softmax(s / self.student_temp, dim=-1)
+ for t in teacher_out_softmaxed_centered_list:
+ loss = torch.sum(t * lsm, dim=-1)
+ total_loss -= loss.mean()
+ return total_loss
+
+ @torch.no_grad()
+ def update_center(self, teacher_output):
+ self.reduce_center_update(teacher_output)
+
+ @torch.no_grad()
+ def reduce_center_update(self, teacher_output):
+ self.updated = False
+ self.len_teacher_output = len(teacher_output)
+ self.async_batch_center = torch.sum(teacher_output, dim=0, keepdim=True)
+ if dist.is_initialized():
+ self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True)
+
+ @torch.no_grad()
+ def apply_center_update(self):
+ if self.updated is False:
+ world_size = dist.get_world_size() if dist.is_initialized() else 1
+
+ if self.reduce_handle is not None:
+ self.reduce_handle.wait()
+ _t = self.async_batch_center / (self.len_teacher_output * world_size)
+
+ self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum)
+
+ self.updated = True
diff --git a/facebookresearch/dinov2/dinov2/loss/ibot_patch_loss.py b/facebookresearch/dinov2/dinov2/loss/ibot_patch_loss.py
new file mode 100644
index 0000000..6732cda
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/loss/ibot_patch_loss.py
@@ -0,0 +1,151 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from torch import nn
+
+import logging
+
+
+logger = logging.getLogger("dinov2")
+
+
+try:
+ from xformers.ops import cross_entropy
+
+ def lossfunc(t, s, temp):
+ s = s.float()
+ t = t.float()
+ if s.ndim == 2:
+ return -cross_entropy(s.unsqueeze(0), t.unsqueeze(0), temp, bw_inplace=True).squeeze(0)
+ elif s.ndim == 3:
+ return -cross_entropy(s, t, temp, bw_inplace=True)
+
+except ImportError:
+
+ def lossfunc(t, s, temp):
+ return torch.sum(t * F.log_softmax(s / temp, dim=-1), dim=-1)
+
+
+class iBOTPatchLoss(nn.Module):
+ def __init__(self, patch_out_dim, student_temp=0.1, center_momentum=0.9):
+ super().__init__()
+ self.student_temp = student_temp
+ self.center_momentum = center_momentum
+ self.register_buffer("center", torch.zeros(1, 1, patch_out_dim))
+ self.updated = True
+ self.reduce_handle = None
+ self.len_teacher_patch_tokens = None
+ self.async_batch_center = None
+
+ @torch.no_grad()
+ def softmax_center_teacher(self, teacher_patch_tokens, teacher_temp):
+ self.apply_center_update()
+ # teacher centering and sharpening
+ #
+ # WARNING:
+ # as self.center is a float32, everything gets casted to float32 afterwards
+ #
+ # teacher_patch_tokens = teacher_patch_tokens.float()
+ # return F.softmax((teacher_patch_tokens.sub_(self.center.to(teacher_patch_tokens.dtype))).mul_(1 / teacher_temp), dim=-1)
+
+ return F.softmax((teacher_patch_tokens - self.center) / teacher_temp, dim=-1)
+
+ # this is experimental, keep everything in float16 and let's see what happens:
+ # return F.softmax((teacher_patch_tokens.sub_(self.center)) / teacher_temp, dim=-1)
+
+ @torch.no_grad()
+ def sinkhorn_knopp_teacher(self, teacher_output, teacher_temp, n_masked_patches_tensor, n_iterations=3):
+ teacher_output = teacher_output.float()
+ # world_size = dist.get_world_size() if dist.is_initialized() else 1
+ Q = torch.exp(teacher_output / teacher_temp).t() # Q is K-by-B for consistency with notations from our paper
+ # B = Q.shape[1] * world_size # number of samples to assign
+ B = n_masked_patches_tensor
+ dist.all_reduce(B)
+ K = Q.shape[0] # how many prototypes
+
+ # make the matrix sums to 1
+ sum_Q = torch.sum(Q)
+ if dist.is_initialized():
+ dist.all_reduce(sum_Q)
+ Q /= sum_Q
+
+ for it in range(n_iterations):
+ # normalize each row: total weight per prototype must be 1/K
+ sum_of_rows = torch.sum(Q, dim=1, keepdim=True)
+ if dist.is_initialized():
+ dist.all_reduce(sum_of_rows)
+ Q /= sum_of_rows
+ Q /= K
+
+ # normalize each column: total weight per sample must be 1/B
+ Q /= torch.sum(Q, dim=0, keepdim=True)
+ Q /= B
+
+ Q *= B # the columns must sum to 1 so that Q is an assignment
+ return Q.t()
+
+ def forward(self, student_patch_tokens, teacher_patch_tokens, student_masks_flat):
+ """
+ Cross-entropy between softmax outputs of the teacher and student networks.
+ student_patch_tokens: (B, N, D) tensor
+ teacher_patch_tokens: (B, N, D) tensor
+ student_masks_flat: (B, N) tensor
+ """
+ t = teacher_patch_tokens
+ s = student_patch_tokens
+ loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1)
+ loss = torch.sum(loss * student_masks_flat.float(), dim=-1) / student_masks_flat.sum(dim=-1).clamp(min=1.0)
+ return -loss.mean()
+
+ def forward_masked(
+ self,
+ student_patch_tokens_masked,
+ teacher_patch_tokens_masked,
+ student_masks_flat,
+ n_masked_patches=None,
+ masks_weight=None,
+ ):
+ t = teacher_patch_tokens_masked
+ s = student_patch_tokens_masked
+ # loss = torch.sum(t * F.log_softmax(s / self.student_temp, dim=-1), dim=-1)
+ loss = lossfunc(t, s, self.student_temp)
+ if masks_weight is None:
+ masks_weight = (
+ (1 / student_masks_flat.sum(-1).clamp(min=1.0))
+ .unsqueeze(-1)
+ .expand_as(student_masks_flat)[student_masks_flat]
+ )
+ if n_masked_patches is not None:
+ loss = loss[:n_masked_patches]
+ loss = loss * masks_weight
+ return -loss.sum() / student_masks_flat.shape[0]
+
+ @torch.no_grad()
+ def update_center(self, teacher_patch_tokens):
+ self.reduce_center_update(teacher_patch_tokens)
+
+ @torch.no_grad()
+ def reduce_center_update(self, teacher_patch_tokens):
+ self.updated = False
+ self.len_teacher_patch_tokens = len(teacher_patch_tokens)
+ self.async_batch_center = torch.sum(teacher_patch_tokens.mean(1), dim=0, keepdim=True)
+ if dist.is_initialized():
+ self.reduce_handle = dist.all_reduce(self.async_batch_center, async_op=True)
+
+ @torch.no_grad()
+ def apply_center_update(self):
+ if self.updated is False:
+ world_size = dist.get_world_size() if dist.is_initialized() else 1
+
+ if self.reduce_handle is not None:
+ self.reduce_handle.wait()
+ _t = self.async_batch_center / (self.len_teacher_patch_tokens * world_size)
+
+ self.center = self.center * self.center_momentum + _t * (1 - self.center_momentum)
+
+ self.updated = True
diff --git a/facebookresearch/dinov2/dinov2/loss/koleo_loss.py b/facebookresearch/dinov2/dinov2/loss/koleo_loss.py
new file mode 100644
index 0000000..b5cbcd9
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/loss/koleo_loss.py
@@ -0,0 +1,48 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# import torch.distributed as dist
+
+
+logger = logging.getLogger("dinov2")
+
+
+class KoLeoLoss(nn.Module):
+ """Kozachenko-Leonenko entropic loss regularizer from Sablayrolles et al. - 2018 - Spreading vectors for similarity search"""
+
+ def __init__(self):
+ super().__init__()
+ self.pdist = nn.PairwiseDistance(2, eps=1e-8)
+
+ def pairwise_NNs_inner(self, x):
+ """
+ Pairwise nearest neighbors for L2-normalized vectors.
+ Uses Torch rather than Faiss to remain on GPU.
+ """
+ # parwise dot products (= inverse distance)
+ dots = torch.mm(x, x.t())
+ n = x.shape[0]
+ dots.view(-1)[:: (n + 1)].fill_(-1) # Trick to fill diagonal with -1
+ # max inner prod -> min distance
+ _, I = torch.max(dots, dim=1) # noqa: E741
+ return I
+
+ def forward(self, student_output, eps=1e-8):
+ """
+ Args:
+ student_output (BxD): backbone output of student
+ """
+ with torch.cuda.amp.autocast(enabled=False):
+ student_output = F.normalize(student_output, eps=eps, p=2, dim=-1)
+ I = self.pairwise_NNs_inner(student_output) # noqa: E741
+ distances = self.pdist(student_output, student_output[I]) # BxD, BxD -> B
+ loss = -torch.log(distances + eps).mean()
+ return loss
diff --git a/facebookresearch/dinov2/dinov2/models/__init__.py b/facebookresearch/dinov2/dinov2/models/__init__.py
new file mode 100644
index 0000000..3fdff20
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/models/__init__.py
@@ -0,0 +1,43 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+
+from . import vision_transformer as vits
+
+
+logger = logging.getLogger("dinov2")
+
+
+def build_model(args, only_teacher=False, img_size=224):
+ args.arch = args.arch.removesuffix("_memeff")
+ if "vit" in args.arch:
+ vit_kwargs = dict(
+ img_size=img_size,
+ patch_size=args.patch_size,
+ init_values=args.layerscale,
+ ffn_layer=args.ffn_layer,
+ block_chunks=args.block_chunks,
+ qkv_bias=args.qkv_bias,
+ proj_bias=args.proj_bias,
+ ffn_bias=args.ffn_bias,
+ num_register_tokens=args.num_register_tokens,
+ interpolate_offset=args.interpolate_offset,
+ interpolate_antialias=args.interpolate_antialias,
+ )
+ teacher = vits.__dict__[args.arch](**vit_kwargs)
+ if only_teacher:
+ return teacher, teacher.embed_dim
+ student = vits.__dict__[args.arch](
+ **vit_kwargs,
+ drop_path_rate=args.drop_path_rate,
+ drop_path_uniform=args.drop_path_uniform,
+ )
+ embed_dim = student.embed_dim
+ return student, teacher, embed_dim
+
+
+def build_model_from_cfg(cfg, only_teacher=False):
+ return build_model(cfg.student, only_teacher=only_teacher, img_size=cfg.crops.global_crops_size)
diff --git a/facebookresearch/dinov2/dinov2/models/vision_transformer.py b/facebookresearch/dinov2/dinov2/models/vision_transformer.py
new file mode 100644
index 0000000..13b44ae
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/models/vision_transformer.py
@@ -0,0 +1,396 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+# References:
+# https://github.com/facebookresearch/dino/blob/main/vision_transformer.py
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+from functools import partial
+import math
+import logging
+from typing import Sequence, Tuple, Union, Callable
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint
+from torch.nn.init import trunc_normal_
+
+from dinov2.layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block
+
+
+logger = logging.getLogger("dinov2")
+
+
+def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module:
+ if not depth_first and include_root:
+ fn(module=module, name=name)
+ for child_name, child_module in module.named_children():
+ child_name = ".".join((name, child_name)) if name else child_name
+ named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True)
+ if depth_first and include_root:
+ fn(module=module, name=name)
+ return module
+
+
+class BlockChunk(nn.ModuleList):
+ def forward(self, x):
+ for b in self:
+ x = b(x)
+ return x
+
+
+class DinoVisionTransformer(nn.Module):
+ def __init__(
+ self,
+ img_size=224,
+ patch_size=16,
+ in_chans=3,
+ embed_dim=768,
+ depth=12,
+ num_heads=12,
+ mlp_ratio=4.0,
+ qkv_bias=True,
+ ffn_bias=True,
+ proj_bias=True,
+ drop_path_rate=0.0,
+ drop_path_uniform=False,
+ init_values=None, # for layerscale: None or 0 => no layerscale
+ embed_layer=PatchEmbed,
+ act_layer=nn.GELU,
+ block_fn=Block,
+ ffn_layer="mlp",
+ block_chunks=1,
+ num_register_tokens=0,
+ interpolate_antialias=False,
+ interpolate_offset=0.1,
+ ):
+ """
+ Args:
+ img_size (int, tuple): input image size
+ patch_size (int, tuple): patch size
+ in_chans (int): number of input channels
+ embed_dim (int): embedding dimension
+ depth (int): depth of transformer
+ num_heads (int): number of attention heads
+ mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+ qkv_bias (bool): enable bias for qkv if True
+ proj_bias (bool): enable bias for proj in attn if True
+ ffn_bias (bool): enable bias for ffn if True
+ drop_path_rate (float): stochastic depth rate
+ drop_path_uniform (bool): apply uniform drop rate across blocks
+ weight_init (str): weight init scheme
+ init_values (float): layer-scale init values
+ embed_layer (nn.Module): patch embedding layer
+ act_layer (nn.Module): MLP activation layer
+ block_fn (nn.Module): transformer block class
+ ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+ block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+ num_register_tokens: (int) number of extra cls tokens (so-called "registers")
+ interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings
+ interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings
+ """
+ super().__init__()
+ norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+ self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
+ self.num_tokens = 1
+ self.n_blocks = depth
+ self.num_heads = num_heads
+ self.patch_size = patch_size
+ self.num_register_tokens = num_register_tokens
+ self.interpolate_antialias = interpolate_antialias
+ self.interpolate_offset = interpolate_offset
+
+ self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+ num_patches = self.patch_embed.num_patches
+
+ self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+ self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+ assert num_register_tokens >= 0
+ self.register_tokens = (
+ nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None
+ )
+
+ if drop_path_uniform is True:
+ dpr = [drop_path_rate] * depth
+ else:
+ dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule
+
+ if ffn_layer == "mlp":
+ logger.info("using MLP layer as FFN")
+ ffn_layer = Mlp
+ elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+ logger.info("using SwiGLU layer as FFN")
+ ffn_layer = SwiGLUFFNFused
+ elif ffn_layer == "identity":
+ logger.info("using Identity layer as FFN")
+
+ def f(*args, **kwargs):
+ return nn.Identity()
+
+ ffn_layer = f
+ else:
+ raise NotImplementedError
+
+ blocks_list = [
+ block_fn(
+ dim=embed_dim,
+ num_heads=num_heads,
+ mlp_ratio=mlp_ratio,
+ qkv_bias=qkv_bias,
+ proj_bias=proj_bias,
+ ffn_bias=ffn_bias,
+ drop_path=dpr[i],
+ norm_layer=norm_layer,
+ act_layer=act_layer,
+ ffn_layer=ffn_layer,
+ init_values=init_values,
+ )
+ for i in range(depth)
+ ]
+ if block_chunks > 0:
+ self.chunked_blocks = True
+ chunked_blocks = []
+ chunksize = depth // block_chunks
+ for i in range(0, depth, chunksize):
+ # this is to keep the block index consistent if we chunk the block list
+ chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+ self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+ else:
+ self.chunked_blocks = False
+ self.blocks = nn.ModuleList(blocks_list)
+
+ self.norm = norm_layer(embed_dim)
+ self.head = nn.Identity()
+
+ self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+ self.init_weights()
+
+ def init_weights(self):
+ trunc_normal_(self.pos_embed, std=0.02)
+ nn.init.normal_(self.cls_token, std=1e-6)
+ if self.register_tokens is not None:
+ nn.init.normal_(self.register_tokens, std=1e-6)
+ named_apply(init_weights_vit_timm, self)
+
+ def interpolate_pos_encoding(self, x, w, h):
+ previous_dtype = x.dtype
+ npatch = x.shape[1] - 1
+ N = self.pos_embed.shape[1] - 1
+ if npatch == N and w == h:
+ return self.pos_embed
+ pos_embed = self.pos_embed.float()
+ class_pos_embed = pos_embed[:, 0]
+ patch_pos_embed = pos_embed[:, 1:]
+ dim = x.shape[-1]
+ w0 = w // self.patch_size
+ h0 = h // self.patch_size
+ M = int(math.sqrt(N)) # Recover the number of patches in each dimension
+ assert N == M * M
+ kwargs = {}
+ if self.interpolate_offset:
+ # Historical kludge: add a small number to avoid floating point error in the interpolation, see https://github.com/facebookresearch/dino/issues/8
+ # Note: still needed for backward-compatibility, the underlying operators are using both output size and scale factors
+ sx = float(w0 + self.interpolate_offset) / M
+ sy = float(h0 + self.interpolate_offset) / M
+ kwargs["scale_factor"] = (sx, sy)
+ else:
+ # Simply specify an output size instead of a scale factor
+ kwargs["size"] = (w0, h0)
+ patch_pos_embed = nn.functional.interpolate(
+ patch_pos_embed.reshape(1, M, M, dim).permute(0, 3, 1, 2),
+ mode="bicubic",
+ antialias=self.interpolate_antialias,
+ **kwargs,
+ )
+ assert (w0, h0) == patch_pos_embed.shape[-2:]
+ patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+ return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+ def prepare_tokens_with_masks(self, x, masks=None):
+ B, nc, w, h = x.shape
+ x = self.patch_embed(x)
+ if masks is not None:
+ x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+ x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+ x = x + self.interpolate_pos_encoding(x, w, h)
+
+ if self.register_tokens is not None:
+ x = torch.cat(
+ (
+ x[:, :1],
+ self.register_tokens.expand(x.shape[0], -1, -1),
+ x[:, 1:],
+ ),
+ dim=1,
+ )
+
+ return x
+
+ def forward_features_list(self, x_list, masks_list):
+ x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+ for blk in self.blocks:
+ x = blk(x)
+
+ all_x = x
+ output = []
+ for x, masks in zip(all_x, masks_list):
+ x_norm = self.norm(x)
+ output.append(
+ {
+ "x_norm_clstoken": x_norm[:, 0],
+ "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+ "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+ "x_prenorm": x,
+ "masks": masks,
+ }
+ )
+ return output
+
+ def forward_features(self, x, masks=None):
+ if isinstance(x, list):
+ return self.forward_features_list(x, masks)
+
+ x = self.prepare_tokens_with_masks(x, masks)
+
+ for blk in self.blocks:
+ x = blk(x)
+
+ x_norm = self.norm(x)
+ return {
+ "x_norm_clstoken": x_norm[:, 0],
+ "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+ "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+ "x_prenorm": x,
+ "masks": masks,
+ }
+
+ def _get_intermediate_layers_not_chunked(self, x, n=1):
+ x = self.prepare_tokens_with_masks(x)
+ # If n is an int, take the n last blocks. If it's a list, take them
+ output, total_block_len = [], len(self.blocks)
+ blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+ for i, blk in enumerate(self.blocks):
+ x = blk(x)
+ if i in blocks_to_take:
+ output.append(x)
+ assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+ return output
+
+ def _get_intermediate_layers_chunked(self, x, n=1):
+ x = self.prepare_tokens_with_masks(x)
+ output, i, total_block_len = [], 0, len(self.blocks[-1])
+ # If n is an int, take the n last blocks. If it's a list, take them
+ blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+ for block_chunk in self.blocks:
+ for blk in block_chunk[i:]: # Passing the nn.Identity()
+ x = blk(x)
+ if i in blocks_to_take:
+ output.append(x)
+ i += 1
+ assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+ return output
+
+ def get_intermediate_layers(
+ self,
+ x: torch.Tensor,
+ n: Union[int, Sequence] = 1, # Layers or n last layers to take
+ reshape: bool = False,
+ return_class_token: bool = False,
+ norm=True,
+ ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+ if self.chunked_blocks:
+ outputs = self._get_intermediate_layers_chunked(x, n)
+ else:
+ outputs = self._get_intermediate_layers_not_chunked(x, n)
+ if norm:
+ outputs = [self.norm(out) for out in outputs]
+ class_tokens = [out[:, 0] for out in outputs]
+ outputs = [out[:, 1 + self.num_register_tokens :] for out in outputs]
+ if reshape:
+ B, _, w, h = x.shape
+ outputs = [
+ out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+ for out in outputs
+ ]
+ if return_class_token:
+ return tuple(zip(outputs, class_tokens))
+ return tuple(outputs)
+
+ def forward(self, *args, is_training=False, **kwargs):
+ ret = self.forward_features(*args, **kwargs)
+ if is_training:
+ return ret
+ else:
+ return self.head(ret["x_norm_clstoken"])
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = ""):
+ """ViT weight initialization, original timm impl (for reproducibility)"""
+ if isinstance(module, nn.Linear):
+ trunc_normal_(module.weight, std=0.02)
+ if module.bias is not None:
+ nn.init.zeros_(module.bias)
+
+
+def vit_small(patch_size=16, num_register_tokens=0, **kwargs):
+ model = DinoVisionTransformer(
+ patch_size=patch_size,
+ embed_dim=384,
+ depth=12,
+ num_heads=6,
+ mlp_ratio=4,
+ block_fn=partial(Block, attn_class=MemEffAttention),
+ num_register_tokens=num_register_tokens,
+ **kwargs,
+ )
+ return model
+
+
+def vit_base(patch_size=16, num_register_tokens=0, **kwargs):
+ model = DinoVisionTransformer(
+ patch_size=patch_size,
+ embed_dim=768,
+ depth=12,
+ num_heads=12,
+ mlp_ratio=4,
+ block_fn=partial(Block, attn_class=MemEffAttention),
+ num_register_tokens=num_register_tokens,
+ **kwargs,
+ )
+ return model
+
+
+def vit_large(patch_size=16, num_register_tokens=0, **kwargs):
+ model = DinoVisionTransformer(
+ patch_size=patch_size,
+ embed_dim=1024,
+ depth=24,
+ num_heads=16,
+ mlp_ratio=4,
+ block_fn=partial(Block, attn_class=MemEffAttention),
+ num_register_tokens=num_register_tokens,
+ **kwargs,
+ )
+ return model
+
+
+def vit_giant2(patch_size=16, num_register_tokens=0, **kwargs):
+ """
+ Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+ """
+ model = DinoVisionTransformer(
+ patch_size=patch_size,
+ embed_dim=1536,
+ depth=40,
+ num_heads=24,
+ mlp_ratio=4,
+ block_fn=partial(Block, attn_class=MemEffAttention),
+ num_register_tokens=num_register_tokens,
+ **kwargs,
+ )
+ return model
diff --git a/facebookresearch/dinov2/dinov2/run/__init__.py b/facebookresearch/dinov2/dinov2/run/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/run/eval/knn.py b/facebookresearch/dinov2/dinov2/run/eval/knn.py
new file mode 100644
index 0000000..d119184
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/eval/knn.py
@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+import sys
+
+from dinov2.eval.knn import get_args_parser as get_knn_args_parser
+from dinov2.logging import setup_logging
+from dinov2.run.submit import get_args_parser, submit_jobs
+
+
+logger = logging.getLogger("dinov2")
+
+
+class Evaluator:
+ def __init__(self, args):
+ self.args = args
+
+ def __call__(self):
+ from dinov2.eval.knn import main as knn_main
+
+ self._setup_args()
+ knn_main(self.args)
+
+ def checkpoint(self):
+ import submitit
+
+ logger.info(f"Requeuing {self.args}")
+ empty = type(self)(self.args)
+ return submitit.helpers.DelayedSubmission(empty)
+
+ def _setup_args(self):
+ import submitit
+
+ job_env = submitit.JobEnvironment()
+ self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id))
+ logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}")
+ logger.info(f"Args: {self.args}")
+
+
+def main():
+ description = "Submitit launcher for DINOv2 k-NN evaluation"
+ knn_args_parser = get_knn_args_parser(add_help=False)
+ parents = [knn_args_parser]
+ args_parser = get_args_parser(description=description, parents=parents)
+ args = args_parser.parse_args()
+
+ setup_logging()
+
+ assert os.path.exists(args.config_file), "Configuration file does not exist!"
+ submit_jobs(Evaluator, args, name="dinov2:knn")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/facebookresearch/dinov2/dinov2/run/eval/linear.py b/facebookresearch/dinov2/dinov2/run/eval/linear.py
new file mode 100644
index 0000000..e1dc329
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/eval/linear.py
@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+import sys
+
+from dinov2.eval.linear import get_args_parser as get_linear_args_parser
+from dinov2.logging import setup_logging
+from dinov2.run.submit import get_args_parser, submit_jobs
+
+
+logger = logging.getLogger("dinov2")
+
+
+class Evaluator:
+ def __init__(self, args):
+ self.args = args
+
+ def __call__(self):
+ from dinov2.eval.linear import main as linear_main
+
+ self._setup_args()
+ linear_main(self.args)
+
+ def checkpoint(self):
+ import submitit
+
+ logger.info(f"Requeuing {self.args}")
+ empty = type(self)(self.args)
+ return submitit.helpers.DelayedSubmission(empty)
+
+ def _setup_args(self):
+ import submitit
+
+ job_env = submitit.JobEnvironment()
+ self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id))
+ logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}")
+ logger.info(f"Args: {self.args}")
+
+
+def main():
+ description = "Submitit launcher for DINOv2 linear evaluation"
+ linear_args_parser = get_linear_args_parser(add_help=False)
+ parents = [linear_args_parser]
+ args_parser = get_args_parser(description=description, parents=parents)
+ args = args_parser.parse_args()
+
+ setup_logging()
+
+ assert os.path.exists(args.config_file), "Configuration file does not exist!"
+ submit_jobs(Evaluator, args, name="dinov2:linear")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/facebookresearch/dinov2/dinov2/run/eval/log_regression.py b/facebookresearch/dinov2/dinov2/run/eval/log_regression.py
new file mode 100644
index 0000000..cdf0218
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/eval/log_regression.py
@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+import sys
+
+from dinov2.eval.log_regression import get_args_parser as get_log_regression_args_parser
+from dinov2.logging import setup_logging
+from dinov2.run.submit import get_args_parser, submit_jobs
+
+
+logger = logging.getLogger("dinov2")
+
+
+class Evaluator:
+ def __init__(self, args):
+ self.args = args
+
+ def __call__(self):
+ from dinov2.eval.log_regression import main as log_regression_main
+
+ self._setup_args()
+ log_regression_main(self.args)
+
+ def checkpoint(self):
+ import submitit
+
+ logger.info(f"Requeuing {self.args}")
+ empty = type(self)(self.args)
+ return submitit.helpers.DelayedSubmission(empty)
+
+ def _setup_args(self):
+ import submitit
+
+ job_env = submitit.JobEnvironment()
+ self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id))
+ logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}")
+ logger.info(f"Args: {self.args}")
+
+
+def main():
+ description = "Submitit launcher for DINOv2 logistic evaluation"
+ log_regression_args_parser = get_log_regression_args_parser(add_help=False)
+ parents = [log_regression_args_parser]
+ args_parser = get_args_parser(description=description, parents=parents)
+ args = args_parser.parse_args()
+
+ setup_logging()
+
+ assert os.path.exists(args.config_file), "Configuration file does not exist!"
+ submit_jobs(Evaluator, args, name="dinov2:logreg")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/facebookresearch/dinov2/dinov2/run/submit.py b/facebookresearch/dinov2/dinov2/run/submit.py
new file mode 100644
index 0000000..4d1f718
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/submit.py
@@ -0,0 +1,122 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+import logging
+import os
+from pathlib import Path
+from typing import List, Optional
+
+import submitit
+
+from dinov2.utils.cluster import (
+ get_slurm_executor_parameters,
+ get_slurm_partition,
+ get_user_checkpoint_path,
+)
+
+
+logger = logging.getLogger("dinov2")
+
+
+def get_args_parser(
+ description: Optional[str] = None,
+ parents: Optional[List[argparse.ArgumentParser]] = None,
+ add_help: bool = True,
+) -> argparse.ArgumentParser:
+ parents = parents or []
+ slurm_partition = get_slurm_partition()
+ parser = argparse.ArgumentParser(
+ description=description,
+ parents=parents,
+ add_help=add_help,
+ )
+ parser.add_argument(
+ "--ngpus",
+ "--gpus",
+ "--gpus-per-node",
+ default=8,
+ type=int,
+ help="Number of GPUs to request on each node",
+ )
+ parser.add_argument(
+ "--nodes",
+ "--nnodes",
+ default=1,
+ type=int,
+ help="Number of nodes to request",
+ )
+ parser.add_argument(
+ "--timeout",
+ default=2800,
+ type=int,
+ help="Duration of the job",
+ )
+ parser.add_argument(
+ "--partition",
+ default=slurm_partition,
+ type=str,
+ help="Partition where to submit",
+ )
+ parser.add_argument(
+ "--use-volta32",
+ action="store_true",
+ help="Request V100-32GB GPUs",
+ )
+ parser.add_argument(
+ "--comment",
+ default="",
+ type=str,
+ help="Comment to pass to scheduler, e.g. priority message",
+ )
+ parser.add_argument(
+ "--exclude",
+ default="",
+ type=str,
+ help="Nodes to exclude",
+ )
+ return parser
+
+
+def get_shared_folder() -> Path:
+ user_checkpoint_path = get_user_checkpoint_path()
+ if user_checkpoint_path is None:
+ raise RuntimeError("Path to user checkpoint cannot be determined")
+ path = user_checkpoint_path / "experiments"
+ path.mkdir(exist_ok=True)
+ return path
+
+
+def submit_jobs(task_class, args, name: str):
+ if not args.output_dir:
+ args.output_dir = str(get_shared_folder() / "%j")
+
+ Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+ executor = submitit.AutoExecutor(folder=args.output_dir, slurm_max_num_timeout=30)
+
+ kwargs = {}
+ if args.use_volta32:
+ kwargs["slurm_constraint"] = "volta32gb"
+ if args.comment:
+ kwargs["slurm_comment"] = args.comment
+ if args.exclude:
+ kwargs["slurm_exclude"] = args.exclude
+
+ executor_params = get_slurm_executor_parameters(
+ nodes=args.nodes,
+ num_gpus_per_node=args.ngpus,
+ timeout_min=args.timeout, # max is 60 * 72
+ slurm_signal_delay_s=120,
+ slurm_partition=args.partition,
+ **kwargs,
+ )
+ executor.update_parameters(name=name, **executor_params)
+
+ task = task_class(args)
+ job = executor.submit(task)
+
+ logger.info(f"Submitted job_id: {job.job_id}")
+ str_output_dir = os.path.abspath(args.output_dir).replace("%j", str(job.job_id))
+ logger.info(f"Logs and checkpoints will be saved at: {str_output_dir}")
diff --git a/facebookresearch/dinov2/dinov2/run/train/train.py b/facebookresearch/dinov2/dinov2/run/train/train.py
new file mode 100644
index 0000000..c2366e9
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/run/train/train.py
@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+import sys
+
+from dinov2.logging import setup_logging
+from dinov2.train import get_args_parser as get_train_args_parser
+from dinov2.run.submit import get_args_parser, submit_jobs
+
+
+logger = logging.getLogger("dinov2")
+
+
+class Trainer(object):
+ def __init__(self, args):
+ self.args = args
+
+ def __call__(self):
+ from dinov2.train import main as train_main
+
+ self._setup_args()
+ train_main(self.args)
+
+ def checkpoint(self):
+ import submitit
+
+ logger.info(f"Requeuing {self.args}")
+ empty = type(self)(self.args)
+ return submitit.helpers.DelayedSubmission(empty)
+
+ def _setup_args(self):
+ import submitit
+
+ job_env = submitit.JobEnvironment()
+ self.args.output_dir = self.args.output_dir.replace("%j", str(job_env.job_id))
+ logger.info(f"Process group: {job_env.num_tasks} tasks, rank: {job_env.global_rank}")
+ logger.info(f"Args: {self.args}")
+
+
+def main():
+ description = "Submitit launcher for DINOv2 training"
+ train_args_parser = get_train_args_parser(add_help=False)
+ parents = [train_args_parser]
+ args_parser = get_args_parser(description=description, parents=parents)
+ args = args_parser.parse_args()
+
+ setup_logging()
+
+ assert os.path.exists(args.config_file), "Configuration file does not exist!"
+ submit_jobs(Trainer, args, name="dinov2:train")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/facebookresearch/dinov2/dinov2/train/__init__.py b/facebookresearch/dinov2/dinov2/train/__init__.py
new file mode 100644
index 0000000..5f17529
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/train/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from .train import get_args_parser, main
+from .ssl_meta_arch import SSLMetaArch
diff --git a/facebookresearch/dinov2/dinov2/train/ssl_meta_arch.py b/facebookresearch/dinov2/dinov2/train/ssl_meta_arch.py
new file mode 100644
index 0000000..3ccf15e
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/train/ssl_meta_arch.py
@@ -0,0 +1,400 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from functools import partial
+import logging
+
+import torch
+from torch import nn
+
+from dinov2.loss import DINOLoss, iBOTPatchLoss, KoLeoLoss
+from dinov2.models import build_model_from_cfg
+from dinov2.layers import DINOHead
+from dinov2.utils.utils import has_batchnorms
+from dinov2.utils.param_groups import get_params_groups_with_decay, fuse_params_groups
+from dinov2.fsdp import get_fsdp_wrapper, ShardedGradScaler, get_fsdp_modules, reshard_fsdp_model
+
+from dinov2.models.vision_transformer import BlockChunk
+
+
+try:
+ from xformers.ops import fmha
+except ImportError:
+ raise AssertionError("xFormers is required for training")
+
+
+logger = logging.getLogger("dinov2")
+
+
+class SSLMetaArch(nn.Module):
+ def __init__(self, cfg):
+ super().__init__()
+ self.cfg = cfg
+ self.fp16_scaler = ShardedGradScaler() if cfg.compute_precision.grad_scaler else None
+
+ student_model_dict = dict()
+ teacher_model_dict = dict()
+
+ student_backbone, teacher_backbone, embed_dim = build_model_from_cfg(cfg)
+ student_model_dict["backbone"] = student_backbone
+ teacher_model_dict["backbone"] = teacher_backbone
+ logger.info(f"OPTIONS -- architecture : embed_dim: {embed_dim}")
+
+ if cfg.student.pretrained_weights:
+ chkpt = torch.load(cfg.student.pretrained_weights)
+ logger.info(f"OPTIONS -- pretrained weights: loading from {cfg.student.pretrained_weights}")
+ student_backbone.load_state_dict(chkpt["model"], strict=False)
+
+ self.embed_dim = embed_dim
+ self.dino_out_dim = cfg.dino.head_n_prototypes
+
+ self.do_dino = cfg.dino.loss_weight > 0
+ self.do_koleo = cfg.dino.koleo_loss_weight > 0
+ self.do_ibot = cfg.ibot.loss_weight > 0
+ self.ibot_separate_head = cfg.ibot.separate_head
+
+ logger.info("OPTIONS -- DINO")
+ if self.do_dino:
+ logger.info(f"OPTIONS -- DINO -- loss_weight: {cfg.dino.loss_weight}")
+ logger.info(f"OPTIONS -- DINO -- head_n_prototypes: {cfg.dino.head_n_prototypes}")
+ logger.info(f"OPTIONS -- DINO -- head_bottleneck_dim: {cfg.dino.head_bottleneck_dim}")
+ logger.info(f"OPTIONS -- DINO -- head_hidden_dim: {cfg.dino.head_hidden_dim}")
+ self.dino_loss_weight = cfg.dino.loss_weight
+ dino_head = partial(
+ DINOHead,
+ in_dim=embed_dim,
+ out_dim=cfg.dino.head_n_prototypes,
+ hidden_dim=cfg.dino.head_hidden_dim,
+ bottleneck_dim=cfg.dino.head_bottleneck_dim,
+ nlayers=cfg.dino.head_nlayers,
+ )
+ self.dino_loss = DINOLoss(self.dino_out_dim)
+ if self.do_koleo:
+ logger.info("OPTIONS -- DINO -- applying KOLEO regularization")
+ self.koleo_loss = KoLeoLoss()
+
+ else:
+ logger.info("OPTIONS -- DINO -- not using DINO")
+
+ if self.do_dino or self.do_ibot:
+ student_model_dict["dino_head"] = dino_head()
+ teacher_model_dict["dino_head"] = dino_head()
+
+ logger.info("OPTIONS -- IBOT")
+ logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}")
+ logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_ratio_tuple: {cfg.ibot.mask_ratio_min_max}")
+ logger.info(f"OPTIONS -- IBOT masking -- ibot_mask_sample_probability: {cfg.ibot.mask_sample_probability}")
+ if self.do_ibot:
+ self.ibot_loss_weight = cfg.ibot.loss_weight
+ assert max(cfg.ibot.mask_ratio_min_max) > 0, "please provide a positive mask ratio tuple for ibot"
+ assert cfg.ibot.mask_sample_probability > 0, "please provide a positive mask probability for ibot"
+ self.ibot_out_dim = cfg.ibot.head_n_prototypes if self.ibot_separate_head else cfg.dino.head_n_prototypes
+ self.ibot_patch_loss = iBOTPatchLoss(self.ibot_out_dim)
+ if self.ibot_separate_head:
+ logger.info(f"OPTIONS -- IBOT -- loss_weight: {cfg.ibot.loss_weight}")
+ logger.info(f"OPTIONS -- IBOT -- head_n_prototypes: {cfg.ibot.head_n_prototypes}")
+ logger.info(f"OPTIONS -- IBOT -- head_bottleneck_dim: {cfg.ibot.head_bottleneck_dim}")
+ logger.info(f"OPTIONS -- IBOT -- head_hidden_dim: {cfg.ibot.head_hidden_dim}")
+ ibot_head = partial(
+ DINOHead,
+ in_dim=embed_dim,
+ out_dim=cfg.ibot.head_n_prototypes,
+ hidden_dim=cfg.ibot.head_hidden_dim,
+ bottleneck_dim=cfg.ibot.head_bottleneck_dim,
+ nlayers=cfg.ibot.head_nlayers,
+ )
+ student_model_dict["ibot_head"] = ibot_head()
+ teacher_model_dict["ibot_head"] = ibot_head()
+ else:
+ logger.info("OPTIONS -- IBOT -- head shared with DINO")
+
+ self.need_to_synchronize_fsdp_streams = True
+
+ self.student = nn.ModuleDict(student_model_dict)
+ self.teacher = nn.ModuleDict(teacher_model_dict)
+
+ # there is no backpropagation through the teacher, so no need for gradients
+ for p in self.teacher.parameters():
+ p.requires_grad = False
+ logger.info(f"Student and Teacher are built: they are both {cfg.student.arch} network.")
+
+ def forward(self, inputs):
+ raise NotImplementedError
+
+ def backprop_loss(self, loss):
+ if self.fp16_scaler is not None:
+ self.fp16_scaler.scale(loss).backward()
+ else:
+ loss.backward()
+
+ def forward_backward(self, images, teacher_temp):
+ n_global_crops = 2
+ assert n_global_crops == 2
+ n_local_crops = self.cfg.crops.local_crops_number
+
+ global_crops = images["collated_global_crops"].cuda(non_blocking=True)
+ local_crops = images["collated_local_crops"].cuda(non_blocking=True)
+
+ masks = images["collated_masks"].cuda(non_blocking=True)
+ mask_indices_list = images["mask_indices_list"].cuda(non_blocking=True)
+ n_masked_patches_tensor = images["n_masked_patches"].cuda(non_blocking=True)
+ n_masked_patches = mask_indices_list.shape[0]
+ upperbound = images["upperbound"]
+ masks_weight = images["masks_weight"].cuda(non_blocking=True)
+
+ n_local_crops_loss_terms = max(n_local_crops * n_global_crops, 1)
+ n_global_crops_loss_terms = (n_global_crops - 1) * n_global_crops
+
+ do_dino = self.do_dino
+ do_ibot = self.do_ibot
+
+ # loss scales
+ ibot_loss_scale = 1.0 / n_global_crops
+
+ # teacher output
+ @torch.no_grad()
+ def get_teacher_output():
+ x, n_global_crops_teacher = global_crops, n_global_crops
+ teacher_backbone_output_dict = self.teacher.backbone(x, is_training=True)
+ teacher_cls_tokens = teacher_backbone_output_dict["x_norm_clstoken"]
+ teacher_cls_tokens = teacher_cls_tokens.chunk(n_global_crops_teacher)
+ # watch out: these are chunked and cat'd in reverse so A is matched to B in the global crops dino loss
+ teacher_cls_tokens = torch.cat((teacher_cls_tokens[1], teacher_cls_tokens[0]))
+ ibot_teacher_patch_tokens = teacher_backbone_output_dict["x_norm_patchtokens"]
+ _dim = ibot_teacher_patch_tokens.shape[-1]
+ n_cls_tokens = teacher_cls_tokens.shape[0]
+
+ if do_ibot and not self.ibot_separate_head:
+ buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound + n_cls_tokens, _dim)
+ buffer_tensor_teacher[:n_cls_tokens].copy_(teacher_cls_tokens)
+ torch.index_select(
+ ibot_teacher_patch_tokens.flatten(0, 1),
+ dim=0,
+ index=mask_indices_list,
+ out=buffer_tensor_teacher[n_cls_tokens : n_cls_tokens + n_masked_patches],
+ )
+ tokens_after_head = self.teacher.dino_head(buffer_tensor_teacher)
+ teacher_cls_tokens_after_head = tokens_after_head[:n_cls_tokens]
+ masked_teacher_patch_tokens_after_head = tokens_after_head[
+ n_cls_tokens : n_cls_tokens + n_masked_patches
+ ]
+ elif do_ibot and self.ibot_separate_head:
+ buffer_tensor_teacher = ibot_teacher_patch_tokens.new_zeros(upperbound, _dim)
+ torch.index_select(
+ ibot_teacher_patch_tokens.flatten(0, 1),
+ dim=0,
+ index=mask_indices_list,
+ out=buffer_tensor_teacher[:n_masked_patches],
+ )
+ teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens)
+ masked_teacher_patch_tokens_after_head = self.teacher.ibot_head(buffer_tensor_teacher)[
+ :n_masked_patches
+ ]
+ else:
+ teacher_cls_tokens_after_head = self.teacher.dino_head(teacher_cls_tokens)
+ masked_teacher_ibot_softmaxed_centered = None
+
+ if self.cfg.train.centering == "centering":
+ teacher_dino_softmaxed_centered_list = self.dino_loss.softmax_center_teacher(
+ teacher_cls_tokens_after_head, teacher_temp=teacher_temp
+ ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:])
+ self.dino_loss.update_center(teacher_cls_tokens_after_head)
+ if do_ibot:
+ masked_teacher_patch_tokens_after_head = masked_teacher_patch_tokens_after_head.unsqueeze(0)
+ masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.softmax_center_teacher(
+ masked_teacher_patch_tokens_after_head[:, :n_masked_patches], teacher_temp=teacher_temp
+ )
+ masked_teacher_ibot_softmaxed_centered = masked_teacher_ibot_softmaxed_centered.squeeze(0)
+ self.ibot_patch_loss.update_center(masked_teacher_patch_tokens_after_head[:n_masked_patches])
+
+ elif self.cfg.train.centering == "sinkhorn_knopp":
+ teacher_dino_softmaxed_centered_list = self.dino_loss.sinkhorn_knopp_teacher(
+ teacher_cls_tokens_after_head, teacher_temp=teacher_temp
+ ).view(n_global_crops_teacher, -1, *teacher_cls_tokens_after_head.shape[1:])
+
+ if do_ibot:
+ masked_teacher_ibot_softmaxed_centered = self.ibot_patch_loss.sinkhorn_knopp_teacher(
+ masked_teacher_patch_tokens_after_head,
+ teacher_temp=teacher_temp,
+ n_masked_patches_tensor=n_masked_patches_tensor,
+ )
+
+ else:
+ raise NotImplementedError
+
+ return teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered
+
+ teacher_dino_softmaxed_centered_list, masked_teacher_ibot_softmaxed_centered = get_teacher_output()
+ reshard_fsdp_model(self.teacher)
+
+ loss_dict = {}
+
+ loss_accumulator = 0 # for backprop
+ student_global_backbone_output_dict, student_local_backbone_output_dict = self.student.backbone(
+ [global_crops, local_crops], masks=[masks, None], is_training=True
+ )
+
+ inputs_for_student_head_list = []
+
+ # 1a: local crops cls tokens
+ student_local_cls_tokens = student_local_backbone_output_dict["x_norm_clstoken"]
+ inputs_for_student_head_list.append(student_local_cls_tokens.unsqueeze(0))
+
+ # 1b: global crops cls tokens
+ student_global_cls_tokens = student_global_backbone_output_dict["x_norm_clstoken"]
+ inputs_for_student_head_list.append(student_global_cls_tokens.unsqueeze(0))
+
+ # 1c: global crops patch tokens
+ if do_ibot:
+ _dim = student_global_backbone_output_dict["x_norm_clstoken"].shape[-1]
+ ibot_student_patch_tokens = student_global_backbone_output_dict["x_norm_patchtokens"]
+ buffer_tensor_patch_tokens = ibot_student_patch_tokens.new_zeros(upperbound, _dim)
+ buffer_tensor_patch_tokens[:n_masked_patches].copy_(
+ torch.index_select(ibot_student_patch_tokens.flatten(0, 1), dim=0, index=mask_indices_list)
+ )
+ if not self.ibot_separate_head:
+ inputs_for_student_head_list.append(buffer_tensor_patch_tokens.unsqueeze(0))
+ else:
+ student_global_masked_patch_tokens_after_head = self.student.ibot_head(buffer_tensor_patch_tokens)[
+ :n_masked_patches
+ ]
+
+ # 2: run
+ _attn_bias, cat_inputs = fmha.BlockDiagonalMask.from_tensor_list(inputs_for_student_head_list)
+ outputs_list = _attn_bias.split(self.student.dino_head(cat_inputs))
+
+ # 3a: local crops cls tokens
+ student_local_cls_tokens_after_head = outputs_list.pop(0).squeeze(0)
+
+ # 3b: global crops cls tokens
+ student_global_cls_tokens_after_head = outputs_list.pop(0).squeeze(0)
+
+ # 3c: global crops patch tokens
+ if do_ibot and not self.ibot_separate_head:
+ student_global_masked_patch_tokens_after_head = outputs_list.pop(0).squeeze(0)[:n_masked_patches]
+
+ if n_local_crops > 0:
+ dino_local_crops_loss = self.dino_loss(
+ student_output_list=student_local_cls_tokens_after_head.chunk(n_local_crops),
+ teacher_out_softmaxed_centered_list=teacher_dino_softmaxed_centered_list,
+ ) / (n_global_crops_loss_terms + n_local_crops_loss_terms)
+
+ # store for display
+ loss_dict["dino_local_crops_loss"] = dino_local_crops_loss
+
+ # accumulate loss
+ loss_accumulator += self.dino_loss_weight * dino_local_crops_loss
+
+ # process global crops
+ loss_scales = 2 # this is here since we process global crops together
+
+ if do_dino:
+ # compute loss
+ dino_global_crops_loss = (
+ self.dino_loss(
+ student_output_list=[student_global_cls_tokens_after_head],
+ teacher_out_softmaxed_centered_list=[
+ teacher_dino_softmaxed_centered_list.flatten(0, 1)
+ ], # these were chunked and stacked in reverse so A is matched to B
+ )
+ * loss_scales
+ / (n_global_crops_loss_terms + n_local_crops_loss_terms)
+ )
+
+ loss_dict["dino_global_crops_loss"] = dino_global_crops_loss
+
+ # accumulate loss
+ loss_accumulator += self.dino_loss_weight * dino_global_crops_loss
+
+ student_cls_tokens = student_global_cls_tokens
+
+ if self.do_koleo:
+ koleo_loss = self.cfg.dino.koleo_loss_weight * sum(
+ self.koleo_loss(p) for p in student_cls_tokens.chunk(2)
+ ) # we don't apply koleo loss between cls tokens of a same image
+ loss_accumulator += koleo_loss
+ loss_dict["koleo_loss"] = (
+ koleo_loss / loss_scales
+ ) # this is to display the same losses as before but we can remove eventually
+
+ if do_ibot:
+ # compute loss
+ ibot_patch_loss = (
+ self.ibot_patch_loss.forward_masked(
+ student_global_masked_patch_tokens_after_head,
+ masked_teacher_ibot_softmaxed_centered,
+ student_masks_flat=masks,
+ n_masked_patches=n_masked_patches,
+ masks_weight=masks_weight,
+ )
+ * loss_scales
+ * ibot_loss_scale
+ )
+
+ # store for display
+ loss_dict["ibot_loss"] = ibot_patch_loss / 2
+
+ # accumulate loss
+ loss_accumulator += self.ibot_loss_weight * ibot_patch_loss
+
+ self.backprop_loss(loss_accumulator)
+
+ self.fsdp_synchronize_streams()
+
+ return loss_dict
+
+ def fsdp_synchronize_streams(self):
+ if self.need_to_synchronize_fsdp_streams:
+ torch.cuda.synchronize()
+ self.student.dino_head._streams = (
+ self.teacher.dino_head._streams
+ ) = self.student.backbone._streams = self.teacher.backbone._streams
+ self.need_to_synchronize_fsdp_streams = False
+
+ def update_teacher(self, m):
+ student_param_list = []
+ teacher_param_list = []
+ with torch.no_grad():
+ for k in self.student.keys():
+ for ms, mt in zip(get_fsdp_modules(self.student[k]), get_fsdp_modules(self.teacher[k])):
+ student_param_list += ms.params
+ teacher_param_list += mt.params
+ torch._foreach_mul_(teacher_param_list, m)
+ torch._foreach_add_(teacher_param_list, student_param_list, alpha=1 - m)
+
+ def train(self):
+ super().train()
+ self.teacher.eval()
+
+ def get_maybe_fused_params_for_submodel(self, m):
+ params_groups = get_params_groups_with_decay(
+ model=m,
+ lr_decay_rate=self.cfg.optim.layerwise_decay,
+ patch_embed_lr_mult=self.cfg.optim.patch_embed_lr_mult,
+ )
+ fused_params_groups = fuse_params_groups(params_groups)
+ logger.info("fusing param groups")
+
+ for g in fused_params_groups:
+ g["foreach"] = True
+ return fused_params_groups
+
+ def get_params_groups(self):
+ all_params_groups = []
+ for m in self.student.values():
+ all_params_groups += self.get_maybe_fused_params_for_submodel(m)
+ return all_params_groups
+
+ def prepare_for_distributed_training(self):
+ logger.info("DISTRIBUTED FSDP -- preparing model for distributed training")
+ if has_batchnorms(self.student):
+ raise NotImplementedError
+ # below will synchronize all student subnetworks across gpus:
+ for k, v in self.student.items():
+ self.teacher[k].load_state_dict(self.student[k].state_dict())
+ student_model_cfg = self.cfg.compute_precision.student[k]
+ self.student[k] = get_fsdp_wrapper(student_model_cfg, modules_to_wrap={BlockChunk})(self.student[k])
+ teacher_model_cfg = self.cfg.compute_precision.teacher[k]
+ self.teacher[k] = get_fsdp_wrapper(teacher_model_cfg, modules_to_wrap={BlockChunk})(self.teacher[k])
diff --git a/facebookresearch/dinov2/dinov2/train/train.py b/facebookresearch/dinov2/dinov2/train/train.py
new file mode 100644
index 0000000..473b8d0
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/train/train.py
@@ -0,0 +1,318 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import argparse
+import logging
+import math
+import os
+from functools import partial
+
+from fvcore.common.checkpoint import PeriodicCheckpointer
+import torch
+
+from dinov2.data import SamplerType, make_data_loader, make_dataset
+from dinov2.data import collate_data_and_cast, DataAugmentationDINO, MaskingGenerator
+import dinov2.distributed as distributed
+from dinov2.fsdp import FSDPCheckpointer
+from dinov2.logging import MetricLogger
+from dinov2.utils.config import setup
+from dinov2.utils.utils import CosineScheduler
+
+from dinov2.train.ssl_meta_arch import SSLMetaArch
+
+
+torch.backends.cuda.matmul.allow_tf32 = True # PyTorch 1.12 sets this to False by default
+logger = logging.getLogger("dinov2")
+
+
+def get_args_parser(add_help: bool = True):
+ parser = argparse.ArgumentParser("DINOv2 training", add_help=add_help)
+ parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file")
+ parser.add_argument(
+ "--no-resume",
+ action="store_true",
+ help="Whether to not attempt to resume from the checkpoint directory. ",
+ )
+ parser.add_argument("--eval-only", action="store_true", help="perform evaluation only")
+ parser.add_argument("--eval", type=str, default="", help="Eval type to perform")
+ parser.add_argument(
+ "opts",
+ help="""
+Modify config options at the end of the command. For Yacs configs, use
+space-separated "PATH.KEY VALUE" pairs.
+For python-based LazyConfig, use "path.key=value".
+ """.strip(),
+ default=None,
+ nargs=argparse.REMAINDER,
+ )
+ parser.add_argument(
+ "--output-dir",
+ "--output_dir",
+ default="",
+ type=str,
+ help="Output directory to save logs and checkpoints",
+ )
+
+ return parser
+
+
+def build_optimizer(cfg, params_groups):
+ return torch.optim.AdamW(params_groups, betas=(cfg.optim.adamw_beta1, cfg.optim.adamw_beta2))
+
+
+def build_schedulers(cfg):
+ OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH
+ lr = dict(
+ base_value=cfg.optim["lr"],
+ final_value=cfg.optim["min_lr"],
+ total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH,
+ warmup_iters=cfg.optim["warmup_epochs"] * OFFICIAL_EPOCH_LENGTH,
+ start_warmup_value=0,
+ )
+ wd = dict(
+ base_value=cfg.optim["weight_decay"],
+ final_value=cfg.optim["weight_decay_end"],
+ total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH,
+ )
+ momentum = dict(
+ base_value=cfg.teacher["momentum_teacher"],
+ final_value=cfg.teacher["final_momentum_teacher"],
+ total_iters=cfg.optim["epochs"] * OFFICIAL_EPOCH_LENGTH,
+ )
+ teacher_temp = dict(
+ base_value=cfg.teacher["teacher_temp"],
+ final_value=cfg.teacher["teacher_temp"],
+ total_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH,
+ warmup_iters=cfg.teacher["warmup_teacher_temp_epochs"] * OFFICIAL_EPOCH_LENGTH,
+ start_warmup_value=cfg.teacher["warmup_teacher_temp"],
+ )
+
+ lr_schedule = CosineScheduler(**lr)
+ wd_schedule = CosineScheduler(**wd)
+ momentum_schedule = CosineScheduler(**momentum)
+ teacher_temp_schedule = CosineScheduler(**teacher_temp)
+ last_layer_lr_schedule = CosineScheduler(**lr)
+
+ last_layer_lr_schedule.schedule[
+ : cfg.optim["freeze_last_layer_epochs"] * OFFICIAL_EPOCH_LENGTH
+ ] = 0 # mimicking the original schedules
+
+ logger.info("Schedulers ready.")
+
+ return (
+ lr_schedule,
+ wd_schedule,
+ momentum_schedule,
+ teacher_temp_schedule,
+ last_layer_lr_schedule,
+ )
+
+
+def apply_optim_scheduler(optimizer, lr, wd, last_layer_lr):
+ for param_group in optimizer.param_groups:
+ is_last_layer = param_group["is_last_layer"]
+ lr_multiplier = param_group["lr_multiplier"]
+ wd_multiplier = param_group["wd_multiplier"]
+ param_group["weight_decay"] = wd * wd_multiplier
+ param_group["lr"] = (last_layer_lr if is_last_layer else lr) * lr_multiplier
+
+
+def do_test(cfg, model, iteration):
+ new_state_dict = model.teacher.state_dict()
+
+ if distributed.is_main_process():
+ iterstring = str(iteration)
+ eval_dir = os.path.join(cfg.train.output_dir, "eval", iterstring)
+ os.makedirs(eval_dir, exist_ok=True)
+ # save teacher checkpoint
+ teacher_ckp_path = os.path.join(eval_dir, "teacher_checkpoint.pth")
+ torch.save({"teacher": new_state_dict}, teacher_ckp_path)
+
+
+def do_train(cfg, model, resume=False):
+ model.train()
+ inputs_dtype = torch.half
+ fp16_scaler = model.fp16_scaler # for mixed precision training
+
+ # setup optimizer
+
+ optimizer = build_optimizer(cfg, model.get_params_groups())
+ (
+ lr_schedule,
+ wd_schedule,
+ momentum_schedule,
+ teacher_temp_schedule,
+ last_layer_lr_schedule,
+ ) = build_schedulers(cfg)
+
+ # checkpointer
+ checkpointer = FSDPCheckpointer(model, cfg.train.output_dir, optimizer=optimizer, save_to_disk=True)
+
+ start_iter = checkpointer.resume_or_load(cfg.MODEL.WEIGHTS, resume=resume).get("iteration", -1) + 1
+
+ OFFICIAL_EPOCH_LENGTH = cfg.train.OFFICIAL_EPOCH_LENGTH
+ max_iter = cfg.optim.epochs * OFFICIAL_EPOCH_LENGTH
+
+ periodic_checkpointer = PeriodicCheckpointer(
+ checkpointer,
+ period=3 * OFFICIAL_EPOCH_LENGTH,
+ max_iter=max_iter,
+ max_to_keep=3,
+ )
+
+ # setup data preprocessing
+
+ img_size = cfg.crops.global_crops_size
+ patch_size = cfg.student.patch_size
+ n_tokens = (img_size // patch_size) ** 2
+ mask_generator = MaskingGenerator(
+ input_size=(img_size // patch_size, img_size // patch_size),
+ max_num_patches=0.5 * img_size // patch_size * img_size // patch_size,
+ )
+
+ data_transform = DataAugmentationDINO(
+ cfg.crops.global_crops_scale,
+ cfg.crops.local_crops_scale,
+ cfg.crops.local_crops_number,
+ global_crops_size=cfg.crops.global_crops_size,
+ local_crops_size=cfg.crops.local_crops_size,
+ )
+
+ collate_fn = partial(
+ collate_data_and_cast,
+ mask_ratio_tuple=cfg.ibot.mask_ratio_min_max,
+ mask_probability=cfg.ibot.mask_sample_probability,
+ n_tokens=n_tokens,
+ mask_generator=mask_generator,
+ dtype=inputs_dtype,
+ )
+
+ # setup data loader
+
+ dataset = make_dataset(
+ dataset_str=cfg.train.dataset_path,
+ transform=data_transform,
+ target_transform=lambda _: (),
+ )
+ # sampler_type = SamplerType.INFINITE
+ sampler_type = SamplerType.SHARDED_INFINITE
+ data_loader = make_data_loader(
+ dataset=dataset,
+ batch_size=cfg.train.batch_size_per_gpu,
+ num_workers=cfg.train.num_workers,
+ shuffle=True,
+ seed=start_iter, # TODO: Fix this -- cfg.train.seed
+ sampler_type=sampler_type,
+ sampler_advance=0, # TODO(qas): fix this -- start_iter * cfg.train.batch_size_per_gpu,
+ drop_last=True,
+ collate_fn=collate_fn,
+ )
+
+ # training loop
+
+ iteration = start_iter
+
+ logger.info("Starting training from iteration {}".format(start_iter))
+ metrics_file = os.path.join(cfg.train.output_dir, "training_metrics.json")
+ metric_logger = MetricLogger(delimiter=" ", output_file=metrics_file)
+ header = "Training"
+
+ for data in metric_logger.log_every(
+ data_loader,
+ 10,
+ header,
+ max_iter,
+ start_iter,
+ ):
+ current_batch_size = data["collated_global_crops"].shape[0] / 2
+ if iteration > max_iter:
+ return
+
+ # apply schedules
+
+ lr = lr_schedule[iteration]
+ wd = wd_schedule[iteration]
+ mom = momentum_schedule[iteration]
+ teacher_temp = teacher_temp_schedule[iteration]
+ last_layer_lr = last_layer_lr_schedule[iteration]
+ apply_optim_scheduler(optimizer, lr, wd, last_layer_lr)
+
+ # compute losses
+
+ optimizer.zero_grad(set_to_none=True)
+ loss_dict = model.forward_backward(data, teacher_temp=teacher_temp)
+
+ # clip gradients
+
+ if fp16_scaler is not None:
+ if cfg.optim.clip_grad:
+ fp16_scaler.unscale_(optimizer)
+ for v in model.student.values():
+ v.clip_grad_norm_(cfg.optim.clip_grad)
+ fp16_scaler.step(optimizer)
+ fp16_scaler.update()
+ else:
+ if cfg.optim.clip_grad:
+ for v in model.student.values():
+ v.clip_grad_norm_(cfg.optim.clip_grad)
+ optimizer.step()
+
+ # perform teacher EMA update
+
+ model.update_teacher(mom)
+
+ # logging
+
+ if distributed.get_global_size() > 1:
+ for v in loss_dict.values():
+ torch.distributed.all_reduce(v)
+ loss_dict_reduced = {k: v.item() / distributed.get_global_size() for k, v in loss_dict.items()}
+
+ if math.isnan(sum(loss_dict_reduced.values())):
+ logger.info("NaN detected")
+ raise AssertionError
+ losses_reduced = sum(loss for loss in loss_dict_reduced.values())
+
+ metric_logger.update(lr=lr)
+ metric_logger.update(wd=wd)
+ metric_logger.update(mom=mom)
+ metric_logger.update(last_layer_lr=last_layer_lr)
+ metric_logger.update(current_batch_size=current_batch_size)
+ metric_logger.update(total_loss=losses_reduced, **loss_dict_reduced)
+
+ # checkpointing and testing
+
+ if cfg.evaluation.eval_period_iterations > 0 and (iteration + 1) % cfg.evaluation.eval_period_iterations == 0:
+ do_test(cfg, model, f"training_{iteration}")
+ torch.cuda.synchronize()
+ periodic_checkpointer.step(iteration)
+
+ iteration = iteration + 1
+ metric_logger.synchronize_between_processes()
+ return {k: meter.global_avg for k, meter in metric_logger.meters.items()}
+
+
+def main(args):
+ cfg = setup(args)
+
+ model = SSLMetaArch(cfg).to(torch.device("cuda"))
+ model.prepare_for_distributed_training()
+
+ logger.info("Model:\n{}".format(model))
+ if args.eval_only:
+ iteration = (
+ FSDPCheckpointer(model, save_dir=cfg.train.output_dir)
+ .resume_or_load(cfg.MODEL.WEIGHTS, resume=not args.no_resume)
+ .get("iteration", -1)
+ + 1
+ )
+ return do_test(cfg, model, f"manual_{iteration}")
+
+ do_train(cfg, model, resume=not args.no_resume)
+
+
+if __name__ == "__main__":
+ args = get_args_parser(add_help=True).parse_args()
+ main(args)
diff --git a/facebookresearch/dinov2/dinov2/utils/__init__.py b/facebookresearch/dinov2/dinov2/utils/__init__.py
new file mode 100644
index 0000000..b88da6b
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
diff --git a/facebookresearch/dinov2/dinov2/utils/cluster.py b/facebookresearch/dinov2/dinov2/utils/cluster.py
new file mode 100644
index 0000000..3df87dc
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/cluster.py
@@ -0,0 +1,95 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class ClusterType(Enum):
+ AWS = "aws"
+ FAIR = "fair"
+ RSC = "rsc"
+
+
+def _guess_cluster_type() -> ClusterType:
+ uname = os.uname()
+ if uname.sysname == "Linux":
+ if uname.release.endswith("-aws"):
+ # Linux kernel versions on AWS instances are of the form "5.4.0-1051-aws"
+ return ClusterType.AWS
+ elif uname.nodename.startswith("rsc"):
+ # Linux kernel versions on RSC instances are standard ones but hostnames start with "rsc"
+ return ClusterType.RSC
+
+ return ClusterType.FAIR
+
+
+def get_cluster_type(cluster_type: Optional[ClusterType] = None) -> Optional[ClusterType]:
+ if cluster_type is None:
+ return _guess_cluster_type()
+
+ return cluster_type
+
+
+def get_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]:
+ cluster_type = get_cluster_type(cluster_type)
+ if cluster_type is None:
+ return None
+
+ CHECKPOINT_DIRNAMES = {
+ ClusterType.AWS: "checkpoints",
+ ClusterType.FAIR: "checkpoint",
+ ClusterType.RSC: "checkpoint/dino",
+ }
+ return Path("/") / CHECKPOINT_DIRNAMES[cluster_type]
+
+
+def get_user_checkpoint_path(cluster_type: Optional[ClusterType] = None) -> Optional[Path]:
+ checkpoint_path = get_checkpoint_path(cluster_type)
+ if checkpoint_path is None:
+ return None
+
+ username = os.environ.get("USER")
+ assert username is not None
+ return checkpoint_path / username
+
+
+def get_slurm_partition(cluster_type: Optional[ClusterType] = None) -> Optional[str]:
+ cluster_type = get_cluster_type(cluster_type)
+ if cluster_type is None:
+ return None
+
+ SLURM_PARTITIONS = {
+ ClusterType.AWS: "learnlab",
+ ClusterType.FAIR: "learnlab",
+ ClusterType.RSC: "learn",
+ }
+ return SLURM_PARTITIONS[cluster_type]
+
+
+def get_slurm_executor_parameters(
+ nodes: int, num_gpus_per_node: int, cluster_type: Optional[ClusterType] = None, **kwargs
+) -> Dict[str, Any]:
+ # create default parameters
+ params = {
+ "mem_gb": 0, # Requests all memory on a node, see https://slurm.schedmd.com/sbatch.html
+ "gpus_per_node": num_gpus_per_node,
+ "tasks_per_node": num_gpus_per_node, # one task per GPU
+ "cpus_per_task": 10,
+ "nodes": nodes,
+ "slurm_partition": get_slurm_partition(cluster_type),
+ }
+ # apply cluster-specific adjustments
+ cluster_type = get_cluster_type(cluster_type)
+ if cluster_type == ClusterType.AWS:
+ params["cpus_per_task"] = 12
+ del params["mem_gb"]
+ elif cluster_type == ClusterType.RSC:
+ params["cpus_per_task"] = 12
+ # set additional parameters / apply overrides
+ params.update(kwargs)
+ return params
diff --git a/facebookresearch/dinov2/dinov2/utils/config.py b/facebookresearch/dinov2/dinov2/utils/config.py
new file mode 100644
index 0000000..c9de578
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/config.py
@@ -0,0 +1,72 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import math
+import logging
+import os
+
+from omegaconf import OmegaConf
+
+import dinov2.distributed as distributed
+from dinov2.logging import setup_logging
+from dinov2.utils import utils
+from dinov2.configs import dinov2_default_config
+
+
+logger = logging.getLogger("dinov2")
+
+
+def apply_scaling_rules_to_cfg(cfg): # to fix
+ if cfg.optim.scaling_rule == "sqrt_wrt_1024":
+ base_lr = cfg.optim.base_lr
+ cfg.optim.lr = base_lr
+ cfg.optim.lr *= math.sqrt(cfg.train.batch_size_per_gpu * distributed.get_global_size() / 1024.0)
+ logger.info(f"sqrt scaling learning rate; base: {base_lr}, new: {cfg.optim.lr}")
+ else:
+ raise NotImplementedError
+ return cfg
+
+
+def write_config(cfg, output_dir, name="config.yaml"):
+ logger.info(OmegaConf.to_yaml(cfg))
+ saved_cfg_path = os.path.join(output_dir, name)
+ with open(saved_cfg_path, "w") as f:
+ OmegaConf.save(config=cfg, f=f)
+ return saved_cfg_path
+
+
+def get_cfg_from_args(args):
+ args.output_dir = os.path.abspath(args.output_dir)
+ args.opts += [f"train.output_dir={args.output_dir}"]
+ default_cfg = OmegaConf.create(dinov2_default_config)
+ cfg = OmegaConf.load(args.config_file)
+ cfg = OmegaConf.merge(default_cfg, cfg, OmegaConf.from_cli(args.opts))
+ return cfg
+
+
+def default_setup(args):
+ distributed.enable(overwrite=True)
+ seed = getattr(args, "seed", 0)
+ rank = distributed.get_global_rank()
+
+ global logger
+ setup_logging(output=args.output_dir, level=logging.INFO)
+ logger = logging.getLogger("dinov2")
+
+ utils.fix_random_seeds(seed + rank)
+ logger.info("git:\n {}\n".format(utils.get_sha()))
+ logger.info("\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items())))
+
+
+def setup(args):
+ """
+ Create configs and perform basic setups.
+ """
+ cfg = get_cfg_from_args(args)
+ os.makedirs(args.output_dir, exist_ok=True)
+ default_setup(args)
+ apply_scaling_rules_to_cfg(cfg)
+ write_config(cfg, args.output_dir)
+ return cfg
diff --git a/facebookresearch/dinov2/dinov2/utils/dtype.py b/facebookresearch/dinov2/dinov2/utils/dtype.py
new file mode 100644
index 0000000..80f4cd7
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/dtype.py
@@ -0,0 +1,37 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+
+from typing import Dict, Union
+
+import numpy as np
+import torch
+
+
+TypeSpec = Union[str, np.dtype, torch.dtype]
+
+
+_NUMPY_TO_TORCH_DTYPE: Dict[np.dtype, torch.dtype] = {
+ np.dtype("bool"): torch.bool,
+ np.dtype("uint8"): torch.uint8,
+ np.dtype("int8"): torch.int8,
+ np.dtype("int16"): torch.int16,
+ np.dtype("int32"): torch.int32,
+ np.dtype("int64"): torch.int64,
+ np.dtype("float16"): torch.float16,
+ np.dtype("float32"): torch.float32,
+ np.dtype("float64"): torch.float64,
+ np.dtype("complex64"): torch.complex64,
+ np.dtype("complex128"): torch.complex128,
+}
+
+
+def as_torch_dtype(dtype: TypeSpec) -> torch.dtype:
+ if isinstance(dtype, torch.dtype):
+ return dtype
+ if isinstance(dtype, str):
+ dtype = np.dtype(dtype)
+ assert isinstance(dtype, np.dtype), f"Expected an instance of nunpy dtype, got {type(dtype)}"
+ return _NUMPY_TO_TORCH_DTYPE[dtype]
diff --git a/facebookresearch/dinov2/dinov2/utils/param_groups.py b/facebookresearch/dinov2/dinov2/utils/param_groups.py
new file mode 100644
index 0000000..9a5d2ff
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/param_groups.py
@@ -0,0 +1,103 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from collections import defaultdict
+import logging
+
+
+logger = logging.getLogger("dinov2")
+
+
+def get_vit_lr_decay_rate(name, lr_decay_rate=1.0, num_layers=12, force_is_backbone=False, chunked_blocks=False):
+ """
+ Calculate lr decay rate for different ViT blocks.
+ Args:
+ name (string): parameter name.
+ lr_decay_rate (float): base lr decay rate.
+ num_layers (int): number of ViT blocks.
+ Returns:
+ lr decay rate for the given parameter.
+ """
+ layer_id = num_layers + 1
+ if name.startswith("backbone") or force_is_backbone:
+ if (
+ ".pos_embed" in name
+ or ".patch_embed" in name
+ or ".mask_token" in name
+ or ".cls_token" in name
+ or ".register_tokens" in name
+ ):
+ layer_id = 0
+ elif force_is_backbone and (
+ "pos_embed" in name
+ or "patch_embed" in name
+ or "mask_token" in name
+ or "cls_token" in name
+ or "register_tokens" in name
+ ):
+ layer_id = 0
+ elif ".blocks." in name and ".residual." not in name:
+ layer_id = int(name[name.find(".blocks.") :].split(".")[2]) + 1
+ elif chunked_blocks and "blocks." in name and "residual." not in name:
+ layer_id = int(name[name.find("blocks.") :].split(".")[2]) + 1
+ elif "blocks." in name and "residual." not in name:
+ layer_id = int(name[name.find("blocks.") :].split(".")[1]) + 1
+
+ return lr_decay_rate ** (num_layers + 1 - layer_id)
+
+
+def get_params_groups_with_decay(model, lr_decay_rate=1.0, patch_embed_lr_mult=1.0):
+ chunked_blocks = False
+ if hasattr(model, "n_blocks"):
+ logger.info("chunked fsdp")
+ n_blocks = model.n_blocks
+ chunked_blocks = model.chunked_blocks
+ elif hasattr(model, "blocks"):
+ logger.info("first code branch")
+ n_blocks = len(model.blocks)
+ elif hasattr(model, "backbone"):
+ logger.info("second code branch")
+ n_blocks = len(model.backbone.blocks)
+ else:
+ logger.info("else code branch")
+ n_blocks = 0
+ all_param_groups = []
+
+ for name, param in model.named_parameters():
+ name = name.replace("_fsdp_wrapped_module.", "")
+ if not param.requires_grad:
+ continue
+ decay_rate = get_vit_lr_decay_rate(
+ name, lr_decay_rate, num_layers=n_blocks, force_is_backbone=n_blocks > 0, chunked_blocks=chunked_blocks
+ )
+ d = {"params": param, "is_last_layer": False, "lr_multiplier": decay_rate, "wd_multiplier": 1.0, "name": name}
+
+ if "last_layer" in name:
+ d.update({"is_last_layer": True})
+
+ if name.endswith(".bias") or "norm" in name or "gamma" in name:
+ d.update({"wd_multiplier": 0.0})
+
+ if "patch_embed" in name:
+ d.update({"lr_multiplier": d["lr_multiplier"] * patch_embed_lr_mult})
+
+ all_param_groups.append(d)
+ logger.info(f"""{name}: lr_multiplier: {d["lr_multiplier"]}, wd_multiplier: {d["wd_multiplier"]}""")
+
+ return all_param_groups
+
+
+def fuse_params_groups(all_params_groups, keys=("lr_multiplier", "wd_multiplier", "is_last_layer")):
+ fused_params_groups = defaultdict(lambda: {"params": []})
+ for d in all_params_groups:
+ identifier = ""
+ for k in keys:
+ identifier += k + str(d[k]) + "_"
+
+ for k in keys:
+ fused_params_groups[identifier][k] = d[k]
+ fused_params_groups[identifier]["params"].append(d["params"])
+
+ return fused_params_groups.values()
diff --git a/facebookresearch/dinov2/dinov2/utils/utils.py b/facebookresearch/dinov2/dinov2/utils/utils.py
new file mode 100644
index 0000000..68f8e2c
--- /dev/null
+++ b/facebookresearch/dinov2/dinov2/utils/utils.py
@@ -0,0 +1,95 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+import logging
+import os
+import random
+import subprocess
+from urllib.parse import urlparse
+
+import numpy as np
+import torch
+from torch import nn
+
+
+logger = logging.getLogger("dinov2")
+
+
+def load_pretrained_weights(model, pretrained_weights, checkpoint_key):
+ if urlparse(pretrained_weights).scheme: # If it looks like an URL
+ state_dict = torch.hub.load_state_dict_from_url(pretrained_weights, map_location="cpu")
+ else:
+ state_dict = torch.load(pretrained_weights, map_location="cpu")
+ if checkpoint_key is not None and checkpoint_key in state_dict:
+ logger.info(f"Take key {checkpoint_key} in provided checkpoint dict")
+ state_dict = state_dict[checkpoint_key]
+ # remove `module.` prefix
+ state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
+ # remove `backbone.` prefix induced by multicrop wrapper
+ state_dict = {k.replace("backbone.", ""): v for k, v in state_dict.items()}
+ msg = model.load_state_dict(state_dict, strict=False)
+ logger.info("Pretrained weights found at {} and loaded with msg: {}".format(pretrained_weights, msg))
+
+
+def fix_random_seeds(seed=31):
+ """
+ Fix random seeds.
+ """
+ torch.manual_seed(seed)
+ torch.cuda.manual_seed_all(seed)
+ np.random.seed(seed)
+ random.seed(seed)
+
+
+def get_sha():
+ cwd = os.path.dirname(os.path.abspath(__file__))
+
+ def _run(command):
+ return subprocess.check_output(command, cwd=cwd).decode("ascii").strip()
+
+ sha = "N/A"
+ diff = "clean"
+ branch = "N/A"
+ try:
+ sha = _run(["git", "rev-parse", "HEAD"])
+ subprocess.check_output(["git", "diff"], cwd=cwd)
+ diff = _run(["git", "diff-index", "HEAD"])
+ diff = "has uncommitted changes" if diff else "clean"
+ branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+ except Exception:
+ pass
+ message = f"sha: {sha}, status: {diff}, branch: {branch}"
+ return message
+
+
+class CosineScheduler(object):
+ def __init__(self, base_value, final_value, total_iters, warmup_iters=0, start_warmup_value=0, freeze_iters=0):
+ super().__init__()
+ self.final_value = final_value
+ self.total_iters = total_iters
+
+ freeze_schedule = np.zeros((freeze_iters))
+
+ warmup_schedule = np.linspace(start_warmup_value, base_value, warmup_iters)
+
+ iters = np.arange(total_iters - warmup_iters - freeze_iters)
+ schedule = final_value + 0.5 * (base_value - final_value) * (1 + np.cos(np.pi * iters / len(iters)))
+ self.schedule = np.concatenate((freeze_schedule, warmup_schedule, schedule))
+
+ assert len(self.schedule) == self.total_iters
+
+ def __getitem__(self, it):
+ if it >= self.total_iters:
+ return self.final_value
+ else:
+ return self.schedule[it]
+
+
+def has_batchnorms(model):
+ bn_types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.SyncBatchNorm)
+ for name, module in model.named_modules():
+ if isinstance(module, bn_types):
+ return True
+ return False
diff --git a/facebookresearch/dinov2/hubconf.py b/facebookresearch/dinov2/hubconf.py
new file mode 100644
index 0000000..d3664e2
--- /dev/null
+++ b/facebookresearch/dinov2/hubconf.py
@@ -0,0 +1,15 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+
+from dinov2.hub.backbones import dinov2_vitb14, dinov2_vitg14, dinov2_vitl14, dinov2_vits14
+from dinov2.hub.backbones import dinov2_vitb14_reg, dinov2_vitg14_reg, dinov2_vitl14_reg, dinov2_vits14_reg
+from dinov2.hub.classifiers import dinov2_vitb14_lc, dinov2_vitg14_lc, dinov2_vitl14_lc, dinov2_vits14_lc
+from dinov2.hub.classifiers import dinov2_vitb14_reg_lc, dinov2_vitg14_reg_lc, dinov2_vitl14_reg_lc, dinov2_vits14_reg_lc
+from dinov2.hub.depthers import dinov2_vitb14_ld, dinov2_vitg14_ld, dinov2_vitl14_ld, dinov2_vits14_ld
+from dinov2.hub.depthers import dinov2_vitb14_dd, dinov2_vitg14_dd, dinov2_vitl14_dd, dinov2_vits14_dd
+
+
+dependencies = ["torch"]
diff --git a/facebookresearch/dinov2/notebooks/depth_estimation.ipynb b/facebookresearch/dinov2/notebooks/depth_estimation.ipynb
new file mode 100644
index 0000000..717739a
--- /dev/null
+++ b/facebookresearch/dinov2/notebooks/depth_estimation.ipynb
@@ -0,0 +1,482 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Copyright (c) Meta Platforms, Inc. and affiliates."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Depth Estimation ![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "\n",
+ "INSTALL = False # Switch this to install dependencies\n",
+ "if INSTALL: # Try installing package with extras\n",
+ " REPO_URL = \"https://github.com/facebookresearch/dinov2\"\n",
+ " !{sys.executable} -m pip install -e {REPO_URL}'[extras]' --extra-index-url https://download.pytorch.org/whl/cu117 --extra-index-url https://pypi.nvidia.com\n",
+ "else:\n",
+ " REPO_PATH = \"\" # Specify a local path to the repository (or use installed package instead)\n",
+ " sys.path.append(REPO_PATH)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Utilities"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import itertools\n",
+ "from functools import partial\n",
+ "\n",
+ "import torch\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "from dinov2.eval.depth.models import build_depther\n",
+ "\n",
+ "\n",
+ "class CenterPadding(torch.nn.Module):\n",
+ " def __init__(self, multiple):\n",
+ " super().__init__()\n",
+ " self.multiple = multiple\n",
+ "\n",
+ " def _get_pad(self, size):\n",
+ " new_size = math.ceil(size / self.multiple) * self.multiple\n",
+ " pad_size = new_size - size\n",
+ " pad_size_left = pad_size // 2\n",
+ " pad_size_right = pad_size - pad_size_left\n",
+ " return pad_size_left, pad_size_right\n",
+ "\n",
+ " @torch.inference_mode()\n",
+ " def forward(self, x):\n",
+ " pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1]))\n",
+ " output = F.pad(x, pads)\n",
+ " return output\n",
+ "\n",
+ "\n",
+ "def create_depther(cfg, backbone_model, backbone_size, head_type):\n",
+ " train_cfg = cfg.get(\"train_cfg\")\n",
+ " test_cfg = cfg.get(\"test_cfg\")\n",
+ " depther = build_depther(cfg.model, train_cfg=train_cfg, test_cfg=test_cfg)\n",
+ "\n",
+ " depther.backbone.forward = partial(\n",
+ " backbone_model.get_intermediate_layers,\n",
+ " n=cfg.model.backbone.out_indices,\n",
+ " reshape=True,\n",
+ " return_class_token=cfg.model.backbone.output_cls_token,\n",
+ " norm=cfg.model.backbone.final_norm,\n",
+ " )\n",
+ "\n",
+ " if hasattr(backbone_model, \"patch_size\"):\n",
+ " depther.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone_model.patch_size)(x[0]))\n",
+ "\n",
+ " return depther"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Load pretrained backbone"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Using cache found in /private/home/plabatut/.cache/torch/hub/facebookresearch_dinov2_main\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DinoVisionTransformer(\n",
+ " (patch_embed): PatchEmbed(\n",
+ " (proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))\n",
+ " (norm): Identity()\n",
+ " )\n",
+ " (blocks): ModuleList(\n",
+ " (0-11): 12 x NestedTensorBlock(\n",
+ " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MemEffAttention(\n",
+ " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=384, out_features=384, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ls1): LayerScale()\n",
+ " (drop_path1): Identity()\n",
+ " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): Mlp(\n",
+ " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ls2): LayerScale()\n",
+ " (drop_path2): Identity()\n",
+ " )\n",
+ " )\n",
+ " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (head): Identity()\n",
+ ")"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "BACKBONE_SIZE = \"small\" # in (\"small\", \"base\", \"large\" or \"giant\")\n",
+ "\n",
+ "\n",
+ "backbone_archs = {\n",
+ " \"small\": \"vits14\",\n",
+ " \"base\": \"vitb14\",\n",
+ " \"large\": \"vitl14\",\n",
+ " \"giant\": \"vitg14\",\n",
+ "}\n",
+ "backbone_arch = backbone_archs[BACKBONE_SIZE]\n",
+ "backbone_name = f\"dinov2_{backbone_arch}\"\n",
+ "\n",
+ "backbone_model = torch.hub.load(repo_or_dir=\"facebookresearch/dinov2\", model=backbone_name)\n",
+ "backbone_model.eval()\n",
+ "backbone_model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Load pretrained depth head"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_nyu_dpt_head.pth\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Downloading: \"https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_nyu_dpt_head.pth\" to /private/home/plabatut/.cache/torch/hub/checkpoints/dinov2_vits14_nyu_dpt_head.pth\n",
+ "100%|██████████| 160M/160M [00:06<00:00, 27.2MB/s] \n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DepthEncoderDecoder(\n",
+ " (backbone): DinoVisionTransformer()\n",
+ " (decode_head): DPTHead(\n",
+ " align_corners=False\n",
+ " (loss_decode): ModuleList(\n",
+ " (0): SigLoss()\n",
+ " (1): GradientLoss()\n",
+ " )\n",
+ " (conv_depth): HeadDepth(\n",
+ " (head): Sequential(\n",
+ " (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (1): Interpolate()\n",
+ " (2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (3): ReLU()\n",
+ " (4): Conv2d(32, 1, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " )\n",
+ " (relu): ReLU()\n",
+ " (sigmoid): Sigmoid()\n",
+ " (reassemble_blocks): ReassembleBlocks(\n",
+ " (projects): ModuleList(\n",
+ " (0): ConvModule(\n",
+ " (conv): Conv2d(384, 48, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (1): ConvModule(\n",
+ " (conv): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (2): ConvModule(\n",
+ " (conv): Conv2d(384, 192, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (3): ConvModule(\n",
+ " (conv): Conv2d(384, 384, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " )\n",
+ " (resize_layers): ModuleList(\n",
+ " (0): ConvTranspose2d(48, 48, kernel_size=(4, 4), stride=(4, 4))\n",
+ " (1): ConvTranspose2d(96, 96, kernel_size=(2, 2), stride=(2, 2))\n",
+ " (2): Identity()\n",
+ " (3): Conv2d(384, 384, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+ " )\n",
+ " (readout_projects): ModuleList(\n",
+ " (0-3): 4 x Sequential(\n",
+ " (0): Linear(in_features=768, out_features=384, bias=True)\n",
+ " (1): GELU(approximate='none')\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (convs): ModuleList(\n",
+ " (0): ConvModule(\n",
+ " (conv): Conv2d(48, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (1): ConvModule(\n",
+ " (conv): Conv2d(96, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (2): ConvModule(\n",
+ " (conv): Conv2d(192, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (3): ConvModule(\n",
+ " (conv): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (fusion_blocks): ModuleList(\n",
+ " (0): FeatureFusionBlock(\n",
+ " (project): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (res_conv_unit1): None\n",
+ " (res_conv_unit2): PreActResidualConvUnit(\n",
+ " (conv1): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " (conv2): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (1-3): 3 x FeatureFusionBlock(\n",
+ " (project): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (res_conv_unit1): PreActResidualConvUnit(\n",
+ " (conv1): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " (conv2): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (res_conv_unit2): PreActResidualConvUnit(\n",
+ " (conv1): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " (conv2): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (project): ConvModule(\n",
+ " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import urllib\n",
+ "\n",
+ "import mmcv\n",
+ "from mmcv.runner import load_checkpoint\n",
+ "\n",
+ "\n",
+ "def load_config_from_url(url: str) -> str:\n",
+ " with urllib.request.urlopen(url) as f:\n",
+ " return f.read().decode()\n",
+ "\n",
+ "\n",
+ "HEAD_DATASET = \"nyu\" # in (\"nyu\", \"kitti\")\n",
+ "HEAD_TYPE = \"dpt\" # in (\"linear\", \"linear4\", \"dpt\")\n",
+ "\n",
+ "\n",
+ "DINOV2_BASE_URL = \"https://dl.fbaipublicfiles.com/dinov2\"\n",
+ "head_config_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_config.py\"\n",
+ "head_checkpoint_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_head.pth\"\n",
+ "\n",
+ "cfg_str = load_config_from_url(head_config_url)\n",
+ "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n",
+ "\n",
+ "model = create_depther(\n",
+ " cfg,\n",
+ " backbone_model=backbone_model,\n",
+ " backbone_size=BACKBONE_SIZE,\n",
+ " head_type=HEAD_TYPE,\n",
+ ")\n",
+ "\n",
+ "load_checkpoint(model, head_checkpoint_url, map_location=\"cpu\")\n",
+ "model.eval()\n",
+ "model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Load sample image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import urllib\n",
+ "\n",
+ "from PIL import Image\n",
+ "\n",
+ "\n",
+ "def load_image_from_url(url: str) -> Image:\n",
+ " with urllib.request.urlopen(url) as f:\n",
+ " return Image.open(f).convert(\"RGB\")\n",
+ "\n",
+ "\n",
+ "EXAMPLE_IMAGE_URL = \"https://dl.fbaipublicfiles.com/dinov2/images/example.jpg\"\n",
+ "\n",
+ "\n",
+ "image = load_image_from_url(EXAMPLE_IMAGE_URL)\n",
+ "display(image)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Estimate depth on sample image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAIAAAC6s0uzAAEAAElEQVR4nMz927LkOJItCC5VkGbbPTKrsupcep5mXuY/R+ZzR0r6dNfJiou7GaHzoIBCcSXN9o6sUgnxsE2CAEiCWFh6A/1//t//3z8OAHhGPAUCRJFDYCKCKADSKfsNgHIZJgyFiQhgAhEYIAJTVTSKpCZGbQGIqUsQ5D9L4XQEQEx/pR8xdTBVspCmPwwCYMcY4xvzF/UtWOvNqZhuQZAfoB6RXC4V0IOQprZB5133KP/WgwwionJH+U4Zerj6gfwG8yXlHu3NlvrdvVN9xB5mPzByW+7ayZjxcvb2Kon1nzwu9ZXiW7SuRv/tWEl7xdKe6q9yl0tzSge/iERBhByS/nvI8cDxwPMnHg96HHgc9HziceChn0vEASB/OqD8eBjB/vS/h2KXW20RhyAe8oh4RImCI3Utt0LEgXbGHmjfcN9x30X/3XfsG3hHCMQ7MYMCEVE1qu0ef8bjdzz+g379D/q/f5P/64/j//rj+e8/n38/4h8x/iFyQIcobYE/tvD9vv/zx/a3X/i//5P8j7/JP/0tfPx1D3/Z+Xuge8BHwD1gI7kzAkkgbCQ6Rw2nMnKvqx//+bjYWStfPg0tr2VyeXIXkqtBL+dcmIbHXUOpBnK1pWvLcd9JK9AcLPfVHWkkTxdCJIGFSEKIYYvbFnmPYZNwF9pAW249PwiywcX5T6b8m8ozZSpH7K2USurH6vvU/74y0VjZCZLJ+PsUREEUeQqeUX5G+RHjT8QfEh+IPykeJAfFI3db748FAO+y/yUiYgOwMz4C/jjwM+K3pxyCp5taPBACBpDpYOqwAN0cTQAgZVKmhMdeApEAERJ0CiMQpbmMQIb1BEgGEiEJ2g0iEQRCBAJIZyUtJEKKW/Yxz2CsgViPScA5EmtHm8pZSFu0yz2QMFGU/O0hDWStQe9CD1qd4XL/8+qhQmIPvXpHfpFh6Ouht5xN77EgNEbgusBdVM8w/anlqSt5KsOvABnMwujU9eovYr1f0vkW7Wj/0qMgEGkZvd/o1o4qk+dAURD0Q0qLMwRA9HXFcnsRHEUiwpYXqBGRwYIQM3CKWzDobwJHHDx6cuzmtmEBxeCIeOARaFekjziEouBIvUcI2Ik4YA/Yd9x3uQXsir43hADeKQQi/Y9BNhRT06JDNAbiTThI2GgPtDPtgW+Bb3oXgigSmTaibQsfe/jlHv7pg//5F/nbL/L9O90+QvgIfGO6B9wd+u4sgRBIOCNcP87zC2oxNRdrsdljrf1pKNv8tj973NVKeqBtSq5xt0dcX9LfzinoNkIkTEJkP8rl1CzhmAa4i+p5EZM9HfLP0UHvAHfdHOR7lrsx//rnlDH9qOeavrREARECgYUUCSPkEHoKMThAGDgAFgYkav9FfwAIuwCgDdtfd/njoEfE7890+4AcwOHW7IK0spWyxJWGnejMrt9PJrsgISZ5AhuT6KvqViSZubrfmYg7NlyxAXFziUhZnQx5sGecVsxw63BnKJcriJVP9qNzyG7Ln12jTRn/+ApfN+o8ob++57mkgV9C8XQLIJ0F9S7I3VEZ57qeIUDWhLhaRxsqH+lZ4cjrCStgGhQmP0GVCYioBfuZvESCFzIcdb3E8eF5+fr4gvKiGYTV8WbwjNuNTutziBg7fMhxIP7E8QM/HvR40I8Djwd+KCge8hBEwRFFYfiwCgmBiXUWAcAIRNyQY9f64f9UzDMGLDiiPEWOiCgSARAxg4kCgZn2QPtG943uO+477nd8HHLbsUWRTXgjPhSDhfRbsw9Z7/GHPH/g8ZP++IHfHvLbU35EeSKR7A2IiV4Qa9+iPA55POjHU46HHD+P8AcjELOu+AU3JoEcQoGg/9md2+B0YCyHpO/CxrZHakW1Q8CEQ/FS0vyvxY98XwzkqhIMH0JMcoitdKWuRBShiOQQYtKhpZcQE0inGvfBSqq5PEY7ZWfzQale6iui/U/0lyMLbTgiERHHEGkTipAnwPV8XYGrIIOxcEZiyXQzgW4pKR3cOlwXdypdXily3T0D87X8TAyZXOtZ+5oZ8DPiKfIUiYgHpNyyUO6e/jh+BPohIYJ32RR9D0EEGIgivi1k/JvdiJeoIwYSiUJ+GgRsTIHycsGtb3OnEEWCO6IkmECBEhJXDBiSeID2k4gnGoJ0+45xpiMv8KLc1eX7GqIv8idq5zy1JaJ2CWNtXdM5L/TP/kejiEaB3kKCh9DrFdHleKeIHrLeRrHfwPMrOqGrhX2Lvd2hPztUTkA/ga7yl9B3oW12R9zyq6u8Ad18sCxAs+VCsU70iCe4Mf8WGa8oCAGAoq8e8ehr0OvV0QHsVdCU/1REF4mGvqmY4EAkxEB7lAcTi0ShGLsH7IeoOwiRdI+qYP+Jx4N+PuT3R/z9eeh/f4g8FYnT/dJTb5lp2/j7g34c9ExvHEQZawNhY/tdVNBApYWm+ZcIQNzAjhlT8xRNsJGQqxUhovQ+2F2CwW9xlUBVgbo0iaJTqEQhLS+o/hyK+4pbQnxFhjVTXVVmw6AtchAigFXDjGSGtAs5PwJkFTSQ2BuSyg493x2g72hqMK1sA5YmPXG8Lk1tTIOvl8ngVgSIZPTXihyRwpEI0nZkuI2iylscgkPk6MyuRxRjlt7Omm9cSgfSWKedORAOwc4IVEhwumTyWJy6W8wGDIXe2gbsDcBlVsrEN1Xi7Kw912yfnoJQxutGnXsqw2obE6//IZD+YEWUR5TMcRSbuXRxTUfS2DsNvIgep4y7OmsrN2VQJNEfR2LDifUeevuSGksTR/7qYn5EE53N5PESHZIWU4ddK62a+qL4b2dt7G/ODhGuPT6htrM6G7htLDW+/rrFcbcboO1/R5EDIiJPxAPRrL8P+vHAjyd+HHh47istfz0IIUosrw+AJHV0xFMXYEN7sHHfiMchjyhP/VekMgAj0VOO9GTa0gJfQMQH7U85CM+AIJBDIlOIEBaKJPb1HSJPiT/l+IHn7/jjN/6P3/DvP+TvP4//eBy/Po7fYvwjxh8ot0aEIPwEEPj+jL8d/E9PHPaVJYNjxl1T1AGIIBaheuqW7qv3nKpXPh/O6AQYUoIpfz6iC1+Jk6HeLGcJ4jXSqGDIVvni/zQN8xVFdNX0iypoMwNjhGI0Qd+mTK7LDvXN5B8eWZmAtOjIZ0clm99DEVlh8PqsrbY2qAoaAl1h8g4dA8cTiNrbth45KDK2mBC3sM8ARKJIIqAoYEqqqx7vG0WrKkhVOZYQK0bVNrIUxb5ZAYOvh8r0xA6DS3frAx7VbBJT9LVeRYjhrvdsmsFwpbZVtpdMUPDHG+ns2oNOWv1NgWS9zmAZ6x8AJpbNqsIrVLjppLcKd10STu990XIrDccddHX0lMpMl2/3wACMTxepw8pxhsoLmemNh3X2hZvPxD4cZXV+ATocPCJZ2abOBJkAVb8poSgLCYjADObEXxVlmBHysgnDCZ+y15XSX2TEHRp9y/1qOYEgEiIlYzM3GH8qZmb2Lhemj0lTn4BBG3jDtsm208eDPgLfA/+M8Sn0JEr29HQ7tBFtREzETHvAviVLM++MjWkjbISdsRM2xkaiAMHOY+OiKPVMz0QqaHTwqTeod1egdGYSrq9N5c0JqzreWYIX0Gsk1X7nrr52y430mE0sRJ0N+LoIQOlpJnw1jcFa+hUK5rfX6OdWTyGdGiuSXK+IYcxSBIhApHhQ+rcUEwCSaXE8ZHtESDfL6JFDlUqAiDxFJFuebPWNjGEeyRjEIAJFIaG0nGUCRRAT0erjnlng0llJM7Wp43ruq8RXoVdx14Nu7WbctnaUCajg08DI6oRBmJGYpf4KjR7yrPBCesOwP5hAXRc3WdmjVlvPgw9nDI7J+40g2RyVqfBRVoSS16MrKuwO+s++fLjUlZeMValAmddeni0qTWAnax/msqxcIi7qb6dXMjf017e7pr84Y8D9xabdZQRBFIqmNW5Mv/lHZfrlbAxGh8FmAG6+GiYeqdCTDVg/zWyPOhd1w/Ssg0m9fCioPxc4YA+0B75FfgoigaNspqBJflj8beNvO3+/4/td7jcKO9POtGX6O9SpartGpdZWwmzftclBHEMjb69MBSboW9dZkdpe1irxmXj07W+hL3lF1KYntcFeBBJJJMGVRBAj0TjXqh63KY+yLj+Zzd0aNhXg/FZswd6T4JlK4UyW6HtZmMCiayLaiH6KzrkccAg4lNtXAN62SFvU6biooNGNuZhjHgx9nxIN3p6ZpirOGXvT/4IwiCER4CAUpdhCUlfyD0E201LBCX3aOjGYDZgAIYmCAIoAK1dTw7AgKa8IUYRB0WoDJJUUTy7J2bR6pa6uIfyRxfMvDg4eZpaXxMqENFiUNL7Q7qpBsVMZwjAMXfRI5liebJlGGsiOLrVSukFipnJjjhN4jm4Hqx72ztJ24eyS9h4ns0ewt2Ml89NolmBXPDP6MjRTuH9OPOKWthKHJlBxkzRhMAsLhYiYnIpocJu522P0nThFq2r6IDBnvknCgoOSG1ckBG9yFonKRJWdp2KUGuL0HxFIA+YsDAlIN6irGP0Y9eCGnYiZNqY9hJuqAEie5tSdzvIWaAvYg2wBYSMOqaWJegbFK9CIZrmRod6rUZ6lq+DpqfPqusR9UX0y5RJ0I3/27bT3NdczD9cHb0jyrlG+6o9nlAXXS+qsUy1no2oaa0B9VXr0Ha0vqr8mmrrUyebS3L1phRtTujDSjegQiglFzEHMiK9eKiyItD0jAkMERxTKPn7PqM6HONIPiZCHRMNdA11BzLQyQqcAUEBIqmAKrMWy713MYGPTdB5/CYNVR2cYTGkWzqYUIVWJswCUYBjZdOQxuHmC0a0VcpyGL3MAqvv10Repw9xx39YVedLcrPzwyFCaMKq+J0P6u2hr6PDSyJU6G/GhSv2VUaTnr2std6IjIkqXr/TG13YKpf6Nea/DvP5u+SsmKDt0Zu5ZLybEd9jPnvhW/Ux2ZanVPDHqf5Q8k5OHlERHXkt0kP5Yq5obA7AgZhhGnjxDo4Vm3mN8NG/LenJ9TC3WnYnEKq7TjsSlYlo98JYjlO4b3YPsGzhQUYtmnxKKpMozNdCmCBHOw3IIunCD1nPfK3d0HX1LDLHW/y40XpdXm/Aurf5aEcpuRyKSpqpCtJIz9wCDASQXJM4YLJUuGmZcszfUTB++nuG00s0/K7AfeldNMFvMvMSEjSmCbkJPUBQ6VAeQeI8OMmJhFB3AFgESRL2F5HYIAY6IIyroQomvoe8T0aA3JjAz98ioph1FMhbKVuHWrEv9KgxpSEbRxYF/pAMMhpIYIo/BhyO7R/cZ9ysGp7XjmKmegCI4L70lO2CTrwqXQbQvP7T89eBq4oOD+8jmWL7Yqtphc+WgHfFu0lSVyQWafqKUTFNGQt8hVb2iOp7Zfc1n3tvSZtd6tDPjkUosPD9rXCBpqZdppSssdknzPoZ4OXRp7hXOuAy96NDX1VZcHBR9zcPIAnAjYhyZY73xx8DV098mEYfZaGPml8gwnByqKJIwk2rfAiHqBAMpmmqRSBQion93LMM3CfXDonZayBop4YBtp48n/Yj0EI56DXFQnzLmjYgD3ze67fR9w/0u9x0aZ5xmyGbSJuQYCqowOPVzNA/7GT5bYVM/7SqPyuZ22iCuKy/+qiYO2NVfzqK+dia9a7Qpjf1d2EHrcB01spLk2p3DgKOQRBIhRAhlf25UbLjHYEkFphg8u71iKp6cXfTceVl3cI4RgZ4s6gs5ZqKNBMxA8hpKlxCQY8OChglJuEd5ZiesQMm8ekAXzyXDTvJ5LujVom9EFDL0Tf47z4xkDGKhR1QfD2YFMoYo2UVRMHrm0XtEqzu0OmabI7TlA5KcFWhoAG7IuvYZgHbb5rgDB4OiJDcWdQPmHBM4pLBH/ef49XSwXe62q7AqAyvrZu2lRroJUjqsA1LOHgVrE+6mKF5FuJHXTxRojEAyveuFAhSTsDBBAxm9Cif/1olj8HwKn8iLSFvImiHQL6K9Q4ZPKtFXOzxpvNZ7I/f0Nz1ASgoYX8/Qzk3Zje6it/MaelGPf1eb2C1IXV7fNQkTBeBp+TfUq4rAIhEIhsolyqhG3zzUx2bg3M+CwXqVkuAym4MjHrlReBU0En9tiLWIiBD1XtD5s7XbZPUvC7RvfC8Yn4GfaSMKGyX6u+O+IWzEO9PG6n8CqrUphQRnDPZugDM9SsxWGO9kUBuAk/8zCOmmRnAIgLtUG2vobVyxBp5WqI4P3a/KAqLG3eb3dRhWMf2qTri6vNVZptFIDzE43ykhT3p+NskFnJoCNQa7AK+2Z0ztR4XiV5VH22opky9JZXrIz4rZ5BHNDOAgBv0QpYmVXVxDMTdhYBM3B6nBNaYEW9m4Wyu7evT1hDLNBnnGf4IIFMDJgUsoiogkA606AZ3ft3uMsSyq8kNxWUE8+h6pky3rHfW5tABSGC5HGBHZC9rPHQs9rT++COql+vIZ/bX5HR1L9g3pnXp+nJ3I1GW2UmIzSESI8m8DJwKnyH5E0mKKiy6xQLqwQsr6i6ifRp7P+oflS2byXf40A3A7Z6MqCbRv0Ytf3nF2mf1a6fzzqy6toXew3nJw2/DgYUoZ5FdvBxmJcZquWJ9CUAqrJBVARlDfevajbg42DlmJ4DKCkeBD1DzMkcDYBSkXQLbL7uRI9lDMTuF5vwU65w4HBgfsB/ZAkZgDbWb8IgpMW6B9w8cN3+/y7Y59Zw6M4D62vNZPpi5CcjZMGNwZlLzqnO1duIFlMNxjsH9oIzPlmM5+FfoOn/Mp+jYHexj2FNkuTDNwpPL0slfARQyu7MHpz4E6mlA9+pYHV4v0s5hgreiy4XldjJgEnNJubMRMEg5wBIs8RYPVRcABEsE3yBNCsh1RQiBR9LJUzPkhKqdU5fMDx4HjicMY5DOlhD1K4L/eOgGCJ0DgA/GQ+BAi4RBFw5QDoBh8SOX931ATT38lsWFp6K8x4Myey0JB/ztweNyNiNrhSGUFXdRuyoCJ9VOHkmAxTuAtxHyU38V4vMDI5ohUM0tVbMZ6ZyC9LuAc34onmmIw0PpkxZw9VFfu+qPB4NzWWCcM+E+mTKxNz9bqJSvzSS/FCq48FupZR38bmdNof1yag/UAbs9i+Qa9ntlV1aJvPtsoeKKqoC0/s/8XwCwjxxUx5TMyGEcAtVs1ISroqvHI7lJzQRMxU0Jfr9m2BQRBGPSUqNpmo/s6+RyI+hWrjl1JMIBIHGVP+mdizXzJtO34+Ca/mP7Zf1w6jTyigpjl/6EIbCSHILppdrRgyuGUIqawMbNxj8EaYMmWgkPIlM+SObGDiZxbo+TcwDDYSUvmta/+1iaIT6eIonai9wzMHpLXlRSH9ugwuOvNwB68xmCmavZZ6KL9FNNMN87bfkht/UHvflW1wjX5AJLONM2hxHzQFhMAx/TKRMA7yQ45ZIuAOls9Y1IkCsQS3QlwSNRgf0Xfg55m+m2QDEgfHiFydvOKIEVHBc4oiCLqE5Gm/mp6Sk8GaG3GMeufXWFpFgr2PUvFfRP6PvVGESNFcXYyW0EDENL5hTmN/xCTXojgPkgG+6vgULxhxr2WuJ+C2XFcf0n/Y+LQ2krTE/vhlbfloMBTYXg23PtFO6do48FOXSyUY4jtk0kdb245u1bZ2jRT7UKsY5rC0Hxu7kHVf9aN9NA70zz7whd277iirJpfPrf0N6ZoGqjNBhKdU6G5NazR14cJFb2d0eWqtwH1qIsJCKMvcyBXmBvyv7sOx/pPIUi2vybEgvuiTxedPqpK807vuO+43bHfOGzZAAxAgKdhgKqekZY1AXhqMCdhmMEwNzFdNRpMklMse2FUpl9yvHatf+7TUK8ZcHtwpH+e0V/Pm2NOG4IadF9VULe460kwLizDF3J6bQOWXiZO0QtC3EJv9yMtrXSA74E4EpNshzyrbUrkKXQjAuQntiMCkCPiKUJCzygReEQzAyf0fSIq+iqMQb/zjkRGiiwakh8iYgRTNuQcIkeUI03rIiDKqVObR4q0PNRVcOG+yQwsedcViDmIHRIbK/WQ+D7pqRNTXkDohHWgpNrIljDigJ0lMvjAEZUQ0+GR2GAYYE6ubCDwggH3s8lsfnFp/3RVUdzchuW9ODNeFV5F4CbEOZEDly3LzvqEWaLDNf9Qq3BS3GWTcHoQycVD13+pP0cC9Ny9zr05YbaCYtZFewyGTZj23CYMFTWINs5Qk7Xd6RQ/fklUr5zasznbaIPZvRtdIwuQ9rIuk3yhpYzwthW9mpC3ZHAMJHWDY4oOCFbnaa96ETmk/g4ixShRgTymaEXzu6RhHnVKFu3QK7HTdCQAPViC+naQJCdKH4R2mMUxxdUlDI6piUSFZyTSlpX5vlrX2naGz5FIDUesPbCm6Hu699Fa+XwFfdd7Ipn0WDskwVFKxLeBbkOC60qcB2XvkPUZ3VdDptH9Rvv+PLdrwo3sz+SPvehY8nLKF6pGeiN6ijyjIYf8jHRjABJisgFrzg0iyyaXGKQFHR0ZfR/0w+MWHCQUEinbEweTqEb3AB8SCQhChxCLDuMyt3oGbyTMIfEl9FWj7zN91fLE06D3wMNYb/7sD38XTUCwwnBEZAtblOR4EVMSXbGrSNh8vxkMHH6yMeOxwfPwxTXU1nHfCneFztEXwKEGXMA6htS9eOQlQu6kFBjOk3KjlObsIKOK6PJDyS6ySdjBpFFhL82HMIxNWntMLzhuLpA/lRp37UjjbFUppedwNjtz0fp7xfSr0rPeIRjPMnjUF4Yjhz5YFO+icOMFPTMG95XEShedIo8BnUdhmzF4H2wW5smH4NU2Po2d/0IDdkFMgJlUJEH10gH7B/7yIb/ccb/RlvY3zJQ6UtpBxCZoiYikOedF+YAqhHznypj0y6m07vTBS0UFnYqjUkEDpnMmj8FeyZyezwjXT9G3l5nvlUugURTIPh+1lwZr/SmvzUadkQOKqXk0FDyutc3eGFxaqbQUZ1roPJvAfadjnyy/EPbOn+ma8nSGD9OK5dZrOO8rN6iOIkHoxunzjkI3wUYAsMVN99aIObG65dxQ+quEUtmkou+Bx4EnRnJkHkzELEfMAKC4SCAlwSG7IyK5KkznPkn/Js9nAI3dV/L32fhbeeLr0ffAs9nKND/zyiUuaVYRYzcHocxNBIDEz1aVv3SDtTPo9WdnGuYh+k7MvXm9T2Vx4C4BZ7eyJuLZV+3SoST/rAUGA5VbltRU2N1gu9jqVTgz9PW0w45Uj2JOee1Io21eQ+/sE1wbgKsaJuh7hdqazLTQyq37QDvvlwC37Mtn25Hs9z6ySxro9QV8KDCcT/WBmFJipRm3XKL5NziF7W5WP7rvxaRxejBzUrpKWLVT2jmRCOwAmDZVPt/k2zf5uGPbiXemQGTrPF1EG2+gqu1s6dOnZoMzjx/ScOHOHIsBtbsqTc6svp7JLghdPRPTr5mHkYBD6wRqDIYD6XhZsRzzZ3XKVMeW4AyQhsGCeuEztATnhtMar3fIAmChwx6Gm776Z2G9fFuSX8DkQdj4sx4+IzYGE+3HluOOcMS0hInZ89nx4OOg54GHbnNmBlTuIgvz4iZGxNB98Bk7SXKiacPg9BDSwznhJc3UY15FAICQXpRsaopm8CGPiKhZeLz+ueQooEJPlQ1s2AnMwgF7StkjPt0uufJFbTuT2bT72nQsfMqA2wqzztw4MTIM5xiixIa9UjodEdgWDiVUqdu/IaKooydJKwFbjLss0/b2yyt2H4hGg3g3vdl+R53PanV8hru99bc53kivaq7A2HHfHnpfBV2g2lI6heXklHCeE1NyWUp6F4++tr7szbHUesLU91W0JoNFZLNGzGiVZjhC0NxY5mud002H7IEVGIFTkD1nxbJu35ISB6kIkJPZcYQEhIi4IQiOgN2n+kKmxTvud/l2l/uO7U7bTpz2YQPULYbznmy6GxJT5s6U1MJZY4ysDU6dSUGVqS0tVu2eZAHB5FDTJ8NK9czVvN4DK0KyV5c9DJRNkJL6XKedfHkaNu0pWw33MCwjE6/frSHW2Nxgdk8CJzdG4GTP997OQOcUnUizB+kOg5HX4zMqjPJjkKhyuPDHieZtoHPuEbcnFn1hzq/reWDfwITtueklSnmBvM8oRJ0Plf6q8vmg54GnbjKqGXaSziqtow+L0I84lAQLhSgaN5yig5Re695fRtD7udVMv+V4ntp0iWAlxQUqNNoqI8HpT4+43TyCDL0AFujbRAZfRN+ZW9ZFa5/dzrASOE31SPJbJ52jCxIjT9zD/F/pTykaaU+FgRKnNEta2bvXcVHElRsoiqP6jTduesUTbYK4zdk19FodS83zCnTb5tKfn0LftbwXRvUS+jpfwiPH+J6wOyKNmQcTR4lJ1ZywKm16+GqfVRgUCRBzIeRDsVziRrt1GAbAct9x27HX9BeKu3SBp/bo69ya0m1Vs26Hvla4ycVRfr/3LIa9bcKWlmZgVOA6qK3fKKnZ+qzRWovzVXJG5Qv9dvr/gfNzLrDC4FmdtrhYUGFf5oKZ+RL6NqfsdwF7BhFtrL8lMN0UgMN2JF//jGrJY9kn3FAL6+OJR7PFtxlBNaOsOVJS0XMKJZsrF42xkKjJpeJDFeuVMlEW/TPydNbrn6VTQUdc8r0aPMNORTZE3wZ6afRl2TZHcBNx/6cjNOPEvc7bC/7aBneH29HU1al/WWxgmBFjPTvl70LhFpTjiAoGZ+j1scIWQl3ljtYKHUdkZ0ax1T1qMkpZYYgMww2Q9Ug0dMuaUd6hMnkmC9xNBdLBL0Zfff6U8z+/Uds6+qgBV1tSvyr1tkv5WGklpGjggTWHuNEET5tIyUaYRMCQDZS+CwYzQpDtjo+73O/YNuItJd8AEw1RIQoI6T8mRKFQOQZXrDffSJ57c+5oz6Yo/XDL6xqqBzd1OQrINVRQNnf1HH2H0Dt0hG7qFykHDYbF/bjoxtVKg8GoSXBWUAsmGFyTYBjEtkBeYHi8Z4MzYl9bO1zAXTviKa8aYbagx2ljhIAtIByb5DyUh+5hYMmkXIihD91RJ61DHoJD1xW6wmUB3ENoclYUpExZQYikDOiZzlkK3Cb3K8keWPnf6D2fL7pfYWJtVcuWJGXX/qTnJngCW7GvDwyoAHwckSHxerOjPmOGllEMduFDBXobFbRH38VOcDl0Uk13ySTPIKEYxaCdeRJGNXhKI+ep6taUK1ClIstTA6AqR8qqvJxtY17P6KbOvnTKQGus0ZbFesr7TLwkc423TlJ6UGblB12tJztXc8X43SqtNcG8JFWk0JzgVg5ZZrygSGkzhphBtxp4qoL2f2olgXadkAK2IFvArl7KyN+L1z9bXovmDlVrLYgRgQHIRsQByaVrx22X2x37TmFn3pk1A2VwYZkRCICkpSR0JtffIc/Pfo3gYFU74ECuDGZp0JGpHOQa26j+YTXrwcy8u9xY7s/SgYkLdC5zFX07llwOSk4LajDcY3DucFLIp+0Im2/WaaFLB/IPBVO4fZNShkQug57s/5NEleNkWO6GWwzu9NXF1F/LmHb3yufmT6ccABMp9Ca1c0AUbIwtIG6b+q8eMWe80ifmgmg1wF8NwFGeeaPvhMSUnC8egDoQnqh5kg3YrTjWmoBCJrL7FZzyGUqRFadRKZxfkkbhxnnecek4CgM27utnEDhMzXUW6R9KdAkxmuPmkJULcAbOd25NxWB4jcEx353vZP+7vxFPgmd3beh7obfl47LvosWnCQA1h3udbcOAZ/R3zXpjdbwivqakuSjvOX/QxTDh09bzmO/B2KNvGoTCGnmoidPN6mR6YEHsM06bi3VvADYGrOjrF3bJqRgkSPvKRDBDovBGiGBCZDkoV5jQF2En3olDsvWSx4PaHFsxYMU5hmmhxdaIyJTXamigl2roRbkKPhE0dT/yU3rtPfZsLeac/24xR9ldt+Wp6NDXHW/PZqBN7TaGYV8zkRB331rxZ84Y7Dqdbz9jMPKGDR6G9bhR4eSqMsdgdDrtWYFXVdBrGO4lwUW2guwbstoZQGLAUTYRiZqbHgBwaMIWg7pKo3tEHB59AYhEQgR20EO/4aSOQ4wpSSw1ZuBIRQvtVJFFJGmhJc9oxfoLtMpn+0+vbTNezelvo4L2+reYvT1Fcyf3z/YMff2RmJNB+rnea7Bj1lQbKsNR4bXisee+M5zmvGV6tAMAZwzOtUWX0msFlg3W5ulpXP5Uu9PfoYdJTt77V69Fh7sz/fN19H1Vvggfi6ThcWYGpvL6gqIiakX06RK5arR28m+GlpFgImaBblbYFLB00wF7QN6QV3hDKB+Rx1331eQOEwsJSMF4wxYlTyzZP2PDtmML4KDoyxQoq6ABdfPc8n4MoWhf0n8JhgFFa4Ykz6zMLD3fRcWMC9w20ItOr+t/5D/Hj72BhubP/ms6ZcCNsbbvGNHgwth6SicMhlNHa+GyxOmjmIq/FXmvkLKwjkVf1cLwMFk0u7R8CwyGQ9leF+3FP98ruuiZDbiBakPfLSS+e9tAnBTRW0DYEOMGQPKmCwvdY7GMEh/STvrqQx0opP2WEM0PS9eqB45nGt7EIgxhASJZMoZmwBn6Dqy/Nf0tVzn6a/km+9hfj8FthqCco1r/jXQE7FEig9XYGWTzmzR4EPX7ly3ySjYS6/7XV/kAkjT3pagn8s71ZVqU5Jo+nWGpzgVo5m1XgB0jyT/IVhtotk6yH3bQ9M+N8vk9Mbx8FcsaoJrpn2eZNLwJycRjqndVs4Qb+VReQjnN1qvSe5x53c9FWaTBgkNiH25nGTmg05cREO1DGwh31KO0ihJem5NjTgMJFO5mabCQVdDRVu3dayLhkBrigLCBdedB1TzbHEjdbGlzsmfA4vTPjaEXmdqe4i5q6GVX2Npv6C/Gf1bHmz9LnWfW3yqj1oT1Vo+0VkePdM6tOtoXTuje8eAiXe7DcYRSKb9KVNlv2ACXM7JopNt5FbAp2txMTLheOJO3MWc2UBPrpre5Hk5XKdyGALP7bkFhWLYNwNYv9omIdBvBRJssy0QItIvEQLC8rLBp3T25vHF3RYJ1uyHdoJDT7kwIoAOaCX0wT3vrL0aWVPdYK89nRd+Dnoq+6jvmM/ONLcGiCJSW7RH7gScRb9ifeG6yPelIGx7LBqTfR1G1TdnwqXhH7vxUk0OWKaJL4fTokl80I+SrVmrqNitW2fepdS7r0ddDr4fbBfS6RTHyHZEdyRRkjM4y+nOIPQtrdHcqP+H8Henvoc2+6bl9Iw2mco3B5SP1Rn3XiyvoOTP94kX0TSN87oTVGINj0nkkdbRf4kV/C25Fe70zbdMUkS1KlPQ9SQl0eHeQjL72Z18VI5FpAgVic3v21l8/DjwjckdBmjsXGYnd6KWijm7NsUPctT+dkjn92eD3bP/BvolmAwYr+Tb6Do2+/rj/U6lwj8FWwxDUB5mfVUqQ9WQ8N65SVlVvEs6fbQXDqJEYWSnh3rol4K4iiRtxYJx5fJ1tw/8eXq7bdxnuaqT6FoQ5MWBg05s6RETSdlIi0kxGZQs/zWzXfdUefXNKj5YEqyO0/afp6SjjjMWJ2s5u4j7xmA1tM/1zcrnKeaptZ/IGfT305gx2sbkLNYqDcOCRXhwOBtQnK+rLpGdONYUmtcXQsgunZ+7fVD/FNHkoMVcsXxe3VXMyAFu2LDgnrD9PbF+m0iWRZn5cYK1fX7rFqKe5o2c70kX3ta+0FPWZiyD4kh/WrPyQ9UoqI8jdXmNh7+3fcFOL2XUJKV/2hfYpt/xBchsdAkmn7TzwF91uNxVFreVCXj4iLxwpLRApbf+lUe2SYs1tVpcu9RQTjuxpS0DaJBgUymo4oa8P7fU0FzV0UXeQxry5quEl96uFvOCN/I+SMRjXSumvlAE9rQl0/pEIbgPSHZzroFntPQxHjhtRHrzvCX1ve1JEKwNGIpryRNykJCls1puNYtPTX3YR9/lsRPL3UeR+GAnewCJyIOfxiQATS84KQUXzbKEdxWI30j+bs5iPO4oUDzx0ne7RVzE1+Zz11tPkGHlofE2gXcEbhl4EzUkZETiH4eRACO5jagdvamZ09PPvEn39b/OLNrVnRZRbi13FgN+Q4YUN/b1eW3E/nBdITeS1ZoOFjavjKUFcWHYXWZ0bwrQ27g7YlWMtL6mjF+j7nyuWDIvdv+qPibxGt91/7RLKqS4XJpKZ+K/DfBLtSKN/grqwCIWsrkifRs5DqX0WKdCXUMDhAWer8BPYKI0Nn9uZC2dwT6bxaaqPG+UtR6zkBJtnNffSODzng/AHZzQXzp2q2bT4emKsd6RB35r4yihL5YmIe+inzlm9+AKoNWA9Bs9U0JUiOtPffVMGLLcdYSuKaGBLzLKbG9gl1tHhnmzKwkwMcJSoW4DZZ6ZQx4JIadcwACBEMDRdg+SDZZwD6qRECYbtUXi7mngX6M5umszDpMzbLL5mAC7oq9CrxcrmFEWeUVfoxJSdohnhoEfATm12aE5bkIJVu57tqQeDswvfa3NND732/JuE27lYCec1jbS7asBj/NaKJdC5Nv3qwUDsI0OSumKueUY1oQB44cOxgg0vGf6+IsO0WU7tnNryK91607rBRFZKOkC1W9agZ7FswMOZy+rp1d059RUyxl8J/CUQIARW1wRNUsHEgpDUyEuO4TcGRg2Trglu/uyT2Jgq3teJPAItsoDAL6GveXq79WWz16f/FpJuTJPdHgCrf2l5fenZ5mtBEYFoIzwYgbAzDqFA2FmEKBAOwq4q+USpaWNJy17KO4M5GDb06hnwUOGMGnrRMOP6kivRR2vxKGtVuSgD/bSlB906HfRZK5EoDFyvi7gRWXW+Hho29UxbclB3aU9fp6zoa8hHXLFG5+YxGPVae9R0soU45XNC39sOJoRN7cRbjuGBBf4OGTBUbZtBq9dCO80z1BeaAUF84rGl1HHxoOcmQb2xIEb7k9ZXYTjV1kVV6otPS1XnlGEMtVE+F+KbNc9GfPUuRI5er5uXGrq/6UEIgXYSFkSmTRA1DR6DhUIEA09FYuPEAGJJWnn0rNHMbP07Gz52zPXPzXR20Xe3yVw9RN8qmmiJvvbKrqCvFIfw6rk0f66luc2JTiiRHv13TY572tp7rQ9L9mzY74DUd7XUswTX3vr7n0h8m/CkZtya41W/T4Ohr1dBR8RmVag7bOV04tXkU+K7Lj8A1UodQtrxUMNbqi3Pq0wUSJ6EILQTDsEhCIRD6GDcWIC0cwxDyBmGATQMuDf3pmJDZNUjdZmWHLu21rv/Lvx2M2qQNedTThrQcnYiNBhePN66fsrXps0YolDQLmn5XvPcrQdfy5PW+2p1BuP1tdpvwH2iPpsHOgyuSxa3sV5Z7ekvZd9/Juwb9l3U6HvbEQKY1QMLhQFnhwjpDKtI8GZsMsFYp3OGHlTAQ/ZBC9ifeIAAAYOfOAh8ICYVtESAA/KKsrHYZehNnUnJLKvUV7FsveDjjhL6Hnh47tugryQ2nL1RwGlnU0S1nlumEdVjCcWII2DXZB0ADImLahqssT1ZUdaODp7Q3HzwfVvvdXrh0bc7NUjMa9Jz32GBhUi9WrW0HvYs+txVo0pyc0s8vui1NGxoqJEeqpeTTwref3Ozbg435itnUXw13hs2Zv19SXqjcg6ZMz/qwUYOKu2SsYuGdz5oxQCMYmmavlCbDUToSPNgeq7q/GTOJU5EXaY3xoOxC2mSfEXiKBRZ1Lqt0c1Moo5aQVNP6B2NYLjB3eqUHh8RX18s9S9bq08xOMId9AUyNMyQ1TG6K5tsAbVe2kh/FCJd91jnhyT41AOra2w40UwTVfq1/FALjU4RXXtQO/fpXLg2G+vQbLyvy1lPiz0D1v+Y1PRrN7WhQ4I87ss+9opqghg1C0fGLQEDj0C76XWBByEIHSRpgzBFLABEfMgjIBzJVircLd7q2TNN9LohvA5zERT78VwYLAjKxUEIskcw6BH19Qh6A3AjtpmERVhFHKGQ10tpcrWeftJx/WznnR5EP+9+1UizC43R365daTA4dvsgTZuYn2z8sExX7NTCqu4bbGleejJ/+Y35Zti3rHMejKGX8j+XMuXUYPWwJnBLi3LF3Ydq2Fh5K74gDfRed7xSsqu5OCSlxDpc9piidu6r9WER6jARIQw8ETnlEi9fhF9nD3vi/QpDxuwj7WCBA5SJXVGhNU9KRA7CIXhGHA6GH4wj4BBSMD4EB5NANhJwBCgCW8Zgqmnr0NA7y8M8QOi6En+q3HhtqfUHhyk4el3pcEfCr5Uq1aU+hRp0NdYCSM+o+u2U+OVUPusKk7s8PTh/YTleX16ZaUsnRyX7wkTj7BxsoeVMG6fY331LEUdq+g2bmi6znx9vyiyRB3Ejs6GfvnkBETv0ReKXYEJkYggYIeuaGYSAg4Xt05JkAs6FuruuIkDS56TLufQ3w6Ji+cDBwoczhepeacNbmN5Uvi+RIzVCqpvaPbP3pi/WhZ0YDWImv/tQi8EvyWeuHdVmgFfcRy2piNFfJH5cGVObGCRk0y/KLANcQN9lAcDB8FxOWPLadaPRJPs/F95Yb8ta4VyHFw+SP9tC4aL3HCNExDI+lxf5RaT99sbaoQ3YFM4N9+1x1wzAPcDrhKP3GFwWmivGby95QZzQlyGHQFSZrIPNZXEZWN9BTEJEP6MSYtmZdoZumn4P+Ml0Y/oIcghuDAEfJDsDwEZiSaS9ybanuYt0Vx5KT+2YnrP0iugGg9Hp3/rVP9XlX5IC9pDh90oVsrboa/1wZerrJ4+jWjp69F1LP49eQd9FZ4ZeKkwIGmXkQo/2PcUdGfpq6Azz1qd1HLaewV2NowPy53cis4NGFpVPc3ZXPnBEsH5+JAhUMvvDGdLSfUm/72lxykg73gvXu7GtxDOGHBmcnbpJWa9au5kQA+2GwaC084TOK+YCCofBtgmjuCRTQxcqvGLcWsjMZm+nGnGzJDk8vpQTf9KBq6I24Fr3o5NUTsgyEiqXvyCnVBge2y6nhl7Q33E3zmy9fcliFapV0L374T9MNHwotl5+HF0my5n3lqEvu6wvyZECEUnPVELUel/LUzELGovoXCGmMHDebU18lyEQCxHJ0SDxU3amW8Cd6RbwEegj0AfLR5Abyx7lHuQgCSSSMngIEwWKjEFAUfs862FZ1gclNICGmH1q4un2ACbfAW8P9hZiV/+lx25XNdkoS4EIalZcXxd01NuAB05YV/TPMzeui3bl3kvLhLMNWOnvln+o+1Uqw2DeUHs2PRE38IHD9gDWUFpNBC1mH7FkWJJACx7GEICnYCNEBS1QWlYfeDAxCz8RNS+HGPoKxWSuKPym09jkzqcksckFNCWKQkCaEXQxfhWSiYLIQW7IqMv3jH1a4oIIhLqM4EgkOOFiob+vctlJPNj4Exxps0/QtzlVKEi3/VEpIOSngOw7U93Ymn2OMBgGw7mG6k9xSPlVskDct0nw9d2QXopHGlZ1ShNN92N+yzOLSe2rHHoWa5sxWC5oVIroaeWWwKcvYIEVi1sYVdgmpTGJEIY8M7aalcTW7r1DQIQwEQsdSNbLvBgnTQH/FHlEegb8iHhEekQ8Av2I9BHkzvIQ2Ul2lp0lkGwkgSQSMyFA95fXMPfCg3vRs+belaMnqq42TsvZB2ighW5k6PZcH287tjAVrwuonHTpTwr8vWADRu9j5U22w2IqjBVa98t85uz/zLhtNf3N3NfJJu7bVnvSE3jmPYCf9Dzw0G2AdRuGKE81A3uFbfq/45EEDnQw7YLDSCQApsDCTMTCagEipd1CcDk+UQ8OIngzcMoVCdrAT0TJ26QALGAIJEHpfuChZmAWCCITDjnsSMzzuiBqn+25KPqmrHbEFu7cyCuWsynyoV6Sdxe+SUz7Ovv5zuapQZaMZicGtzWK6iqq9R/A1exwFYPT4s/BcOlAxn5KnS8lruyMe0UphRdJ8EvW30EcwddNPjP0ZXBMK92khUY1mYwi0zqYNM6q4XbD8j3lzR1Lzom+xRK2l3c3md3U26M9Xw7FYCI6ZODblXtVxpV3vbaNrmMUBh2CB+FnlJ3px4HfGR+B7saGg9xZbiJ7TDC8k0SSQAJmUOvvbdLgaw1aU1WwIW7jOdMEIy0gcIHZQx48dJ++KGPfvkYL/ZW2NScjDK5kSXCXuw6fBSUzlbASCz267dhvwly4L5ASReZEHMnr6gCeOBii6JtzSJUkjm1fM+IOMt5RcriAICISRRF16XoQMUkIaZvhyJKzzEMaS3BRyORo+tm0y+DotNDZABY5B0Rm1E5+2l1nWfXk9me5QbI3ejJe/BQz4pcrS/CarabOvOhrc8qVF5OdSKG6xVE5Q2+Fwen7px6DV30rUf96a6DRalKb9h9UQ4WHqHkRej8vV9D31cxZTQyS1GdnV6moG4T+NhvwDCkxcZUaWn/NkmIkeAjDyombCnsUN/cIU0HDlmXujmTuftWLU/wUl64qQzuNh33zORiSRc1XKBDCIXhEeTD9jLgd+BHo94CPQDemG8udkcCYo8KwIIKZEUHiUmi1hlIL/vESOoxcDCHR/PXzYKTGx8o5PJuOGug+mTrwt8DwTDSHEvUbEWoN9Z5IuKBIf0+kmVBmZ006R+hByehI8BUxVywlvvuOEETTbuh62BiwjwM2V8ODngrDBx4HPZ9KfKGU9xCJIodIjI4E+9w3uKxWijmowP4N6rXYPaLTj9C0zQzKe4WqJppjPkvEkCPpqImRHaHNaD3stmfASJNaGCTYQ+gvt2TL3Y1PyW53UydHMELl9zjEbOMjeyEVUXA/zDPfYzDcN9ZPH5TVOeLW+5x70HhsGga3t9lt9PuqvH2hSr8auoi+vY3gIsykiMvsIbHQk3MOk8NSBd3AJJzSOP1Zj2HblBDZHtwEtS+SeMw0QP5peDXMNDHZme5defDh4Dy1mAlxpLYPTYw73Is7IIcAECI8I/0k+sH0x6HmYfoIuDF9BNwO+gjywfQtyI3jXShKRABiDAEECaxjte559801Iz0BYdY5z2+ZeOVqQE3ljky3btIqPdacqqaBtA2DbglclTkDhFep8Kx8Qc1RZ53r8mvNXRXFXSApnzXv1bbJ7VbZfe1HjGDeROSJKHkf+ycOwfGgnxGHaZ6f8uOQxyE/nvFHlEeUZ4xPqbM5kiITJXOvWnyZtkA7Yw+0b7gH7Bv2LTtlp3BSlHeoHtGWRahRSRlU+xTt6XZAnMKLOVtn1VczkeADUa1iTBwl6ZxVIxLrt5WsU5QQl0i3Ew8efQP2nDaoToyV6a/fZehr3Zgb6WfVIb93d9fygCEhvp5UcrYu1CX5S0pXSb1N4qLbdfJyI8EH5/Rq4Wur1QX6ejPwdZzuSw6fQL9Cesnvdxit6TVAGghgHwIAzDXPdnn+4RTRbgxTDsnzVFhPRVrF43kIX+ufu+6ROI9odkleGa2mytwJzZ/fjrt7rEEX8Blm9N8ybCz7qXsvz8w5DsEj4hHl50EbJy+tGye99AfTR5DvgR5CH0wR2Fl2xEARBCLxYBnVAOR4agWlpJv1AZkZeyAcX1KfWsus2Cke12fFNgPut0KqPZYL/R24PeffPgfWSQBSPj6A3nxkgLtD7+WmcNOr7nhlMC6FNTmkc34OQTNv6Nnyb/6hTlgSIbqPkGZLtm0M1O57yCPmfz36ikS3p0rkHO9b3RLCkCCaqBmY8t4M3h0aI3LQBAH7yUt9oX08EufcGr3YOtjGjDlhUcLgZPpV9A20G/H16BtkazTPhr7D6WbBUNfKg4uE6bIGorW3vWeBW6DdDH1zyEQiwZY637RHJlRpiV4A8yszCHcBwZ/lxJ+49uW2JmPA/BAb628vzeBsA4fyGKaKJVcwjBqJF63YPpinA8zlSht8+Dkuq+l5tUb3TNrT617z5NF3U28Dl1GV3ORgergIiTHZpX4yMSQwNiKNXLol2zB9BHwL/D3I9xC/h/ARjo9w3Jh2iYEFHE3PzElfNHib2gHdEKKMfSWsZYUhvvAwI/SfJ1T2XBKiSseuG+pV0qMv2t9WYNpiW6ceLHoC4DL01n9OoXcplbJaDcA+8aTS323DtqUNxgr6phlwi3VKKcsklVI5prjelE65NGymppE6gEjZ8NRBqQmocDuDVtqDWYCNJo72X9eRP3VNl0MIDMRsCVZGDgIJe81z8sSisurPSeTTBotvEF+kiWY6R1Q3MnnJ63lq4ca1lp4QNIzhHyOvZop+Kaj3k+JQeeALPWS0iwRC19cMpyTYtzL3wFIrwDhzeFe4/Tx7tbOhr0dcKlbbo6m/2aooV1vtwUAlUSvqa4s/4OmdulZmppOMTM5cwi7FG1NCX/22dRtNojLSAhAluyUXJxHRXEAR8tAp8EAgYlBQDE6qafoW6PtG3wL9ZeNfAn/fwvdwKBLvAoSo6bSQd2Ltcpq6eyRptNBcl76irmpMuU2mjrU0KZ5Qf7wJU80AzB30viEtUo7ONty3vvBPRN+h6d5Mv6p/vt8S91X6y1Rq9IDtM2HFDLR+43ov5AwNfdSv6p+JmGlTzXNhjaSbEe8b9iBbwB4kNFqj+t6LI/TiC+SUgiMtitWrjISZIpw3intuKyemJriZs9033RqYM5U/VTsPV/ojC9z0u7nIRPuweju+dqieaeqyJcxj86tdKvd5ZV5YY78ppf8McunrJKxm+vcw/iX1uw9UbfwNL3pgqZj6JxJCt3GCl5ZHul060KEmygColIZNmrbQgXpj+vXoy9lhdNbD0d2tRvVQevf+qj+EBn194QyQCFDH6vRA1V865kXRU4RIHgcekf4A7Uy/Mt0D3QO+b/S/A/2yKRsOv2zxe4jft+PGx85x59hN44nCshQ22Vh/R0tA6L2kkp23c6nBnfJhsacw3Iz/Zk1MLPbfup5KRvpnL42aepr9Cnmeuo6+tQz0yT4MCbW7ljkGw81xrECXNM/q/Jzpr3pgxTqwx2fC0o8fR074bNv2xSPnnhQ5ojxV52z6Z/QeWJQQiMBMu25moMSRwYq+aq9NjHMOG/bKJS88AUi2AadTly1nM/EuKkZ/Z9w3YLtCfDN0vaZ/fkP929MmH1F24u1Zr37sx8z621TovS69H9bVnk8KDnFuVrg/LJPj5/FFl0ueynVr7quX9MWi8xPmksk8+SGi828wafTGDVv1R2ajqBxYShlX3TfyahDwrBujxe58DEuZNN3gL+jb2ASRFmeSVSJEpHoA0QDiCIki4hVyBwWiQLQTf2z0EfjbRt8C/bKFXzb+yya/hPB9ix8cP8KxcwwkG4u6Scf0Vaq/cNHZ4sJ6zgoUJO7O2qk+aWV122fRSn5nQ8r6Z2u91LOA1ZEMrL8z0291WXXqJe57Lv0WDjONHGX6e8sbDpr1typWHVEbcN5xIW1poH8eRhmr1FEOd0sBicqGc7LGmBZWBWhLLror23GXO037NDR3Wvbg4MrSw875M7DEw+UNEIrqCJ0IDeWeu4lgYfRV9PUWX+g80hFfmkxe49uclJkdv86Hhu7Wi2qv9HYY7TAbjcMy1Srwq1XfayJ7RYZk168Fz2swU+WLPmgvyXDpaeqf4oc4/9a4Hvb9wQY7B32geDpm/LXrUHhMnC7hHul6MK+H03CEq1K6QV8r5DwDEmhpqgGk7VlSYQY9JQI4JGZNhmhquf0IO/GN+WOjb4F/2emvO/2y8S9BftniB2/fQrxxVDYcSBSMA8XAiJR3faiTYFzPGcldgskmj4fH4FklQ/9nEYLD4Obsmk8Ptkg6k+vlP+PqPParGoop5TWFiumfk553R1A/4y3FBDOn/Ex1X8G8WbCd7bhQ9alkfD3MSioSNcNGtfcn7cybEt9AOxHr1rn5P1bo8t5JPNoGIFsUdCUoQ0bSWN08EWRwFPi0lAyWnBVokRraxRq1u6KaE9nC+2Mor7o1vUqCPd9dl+E6125/1o7MiKyp7FT6Ir0DS7rw8upzxj5nkb7mMNCcLw4r06YGhZuGykZDnwDRK/Tl1YjhVDMIJdnTsEDIflhTe/Ca71KtlB70fNLhvnyriHaKol4H465KR2zQzn0pSCB+UeI9ud5e5/XrOdatdyTFMkZA9wbmFELJkHjkrVEBPORgoT2GP2L4g8PvB/3+5G8b/bLRL1v4HuRb4DvLR4h3lp3jRmJgvHMMLEGBmd/Zb8PQ1w8tT4VnGDwEXb99IZDQxxuAiWAereceWNz9ntBf5whNdhCol0vpqqpAuWT250imMLw4woQt0BZw2/Bx09yTsuXMz0PxiTh0rEjecBCA/zfdLQVCZN4RQUFNv1tVIW3Me4o7om2jj4B9o3vArm5hDFbr71Yl5kpuEbmVyZ2eb3+kUQqDjdI0LaX+Z4ZeXb74MCrl7sm2/QnlWCPXMfh6sRNvHbfCsBvx6Gueoshz0xCbS4s12F5fJbyk6ellTPK0w1kbtMas5ixNjjdAUjkBdTNXOu6rpcsbuTXtwk951cH1RoQq3iuYs6YsCjIJjjqYr+AuDBpHhLX5vT7oa6sbrTB4YPtYWWdOCmCCuMNLNOVAdHvAmO+nz842bEIgHoM3pKkTlHkwMQs9cAB4Ij7wBPADFGL4LYaPY/vtGb5v/GtIMPwR6PsmH8w3lm9BNpJ7iPeMxPcQd463cIggZGxTXjv0BFLxumgkE17zCc83bxhtstQf8cW8AZjyji6ogHP8RF9A35rXDt2eW/S9gqBzWeXDGlZr+uewpTAk1T/73JPlLsqHs2EiNo9b8ueUhSO7Q/vNRPvQo/Nuu413yM3y3jATJ1q8su2588PK13KEasZY0m/buzfoFp+JDRObIhq18llNvwFeBc0B+8L0e6p8ftX6288d4m7TM9eO1A60iP7Pfsrzx/1WSMjvpXisOB7M3geij99wLft7eZWUNEEpM5+a+eXjg35ULXys/Ck/GNlh8OfR97TYq03o+McoDGmtZJ6B7ku6mYWiaPj79IU2/gpDiWfjirvR3qz73xBKjqkEQSTZVGdHBIHmun+CDhwREvE8cBwSfz7Dz7h5Nvzrkz5SXi25M27MO6e8Wvrvt3B8bMfGMXA0P9hkLV4OjOzTp4sMu9lqA6VGZvrtPv6YKYUheQPwWCYpoF/WRb9UuLfUXg/nvywZ9TX11YagyTcC9ht064WTtngKwOdtO/TN6aLSEcEB7AB0h7LQcOVXNt4pYSF51uQqNr/SoB6p/hL7a9HA4pTPBSYJAEeJnHzH9ibRlf67KRKf+TzP0PeiFfZUquwQldY9wfCs/uumaO//3J2a1jlTPmM0If4ZIU80J4tDdfR1NDtlwMMNgAc9XNqDh/T3VSmgK8k6Gyf7FixwdwG619VCCw+pati89V00xa6kFfPQm8bqBHIbp9r+NRgJRtZ6a5UseAoEIOJDRG3KRwm7OJ44nohPHA+ERzx+xu1n3B4bfkb6Eej3nFRLA5l2lhvjznxj+WD5y8YP4Y9w3PjYQ6xSS45yYMXuSZrx2PytNIFlc5CWWuihqdhif03/rJX0+TemcnHroYvia5sFTp3U0G2jtBZFP9U/33aEgG2TLdPfVOfIgqCJOPLqUlEHnGLtdbefEPHIWxAeaiV1uVlQxc7WUb+CI2atr21ESIgBwQJ/I0RXcJLTCgaiHLEHIOmUvf7Zptq13k8zcvjNkbS3SuHUgUJyRCMTGp/nxvHKo++GsPZ5Pl3vT/t8YQLydLCZcRYT0EyMjJZZTEA01UVfl08qn9dSuj3K3TG/aiqnpt+Z8nk2AodmggaDT00JFyUvv0rEkbpBnHpINeg7g95PhqrPEHd2+fWBN/M6nNV2sWaqf2uNlSIkr4NVFy2SdHWqjqbcFus8lpWyeSaUCHngGSGIiE85YjiEHpEekXamnbAxNK3HRnQP8sH4I9JfIv91o++BBEfQJKCJemlWEFDnyTwMXjqyg4d3tE5kuquhr6TsMZzzbwBV7sm3I4ATHY+irm7qWwvOLDk5PSVwLRsfAaD0raa/mMon6jtzhf5ed7/yl2iM7c3v+xughlbOG/ACKe6oXJhtwFlLPWi7CQUuIb/5zvosHM2KWyRGOvzUkGsWs8SY9ZGyMSbppUnfCkFD4twW5Q33dfBczMBZOw1/ihFSyJGzlGaXkAH3fRV93XO4urqf4e7skljrYKXes2jdVn92jfpGFEznbL+Rh+uC/na1vebQ5Pv29haBpzJE3zekubtGLaFiNjkrcyXRRITocrMv74+YJVi3/Th91A3uLkB37BlwQdk7RNyTZcF8DPWul6if8CmoWxaOruaxreLKaNBpSjGYs4UkAYLiGoiFAvhAfKat0AU4fgdiFADxyQfzI2JnCUQ7I2gEJ2uKafyI/Ih2C7IzmEAiTOIBVWXoeOWPJ+KruJZ5MDqsHVYC942T7r7AwrSMAP4z9h8ctPIVS/4+2Pda07Qx9h23TbaQ8l5t25XFiDBvDAp5u2wfNZiCkSQKjigPDU/S7Y/8RoQ9BjtFdETlS9yWFIhGtW/CfYZ0ZLWzxSMd7XQ2CEZqcJedGVjRN1nvNE2BzyIySjPZaJ6vGH3Xi+7rcHtlwd6A8aurz6ENWH9YpQxq0JfzvIIafc97+7kv0afpbx4jXZsrX5KZ9bdq98z9aqgvbWD4tV451LFsya5+5jTOhbssGa6SE9A9XT6egGj3LXgIXFx4UjPVeyVlLxD9c01/h7aVoUyweNJbQpQKg0Ne3BPhyJxB/92EA+IBjjnz4AMHIqIEEexCz0iB5WckgmxMgXAL9MeBx0YCbMSBQiARoY0jE7RlZNLongzQM2B7UNJ6Wg2Nwc4s4meYZgYW9vS3f3B/DvrONl2oNMZfqNZuxOBZw9c4x/7m5M9J/4xCc61/6aB3wgrEnBQL6jnJzv3K8ClAEkTq3vU+q5TftwBJtctRYnCplSlhmM2h0ULOnctimt8531oUR2k7GSbnO43MobxNW2rSM2CHvqnkcodBk36iuUg0F2g9m6oWQ3oRqbDOB2Q/vEe60d/m+5wpqBvfqzqj0LxnWud4W7C2TF9z6uFJ9XrVuPBQu9ifKgeXz/lVyQS31k7Xux17EmxHkJdfUtadisosWBmA0SDTkuy+rcjpx9WVSj4jr6r0XYSYgCjpPp1q02SxcFz47ukHd+ScWQyKhE1Y+6lvLYADcb3LCPRKiRIJURADmCgQfTB/HHJnVvqrfWciUo0sqj2IYrcbowscSLuI9iQYPW9uV5DEkmptk28MJyaldPlU2qDl9Tjgi9JuIwivGTi7WEvWJDhVaDsSDq4iUA7/1eQbyfOZWvRtusrqgMTbTrwJR82fnNJoHI3yWTEpEgiccm44nuktwaP78tuFSoBGPTHV83j7qefZ/BBo5udhGJIuJJ2LbF465O75IMhMf3XjwhBduJFHXztyMc9z3/+Fp8ngTge8f0kvCi6eKJ/9fLQ2v/Wz5KmslTSFA5E/OBDpiv2p9mOc0eVTXfdqe4MzHXulMZ5slFS/tfx8Ogz2hY1mIaFywuBFT9ZGk/UQfWk12VDPt9+tfw5W80IpPbt9AphaJ9A43C7qgs6mszso9yURMQwWgIg1VVbM79w6qTmzglvsaljHIXgAgRREJRD9dtDHwR+BAwlBjQwERMXvmHfmBhCFFGXdjVT0l4milI2HE6zm33ZVbxJuMmxcTT859IJ+yfeqD/CdSOs5dX2xbIC9wOBakvNxyn6Vd19Y6J8zJEvNgCmACbLlqMFxXD8FFkTk0KPhaqDro0dlUYequeiHoUsK8zYqWmj9eJB3gQXZay3JwswMllMCATvL8aRnLpAS5EYcoV37V5pnvZ0mnqpPpNcrb9ONv6LE65HvlCXodFzKD4b3uSPVTEdHmf42amevi64D86YB3KX++XHf90UNr5qQG7l46TAI2KnjWmlBse7/iECPiVpPggHEPAWKw+BUQCx6W6tt3nhY0MErNt1T0F1XUvqZR5S/r1eleQ7pYP0JNOqB0vMuvnEoPhT4VCpfyKyFhjlkla8pvSDKmu1+xZySVnLJxqXVat6kA/KICEQ/D/yM+BHpx8F3jgKSxJMHaZ8VfYsxGGT3xYRDKIpsjENVKETqyeXduGbBSOZ+lfc+OgtA+rT8eVzZNVED9qzFxrdLX5iy3rT7wuZ2X+hqqXchLE5YgSgQswgJB9oZPxlBc0Gnvkqy/jYmpWb3ApF4IBIxq1WCApwTlmQvaF18cUJBQo6FR74pohJbFYWQttcGgwRJy6YfZIPBSMOdGXHD9pSnpeXb8tKB0yYTPGIAbJuhLiKOMP+Sh+h7Mq/NZ4f1RNUu4bvSF40vvW6Qmj+vTZh+h0E4jfdL3gxt33z92qUOg+3Pr+LN602QbBlXnyVMPKKrT9u6alQ12Q6r1JUVjcu6aHLYkwuTw2BNfFg3PfLYWtz4GnGvYDZG43kIvS9roXPxRjPvi0yzXtc9afYAdj13l5Tm1p1KMGx8KS1D84zUwzDyQAr549qUATMIFHJPBQCLZ2IROHKuL4+Op/hn6KvgeohiJ0URzpGdVXjSxIerf0Tk02CtpxtLj+Xf0SmyvsqPtYmv9cY6bZfUbX3X7FfJ/cqwtldBd8C8BaY98gNxk60kipqnbExZOFD+NdFrFWgFh4A1Ekl12kQcCpMwV5Hqs0wGYJ/RM3Hf5AtNAGdrZpRkWUHrjpEwWM0oTBTBhMhyGIPn7u7SjWfoRYLkFn1fkqleejQZ9S98RhdirRuSfjLCOJ3kaSdtkrp4LSZLxkYF3VTnzb2Y6ISp+/PiSnv47fRY3vTHT7U+zsT62WThSG35JuYwPGwlX1WBrkP6dGRIhXPhgsHWGf8uvI561quqM0uaOzH8Ty/5Guh1V9nTQPcJAAijPXWrCT8rdQx9s76tjlntkHgxG0c5gWEAuuFR8Oq6XBsRBUIgCoSNifIgESAIDoVq+uziMpZZ1w1doaRehVC9eUPR99RIrxm1QgLdlKHae2ARtzrqIQ84JbUvs95Xlvl9cuNVCuhZzUxF/7zvuKXsV8n9qr+kwd1aBY1AFIUCQtSdBojVUCo4NA3WxXsDqvRY5SBiRAw5OJgpQji6bYABEJA35lRVjN5mIcFCgJAg7UOi1ygGg5hFM1qb6XeQnA8ZhuFsw+WZqH6l3mUBgDf6usml+GR5LXTv/9n8XjBOXEa+2mujnYl6PD6VZq50ikTXT/d7FoB0cdV4vT/XpbZ4ta2Iq5PcwaZXQ28sA87ee7lH4uG6p2hHXStD0I3ZlcYfQX4vQ410ntYrGDYJLz7Lta1kdo8de3anFjqes641ixmvv/VIPGx31oHTRvvBc8Us0i/arKGCQUQROXt/OlChrybv1gJHJJ0GOUUGp8TLwbs+4WwfhfxIJDvFpOTVKCTYG4/zE6Dm8qahnAlrbP21VJRf7wLdxAHDfdjXMHi8tUA+VeuiS4XjjBzs9j6y9Moh775wWTYmMGhn3g6WDD8wppv+PdQRGsmhoHKWVpkF7A+00CkoiDPlJSLaiPNwLCtBSgOaDkhA2gjMyBDZNKS2YjHfLvXyJ4IEBEGMIlHzgRChygTSBiinr/Rs6zQPukPoXZh414zzOnb6qbkcHKZRvyCzeeoN9CVXDBW6X+rJ55b744aGdfZIXFHeEQZjBMOoeefQTow5DHvQ9epoO4KRRhoG4frwJxPLOjhnJldAty/WlJhB73X1yrCkPRPUSDyT2WrS6O/V3nQ32JhFGsNw6mEdQRBcTIFafBV9NwYDwQ3cQClVJBPthI2wMzYSRWVC2SLJQ483AHvlc/R0lpJjNoGQkNjfVOmDs++kqkKNwUMpTs5mFahH56kX9BU36QEG5+OY0NkF+lZ1jnR6LQYrTVSL757Df9NW1/p5x9WdxGgkeCMkzAvgZ9r4lvPmfRluqezOrVpcw+AGmRr6qxm1VAv9xIOIWYwE1266hC3vC6bkPtsnEgYLCYlemdxeolAkkfQvAtEhEiEieX8niEBi6raeinCzkufBC5o7owVNitreA6W/ticHNVTjugQLRujqfC/F0qvQu8DdLwHdoUNTyB/de3UuSjYwjIoKSGMX9G+qB+Ohyujing297dYfbCKU7JRhvB9OL2U0e1XDXMr4s0PbSn3Fe1po3549n7KVQl9q1GgzmE35bA5Qs+E6W8AZBmO0bsNoDHv0Zafto0rth0AEneQJO+Mj4MaykxgDFiHL+RFFBwYW6OvjgBWDJS0dvDrBd9V3XZA/vT7PZSqh7trqqt/gTnbVqQIaq0RXAFfJsLoC7iA6Hmy9n3PWU/S9Kgyg9X/W7Fcl/PcV2XQQQGgDPxIlTf5TpxcPWW9JdyUxrVEkqgrEk2A4shhAnB0CyZAp/ZtYnb4dhWGxZaygcTKMeXdFUQBOudYsWikYNmMEVL1NOt/pigE00PsSM/jU9ERjrOUJDW5m5N5A6GcodBMWJug7DDpqu5SVqFdua3ith93in9wV7p72uM6BOdb99hMrlm4vnuL0RmLM7cTGnLh2woJRWxfZ6anw2ipc3ftbc86roIu5CqdZzF1r/aSAZ8Con1LVpXk3bCT7YezR1+aTts56tke9dGuocOpt4wfnVqtZw5xy6NsPImRvLIQMwPeAW1JEt9+2KYeLwjmjr+tGOeK5TXBLB19hc+PJSwuaju0C9+3lGga3VQ0x+B8m0ZJANXM01frnkJNJOufnC+gJADFulMai2pMu3WGDzUqIqyMTdXTqP5gk6Z81FH0jVldAzuaQqjxRA8MgiIYUC6lrgCjIqy8fKfQiQkCIIpLBxpNjdJ9HI/0eLJ6dDJXMvVkXZ9PT2wo6lTEJWAKzs05VQOt7OJuzMEHfhcK5un0Hww2nrPrp+zNUfs6vndWzOHUKxnXhanqtTtnxC3biFCqqn/kccZvj5QstT6DQQX8fLzni9TImxH2xV6D3E91xfXCVNGC8KLkexnXS0/JvubxrpGa9/YrNapuOXkpNJ3digmqhS+tKfwPhxrjl/ZE2Es4hQH3NFn1kbs+mfG7YrWF27BJjXReZbHOEDEDEtUbaMnJMoHqQEbq5PUeOYUz3RUvw8o4ubMCgALxvfvsj8c7PPfo6nXM5AiDbgJOrnnoeBWzQdBwSdQtCLXrIs2SjdEkckZRyKYbH9VPV5DvTlpJ15CSOarPeEQLxTrwxBabs1j5efvrbnyagQVJH64+kpNXhLjl6Q2mfFBgeiieLM48qTLTNTf+zx39b7fDIMC2cn4uHvaVRVodhscWf1tACfWeddAFI5VtAVmD0PXFnuz6M0PeUOuvp9z6+/ournaJL/agn2TYpd56Um4czDGEqW2o6Koz8ir2luTk+c5NuujpEprVt4iLoolsVvQ29lYX72ttr7FYq0tkF+r6t0ZdHUDnC3fK0rUB0hlOZXOjF8LWhv5S9rhoA3hk7QfXP+p9NsikbZYuvVQ4NGY+EC1vGXhPpGjDslMYSOgfsqbyUr6PqQ4HSgf7ZHxl8//NGOYUepe2PNA5Ydx70EHt5KVA2CnR4wwAEGkoUzVBadgVG2hLYjMFagCiY+l8HT8BOxIzACBt2Fg7Yg2w7NkPfQLQRaYZx/xn4mU5qzYlahfM6CSwA5ZTF2TfMJiPb8gFA1B0gRNSLwDZl6p9LPzp7FLwyYV2nCFd00YtZdc0M/D1e0ULbwWbagpu5UNPf/sUtxPFj7+uh/74Ao07vN23itM4e3WfKRpV+ku3DUeC+8RpN89mOCsOxYTjiO9RLD2EYTjXtpaweroHcFdDFZNjMji+aHg/17hXMClcagu5s0c3UY9gGsB+9s6HbLjjqdWHDhq+Ioi/V9NcmQPuR0JdlZwkk22iV0CS9Krbe1EMCBsvc/vKLPNhswFEomOk3knlED83A/s8qIeXMEtx0skD4BNhGpE1yrFV3D63O/WTOsgK6VtoYW9DwX2wBxEkLPaz8TDYDNi+NDtn4rqGv+UhrLKLjwaz/stsk2P4L2IMETVm9U9iJd+KdaWM1ADv7aP1AKGkCWw8UAikGI0MvWVfStpfKd5NeWjkx11ndhwNv8RRfxV2cTUnD6eMFVUqzZVhtFfMzdS+n0Isl+jaa5+uYh45GNJf0oGikub0FN/01By/2ZBFv3VQ1nGTF9aHxna6uyn82hLjKLdoh8VQvTdIf7DvnmfGrMt00t1UCDU7N8Pg9BeHakN/0py88HMDN2nE4CNt63O+8CCtIvDZqLO7C10+Z+BoA1/9Vmaf6L0LRtAQdZfQtWyHVO/7G2oZil5yKLvOqbzQSQoW7n8r5PNNCz2Te6wEGL5SoqUDzp/++CBvTHnC/YQvYd9z2ceorldE9UIyWjbIwYHNfIgROYyAQYqBdcEQkp+hmrZEDkplpJ+JAO9MW0m5a1VZImuNCM4Vs4ADy6EtIS8JMuXL/Rw8q43GlySRTb+R4O3MKjSjoa0hslTd43MgVv6EF3OanNDjb24DrF93U6bpUV54cg10qvmp0KTZMGHAvQ9xFB71Vya7zjYyW7auZrkp4lFdd+pbXMNwdzI962rW2V8PL+7UCKjtf5Ybjw1H8VQ0hRsJOIL/QxkULNSHGCHT7xVbrBX3tITf328t6SDcFhqP9HH4uaD7a5M/LK2rzUOlYj76uwnGN/VE94gwTCnWDcdKLFq5Rv/TNo+/GCCQKvRur9XdAVb2Hc4O+jXp4HTf8kljmLIqgIHCWKSXBcJZgFL8qAsuQ5k7Fs+T6oOvN+CMfOz8POXH1bdsCud39NzFKZcC3TZiTAThdGAG85AudrjRvYaGoyuBAe053daiaNxJSbuR8tx56Gcy0M+2BdnQcOvV/FPjLXaqXgQoiPY30PGt8oaL3y5Ac0lUJfX0aGtjHIwWcmnwFfVbei7K2dTVl+rmpnzKGNYeuk8hW/HxtdS52GukVWJoSou+wQ99eGquKm4zIfx3d2qCVHpsbDLaD03uYNLEmUk1h38+hC3dtDB67wg4jUnrVdA/DqAkxRpy4cdRCN/wWPpULbF6vz9aGktnZGSt9VU7TjU3ilUvfXqXg6+JDGMZk1e4fuP0aJuHy6LsRdkoBSATYXk2SHCrFfHWBCn0dKruZ4Qx9NT1Wf9D/KUKZAaeB783APeW7Ftc7j0d6SdZXLYjvaXNmJFD0VeWz5t8wA7A6W/UuVxOhGDcoQZQyrNXoW9ysEFijkwWgTcBCyRWLKGgQedYfs+DIGdR23fkAACME7DvuumHEjmCmX6pXo4Muqo9YpqqzNU15So5tmFUYMC+zop1GdhUeBNTWnZnx49k6bkEXFqDLo/JN4b6T9jSCh2SqNkVuKDLqeUqkC1+pu+HmharzQ2wbzjJdr6tLVKKUZdbounJV5sFiTKIXmbfVPFsZfXex9yuZQH50zsy5WPlzGJHSGo/t0c1XVNddpusaBk9ybZLo5coIX6DyQqlTX3JV4rKeYYXDFWRv+u3f7+nqbe4fMO3hadfNYkdZBb1lEjyDT0Pf/Cc1p/4MeSui8L+wVEx3Usb0z7r1b0JfbtcXLzHgKClzhf0HwLJcMTHy4iCvtI6o8wBgxFd/6yWCgxAkb/bHCAHbJluQYJ7PtgmXMuCQXRJMFfO2zB2k06erc1kfgtmIB9cm1MfweGboWpxa4G51Sd2fGelchMH0QyBOnux6BXCKvs3kNcPXQc2u2+ImspADLBpFNLqDqCfQXGDajeED6PF4XWFV2JHjrH+249XlGL3E2etLPXc3Gss7ykdttp0Ewg5ReVb4VE5V0H2ZoV4HS6w97dtwYF+pbQ29GA1gL7PBvBgn/TzUw3lzvxaYS0kXnXA3EJiE03F5YXZ/RSw79LXCACCRFpFIL0nOXgnYY3mJ/p7OO3Z2uSRpY5B6/bNy39uWNM/btfwb8wKb8glxean8rgMKpYF2/ZyjRKGDc2INFUl6/aiwTYkQB077FN93ue+43XG/Y9sp3JjvzM7xqkLfNvQL5WAUWExw/lOPJ8+Xyhuw4KUdKWVi0eRMH5o/1QDqzKR60ffkVM2LOejOZL3UvRIW3ux1pX07ii4hKYEPKROZ72Lz1fRAqwd7T6tBQrU0GaVWrWYdAI0WxBZtHjtPF/7zXBnldw/GvnuovnpD3gqGZ5dba/WNlD+i1DeV+9k7TmM2Y45iwS8G+g8qO4PbdPBsnC8qnFXi5YWs9M3aa2T0na0dxzUsn1yjR+k1KH2F7mBZ2to3pfMhw5xxUviv68/LsHeqf14onzln3RoW89Jrm4ndca4Jz5+0mnhVzsC+7NCnmLbnnQe37P/8uvVXZZPsfqUorPrniOPAQ5AigO0HEx9y9Jk3jDGrIjooS6dvO+673D/k+x33b9hvFO4cboF3hrk9k5tDuZsBM3NNQ9yFJEEnYklTs35grYJ6gb49o21kQWq91voK6M6Mu2vcvWCznOYrbhYWw3ExnM6GtmffvYZAeD1ws673ywvOj8AAUt9j3t25zH/aq0CDBVDOh0NDL/Uehvuzw3vsc2X0FTbSEFxCuR2eR0Y10hBle/XDkGJvKp7Zib30hv8FV1Y5JaCLIB8va4vGoNphJY1bRl7/vSR9jrZmmTizYiygdzha/GtCNzxO62wKs1HeBMkpBTTndepF9P2k/nkI2LoPsQj5jQvfWNb9SRv9nsgbT8SNFZQYpPzf4jaUIJ7d5xYFh8gh8kR84jjwYPCBxyGPKA9A/ZyLP7My3UMe+lu10GoMJoRA+0b3Dfcd97t8u8nHDfsd+422O4WPwJt6anGLuyhzfbVwBRLWSXan0iGuDCnPU5JzqlmCU4i6JyTEdY9lmYvAZOGr7PuWCg+m+/M56BR0h8N6OGsPt8/Di3aa62YzTx08n5i9TT93QD0tigd7S/U3DMSU0rorKkAaDDew241ykgzXBFX9Up21fvYlm6sKUtYYnGpYPn+rePZOhy906LHlujSwNGOEx5i4bqXLJ5Pq6VB3NfgyqxpSmeU0/qpCqG+L6oMz4tuReHeqKVn/6UeLOChthOb19yUZwpCQknUI1XPXYpgNPbCQiewVPfYbztJ2L2+w8//KUnKEtvpnt/vvZcerVKcyZnXCgk5tOA56Roqc345kbywyguvwXEmw2oBTABL2QPuG+x3fd7nd5EPVznfaPjjcAt+YdsbOFKjVRqb66z+9R4NuYVQyW7mBnies9A+la4kyDAdAoFsSCoSic0h6abuYuV3TIWh7anz5LH/yejHeiEvlauSpJJKNUqprkm56X/FZW0Ojr01e9mcDuj2l4E693NyCW+mnfzdOLYopLdLWmPSIeMbW3NAqTvQeJ7zfrS2qu/XW5T5pxlAM7M0A7Gk9lu/u+lp8qNvwMFx3aQzJPR5jOdSH3ThtqxS+Xq9WdUGh/RJ7mX1WF4+ns3P0HbQIoFu0zcxYdkkKjBQwkMhDPWMQQRNPzhYK/rH4XY9ObVJ2R5ZOqyowD1gS3e9BKHYbEr7Na4cZoSdlRm6T9tyGcYqnQ2dYZ2MAtvwbISff0JTKr0qtrN4OEREckCeOZ97910J4lemaVdioMIOJdwCB7kys0KupNjz6fsP+nfePwPfA90A3RuAUI4w8wzbPR+rxZBJ02yzFXSAAMcOozkpZOQkzEpPBMFLCrKN5FCM2vE50lZ5D9zHNqNUboNv5AZzOkpXt0A7N1Jt9E8PxmXJ3poxjaYT7gWo2e3KmBJyxTJMtTS4lz8Ce0837NcQhJMAz4hD8jNoExSihW2b7fJ9A5RoymPscAZL6SBRpJtAh1/E1m33EMNiqahsuHUg36Pvg5cp+iKdff+8z3OPx8O1ni/vg1BXK6wq31bYF6uG/WLKs+zzRYw8KXHEYnKmd+1MqhfJq91xhcQoMX6GViSKhDJiy6LSSnBmwIiLRwO5wmntyzWivYLBm+SApS/y6gS9jvT4MaQzMKfQK4Mm+hO8q36e5oJN9npLdVx2vwlBb17HhJUhvOj4OiQc99ZB6JWv+jXwk+TwrAHNONql5nnd8BGy73AP2XXZlvR+0fQ/bt42/b3QP9BFsek1uBcZsbMD5H3qq+dP/FgGIYqlBoEszQCShNQ92UvKbN4BqS/DQ6DvLyNhIYyvFcmYZzgv5zwGDNKlWKl0fph7gIyR29bTf83Xu26CvVz73t2YtbyXHHm6MO8vGuLPcWTaSjUW3HY0CAT0jPYV+RPoR6fcDvz0pEPCkn5CjI4C5b4RudTVcx1DVr1rjIkU9OzOoN/Ms147Qs0bTtXVks11VA3ObV6uB4Zk0eOB720SgoX9NWWqb5XTFOZM19Pbj8FQVpJIf7KTR7kiPu75YMQPNHoKvfP7MW80zgIkJg+sfdnaYnJlQlMbTtrOMXTrchewcqbhWFPfo21zrV2MRpKHA1zcf/8+x+L4uE/TN05zugJT9n9Puv3H04C9rpLcUuJ0DkHKLyfkuUOAcKKQcF0DAzmklsN/l213uO7bk4Rz4I4RvgT42+h7oHvAR8BGws+zJl6+aoWKCwwScBqhQg26G4QakvWYyHyHVUrqDai8k+9MsxAKpt1ECcqxRA8ND3PVY6/0mTIZMd70Yx2hS8M1h5GnZVMJOjzoE42bpapO5lR9OguwUy/mBtDrnvrfNvZtuORA2wj3IB+MjyAfHjxC/hfgR4k5x47ix2IwThQ6hQ/iPI/z2DH9/hn9/8P9+ciD8qhjs3JTINaouAl+2Jp9IM88aBqMD9cG1GeaHVNjVQ7meMVgOX3QPFX0Az8WA2rbbo4OLal7C3Su9uVJmoUN6D3r7Yn1aXCszY8Pn6gq5dnu+PLRFykdo5hHl5pz3PwtB2dPaD7zKmHOt/is65/9MqcdQCUDagiqfsYV39M8mGaE3TpGXov7PQTbNhMUIG90ZgWnziLvJtuMWZNsQ7tg/aP8I4dvG3ze+B3zf6FsCXdEttPImHunFN6YLQ1lkFQdgYGzYWYH0Mx0smkkBDts7wiBZKJcUERwZiZ9R/NbCoFQzUFJXIq/41psQQJ3C3Bw787pE9QGQP3U6ESArrJoCY0WQzdfdV9DM1Be/Qt9JM/fmR1HUzqXarHCzJTPltD4b4R7wLcj3IN9D/B7it3B8C8fHdty3585xC0dgIRduEfNC+3HwzyP8x8/b//px+7cfWyAGCKBHTGntOL8p62ROCXQSkfl54Q6D4alqV3745D1ye5Ln6mlruugY7H240oUT9XVEOe5X9S8FEZWrPgG9pzflZaYqn+WEqZl9PjipvMfd4W84c8MQhmcVjuqpuuu5aRQCCUsVBum3HfQ5Kesmqqou4kaTQivrFMlcoKXedmlBcz+VF/ofIJW5tzpTdjMI2QCs+TdM//y5e9uIEIgCeMsqkCDhjm8gMHiX+y73XfYNQZNY3Sh8hHBnvgW6MX3b6PuGj4BvAd+DfIT4wVG371DoZUoaRRUFTuS3q1Ca8c9GEpDx2BA6/ZmxOe3KBDrE0JcMhiWZD/UUqevsU3CI3JgyTqsnrXFosVGFGt566G2WR/1jbXB3CLqLj7//Std7hw3gtsPFZulDNRLMkud5/b/Cm1rTh4o1e1AKzGbZVT3zR5DvQb6F43uIf9me37bnx/a878/bdmwhcogczMpV3VQUkkjHk3/5+fhlf9z4W6BblKDeZ4+OAzJl7W02FV00CXna2iuih9LF6aaDC6o6a8UQl/JZoH1rdW/PYaq3L0QZgLGKH4fvGXQHl5yZeGfQ6A62R2c5QRdWhr7+l76+WeV9gRkMn5gMhhUm5RN4/qavK4FzJ8eP7lQyGEtIGDxuWicM3QY4HeHy758kYzPw6zLdCdhew763+md/q/1VF2S7MTHhdoRdbgwKOO643WSP8k+NYvkj0Eegbxv9suFbgM6nHyF+sNxDvHO8cdw57lmF2OtLbY0W66ThdhA1QtuPiFS+IHENzEcGY0PiZ/5h/z1jOmI0+oiIwBFbnTYmU7bntVcer8fdhkSm42fL4UUjFXxWK+LSRO8MghHZWuTltxWDp7+NRtrcmIOD3mzilQ+W70G+b/GXcHzfnt+349v2uO/P+37s+3PbIgfhIOA2SrXtVKTbz+dtf6qaOuIOBPwEyn5q1XMLlNxKOcMwJpr20oLDyIx/A02jl+rBdma/Ct56INQyHQw3VuHh5QupdINuBDWMuWfGF+VLcBdL1rtGu1MsPOXTPfpOFdFLUJduIdsMmAWW59fdljC9EREYQnPCWjTPI+Vzp4FIq9s+knhoAG7bAlFGOqeFHj2cPx9xuxY/gbo4G9A5AIksBXQIaWshYI6+V5/C9rHREenO4X7sAHZs3+lGwM7Jmvt9o1/2BLqKuF5/eAvHLcTAUcmu6Q8zmyRdLiGb7pPxVagonN2uHYn7dht6RIFnzDJC5WekTHwpQnXOcggeGYYfkQ7BIxZIPoieAmE1GCf66726Ri8rYc/pi2s+clPbprOlwlEr82qd82T60dO1l8J/q3Y7rd1Q+QyHvmHkyexx93s4voXj+/b82I5v++O+P/f9CFvctsh75AAioTqdqu3jndpKQ114l+0Wt+0IrL76d0HAT/w4Bh4oNpGlzN+OEM9vP/2YoeNQPNfp1z2NLJZBjVXYd+OKzKB6qMTumTFq5B7KiL+ed3DoWDAr89LeJ11nzpr2GD88OG99eILcv+75DxZt/cJ6kTXduh0IWzbKsNsHaUF87SX2mvlZZJGOsiEMSzVmFIMRSO2D9R19DgRfk08i7qIqHhzMOyD5DRhCVabRQi9sw51z1vZPu8JSiD8/1H/4L3tQpvvXHb9s+GWTf96OX7bjL9vxEY4bx3s47ttx25637WAWJiEWiTp9qNEu/QCyG5TQEdm5PllhYITBa1T24C3ZVSdyy5LV7psJMT0SDOMp9IxKkZMV+RBy1mXJncwPbcRjBuQVg1N9tgpfcljPUHrPjl5jaTN4UYTmyxsTct6ewf6czztdh9X0q0FEBrqBcA/YSD4C7pxMvL8kvvtU3L1tx3Y7DHc5CDHa1HQahKDLR1OjaxkAkLAT7w9TVh9yB8K//8TP6FXWJaduoKTe8IS4kRl4x2qbo9eo8Kzy3qVu6Dg924q46WRNdisZ4nEPxsP9mk7lDdzte9gXO00McEUWfDcV6I6/0W7z8IHBS+zl+u2wZuFQF+jlhVWWobpLQ32Puj3pjoEepJtIJA+93t8zurkdgMRp1wZ7EQL4otzRXyOnI94bgDX95BZK8g2Tt/l+jNv//JBDKBDvvAtwY/y3D/rnXf55j/+8H6Y2vIXjviVzXeBisSOCBmNLpCOSxGQeOA42JKYEtJGERIjU4Jqc4AhASL51Os8SygwoANTqAJKMx4LCfRWMJWQk9lrr7Hg1BGMyMH5E6H9b0ktX0U2SVnzdq7GHP5lBGpbce3JdekGdDalhWr2NsHj/+mc4rL3uRlZUVOK9nSmrlz3ZVb57Y3zj+C3ItxB/2Z4f4fi+Pb/tz/v+vO/PFne3om3ubSjlTt2HWsrvQkG+h0dgyXd9jxL+/igYXM/pGX2NE5S926p79BLdta9SYV/zonID7AUM++Ym9tHBwcYNGyMwXvh2oUZlkyu5MoZyirv5CC3Kr+U66DZnrzS6sAyqNMug5tnNbj97uqza1SSUGgGs6PjGTB9THL/pkGWBwQCoTi5p/AdAhAQq2Gww3ObjSAdf7+snpX/W9nWdXtpSYYLjvnTbcNtw22XLmw8urL9XxBJx/D+/Px+R/rrxv94ZwC9B/o+Px9/2x1/3h7qnKndJOsOQc5/YE48EXQexBOBIRySEeBxMyRdGjsiBQSJHZMXdABGIy2qbOHEPxgLKam13kHIuDklMyZhxTP7NlbLawPgZSSCH0DMppeWh+ZU6Wpy5dfWp+G1u21dYvTtgDrovLYS9eA+aNrBkUmmgokVopLmj1KLVl0G3IbsedDV498ZRne++hcNcq9TEu+8x7JF3Mb5LXXrUfvfQ+p7bHbyJEe5yx/Nf8VvWg90DhV+f+BkHd6p5tYzO2ozjN49qhGsMRqcoHkrjgNPLzGMLHQzjQnOzPsyMzV7WwDm07V2x487kincVVaeu1esvv4a4TdP9N/uGNJP8xQXHojAAhq101ZUV6/yRNWRWtZoD8zDbxrqqdKTN8iF2kLLrBnGyJQ2lHM/A4bc/av4kx12aYpUkM6vNC81ZGv/GQDuf91owFaWhLygwNsYtb0G47wjbIADp3ZCk7f/1y2+PyH9/bH8c4cbxr/vjv3374/v95+32VI4bNqEt2epydwHoBg4kJJmZkujL5oTBfnMrSvZ/AkdJnJiQXVWRcNzmJkLS0RnL0cei5FgjdyUKqV4x6CPVTuWNGbKTMwlJFNpIt3CSnQoeR1bzMKmp+BHpIXhExeOExJJ3BIou+0cvvVbZbJC58++9IPgnEPwHVC/A127Sjc4ZKE5JZR7MHId1GxauNMw7YyPZGXcWNfHeQ/zg+BGOj3B4q4SaeANL2CMF4SC8jaHXy3g1mdZWBEBYiLLmJGPwf8evqe90Z+Jfn/TjSI/IP2/KyqQGhhsFQ89ce1U/5qzl1F93aC0ewjAuY5tJD9i9Hjsfn1aeKxmf/QzcYvR8cIa7r1oWF8adGd43y+WXpArWmnCtBYGeETNOWW7EdiFcdM9H3GG0eGpMvz0JnlQ8uB3diWHUiXqc1+SwXXC/OxNmMHZQMZMTv6pydubAlfI/q+l335L/8y17QVd0KndFMXiNxN3Z7f/xz38Xod9+7EfkPRwft+f37z/D/Qibm+pHPjKjTosc/t6ENbjYvRHdyy/k/TQYqhKkoL51JBFKggm2x1Ge8RZIrFw7CkIZkWJb93gk1n9TByBZO003kYNVNS2GxN5pywKWsFQcYfRtv0pBmvsNDtE9ri8qab+cZQGrM20Azggku449ShFlFlq2Z3f3e4i3cGwcb9k2sd0OxV2wVN5V+fv0ZqHSt5VblFudRRLvKc0Id/ng53/HrxrqttP93yj8SvQz4pnrNDOYXtdkYUuQbK9psotUxAAarxiyhqGiDQz3SfyHus1R5VMb8Iw9LyC5r2Td9EW5aF6tJrRPgG5/+SnPftUhY2hfKNk2yi4jq04CA6tWU95vRHiFuSKjb68Dj6KMaKCIxsxUnGux6FC48tpQDjpq0Xd+V5fu4h15S39SoW/fbSYETv7PqoJWG/Ci/us82BJx/PVf/iDG999+HpHUULfdkpXODzWv+SRQO2nqnq5ICzclwSJjDA6kFlzh5r2q9TeZi90zyUictdNAjtl1+7BmGIZt26CDLGmteyRWL6un0CYwJL4pG2Y6hB6x0k5beLGkIZgfiD2i5pHMVSDD8r3oF4hM4IzGEVJOMXNLHnr99Hy3F60hEDaSQDCgvXFUrL1zyk61cdz5CCyBY2BhjvpbvQECC4eiKSkrNq7MvUOZGVMKJuXRpRicBwpSoPpfn/+K3wLLRhLo4/+k8OtBfxw43DtSrKU8P3qE80caDb9/SsgwfAWr1hS5cVb3jtOtpf9siMwmzRlZ7/nxsJ7PyBv+RxfR93RuW/gzD+fniRvHtP4mcGs4QvoaVni03B7e0Jez/zMpM3HSH5GaBDOJ5NsfKqKNBMcuVQBq9NUfTS7onkCv8lJ8oQdWk0JL3Dvu/b/fFWLCFnALCAFhw22v8m8MenWWgbL3gr7/LYIR7lGeVKx0GwCQiwY5MTmPfOFYTXdBEY+iul9Jxk5PhbV8uumWECNBL9lZZFqc124VDKubQM7Ir1eVU9krR9RCbD+SuRcSBbtmQGR6ZjacqTA1bHgxmhZ4PCzWKE655G4U83vaSNObJADOqT0TGFcvxH40lM4BtqVJCY7X3rZDk1JtIW4hhhCJxBzuOOQ1b/ZeVtsPvJrEzDwN9M66uF416yCcY7Dy4LD/uoXjFo7779/+7cf2d6LfnvTMS6X80tMT6DHYP5xmnlWRvDX1Fa+O5lUPUdA7q6PjUi+xQB/aZDLUY/uenCrM13LdOH0RejG564ucYu0L2bQ1coSua3O/7aE0+NQjcVmozfvW1Gujsb/E/J9P6W8UnxqhgsRZ6NHw+GJU24br656ofMY5aV1tvxvSePuEhXL/uqj+OTBCwG0T24PhVfcrSxY9wuaNv2VuGMpMkKy8yL8jwKDRk9WzokCnC5xISoIlki3zGyoMklgswclJ2vywPCEOOey7xKS4s1k7XXBX9dLZ8bXopTMhhqqm4WZSAhSJQ43Eh9Az0k5yZFr8dGk9khW5273EZOF15ZXJzdm01HWuT70SWJFyI9k4ck43hlqN6eO4XDcSjgaOO0flsoq1HOK2RbX3K9D2gNpKHSaEbqKpYHWg4RnX2rB1Gw3i1NEiZQTQBma5heOfw+/7fnz8+/HB3//tx/7vzL8+6WfEI5alkmR1gue+jTJjqAHWkbxwPl/IZDanJs1Wg8Tdk5jX7xrowXimpsZkZfBV0te1mP3WLlSrVs5wt2l3Ab2z3vWvr/W6ct8d6s6vCf2QMeezEgiWVmH4QBr2Kcm1pTipMNROR84dpyiipz2zCmv627f+Xlpp71Bpq5UZb34hZbTMX+EborpBJsobAGsGys/mf7Yf5gVNGwGgvZ5nO8vtFSGlKR0GAyJCHoMBaN2qQtEMzBHiYNJzAoKppkHpEoXwPPTTnxpEqtBT82MlxA0SGydGRmIAkpH4KbRrpg7QM9JH9p12mbY8Gx4PRrcAl+agLXtNjawKfLP9KNndOd45MdR7iDsny+seDlUFp2CwYYi9M9VouLbSWfOQCrvQJhwABjEo5J7ZIizm/trujzGPihp8Vqqn7nhfUvy0gdRQVT5mdXQnxKAbblsM+499P+7b8/uv3/9/f9z/F4W/PxlIhvzkreZ48MaVmrrRRvTzbGO4RT17XgfjXD/lCwdIjKufHeD6M6iknpUWeAzXt0Y+M7OtWccb0Nuj2qlX85CS9tB7rn8GcDY8+n5eZ2jWH85uz6Z/nnYsVUgxo2/JkEUCoZAxmHLTV3ig12wPveI/KePpwgPtaUevoPJcBgbgTIw0+ihtwHDTPRB27HtKP/lVEiOALVHeDare1VNiNNP7XiHjJCcSidhZIGQQmm0YDF2R5bdr67KMqQkmvUGlwdreQqynegyO7gj8ZDdCYgCkzl96i5IctaLQrpzY+U77kGLbMeIp6fav+kjnVERU1MJChI1ASLirfPce4o0P9Xi6hWMLh+Y/CSEyC3EVjd20kn5zSvSYeO0mHEAbwKBAydveD0FfT/JzA0Ck0EtqIcjK4TpfVXlzo5tfqJoHeh2eYDAAR4IFyS+aGOGbfNse/3P7j/v+/P4fv3z//ePffmz/68G/PUkjlDzxbRhwb9/tCXFZ8I3u9WS66JDPs+FcpkLiRhYa4p4395Us7MqnqPye9G3Nbu0NPTOWquZTJXCDvgt91WAYdMeHZoumoYVkulX1QaE3KaKzDa43+gIQtbEBNkdpu5w9XazDQ81z7wvtk1xaE3qbgdp5hmh84waxJ7sVdDhaUeQvlNmb4K4MZ/2zJt/Yd9k2bCP629zY6/x4yyFQkhUWAFLkTReReVKXQq9lxdLfelwxGAyJBnuFB5uYfxZqGDYb8MxRSxNXjRA3DZc6kkehL2mnkcEYGZ4NjBWJdRAfboH5nKSkzosGWFdV2PGKxm3KjLgEqD55I6iGWT2NP8LzFo7bduzboQHZIVT5k1PeqO67ajyhaMscl8kQCwl9p+M9vSpNTaKIGLNlXiPQapiUybL0SlS+lWnZsMf4GQYjqaPDho/w5P23++15+/dj529ENwLLkx41Bqc6kXhwcxxuIm6m2t52e0VX3OuE/UNvOLHJaWJhL70S2/ett2r3ffuT5CXcHfZzBr09efVapfqSrqH6+OwZ9MPglA03LfaIzoSj2yDSXZg8PDzalShQEoPMbLZLDNiyHQDQiHDn6jw2Bqcu9cFL9mMcFL5aKf6nSa+FnuilqRkuKG8rnSIq/s+We5KXkZSD/syXHuYFPb041r/zWka/h2kkEpUPpoQPpSFAgFAQUQalblk5rkz1m9nbOQWc6YJr4Ac/hGFS+3GFuG5G84NPrCEgmYr1klCDcXBRxUGKu5bSYgVjU8d2qTSnw73ZJRsAQbb8yYUMvTc+btvxsT0NevfbwUEoCHFO5YixVlZfgQNaJbsj3F1+RVmhnwayvt4EhKC8Ki6z+Quf5HBk1nFKA2tExnvJKofikJVnBLrjvsWw/whb3FgHyE2QooR7RXRmG3jGsbZwONUuXKhO7ts1sfCpnkHyUIbUeYjH1smLcN6UfMVPa4SCrxSeVlKj7wx6F35VTQEaHfTSIG7FekdeWotG7RKvsqYc3aD/kmrIEg+Ws1Bd/UK9fo6YhIk0HsTrn9trV19hkWHc+Fox/vV+WDHRtZH1yvlhSf1K3hMmSrv/ctI/axbo3N4LVWmPh/GXAIBN1uYI54Fe2k3ZryBC4hiJ575XJOuWK6WKre+SUlrgjb7+8uwXI55r9lZhADLgeGM8bsAYZYBKk28r/y4fQKx9FhYuDHmmKES/cUi+h7hxvIXjY3/u2yClFCVv5KqLSRxoDaB3o4K7TDPuW0ZF1IYouzGROiIaDKvWpCw9QjdHz4Zr714wcvGrRjs7s0hdWPsgDEr3he2v8sv2k+nvTML0C3BXVd8j2uKswj/JR5ruNy4CqKfghQvVQoYm5HTqDJKHMowvmlHeGUVuZIiIb5Ce9TO5XuFpnlerbUY9FwC51gEM9c/DgXGlZrtkuFZIRCt7YPVPz3Lsuwqzcg5kk5IBpKKv/Tt0Sau656qFUz4PHxEVB8wTPH47M+XL1w474nrf0l/uXoO+g5BScMhtH+R/fkOYix9WlsSAe1CXOPg0RQr6LmSGxMlCOzJjmGUUNYa1WsEpGA+OFxtz904K981N6f+8phqOHAMp31ZJEpLKl70UrWkppyrxrvx5BilfBUF2jikiaDtU7WyJlMMtqsMUWZDYZDxYowl0jQdvmfVSGmrEXfQDjIPqWy4Rso4Kw2C4rEkzEqdbM2cCmUNs3/QIWQcYjNyKNhEz+tbPhHciku/0+J/h73oHIrcoAYDHYKuH3JSaavbNzqdgdIS4l8ZDZwGBL0FyI0PSPMTjRWcuypoFXNEtt5dcg+IG2E6hd2HcRfe0T52wGtDt2fCs/mb11jgfIA8//R0IG2GjNqvooFfZABzTFHSJ+9nWhMMK048/wfHq8zKd9IbBSOMaJuhrZ3P6ySr/RggDAJ71plra87gws+LxlpHERVlB32eLssX2lnSA1HHiAUOFMd0alfXPrOxNFRoMR+cXwGitwt4zy0jwzDt6/Iy0Kge3+k1ZeUMQuLHoKTJlxtOYjVF/jb754KAXDnd1nRtYATjewrGFaNsH7XsM98hBeFcXqsUNFXHJV6lHX2pmLy+VvtfBcKbCcDCMHDQmvlEPxh6JZy3OOoCJRrouVqMNhB2mbhR+wTd+/o/4H2ohewoJWKcqj8E2jXJ2zoojvVvPe0wvvXDDSZ0ZnVrw5gVLror55WnXW0zw+A0/r0bec5saV/UW9Po+ePRdQ+/wYV7yk3KLLT8GpDvblG/qzivvilNSXZ6BQEIA4UT/jLz0l6SZo8rCojqfbqE/rarUWbiv3VQUMJH5glHWjQ93Ymjkbfo76ajL5/5ezWM/lTyMOOffUOfn7WwD4FNyPL//DVGUQyCK6JZDZBBblzXNcxwY7VETX/3dKoQtnQLKxDOEYcNgVUczqNJFI13dY3CuFQbDM2nguXOg8Bev9NWURrzSeol5+yaF2z4SN9efukrJ4SIGksCy86FpHT36hl0oiHpRKanFcK5sDA2Z/r6AvtUjSHWSZXPPU04+ApteytLNwDj9zgR60ucT+2JtXPVI3MbIxbQUIgBU5jbawN/o278+/nv8j2fkh5Bgj8KCkq6ytFaTkt440/OeIRPqq/VSa3QG5de+VOvKfSuTBcTggtNtJD4pn4ww9hcviO916J09tEUv7aVx7TZP3dl10351TtlkaZoY/Z03YEhpsBZGQlU+GwOudeCCBLoJfe3UGS154WVV0ZVuyM5+j6o4aWJgaLtGdrt6uoUbu9ET81fHTf6NrdI/zwy6ymit2OUebknVHEWybVMdW3KsZ5U8zMP/GKQ7bZsd8TzYdNH2OJJ3tDMJd3+29mCiEi0FVIHC6F5rP6qaqb8ZlH7Q1wY2XzJFEucaRXIk7WlSoTxliGXSCJruMRxbiPsQfbfcZ1UgN+Syu2e1hiJZfwmhht6FrrPqqKPCgMdgFCqcGsz/k+QLbTBpBLp2PGnEQLofQuAKgojLv0Dlep3V4CJJTw7aEL7hl//2838efz8iPeIvj7gfxX20Sq23nu/sPj3vGSqlFzIsM0Plt2OCF6bHUnnp0vsAORzqX5Inq6sz/9ALqTpOdRlfc2/je6ldX75571x7RC/67I/0+O27qjnvFIbtpQ93TYjFQEvZERo+yQbVvlcvwdZ8w46BvERwv3KRd7Hd658lU5V/Y99V/yzXI4CrQdb1r9+MATH7Nlt25ha7tGeXlVOldUeIawy2aj0MewyGDytyumhklW+mv63amfN00Nigg/Pa7yV2o815U5NX2jQzS94QwkRyc9OFZOK+GYADKwan1MqaAHLbjm2LpPs/evTtl/GZXJYemC6USemvct9i8Z2NpH6hnp8FkKlwXcDbXRIYR31GYs8iqQUcBq8leTL3jLlmw9UlxoazqyQYFCXvbwraKHyTX/728388f31EFtAh299zcPAhhYigVg/2GkXUSDZTSrc9nN9vo8O0JvzTuChr6jzjYbMuXZQ11n7VZPsS+g4Y85wiX5HGDO/tDkPNx4Jt+0t8DW6VoFnNxwbgURBwsQR71LTPfXGvcfVVlQ4DlVeXa0IH3Gq8fLHy+fPS0N/uVPJ/vmXn5+3M+rvQP1/wH8sWRfNk8VjkQSz/vuKDXYKRchwwagxGp6MmSmFxHLU70JHT6KK9a7R32fGGS/3BQw5K0mOtSIMsqbepHlSnqjzmyWw8ewwetnP7WS+kTSj0EiFwVPQNLOrzzEE3gkx2XwPUqgEHbNaMxeEngzE7bFl2t5J+XtHRCULtnFWehemlc6+8tqbt6jUZK6gXvlpuHCS7hTppM3in/a/yT/JHjHQIP+I3IBgG93c/c/tEfR8N9x0qfk/u0f0eajKvP7Mr1LnnxzNN+38FqZAs/1ionYeErwfp4Q0uHnNj4vUv3dssZlc1y7Vau1ZdQvofqQ24XtrXJDg64is5La43AOf6y4RTrnUzXjOdN57P/VXxRR11L22ejbftuPW1az+s6anmOJv/847bVvyfp5d/dn2xAc565zXMrQ5QEMmlJ0xTXsJa2w0ps95K2Vil43CQFrLTcmcYzkkrUztA8r2ahSc1imsMKRTq1jNaU02Ok0G67GRc6mlwujHoNmIOtpWZxG1soqmvguZzZmFOmx9sW444ugnvCX3VjmuPPTehT60bQ0jWYvi0apyH10IWK3mzkTTOWaj00gMMxkAX/Ya0L7SB4ex7lbOMgtBiMO20/yX+0/F7FDoiET48BvegS/P+ns7Ib97ji+yz6c+pHhuj1cuMfH9G3jLSzWvLP4auzgt260suis28Jt/vcD2K/O/ZIDEezITNyOsoEYcXZwCunvgq54Y6+Yw3Yxijr1Vu9hrL2w8AkRDmzc1J4PuxSZWnRoXBVqRB3Ktu0pTzb2yMfUfYwFQlwGoIqObTuE6C+92Q3DmYU+8pzU2U1IeIjDC4dENaGAbGSmmgJI5GpsKp5BkGw9HZhsgOnow4PTPK6tKAHGhh2C6EG+KzJkK99nSKdFEYpmz6JZLAkVlU8xw24V3CLhxAXNA3JdBA8XgyHe9Acv6NpHze0vddKY1n0wBG03BZ7ee3Yvp3m/5HGGyXFAwe1n9Nmrjb2jUDMI33BIP5Tvd/jn/Db5lPfCMKf3/Qz6ipDLIbV+47YYAlPYOxGVyW9zecAZqSPQycLgKGR4Zg3NPi/kP/WuwEpvTmYjqDBfG9Ar3o0Le5SrqXaMcHnZnEjjdlrIA/Mhwk0l0SnBPWqAtAfnQpACmZftuFOLvJJ5FXaUZImeiACsLtjvrQSgu8vC5VttpI0F3yKJ3KQYz170k2ygrOvC802nE2RdwF4U75n2v985+sQ6+DWsy9KyMxgF7FP0jb2xZo44DXSmkooSxK6TRrL/JW9hiMbBVOvT678ypVpFmOayQeLhKbkcFnq1SF+Tx9JNxV52fdSoFZmMT2I+LdmX4DaCPabIVcmgIqd6fmnlPODXXnKMhdv5TOgu3vSu+2PdhhMDyQ9zy4oezFdXlOFa8xsh5U8uUVFfa6aAC0ITB9cPwX/Jpf1jcg/P1BP2JqjamaqbX9BhGbDtaKgEGZhQyfNC1bvF6t9TBVm+iLK1ZfdREUz1v/ojIqn4FeX7ivAe7hDLUa6JB4hqZVhycdW2j7rVfBtgGuSzbW38JKgZwW9x1tbkOdXeiRW6nXBfq7kAgKFTrOUz/lAiMMviJjDMbnVNk6lbHzf96CJOXzpwF4yfQHUaViblkqZ05YA5/VM+k11WMf6bk6utlGCQPuO9eKdHtbDi3HfSqRIST3DQ0yP5vaeQK9RAgh7QbIQWiTZL4tqmO9/wx4mWIWDM4PSNtLns9ZBW3Xtp2/SIjTE/EOJHBvJS+ael00mgShNQZfkTOtblnbGSQ7wp2yZmafLF3H8Z0+/iX+Db9p9Rt/MLZ/f9DPvGlS7xdN3UTcd9BKYqnJHBaYaUSvVDUTu7CFFndZ8+X+eav9oavgxUt6TTI6HG1GUwOBeqG/xF+Y/YyAkQ5j+CLsqn5gNB1rqLaNpeHCS/f8DpPMkY14AzDy5xiRUvjNLuH5doS98rmAQDHwpT+HDq1t6ohmO59YSDB6Y3APVU53dXJL12VUVcn/bP7Pmn+jGSvTji7FSjZpsNJuSJNL5KgPDfY4KlroxhIMD7G1RnpmGC5UmH1ziW/NPLO0qiEMl44PApBKgUbhXKnHHWr0F+amB+PYTRwV7kKRMW8gGDgSi+5oFFg4JO7Lt7RbEQUqsb9uEJQQoH6ZmYly5fk8TzlZdXtSpgBzAzVDc2KDwflgcZLyGHxRLmBw86fk9cEAg9MWwvSB+C/0Gydvl2/A9u8P+uE2D0Y9mfZU2HfQyxVXrKZAz3d7AHhV/IU9L+/BuJHhLgizYlW7F3p80bu7h9sGWXucW1/IVFVihc0JgOpnVWny8w9xV6HG4Bn6WrFhK3mRDKa0G6nPCNRyX8U/+AjgpBaeaW6RtdD252yEGr6iQ99yremlhV51yBpicEuCh1z2CsF9iwSTnzM3HuR/7pUkeBGDB131mzEw6fZHVbcI4gDVg6sr0yWVdNbckia0VjujhuFTKmzFnBkYC8+s9Hxqp6rxQ6gdC6u1F2yQjVHWnlIjBrr+NxOoKJ9b6CUW1TlzEE4uVzmHBo++5vRMyJksq3vw+SZrLVh1h+3xCSiuNNXu2nG+Dl0ldAj6Gga/bjBWDE6LuHZZDQGIwd/ozvGf8Xs+8S1ikwf9dLroVFs3dfazjp+UL67I+8l9AcNDudLQjE8PddReLmLklWJ9P1cDyhUeEtnmyKwVf63/GjJGOl2XMxc2OoyZgQC1AbjvRtPzvpJeqDIAA53auRczAEeZKhVsuA4twXVtqRg69JX8m+rjUBIVygZNbeujaIUFD7avdbCYyPg6JMpNmRPpH4EugkJI+Z9N/+xV0K+ybcy18LnaDbzs9OXw30oRPULrWeGh47QdV5OwZEi2NFhwnlmls+5DiHPUxFALLWPrbx+21EtvBp5Bb0qwnnXOlPboLegLrpXP6VHM+7BYM6I7OI31O73FvuYmnAKzfB2eqVcW67V82hm35cGoslQCoI0C4/6vCYMF9IzfRMK/P+jZKGYnGbL8n29MuH3JGQx/Rlr9cz7+ta28KusWZ3jml5QN11xc3iGxoH4OuuiX0QudaQ5QL8uGvZ11z1ZyHr8pf/E8oX/pWtcNcQbgvokr0l/YoK9K82fMDGphR5AzOyAAn+WpXyXnmW2Meac25kba9H/DajcGU/K9GiZ/7i/8jIU45YI2hfNsZqyTYXnxC7TqZVzYE2mBwaNY4aSLBsDRwJKAQoWbjvVawbp16co7MJ4cP7ujFnr1R0N8iYSDwrDurBAd2U37+5LtO6mQpkv0RUcq9ys35XzOMWHUkJuiWjhKLZopvtLNeUV06me9Or6GuAsl26TD1aIs51rNvd0o/EIfFIHfo9Aj0lO+PYR/fVKDsv19lxbq2dnTo4X0s3Yzs1+X9fNoKO/atPlnyHvg3uuQ7d8eeodNVPNkt939sJ89650tidZOWH0H+ib6sWQMOJtFBvOx+T+j1gzHTBWCD7MUTR+QJlpyJHgovT65c9HqsNnyKdmRChSmtDjnja+cos/nq1mBDlDJj5VTSYSHyNB30w2A570ZpqJ8XTZ1kElG+SEGT1JRvioL1+j+rGHwUHzsb+VKPSpsmSx7cd6hUhc2+ntVmnCjIfE1tfMAfUlyxNGnIHNhx/Ueyxd3DpmKX/bPVKW5jCfB+VT3ZC+jr/173dAorjmbKWwKoI34O98l/u34/fEMP47w+3F/xKSIxoiNxbIZBTChknZDsxvrSZV/qG+/nhmrBloy9/m2vlwWyuch9J7iLmqttaJRU0l++LpoJHvFpzA8G7O+/v7CmbB64JKEvH6eqqtcDK7k9JMXWljV5kXmp/xVbxiA4TXMNQYPT7We0qntMkMug4yv7o8EAEwULAHWlrJfvWHirUbwpcuzExarjvdSK7Ybkj94RQW9xuDhkcYvutJFl+VVWoX1wUjTJdgIlb0JGa/Q3+IO1rFeg17SP+foCxa3j4IqAK40DqwB1SYYN2F8DQx7KUt6Zw9GzeYWk9brMqbCM72HYbAnwVGAtFVU+Eb3fzn+5edvv/68/f0Z/oj78aCjSxOo0NvcR98Lr8ycPeLhbH5dfd3f6+LsEEXWKqLrTV+05l6UfrkzpMINPF+pitwquSHHKG9WopsZhjCMmsX6Ad70itxxceX7Hmr3lAFvtboxc9aaGEjqRixIPH0O5n4lFQkePLiLQyDOFJ9zMbAgkgEG+895wnHfwOCV9FospioAaZiBsq3kxYbH+wFr5l5Onin+eb4RX+Qam2Kw/hhuGFxVUI+SIQYjw61tZei3VYgd+vpx0DQ30FoPPfVHNRju2r/n6Fu0zaL6ZyLAfuASD05f0szQdCavLRJn9fc+0r5MB4Fjd+gZjV7KuTpa1zFR4HiwCHAIQIjQIC5iohuHX+K3vz3/9bff/u8ft//9CH8c4WesajIPs2F/h4RpAXJDYjp0t7wis/I9rg+XC2+0eNr0dWkqsAqvQ++sCw2EV5e7YlXOGBfK2N9a/377R9qT9QanrZh/O0xgko1EN2jxll2XiKpQAkHlgTUTD7ruLl5D377zyCQYtf75K6UzA88w2DrkX9gr9BewBFi2AQN9LgL48qJgS8GakKH+eYbBg5zgfTG/lJvDbePqPCjQbCTsMBhOHW3nrT/9mBvirlXbHB/SERotoi9CLwBDX/9wWvrrpQy+KViO6WxjFJn6MnyaCg9wtyXBJ37UZ7L09QC8OnrtpsjJVgYAJPIkbCD9kgl0o+0v8Zdffv7t15//9HP/+5MfMTnm9PO4UeG2hRE17Elng8RNgdmjeuMtdYrWQff+lNnzLVlDb/8nJp3vCe6M/qYjDoNzEwWG4d5Ls8zq1SFDVflCw+HLh7QTz+iWssSy7y/1ZpylImygz1t/k54CUcbyfCGJQCbRwKmMrrAnOkhfptdCn5RPt4SxU3R3G4sKS7IEC0ByGzAIM8VIMUoDxl+XHmuznAkWudE6juf+D5/iVatwR4hncAsHySNvrIoHA/BUGBkFPSFO7U8WgH3YUn98+AatgIPk5KQ/RF/HegU1/YWHkDEMQ2OfUYNlo1We4qjnbrmv/vyXaaR7RTQ6nvg6Ep9qYk6oMJO6o4gUIi4HCIJIiCLPtGcUf9D9r89/+t8//vr7x7ew/XCWYLgJVyVK+0U0RIGdjyvmjjx9gYvv4eLbGjLsvpXrmuSvMyMMKl9D7/BIX8mi5LQbGYOBAQz7V+8/pgaDe+BvLulJMLKVmjsX6LyX1/hxSy4T5QVXlVdfXYPB4zojzdJBGwYPj7cH3VfcmoHd4mLFg9drkJko+oaAEEoAEgCAssZ4gMHp2qkJ+rINmJLmUzDJjzKSPgL4XF89x+CeBM8w2E4VoK1hGE7zbDCsMgRjzMlxrmF8V7UKWhlwgl7tbY++fQ3m/JwfCJof12WOviNQH43UBYRfpbCfnJuHBE07YF/mpAVnQxp9hBmD0eiik/NoUkRjo/Atfvv4+Zf9+T3svx70iNXsY0g5o6q+4abYDIYXBWY1vySOtYxnp6Fr90I+v05bV7vA2sWRYVWNrDtuGsAZDMPBbY/BfSs9Aya3HjqkKkxI2wC3qrjRrJzQt92AIYWENLcvnxg8qDHYJAoiKMq5JbERm1FbS7CPtRlm5Jhh8OTIJdFVT9I/M25bCUBiVvp7rZ6ube2NHZ/Xs4GJBIJ8eyI9CfbVDgOrr0q16YJefgmDobDaJc9qYBg1IW48qnqS1O9xZHKaz9Jf2BBf/d2jb0N/vdAw+q/qkOlbKn/mr5U1BluZ6fXXCO6lrFgTMH7fLyFPqz4+GLEoopWf8I77x/OX/fER7jsFrlWCvYFwcbt+tp2R3bprpcCVW7kuQx+it2tbNLGQhTLcZEhqL6LvusKL3pQ27cO9lAyx4qmwV0fbi14sCxpQl7owAUEjFZ2bla/Ew7A+wOwLPb4FnM1dL0mDwSkJl7MBvydjHjz3hfZDp8QBfzLS0pL1KvpqAqw/aY05ElNB25ZE83ikidgcekpTktQwvMZg4IQKw6md9Sw6Qox6ODq7b9u1NUtujtvlDfFFxlpTStsRdL5XeiS3qq5YdbfKt14wePRYl3JZObP2zPoU6rtB9VpmyhrX534JYxJc1e+V5HpJTIpoIKXt3D7it/3xPcSdJVi8uXv1fj7yXevf2xCDcQGGh8/gbRlS7U/K2yj+BvQODy7Qt2mh+5bBNAq3rH8YDA+psFc7D13bvHEX3TBo0JfTLoRCNeXTAr56HwHss3NoPC3lRJvtXsIYuGKtpRmiPQ+uoqGijfSBcrR0o7MKi8/ZXn3CFQmuXD1qGDYMdnFN1yDZoLfonzd5LwCp2WSwv3zk/5zOVEmX1mHHtaZ0scK6lCqh8kKqqKQ/4g8WxunKexSknHKZWKwMdxt7Wcn+FrRC/5+vxFNeY70DtXONvo3pd/I0vtCun3p8UiCKraWbMxJF//uatjhnpR4W1rHE6b9VJR5TX8GQFt251YXo7iOpZkbYZd+Oj3DcuBs5pQ7pV0p9l/WSPH0PcIJcAbhi/X/Dqy7+11T+JTKs/41rfQ2+e6cHMfrd92ei36r+Swfdf0Axx1oHPAyTO96O6NECwo7776D6nVTQbW+dKx+N0dct8b92Cqm7Ud2NOmH5aODFGtq2By3/ej5txzMls6psQ7P0p0+3+VX6P69/vu0++uhE/7zeA/iybGDShMPCQgxhgrxi1v+MDDdvGDlFL0zCqIky3BLM56CeMdrZMmLBkv2FBr1IYJx6PkTffKct/f1i6J3NiEMSvBzHiw2uz6XxhXYHlQi4GKSKGdcdaOq87MN1nfGnWQ1GgnmX++15D3EnCV2DhHPyZ1y211LOaK6vo7/DGcEyWT+Vnod9Uvpn8hmZ8dc1r+3lFHpnD6n3TTMS1RuGF+roppKmb75w0yIp+kKcrqLMWl5pH2WQjorz8GKCRjFNbvQFWVSRFy6qhYZE6jVSDYj6D9l7ZjX2YEQSFqKUO7bwWh/4Wyu6Xt3NsJK8ZVxJPxk28DIB1kVp1OuK5SNE1/YEuuu7YklMy79TIHdQN/WdLl0avtIzDEZG0CEG21lrcaaU9iUx+jibJd6pd3QDvdaBBfqeYG3WP3+VB9bg4HteggCuK5/nGNl7clUYjIHVw6xBff2fC1InipKcsBiIIiCU3FgIW/wIz3uQnfDob8QZBfvJtPltE66eWUBgYyeedPy1403lfan3HuFL8D+7qpeGrA+PY/SQu2tfuy0rTaNPpNdIo8NguIfQ0+U0X3UYLJlJZwNw2zGvNPamXwC2CyGgoEv5x1TP8SXAbK0L6IivJcMa7D/ofLJg33utiC4QC5jlCGi9o5NMprixZc30z/uG+01ubgekVFu0eKRyyRuiKuhhIg7aSMAUIceR7pAHmyM18oY31nTGrDdQGm7M0NRQOce3UcIDKmwl9cfQc28GyUOKvEZfa847P1eq8kbd+uX651flE8CchGtbqNlZbUgUDlhIMJph46MLnLQwPMHgl/TSvsXaEgww9j3et+PGUVMDHv2OliPoasDAsLZxmsUE9maoNnwzi3tdV/5J8nql59dleN1F6J3JKczMMINJxGFww6kYrVW4945uus31Yr0hzcjoq//mbYBTSeeNNdhftQqkTP+K/7ORT6ooCurnu1CFUURFgvuYkRHigqjih61JGHVM8Ny+O05UOer9cNxQXqpk/XPOfnWa1fnKZH15QmckWzQoEBn9qp1y1UeXCH2+CP/ETxvtbatXZG0PbgqgnojHht5sIfam4utyir4W8psvMEJcw/mfoX928me4Sa9kMjuSW5BXe5KUg31Vw3pcSbt2MaLWtz+3BBOB9/ixPz843ln62zKKk5Kr1JzDilOZiH2Xyyn/36iDAyqzKH+x8k+aga904HrfGmkeI01ODQvng3/imG+swpTHACfsrO6r74kZj+FeLhM453/2d+QvTmk3JG0AXNc5qE3d/F8Va6I/3nRJcmFxvtAzMcOtrZXTn0u2ttBpf415NEFeTr5x2xA2EL9PcN+VrILemCKKO/RSC70gu2Vdc66+BvyDzrrooQv0MGvHmgf7yr1G2nVVmh8mPseWb665doG+pdhXxPieygtJJS+T3VnGj5Vw7Rva1ui9KlsejFbVrL3te3U5e+Ur31KxBDPApH5Y38JxYwmEY741yIQKrxSPs3pekrUSe1i5P3lRZb0QX8Hp4Fi3trb1TrSpg/LVFzrpWB1OU1WiXLMhwehWg4WJ1QOwR1xrqYx6p7hGpr8EMIoLtE82OXxuUn8WvX+yX+VeFF/DlUSV6hF2xBQKPItKuChpT/dZdG+f8WoSH/yaeP1zCKJm4FEGyqR/HqzEX3nGkzweW3IDQ5QnCCR8poUuSGmMYeB3PphSR1JpETsM9gWG2ukGg1GrlzsVZfljvWrzeS77U742Q19r0X4Mlc+5EuB15v2+vOih0GN5EwTcF5gidBfPVizBNQbjMgxXxWYwPLiFkTt0bQnWq4hBm9xuz4/tuAcJz0HFzr7bT38rxePpsmEt66lmbZqdYdJLDQ17PgPjWWcXd0EXil23JQ+XRyodoiQMBpREnkzs5XvKZRbvlEYYnJXPsmUb8MxrzAP5EB1tELLbBRX19PVVuoFMf0X9sI7IqUuTZFjjSjpFdCXNHoX+whqDX96cNIsFIJEqn83/2afO8H+26pd3ddTdhRttLM+YlgPPSEqIeaDF0MVIvVVRhcGD9Fiukilp9mzVYTA696sZBsN7NY88s9Atx9ZR6j6zh9ZWq8Fb6OX6SEHfTvns9ahJ/8xOw2/yIks+ob+VLasZSc37OhnO56myZiTYTGfSu0bXYb6XYXgQ3dvd0fSSkSTfS4B37Lfjvj1vHHeSn1Tted6YA4epghzLaT1ml328KosaFnHJuEy1Z5/HKfPuz1/Hy9klVwDbK3iHBU7BwRinmV2jA8DZF9kQ4l6axy4VBgsB6n61zU0D1nNVQfswJHW/ijnvPasXdH15c1Nd985HhO+AKgmi0CEkyQZcIpEoTGq4zoaHqPwShTgtyYTN7T94v2HfEbY39/RN/PhNNqxhSCRCxCQb42dUpTRNUkPPxG9IgBHFHC4LSvwlOQzG1CdrqKDGGQxb+dy383sZem+5/M/V8eGRXvncn/oquaqC9mXmNPc9WWCwJXtpMbgP8ii19YQVQAXDLQav+lb9GAzpmEa7FeM9fmzPD447Cx/t5OX7Qm74eRgwxrnwmH1VXnrJTSuz40MZtvMSKr9aeV/PRaKMt+jdEJgbDG7U0f47bohXte9M2zetsLQrbrnAlDNQQgjFYeVK0ox+PUc5kOkiGjQK+fVrtMwbhsHPSEfMTliR6DIDRuefNd03dpF1cojKp2PRrOUb0x6w77htyf95dO10G4ZT3L0GyVvqTSRsRE9gYzmOFBD8ZpACkLFqrelFPYeu1dGz2CS8AsPW0EJ8INPovqznA+6LpfLZj6Sx+9XnmdHFer6qoVrGKaM7LfT0bD1XjQlrDcNXMqH2z7kyJHtTSxSBhsUjbMkMfGcJhOeIuTIAtynscMakDoP7el6V9dVO21kdv6AjaEuu270+O5ze7in0LmoocQejGobI13sR9+IxuO1M3z2naWuGm19han8ca0/hv4FS+NBCvAdWRQ+yA0NxhJ4j99q+6wh/e6rK/iFEgDLgiNcikdqmr+dwfi/SdyTERIFxC7ht+NjT/oNvJMB6VXwwUobnDQCYaGMRwaYaURJWD+HW9yxpoVkIdIUZL9KSlTKOlMzU0b3meZGIYwjDKldSh8+11qVp31CDvrkTLf1NMaaN9ffKS7fvcl5yRV47z+H/TBkqohtqW1uFJ5miL2Hw4tnaqCNLDR2LyocIfJP77flte+6s8yNZZ9vZtt6YnfJNqHh4zvtBvLOwHb48FyQ6RhSpCpffZx7ig4Pr5CFvyHXvqsnlVYc8qjUVjjwEqkOnEDK0Bw8Vpb2mbT66k1t10B0BTjpA9qPLXlOgl5fJsPrbHI6C08GZXSaU/qZIJC9EeY9gnW9fUfh9CQiW+bBfQDFhy+5X9xv2PdHfEKac9dQAfEp2RxHAutnD5vQXKRducsvL/33yM7vo+jSmwlkd3WzDANVgLM29/hsbgvFQZlrr5nIe6aLL7zrtxjDhZSU8aOtN8fPXTOE8QeIXXKmLC+KswMVdGRxj5hcxuKoH8OaMy98wMQStv6Ee5CC325G10OFnBLrZjWx6oZbZ2A15Vu/dst6WIc+eRrF3Ja9Q8OGre483Xx1QdTH3JE9G0ZD1ooY9ewWz1c9wruhlxsFKfgJXEjUx8Kf8jGvcl7P/66DdHGrcyzXnh4G8tAT09FfybyGJQIPBY02y3+moFucQc9ajgb7w8g2US4iYENi5X23Yd7gtCKfip5Wh/jn5v81QfHy8ALB6Y9HG2AQSkxn4wk1dl/4p16ZW4BoVRqeRRofEflE2JArjHo7osj/YQK+d7dHX33JPf2nytbXRShP6+8kt7pO858HPo98F/MYday3EmTC2GAw3a754g1dxt1OJFxKM9EyIQRvC/fh2e36E487bH/ljoAyuyJ0lShjcNOJviM801W/I7M1liB2DCo0KN9IPiiuv4qWhNCt8EXr7q4cfytD6QUv4efXtpA+/Wf0DGMFw3z0mMIQwCDdXHfhpgFCz7DhxL+2aGBbr/Qo9+gI4hFjoED6Ej0g6VYpbgxJDjkVHcn/e20bQWrk85DTXRXK/2hj7hvue3K+ubH/UmH69XKG/81OK/BFIq4O0DKM0NIhFsLThfU6GjtNjq3A6W1hvG+xbI/FQkzzzA+wtQ77C5tpeFz1E34Hyub7cH9QG8o++jwN5AYNnxkC8jsGzvvVTHbehrwsMBjCgwsWH66X05hf6P9Rg11MjBWw3ue3Pj3DcOO5MMS/ItKAOztLZhTqgw+C3ZQg8s+RWUspMNa7Ddz/iiFd7OPP8OpWay8rw+FBWDuGTXq3rvPKCbAw00rPeWJf0zkekccDZCSt3ldQ7Gu5NWZfW3hRD6W9nCK6+hgr1rZ6s/bYyUfCMKRJpbN3r9oCfSb9PcNfpyR0OPacmyrxEf2+BPnZ8v2f3K03B0dDZP9kenGUDUcJgJmyMR8rOZZkp05Tx4gx4fdLs3bUGGDzZwRAjvjtMytGU8dIEbi67WprwRyzoyB1Jt1ah75D+es+sBbyVMv5B0WCoMTXFVlIXe0ELPexkLL26dMrB0cucfoF4w8KLyy0gGIBNAUy8y+3+/L49P0Lcn/xAO6gKBndg7IvZKa411W/LqcvSMOJoiMdDDjRT1b7RtyvSXPFJ9B14uL94J1fuYO0SVMVJ1r2yOYQBdXU1A/B0YxitwWWB7ssM1VJtn0ew6iuMSw2laYg0iPcAHUJHsQQPmxw9y2wYHqSldLsyDAsM7+oqBiuldPRX7nfsO3i6+4Lw5dxY706bG5KLPSd4CEybSDwop8T6Wi30TLrIn6EHbLVzA+YG4GHa52a5+lIq/5q2XkVfuxdfoE+JNTI26yXXFo9vo+YbV70WkDfI/1SFJGGCwRfB1fdkwUPXy5p6Q2JToxGDb7jdj2+7moERosUJF+kx2J/yP9KoufbITw17qxnJXTWL0H2VHH/JJHABTa9C79c6FJ6q3E89sBjt2Fhonq0A5x2QZkv/VmO87AM6CB/klbSaR2DMI2hvtAiaN10/1gTAwmlXhkhCCQ7P2VcHsS0J7tNxXJx8crF2YlSGqfT345aSPyv9/c8QihExbln9WpiTbIQngUAbJJK+q/6BnnLcVzWHMwxuw5NUunwduZKWDTcFfMlGXOpKt+FGdUcTLfQEfUvajdZHuv8x1z9P6C+82nYmLw6tT4YCXyHB7sgAgz/VdN/QldvP5NSTYD1OAeEWP26P79vz9tgCBacmzwpDkB8t/arOCJCH4dPP4orPLUbqH99iX4+PyTGpbnpki2nKf7kskjji01h7/okMVafDgwBG84YOBk6KwgEMo1HRUbqKkhZa+hYvGmvrtla32kPvKBh+cq0ph3TXEiEAh+Bp6Bs5Hi+HAg+dsyq+mws0JLj6c+yyP1gikSbfUPq7b9j3Qn+Z1Se56onR4iFCf5GOegPniVAdUTZGFNpEOMKTYEcXjBbP0hp4kvdVGIxmojljwz0MY4LErvXxb1/DgAp3Y6iN+p0bhusm6r//AVFDb6dRfU96eO4weJCoEmoWA64sq62hrxDaiG/ycX98hOPOsrNI7LiRRi0RNIF6m5+h/tHA8Ju96vUlo6Vkrx1APaZ6MO5p8WdCPNcy43ydOvpTrXzeT3EhhqP+oP8zdjYLXyw5P+ufy9usYnCnnZne6pr1LrK4Nqcy99XfiJK2REx+WKYhj/XUp1Pu3BF6KGu1c3PqlMHaxke4Bbpt+H7Hx21q/Z1JSUt5uWcXROOAk64QADimOOCN5IHkOSbSqvhqo+xCvgqD0TOMzjCMuVLal5mJdDbm2T5L5fgIXO33+HU0o+dE1+br7HjJl/hCf600KDvSQmPZ8xF7nu/ZcCazL6JJdUmAoEo4SQwBeM9a6HA0ZmDrl6kfTxXnDQx/RqZ2Pu38XP+5AOMFEldNTHYo+aT0j+TL0fcVI0DXmdFvg9shaPFcscMp2HPAfRtp1kCDDIN9BNpoKPbEdzZz+OPeY0GPWz6QKBQhR8qHxcfBuvHRl0VUviSjhAp577X8b2DcnPPz0vqbqz27mU/z4C3PIkyIElOOLhwMjhRSXminVW+aF0RqIHaVeOjTMoDVJQyjm4xWlfvUkostDkfo60pmrtwpn7sQo/MureUq+i6Y7j+ABHOdeqAJWFoooms/KR8ZjG4ovrr0bMekz7oaBVFDAMA7wi1+7M+b5qSMae1fLAaGwUTeDwsTjWWfKUll+H2s72ns5+8q7JNCNHU2YLzgxFWv/uQwKt+lr5W3q2y86tqzNPg9+zS1ACkG520NMXnXca4uzv0ZN7NQOM/wdVyPNH9qMmoAYEK2AWc/rEiIJNmS3PIlI8G1a3RvBm4VzldcsYrleJwzhTaiW6A9aOqrRH/Dlq6tcbRXR7f0dxgBvCg/7HCbiAMMlkTViWhj4YgtM5gjURDRcRwvQZrJSxjc+EWPJ9xX2DCucY7hHY2hF2jQtzH99mVWoFu/vzd8Aip3g3+wYrmXoSXYEPSCMXjsjdU6c322m4Mx2TB1Jtqw3VMwkqbE8k9a+9tjcC/FZlwPxIWTTtvb+Ssdehd6JL5YpgePps3++/jycXZ95HpT9xc2d3FYFWfmSYcXN6Loq/vdqAH4vYQLpzvK6I8eeg13X1Kf1YmjSdf/UegRczSw1X/9rcxV0+/vyhDNEUwo7Xaf3K8K+obNUl8p+hriijsILCeaaeasF+YmD8AgJmEGi2mhcRA2IIpMxrvOYld0g1WejSvpjc5g+A02fNbiovMt9AIdr21ybvRluPtd4/cXGC/lT9DlVVW9VnyNwQNt8xCDUUPEe9HPJh2Klzjg3s2Uwbvs+/GxHXeOO/FR74w0xOC2I2569d5beEsXvVBsIjuFqTQoC3d/szIzJE5XvdzZS7IYnqfDrel5X+2aiV5vy4cP5R+1ksz9nr0hck1/UlV7BX2vQO9LZv6K0AoIaU+kx8Ex8nFwiHKabXDU269RXM9YMm1MeyBVPn/coFv/zvb9NSlqrgvWX7zCCVyFaoWOadXADMoBwQdjEzxFp5akyC1T55QEX7SfV8bdRTrfziRsrbgywBkMvypDG7BfrC0ijpqo3xN5Fx0b6PpUCO+XVgJ0YFagd8KDOyMxWvCeK0zHHVhM6u3lBsPErVKOGHTDfjtu4bhx1NT55lzDVX6rAQYTTc2EM2+d0s2lBbFc24xQ54vbr1B7ML6IxP9IeW8VOiPEo5H18n016NvT36a+RfXJIpmtv4sYpElP2sIzc28fPuT/zL+vPohmN5HUEBCBZzQtNERAr2wMDExdnd8TXwllSzs2SlsvmPV3C+r5fFKd79BMC/3SYOr3Ay61xKx/FjUAM5IKmrBBngBAOscgwzBBXlQve2m8lmZMerjFYY/E7XRTByy93rf+q62ILy6g70X6+4a85nv1ilL6yzG4tfW2muQpCW7P9pit8t78OoLhUeg5pWCk/XnnuLFQJHQ24B6Dh61ZMS/2SS26eXofswqHPHvIjK/w5nEHJsf7WLA37NyvyhCGLw2H7sgo3Kgc96/s+tdi6EvLXROui00njdHXnBnSQTUbvgW9a4mCHArM8WCJESFH9y6mqMsZsuY16L80SZvlPtGNkaKPbiX1Vbb+mlRg/MYE+G6okjphKaRH6JQHTki8ESJThBwHbUCEmIOdOa04P6xPOlv1ITpDJO5TVzYlx+bhV2Wyj8eb6LuUlf7Z2TwGoFu7EXnsfAFHO3j+03nw6VltvNFF95fYhafdUDlVU/YbYDOIEXbZt+MWjl1TtRY+JBE0xuDkL1EaIXdnJj0ez+Ti+/AVNtBuPLt3zvJPaHH2Jemv+lqsvd704LVPLpyBbnPWey/bFf26CqNTNXJXc1nGlKvzFde/h1NvA70L3PWt9oXaNL25uCDR30fkI/IRifPeOWe9z3rKd2PyVgTGLZBpI9qYPnZ87LjfEdLGR1P6W9Qajulep78v+kW7XNCRwTG5Q28BUfDUrFhET4ImhVbXN8U8XdHXGbe/NqnIENEXhHjKhk8bapTYWEEv1ug7lNmp7v29/wCjw+BP+2G9hsErMgrEjuaekuB0omAwbP0xm2mmfWs7M+1/lH68ERM2oU32/blz3DkGYr95UoPBdnND9O1Vx3aguf8rc0tTlb9QqtsqXa2uGqmpm7XKnxFS8tIneb38Qi4ad2flfYEmcGiGvsMjdjnlfQEWJU9lcVMN/T1F3/4B25HhBf7zjYIIPIWOyM+D94NkA0WSpQaxT6z0WTOw07dIRFJSEZIH1i3gvmPfZQu47S18ztZKuIy+Z/RXHZ69c7XBvzph6RbBlDAYyRKsmwRTBDaBAE8BBNFtHaNPcxSMZB37ZADSwr2rR+KFXvpSW13hflg0Llfo0XdOf79K/5zkyoO94jQ4kasYXC3vp0jcKqJT+TNL8FAdPTP3XZEFfmfk7NXHvMu2xS1E3TyuqzJhMJJnSvsV9+jb/Bnn4SCvvgGP69KdRYfHM1p8XQX9qrw68k+UmWcN9dfOOjAku6gXLv5hLtB3Uv/LhgbblahygbjUGlBHGTX7OvgGr6wC/U6azbgSoUPoGfmIFA+ORySqYzW7aJS33+nLs9lGtAfsfufBC/v+XtEnj1dYgwtbt+qmg+VKBedkpkiu2xRFNsGN0wuMgo3wFGk2aZjo9PtgzU9aixdIfOqr9U67n0DfIlcGzXpBO9OptbTyT1bzNZVfdHQaGoMvkmB37M2UI59/JqqF3mTnGEgCaawi4Kb4kouj2/LIo28/BdtVsKc1hYeT2++rGk6sM1o8TNv0kgq61tyfFHhJejZ8HcXXJa+ALiYrqq+S4aJtJmst28ydv99VSUZ3cdoFc8VqeqvpOJ5HOOJxHMzhoIlu2SjNDIPHOwq/J4ZiH3vxvXpPx/jphBvKgPs/6zhgRAhBN8QKAVEsMyU2EsDCgikmDE4XXXhiX6KdXiDrwkL8nsyyi7SpNkya3B0vNb3GCTu7mMO+Ovy320ukPn2RmtWcdYDB11TK/6CEX0wE0ffuk+tTAG0xcGHATdZSKb6JlTo61wpMENTT0O55v3bLfVWLxBq9qmKtoJ7JMAfIvIdW+ZvySb3RsIdD3H0JcS9+ed4tIAIQhC7+d2EAnluxqr17LWyECVHS3iL9/r5vP0jD4PwnIhCFnpEfkZ8Hb5HiQUTnTfQY7P1wJ95VF/kMaQQwqf/zvuG2ybZh2yooPYmkqBXO/uCi/IvinMH0WeoP3RxpC4iSFNE3qJcWEAFBTDw4qewihMWe+To79KzMSzIj00ML8dtNLOrv7ygXeKG2lTSfdbem1f9bXHUp5py2rmbneBW8XzUPOyr8AgbPvo5XR86MF0z7bGY0pb8EJg7YQtxIqLLAJLGppFFHo0bf4diQpRf07Kqh+HUAMEDZBRI3JU+jpJq+nSax8WU+Y0O4KKdfW+NRlX6PNMxfLsYCr2wP3WNnc9aX4eRGJ+z27p14N74gp35hAjyFngc/D34+A7NwONB4Y4048VoXLRGEEy+tliZ5hGZANx9UBhxCgrb/JGmzawGonbAEzIiCtA0DSSRsDEAV0QRGlByVJLQRnkn79p8iV/TSXoqpuEnxUZccIndTZoC+o8RYwPlM8E4Kjm7h9iUhdFflVPOMroeeCmeAUpuSnbqa1/rtwfY5/3wOEjgGTjn0Y4clXh2Ncpdaprje9D0amioXoNu/Z7uzpg8Yceu181dfEpiuDxabDQzlDc32qy9tUWfTw4u4e7rU1Kf0Bgm2ywkURvswnn4MHheHGIxMgrMXY57xzns6bsW35XbsQBQ6hB6RH0fYjqgkmINcxOBGvkYLTcDGFJjM9HtR//z5mdTsuRekYcBeo8RggbBmwkKUtF1kTIgnTwEn7Vsiwcg4BH3hlzJyqHxJ/NK6nhZEZ/uxLN99E7sMYBYfPL7Kn/q0xngUt/rJKpOc6J/bRrsbGag4Myv06mjY1GW7feRB+A9ROU+l1beDGMwSKPq50r/VBk3bNEmjuE+vthgnGX6xsz2i9ybemXa6EZmTY9fuwH7cny011A5fV+xWa658neYOu/QZ3G1KpgmSKrXHUFLOY/WZEYQ5FTa2OiTBQ1wEkHcOy1mZawyGsweva/MQe1petdCPyOqKdRzMLEAM28oMPDx+roW+LMRZ/7wFUeXze/R3eNV6zXW5oewFDRQnrMgJR5UEM2MT3QeydcjKlD8n83vfCOoTcSzkPIHlqIYrOTLXzY39mXGGvt083hT+h8qXGIkvxlv0Z/3MlEdOwWCoLeOMBP/DdS2mxqcgQb2goUGQ3YToOtgAzDpvsFuTVFUtLhlKU0/ThwUnxghcT5XV/qpmO/ohzvVByYuvYLjD8UVZgy66G6H5qVNpnlsf+TMWIgC64xqDpM7p4bGtTz6V+3kCjQrDhsHqRMH0gga6aWKsGsmbGWulh9DPI2zPbQsxhEhMdIAxSmo0kul40NsYEGVNDFVOFARhgAkbJefn+w0hYAtXurGSP0F9XScE8WZgZBIc9WY46Ro2wY3lZ9qngTaSTII1JtgCk0Y3UKsjanlDPXCRN7+9klpxWVxF34WReBk6PBmPtfX3T5LKfvxGJ2clDYYbDEb9Wccr1rE/R5wfli1ZyBgwS7K6leLpRx8hVXv3zN2ba081f/zFjucuT/ow48TDthYUuYHkWFc7q7OZwdc25r7bQ1kq6qf4US5vLnllrbOQ02GbLidikQgQkmXP8KHnvp4Ec6ev1vWgbzdpiYFIEtSsRogplQP1dzEcAIsRm1uv1gqH8DPGZ+THMwQWALwfImgV0a/I2zyYNkJgzf8st+z/PPJDHssXYe1ptsucCxoAGPEAMgnGkSzBACRzYosMNmPwT3VLh8T6e+gxeJZX+RM5ydbv5oX9lyb1tC5OXl5F38X8OoHq/+rSUonJe5TuQy8ft1QYDDknwVdkoC39HPVnAguxBI4EcNobrC3SGIZ7GW56k9WDA+3lS5vkZH/XFs4bCzE6JO7FG7DRPc6GHDeWKyxVu+IKrB2wSw0dGM8Dec9Bd9YxnMHqUBZXnDjY6hAiIpSITuuYsVjDYF9Zrxym/O8Qg1FR4QTDgtbK1PewbuLk6QgQBYfQ4+CNw3ZEImEWopizJX7Fgno5Q1pQqDpOku6AdNuwhdb/+cvl4oYNWVwijqoWqgKCo9sneAt6nCyGTI3BUSQSjpEv68WEn/XeCdOzr6cP/TyeDWro9mNoS/ZGYndwsWb/TG+ra8uC4Es13QtGg/WN1cpQeJRIkwahxmDgHRK8mPM+rX6nDYElxQFPysxc0FAr69qaYbEi7fHXeohqYu1XAzMk7mWtr7bKqQbUujOuts4LF7WNucXvOTkeZa06Yd5fKO/B7dBA7nQAxMk9Spjsv9RgA72zLlkDjYq5UUcbFc6VL6u+IJ0hI7li7ZGPSCFSjHRECgAFEYfBi7xXA2PfSP887xPAhJDRV3dfCNtrw+LPgep+m2FhzgCsPDha89EswYApolnxmqLIrTgeEJeY4LwrMqCft6HmaH/7NvXjJP1yOTg8NeTZr7Lq11dnp0bfFfpmxWZzyWeF8+z7501CqaHL6NuXEUf0XCRSwd3/gsIgSo7QG+sUSQ5UzAxmSsJJNaPjUQp20iscbl3VwA3Ol9Sez+v3LLmHEHt7/RqpHuOD33YhRvg9BONBByY+zI0s9OfvjbNXh2fTcz/jHSBACIjurZNbqzGRd12uu5H00qna+k57KgxoUw6GMXg6r2qOPOeKQkJyCB8ij4N/PjcmzbgsQnIFcRtt89Tt5oIQE24M3X/Q/J/XsDq81StIfK1n80xYnDdjsH40nqsAbUGeByIQkp2CnpQAWA3DTx0y9TigjMHuCOoCpX91yRdkAdiN9Kj8VotTI+589NSN/sno+GfLGfo2zLvb7MgtvqqSQtDF/5wE91oWky9Yz2s9s7OkuTgIkqfIVsWw5qxMFf/zx+Gw0x/M1bbS8B7HeKqqhsR6aG+uCmjl/i1N/JnNWN+Icx4Yc1mP38Nb6Ho7eLCzz2h4uL/+v8JKzzyiVVT5TBAXH6BuRnJkGPbD0zTMcGA8kwaGgRTU4jpzdWaauZlGoShy5MyUj4OZOXljxdxeJM9oF4h7Ku3EY1ouBjZKAUgp/8Y8/WS6jVGHhomgh+VHZWaI2/Bgvx2hMt0DTGmqi2YeTlp1iQLzFXgybYJN5CHgtKwyo2n6QQNf0KHMIrLXV72WUPQC3L6UWGDl8Nwd/9M9n698PQtNbHfqjT2RhuX9Bk3uqHvf/ZrvUkDwq2Rkcu8DT/WaiRKIiVg4ILBoLg67rUxWTnrE1HIULzJ5e7OnT5M/PaFsEH3IzocdnvlwpXpqZtwYgHvo9SlKSru1udpuoe9Oq05/5Sn1Ffb3u8gxklr8hCvggv6WBL5AJIrddMMASA6hBn2bLAUHctjkyEWrl8YwDFdhv/5cA+Iw82AUiml3wvg8ODCHZyASJkWHc0vwJyOAiUGmf963lH9jRH/nuyGNjp/u/tttvTAsVeWFZkaMLhGHNTD0qWAGkM8FAHQLIoJnpI1okxwHDDjHpZkb1NCZ+Q2Iuh7J8GpVp51ZoO/X+FINAeNPXbdfMZRW1KwqfIrWLRL7xU72yUpOWP8wjfT6TTl3TzCIJHAkSrk4jg4VLjy8dM0wL6B0R5qrZtIkWGhgOJ86AeO6woHlONVTM+PYvXYPvf0lVqbHYHS601J+vQqfn3oDcat2P+eI30RnrbM+KdNVmsOwbFZFu6zo2yfEU7VjUoo4fJ0Nm8ow7ABPch6PU/EY6X9L+o+iQHXRR+QjxnDwQVBvLHscw+S+b0qzBuQcgPSxJ//nT9p0Z+jb0F8AGG29oL8nkLy5KjQRtDWTSbBkn6z0v4zBm9CTcWM8hZ4iz0yCUX21/bAbxva8FFRzpfzFSAZcwNphB4os0PfKe8+50wYO9z5op5b3Y5DWKLvmGl5eRN++cCHEKZlyho8OOtSkWRHof7gCUSORiKChwO1ZAEskoHpCbPMYCFklXi5uDdvgeg/DQINz02q91rpXVns3ruE31WTcHJLpNsb3GgZfMU++6gl1Kn3iqlelcWeb7kCQu6eJTnWRp9vOGf019PW3KaBDQLozOwFCbLR4yYkrKqxN5yTSjczQ0V9bK6IhQs9IgUhJMJMQyxFpY+lJ8JehL+suj6CNaA9030/2PmoqaReSA3CtZESzBqz6PAyp1SLVabSYiiI69TJfwIRbwBGx1SQYFQ9uwpNm7PAiBr+XU/oL1b/dBgzXrrIOLIFqHPX0SbDp05ePNY/UlskZ505bGJc5myArQuwwWL1CV+beucz2z6g6UClhr75BswFzdoTuYez0SU39fjMpwWi6XL+BevVf6mnWBKeaZxVzycZQF2Y12KqpfwhUlQRee5MX0dcOvoespbmGG/Rjdo7Bs7c5LpyV9vm5uSbaPlRbXqquxZQcWtjeUb6WABzq0QhhAgs12un1Ng9DDF5AY+dg6m+HInCoIjqRYOFDWNE3aMizqUmuTm7FvXeJicSEFH1U+14ZqCnAnZiEh1poU+mM7cSnIb9D2VzVjCjA4drLYFxihe1c1O2SaA+4RfkZiSFM3hJ8Sdw6ao3BC+RW+arEFLPEln9iGtF6VM3Sbw17danRKzDTm/JsVdhf7iaqq+jrq20qU3brrIU6vqo8WaOuNjqD5rFMY7ib1e7i4RS3juQ5QpyVhNkyZ8bdPl/gIpfQcHGyKL+QHgZ6GMbI7auXHFwkGDlw9e9hoNzq0De1eIE9z+QkoLZW816UWQfWccapxe7sFY1SKqkwTNT3QQeSaqHNC1rEpuNSW4e+VQEmOiTBMCwfVmf1mMkVRPSeX7GzAQeSQ5gRjQQzCZGEEI9I5LXQXpW9NFleFSYEohufb/37Qp2can772qVsA8qblM+Sq4iIUmGwMYktIAr2QLcoj0jPRIKJiyLaw+opVLyX6Mpf+1U5pWdHKvkSW6/KCAbWAPP5+ueFC0S94Yp1MlhHMFwwWKeKFAspC+pkmwauZZVKxaTXo42Ecjroma54mSAQqLGtLzA0Dqw9q31Vnb9SgWHU7HxWo6+h76pHeseZukrqwlbhRR7cqKC/XKucWjm79KvCi3u9Eq4tGrLJpRTTpzccPKjwNYF3cuwisFCs07e11667ct7PqkuS6xQYCZYQRXdJkkhCoNB8/u2PK9Kslkj1z0wITHvAR97+qJHL2ySM4fOU/i4tvr3UNmCmsuKqDEH6W4tlN2lNm7UxbYyNaWc8D4kEkTKjXZn+cPnrvCBvw/DL5PXU8eor4PnqjVyZHq5UVZSMIzRIMJLn9Je4wLqkgm4ZbNKSYPusAbz+flv7+tjB7eyVMej/z97bbkmO6tqikuyIzOq13/89z9h379WVGUb3BxgLkATYjqxe516NGt2RNgZsYyZTXxAjZmeZHjkr9QgZSrOat3KMqj08BqyPVgiyBcP7VbW0/FjCMDRIbJkIWvTN5aH8yiUIOU/SOnVR86y3NRPsdLKJPCSAAxavbO8D5DAkSKZcrzb5ovcM/XnDz/gnRwwGSG7PuaG7UtlqGzkAAm4BEHBB3BC3gLTn5aCFWYyne1xWCRP6rojPHX3b5M9C+dxJRanKVF/HKt9twIQp1UZgoHAonxMhjl1HgN3fPb3nuFUDwZPwC3lFfDFvED3zOPTe84ylaCopqFryhH7blBn0HbVAT5FUp+krUnFB22OrgIsRyls31CjgQI6ZnQTb+udZGcJgW5AQKSmfEYo44J3+6hdWz6kCtqN+DZWtahVtcElYVRjer1VqbDXVjSdcgcQZgys5zGRaeUdK1O8sPX7Ak1l97E6rso1uMWrC7vbfAiARAI4AJNgnSP9Fay1iwuDdzzkqftW5cMQAPDjfMGBI2yXEqCRBgjUWP02cmtkSCZL+Oe7++3xwTj8p+ahjALYmU92gptqJ7cdj7FEobMBEKQg4eV0JRbS8PuqiafeXDmnbRV4Jl5C3reCMwbA/KYnHaj+FPTjKrHe0L6o69wyAnea+3Rl/TBdqVF4f8LXH0qm4LrajoKYSxaL8CehVT7V4HFsnTwtd9GtAVz+FwYfTh1hGI8KCoc2Gb8zXaa6UscIVFEm97ngaLOvhqbMzQNVi0YofENXWIBNnaosok7g7vLkqAz0MvuiZbDWtyiDUzxYjLIzAzqtXt95qdSetD4Ec3WGvg0qUdaTdlHfGhHWorjbGhXELBwkOG9KCjAyUmrBca0enVkIkAEJcER4LPhZ4rrr+uSuDnLhbzILnCoOJVnGXWwLUooS0/OwIuUXKv38vTLASPgm+CFfml7Eko/2//pR6o3LEliGteJTQHPHrqeD5hAprGIZPrB7UDLD5oEhgaHbgBvS1Cx8keN+GK/kTtLsfaDJiEvYwuPGGQ5JwlFXQEF1mSt6j91Cib6pGXU8bNmD1JajfqAXDVYuqA/Z+6ngL4Oqlq2illvjmO3LM3u+Ti3rj9up7FdGBo79Vaov2BAoA0QW64sHJOWvjOu3J3luW9guVW8P+mtzJrJYKg2fdSDCuYBm3gIQFCY5O0UUHy715Trjj4Ir4XJL++bEmF+h0JzN8qw3hra61CpwSsRlD1kIfObAEYh/vc3eWJoy5cDggrAQLwZPwO+DK/NL2ixmXQQxuGPM9Qu6fQq7Yfe9xXTavTZPibML15PgxMt/MzklO+ZKg7RiMRTxSr7VxTUnHLUutJy9QEFKywKO/h9uqJbSTD6t6Wez40ympdbYLw1Ur7dBQ44mjZN0p7GS95dnqUkNidlcRrcqg+tqX9l7a4yPVWlk5fakyWlcq6LikazrM0Z+569kndSf+HkeFP0+nw0mk1hom56Sshd4YKRSWYA4IARkZ2y16BzbdabNG44qwIKyY9M/rwqQlfy6v9MzAM8jKwhurL2UclNikaQtJC11foCmbGDMnxhWYF3wGYIav6AvNKYy8WXmw8Q5rG8AIUa5+ZAlasSkXpAHpBgTX3PfeVbTsQKaPg01oU+9c2xahs5S6I1w5cD0zkXDFEr4lp83Auqga4eLs/ngxMuB9S+DS/7Nzi82PQWlNcVzaBVM3y260ttt0rUGLUyW261bLiSUGg4a+uZWKNw+KVDCMD8+RglYZTf3QH2nj+vCipNjMYz/A1m0SMkYyqtmU5Acx4rgnYdgskzqcpFVHQ6k7sSoLjFsAJNw3aYCFeNtoCwE3JG2HHoByO3lZxtA/7/SXMOufUwwS7jbgq5uhieYm6S/uOxQZFGEtisog4LQlMB3uV/k2wl4GsloK4blgYH5u+H3sUdi2OxLse1iORc8nMkyNGZhHazM66dfgo69Ov6oeur06lw/kqiB29M/q9DAoQglbkOB8XGx56cS2TTsNzKnKeaFAabpMGBG3Z7DGV+6dmjtXPe7HYhbJ/4xEvhbNVRNSHl0tr2q10/GGJaaql+d6W5+jrpRwclRS3oV3+UWpAHXKhKTmvc8bAVXJOONRiqmvRvtmTGC2VsMSp6Q0Q8E+tFQMjiI7XypReMEUjxSYt4CImHZoeBEh04Ic6XsKshc7CNhb+BRNY0y+AYCAT4LPVdE/FxdYfLfSPglGm8wAzYU7+tb0N2OYGlzVcOXKCzpqQ8otgdteHs7S6W8gBljgydESzIGTO3TdaRtThRwwvJe/TS5U5aFmVfIK9+1R/wZ6NforDs5qoU0arUKvY12Edlj7q+5ilYoRXVZAIA5bzBGNFMMyIi22+p9+DDm9q0bX8kIOjEtUImPUFi7EVgXW+MqTlzmLtQzDqApEB61Evi0SF5dr8Amub22m+xmDmwKxzkKwwWBCAIag5eKQCaLLfjYlx5TDp8UKbrZEvA6vtjY5LkF2KVDym0Jc2+WXArCJ4emYIQbFmhgqK3JuLmJw1mBmTyvRujKiAsMWAIiIAQNsyCHQthERL4E5cOHkmMFrPFsLAayIT4LHkvcfTPrnwgWa2qfDqonXa6s2A+voq9ZmUE+ZCatqbI8JVv2nM0VOlSMDwGPFjw1ejK/kDl2+n/2/FqaWY8rkyj/D9kbeSJf4gvJs+0A+aHU+EFGWkIUx/5erydLQu44qsUkzWznXjhuVC99NTN5YK8FXqAv3FhZ9F3pzqWGugZAA9w3jopUOkg6sxsJUvoy8jDLlCKPu39BWVdFo3/Di82PLibrCYGien/o0pSbZ0kJn7KSGUvs7ASvN3aRohJlpZrCkfBeIQJx8r7p644jQG2NMFekov6a0P91vqDgbl6ByN8Mdg7ORJudS5eNPJsQXRwM4IuBGmLcpDBviChwAc3JKSk1VCYyP24sFCIAAEaKSLKafxOcS9x8sEmCNp90AODBbPiNopuwKfY9H1BsI1ZSEBADrsXcS0WEGppIEU+uNtccs5aMEEAI/F3gF/NpwS9sznMFLKmepC25W5/JyDHHuG9F3TBz0zXvjqY164oDQVA3nvGukZIokXLKFIlrSqNEhoWKw9wqsU5wuROS8t1pUisfZE/FweFA57rj9BDQmIQ+2SGzBsNWWyo99J2oLg7OIiaBWXFuSjWN757UyJQ86ga/VE5hd0p92q/Bb2YdKvxUrF4e64Bu52XMSbzApSXcYJgG6oMHwxhgYVoIXAzIS42ujZSfBWwhLiHAt0JeKuCs//UOMPoIFccW0/+CywLL2X1s3HXQrd7hrtbLCjuQYtmQGPkCXPeyiPWJYxgo/Vvxk+N7wK8TtGZTRbZnLqjKe6XpIpD5gaqeHvtyLvgPtjqLvUd4dgsLgOnRJ1+LrwPCUtbiOC9qjgXen6CJh1r3eWFVntMr3XBxJZxg0FU8dI3RUWXs2DW521HStRuIuDNc1qP2sdyWq2XCLwbDDsIq+Tbc1G0WJvu3KaiBn5JwMrH704xZPbZNmV2KFZIZk1kjXUtpn+qi2DRgLmiHW2sUITpHjrqNcYM4w7Oz3cAxO5FfAWJ6YiOEVOJLgdcOwIS7MAWp36Dx1NwcL+1GkwivCY4HHCs8Vng+hutmJ5XF7ly2aFv2tCkykojQ1zL3ZIQYsbcXow5WYV3i88DPg906CR0TF6VD+mJHqOVuJGi7mwEqV3Kf4UmUCfYXauayhMQY76Ht6iA6Coo/0wk0zbkee/qTdFQvmSDCc8MzahQNgiGTtgIqYDjp7pRIACXzVLQz73DQCuv5oytdXiF49EsvY7G3A3iyi1Fgm6f6N5XG1xZYuAxRGPrmFw0X70pT2pyvnsoGqXXIyI7QNtU67u9ZRH/XVux5MtdHKiJt6LBN2Y0KR5FLbjCQHMWxMFEJKThkoBAobhS1Edyvm9KFB9c3mYVoqkbL7FS6IzwU/V/x8xPwbvK7FjJnJ7o2+0LcIB0Bq4oAHJU+U0ncaANYFAeBzhS3g31vankF+0ggQQfm0bvlKgGzsw3mAaaqyXugI/R3rhmMzbjZD19F3oAkNfR1vLIf7thh8YtxLGA4IOR0HAOAZzzIp3iLYGFoiUUnUQoOVfrLNTQ8u6J6YDyT1rFoc+aS61uL2BY5E8Y6z+eSHtWNwgb7N43AXjffLSDx3JW0I0L6xV4VGzb3sV2H6kSusnZtkMqx2eLZv3OHEs2KptFKGS8jDMcEANiSYYO99ACRExo3pFXgLuAXaNlpDCBssa8Ps91uVkas1/Y3uV2n7o5j9qnxC7uRzJh107FLjjTUEKrYTlmDNhFB4Qe9K5hw+XGydVFmC94MfD3wFfL4iCY7KlAqGFQzWpr9zWujbHKfdenT01d73iaghDbBN7Vg+66CvhVse93WmnBb7xzHYh+QCfaObR6GF1hu15bwVo1l3A3FMBx0/f+nmn3HRIYJTouW4F6qmvblcMs93ue+OtHM0lRgMhld7pYju3kITv1RGD7voax20ZISwTslI65bawN9OqtvQROBWvkQc9N/voDhu0hGDEViGplJDvqPXNDCmTF6MK+Mr4Eq4BdoCMkPUQstNgi3BXUlS09+PNYX/rnv6yQjat5uoTqC1kQL6OG820LKc1kMs/kMqWNFK+FzhueDngg/ENZWsguE60V1Z56J18+1C+z9bBtE3halVlasVUvGvrlZqnlvlc4u+2i2oqmm9Y1XJWcXylRlF1lDVSWdIkM13vS4dV5XFYi6O6AgdH3Cxrels5wB2RGf52/LDqk45GmAy/h3XIrfJfqshkB92xrZjGIqeTBmzc9i07NI+lg87qPytVtL+G++DKnk+y/9mr1X76RTO1t+qQN7XqKyq85zb9zvbbdlbOeoDY/6nnd1/NPUzIzMGgMDIAIHxxciAzBAYQyBm5IDMwAE4AATTa1Kib5wK8Ek7/V2KBFipNzbsjRhoa7A7/jxHmi3Z44ABmAhzGiwqSXD1VAq6QxBTV3I4XuZK8PHAjxd+Btw4qpyUJ5tz+lWRl6zBm1zCuVroGzXMZhNK96Z1zgNhTq2KM1/bQ19D7DBft11HnOxXDsINkuD0G5Pisq3kZyRbpxCImKAGyJGsQNCdQGvFYy2q9deiwmYrANB4bEGplK4Mw1Uqq/LljL4CQYKLakGg715SPswZzfatMl6feC8Aw6OywOBcFSOLzKZaspRax1sXiKcAoOHBFgkeUyQpkjcaqXiwXT52GwJHDIZtI+YNAnJg5sPx1rK7HaFHK8KC+Lngx4p7+O/Jqf/00GmRWM2T5ZJgEQccdrjNjs3VDkhG8Gh6sxKnlwWfzM8Fn4R/I6zAL4a4STRr+Foh08gDuWwJbtvtynmdc9nWWJhTpeOVl9foa5VMf3YXfLdp7JsI4wlV2sDSdV5U/fPxhbfrgGpcBWCxBse8HwMAthOci39d1TT3Jn2JtVVzLQxbIjXVltKyOutjsJTKziA7ExgrRbTFvWRt4271jlTF1adzBb6b95J+VA9NuzDFs0Hz1qpRlKN6qoNtyXTKwOCBe/Fe8ch6ywlzF0Mdc4R3YOS4RVIAJt59Hu0eEuAK+EjoC58PiO5Xa2sAHo41apNVqadGLlcrsWU1raxtXmhqYoLbfsS5jTCR4K8NnxtwtCKX7UTeFhc+rphm4HMYfAp0dVKuljfWbl4Bf0ZR1cgl+vaCjlwMHnwgIYZ0957CFQx2pXZNGZAh669q0lbKJKqStgSOClgtpqjbTaslTatyoFdVzILh7iNyDMaqf1byRdUwGErfu267FQZDupFiu8bmqk61J4Bz5JLxseZvISWTjuU7lQXi2dqNuSnZ9lwdAKrI16opHIuugrZiaJ+Gb26qNOEEsIfOc968JHtVJhU0Q3gBrcjIR6amlpjR4XsVc0/iryd8PE9uPlh0+p1mThs0V70Q5TjRyG45wWCLwem2RbEoSPhc+bng5wIBOHCqsNkl6QhIaB73OWfp67FeuQPq70LKtz6ndu5PWtW1e3k0jjeX9I/XxeYHsfL93YfB4tr5nZ06Zz1faEOQgBZeKByvQiQRdJTGVoFKo2jN+y0SS94MO7y1x9XCsnz6M1YeCxswnBFXuhf5ZgRxa8ddRHNgVVvuZ1cN4Mu50OorUuFfy4ZbN+nqckLl68wQaPFXrMG+huFq4nQ0HLmrULL27oerpjosCuQMrOJOUyI5YX5OmyNx/MaPXcCL7kYt1Aq4Ij4IPxf81xN/PeHXR9I/t1LliZyd3GodJMHdBmBIAJymoo2JMN68Y/RVRUJ16muA5xLdofnF+AqwRvU/JC10pLYwNDsnEtwOnFsU0bKhqXfko+8s9A4abvPPyvR78TmoONpITIUxWpvPj7rhSeqoG4b2i1lcRIvi2RIgwkKclIcZtI4eKdOxFDdVhckzWpurbEI1AKtPVtVUq1FMLQxbVHhE5I1k7OdyXGDZ7Z+H0r3dicLVe1FhuF2OZsHJ5rrO521oeOpnbK4xCcuzuXttb03bo7ywOYJ7xsoFmZAX5Mj1CXkhXijIzY85IIeUGQ0hXnlQ4fTfFXHFpHz+9YCIvln5rC6o3efb34sQSwhXyzhHKtGmJCMRBwhMhX1DpFCS4EOCMtUSQWB8rrxt+PsFLwIO/GKQlHfHYEsRrZPgeU7sy3QajYv+VmPeUvuFFdstKjkR8qvI7e4rsuYr+ueoNcm/4eb3XrelLzh2u0p2EVoDUVj3eCTYaSsKzLA8ZUSBud51baswZgCW5UFDbtVFq9JequRVFXvDJV1regV03zSK/TwbzTqzhmEWxcpqFf4aRY7EMrrpCHKbguGiXc0kXCFx/Gp9PUflFe+gL4nUrSvykv4FQl4oIDHuGx/xhvGDw8BIgIAcMTje+AJAu+n31wo588ZDRB81D8J5SkqZHoLqgH1N3dok4oi4W5Fg6Y2VMVjKoYiGQjv9XDA84OMFL+YX44r8ypPpvvccFdtfVHB4HJ8hNHdpoQsxXuecv9Uw+irg6qCv00qU2YwGTgHT7bl8+7meizbgwGkEqLpou/5p+jtgDEYEWmChOIMoBaqDodlQvVlQHWfjZKeiWhtOKif91g/LkdZ1C8rwZZnMq1VKSxjuvljrXnYDV0nX3Af1Y2KtKro7K6taigpoUftNzalbpFpXyUWVk7oyYzCMrbGgh74IgAAr8YJhIV6JH0tYiNclEPE+tIAZ9j2AmQGRAaOybd15MCGuiCvh54KfK0bNc1Q+E5ZeVDEy1varGnGz0vTP5p8XZN0Rd0+bWU+gQrEcBcuIo2wSzi+tcL9meK7wXOB7wy/kbwNH+yruw0O9Fpmx7E0yDr1lTwbRd4jIXkFf2J/wXbOao1vuBZ7bdbouiwHAMgOfxXh9ldZUxfsaPOnB4so9JaSk1rsExOxsqR8NFxtbnd7wMDnpq5hqiaOvzqfULNMVDAco5oDqBkF5kMe9ZBdouUC5a2xWr+D27BxVtd09HJ3bojL/83wfYO9DX1r7AmgG5srzDuaX7hX6UtI/hwfxg8Ia/y3bQmFZQk4qxyGafiOh5mOJ90J8MACk0KMnYdx28Lln3sjRRxTTURhIeXp4vdU562DAcSukGA2c1M4g4pF2dXRo2CiVbll5yok/om3844GvAF8BvwKLjL7qDFj5G4/uCtnAsLnl8E1m4z+IvlaLeoFbJED6zAnqSf6IAWwSpfWrLUlnvjYqnwND3DF0/y/A0GRjct/KkCFKjutLYiTSQiFOMZuq6BOzs0N5oaR9I7mlKsurBPgR5SSUyk9bZVqbElv+JA9O6f8ir1JdqZuumqRTLTB4akQspwW1oRH9hChg2nEZMAAv+yc1bnVRq1OXU1VtFhJ3X64sqVYIu1FmEWrnlcJz2R7Llulv1j+DwOA4DpkZEQn23GkEsMTEkwt+PuDjmZTPOn99L2reKGvxF2npoFvvaEtUmrUu+Fz5+wVPwifhN0NgLuObKktwxuBR9M2iwXAXgzshRtoA7KKvV8lp9O2KrzceuXCASrYzSoHBvqhqXoeaR/1znooOk3BT59E9tR7tiLtcS/WERKcSOBEipVwcsRgW/+UKUKvZWVjOlOc8Er+bK7GI1wgMV8pqKjdXUI93MXhcuibGQSXwvTJuLmw/ETXzMxyDnSs1e4XBiMrbSqvNJhnWiUfgY3DuQ/zRJgkfESWl2uEYkUy/DwoPSui7Lon+Zinm/JB0OUzMHCGJMe77u+xpn+PGR0vh/MyRBCdCPDxvnjBYSnVdvrwbdqzngs5K5qRbJgbAKgJYimoAloro1kS3EjxWfLx43XAN/Dr0Mta9T0OvFG1uhQo1S6geD/Ot64GiHr3MFCvNs2N70V6P7vnsYJgvve4dns+xqkWDzxH9tvSo8tcKJf0toNfrZ1VP7wKbENcVHisMhj0XR54391m1rn7XQJqUV7Q8kCulZqu+rtt8XF2sHcHg2c4397Kr0owFyo1yu0pI5SCqT7jQBjYvfR8zP2PqHsHgKI52untJrj83SjvxfVCIuCvQl5HqjHIcEGmnYRtiwACBMshGG3BM+xwDf+tdDK7J1CbBKgY7hQ3JKmiEEHFjS39KLTQJd+hUWLQNBgbHJ0J4xAQ/if/ed7YZf16i80c8kv/Ra4Zh/ymNYPAg8fXQ16G/aPwekfMWDqz/tKAuL2uYOYgOnmu6wmC1Uel1FcHYK1N2tZEKXOtXaRsmOGWdLyJkosUXxJHjv7LKKtzWmKpAa1wd4DV5EvO+r85VaziNwWqQUvtE3W7UGHwCff+Uo5b6qI2tG6/6IBod6G+GUdFly7RvXt7zSPc2nN59r6LyeSV+rttz2Z7rti4hBiBZky0nVyxgBloYw7H/N64EzyXZfdcFljKJRfxvdL9K0EPHf2flRo+ZKHICyh5XHIxEHFIKQ1Pj6Zrtwam74uVK34ydBOP64hUrhrrnPdnTdLwt2mRO2VC+gKvE14Lewbfs098b5cSwc0hwFUfUXqXWdlh8ubiQSz+sFn2bkWPZgxU81kLdDptILomw018mrDU11NRhUd6utPqadLxHhUF72JW1+BYe3HpHW/2vpA0pbnv78zK4BjrK2zAcxYpcqhWI4lrroRFCVEXl99KOqxaSHVsDDLwgXyzim9taiVfkR7T7UnhE7kuBlkDLsWDNUn1LgTGSwSU3sCKsCzz20KNSOOOufktv2Ay4ZcxdDt0UWEsWvxPMwyk6c1zhhEVUQKzlk3VQ4T0m+Lngc8GvgCvz6+jEoSXGa8rn+m6VUVZg8LBDVndHo0HohSn0HRwxd9HfrghXrJoES7+R1qJssmqxRGsuKfTPrQG4h75TYUj1yqzi0wQQDhRGKnYlwvTf/U+hxGthvZLBrdRbylKl0VBhuK6kNEyKawE0n53qeC5fdebE7rP5sZRdmqoDwP12/cc+W78zlByOK/29q0tyAamwHexVRW1Ftbr531pLOdJ9YtUDKSe/wusqej4/1y16PtNu+h1ZQBy3kA3AC+lpN7I62ofh98nZyFfhBS3svskXOuOrdIduTbyw40+rjpYlV4LnCs/vwxUrz6TnPr6RGfa0z7PoUgmuRalOYucp6B14CAr97V5lzRAzz7xOgBXYxGBo4FbjrHUHqjKC/kr9c6uF3oeQdlCtvJW9G1NfEMa8emVmVaq8QJGZ6yp9zZ56tpdBUELpjv32ys7yD0INa6GZvkGD4RPqSnm5vlzwa+zJveoha22WzjarxyyD+cJmM5BYGAzN62vLqxhcdaAL0sXrKy/PmucYd7S7PW/rktC3Nf1WzUUttHSQTi7QcaPbdcfgOOdkTkl4DgJFK29SKhoSAhBViTh4h1vRJzW1Qht3BAKG5cH8Y1nwscDHyn/vrlgDNKVyTz2TXPBa3NHxTu+CXijRdxgI78l7dV3aBVO1OGth2DXf1hNY634VX3osLp2Tu+g7Yn8TfZb+elxybqa0cQgSxDS2+za07Vx2VFzZSke2aG3FyiC4dy02quilVan2unGosHq8OjXCEcEm+tWSYuoztR7mLB2fFceAqi4ppXKi3YwBtb2f7TVz/VKitGUrBQloCylHRvKpwf4oSHhxx9+7z3MkviEFHUXXRaprTnlJQ/3WOCAsDJC+OFwRVtrRV860BCByVB0UZXw1Pao0xhDekws6C+1hSJUOOaIy7MpqB4NBWoXL/ZQIYV3gueCT4IvwxfziSp24l9wtcPswv5rZysFg9dRhcFWuuA16qwuVhoyzP7tQK2TXx8ZuJBI8Dr0qA1YnGy7Df9Pvo/w96CsLi6ct60ljL2RjFADo82Ylx9cjSk4too5JfDRzgq6ElKLG4I7DcHUKoEbiov9WH7T9HtQyJ+T0hZX4QO5zYmg+BQm9Uo1FAAgpXIfKcVLMqcCE2Oot9rMAtl5axeCLUlHe/OdyRBwl029yvFqCfC+y/xF6d2cLhP0NRk014p6CIypQl+UIPZIr+Ox+9Z8m6wG6pTARqumxirBgA4PzkcqBK7pifaz8FfC171EIxbWWGfiexPozomqeT9p6YQh6pzlu6YmbfqgeOJPi9SQvWaQi2jGF+cdb1iBxFwCi5pmLMhX6avnRbApoubvbpsiUEfpQ9KQUem0Wp/gjk56LOot2PSNnsZYWSxhWpTUYOxppsJXS0JwFDfidRS9oq4px7PRrvkWqVcJgZxoDAYCm6wHjFrD0rkdkYoT9vah6i6MwABhseMRluitsFCMRj/egsCTHK5HxSrg9V0xX4m4+y4BIfNwKcdyGoTAAC2I6wUrvT1B8teYVQNMzA0BlCQYxmqQTlsRg2MfakTJaqKwBAAnXJe1R+Aq87WrG2JycGQdNvNclI6tQo6hlbgguUiufwl2rD2/WTjc2YADIns+lMRiaWQdsOGxhO6JvSv6865+D+PMC+mYE9ULOKgV7bU4+fiIW1i/ChMqHN5Zm/xsPtmk9qmqHWyN5gusxJBmtAsONb1fsyXEtDCBxFmveb9241AIn5Pr8Wj29WfO2CsbWbIEpni1uV1C7QLckWKbwhPKBWy9lr6pOGH5ivmhmsjzOIUblxXyTC4bnEp7L9lxfWflcVSW+xEL/vK8zmANi0j8zLQArwmPBp7bvQqS/1CShvCgnVNmzhQGgdMISns+FGRgBmu0Z8qnK30pqrbk5SHs80keAr4AvhhAgMAcR74HnfaFlB51AzxGFdmX6FX/eqW2eo0hWny1vpgsS3Z2QMPs9SQcoTFqTvDLbTfVQThuKz1RViU2OpfuViD5SNc/1te3tNMfUnT+8GvZFxu5oyDmXgqZxSDh3LdPvfsuab3NLi7s5jMQH3YHhpgzsPTlOgTbpg1ESNDA+MV9OOStZ2zxYxapeDa7/LZ1ErioINkHlVdYTqH3aAaAOKG8Vjh29dKvekNcaHUmiPsnMeqM/xIq87Nmeo+PVQrwIfyv5DVaUN9cfjycFSTxIDAS4ID4XWEuglSE9zoSuhgbdsrnCHZDfxDJnqy0RhHAooo9impOz18VyLwdCfK7MDL9f+CLYOO5ReF3UNEZ1bEmLwb6LVrso1Y6f8LHqQ6//ctXLb0LfLHruiwzP8hunHc3KS6waQGB8fdCmvy36jjg8O4s5eaoF43RWzJ119DByhbAyG+VgyIcUVZ1rZXjYS4rOuCrTClpmYRh6lLfs81EMtMKgQvJN5tup2qxVwuDkKkdES5ezG7wKvTlhRTYAE0JlLQ5wuOBZrynfyFQM0vjTrkpW0Eu73XdBfiwx6Oi1LmFpsj1DSXkr3BUfIxbRBAQY3a8WJfNzHf7buogaMudOpaL4YOasCijLP0snLF+q3YhUY/BIJStjWOBjhVfgr4A5r24AIE09OFCxk2/BwuBxcYKAb2a951ZUw2PuXkl66UyF/f0ijQ2frfxWZvTRpOZ5XJVSgXF9YXACP8w6r0950rF5JLHDSFSuNO+UxKjIqyVMTzrlrW6mRTLZj/bO/afxMwO6ewtd8b2xVA12aUdiq3CzzUNWI5vpz0ZikNr+WPepvh6EYq2Qie+CYV1iyskto69sLkOvhbtHtxmW7NS8AC57Co6MtZldWTyEUEdHS/k5nITydkdoF4BbWK32A24J7ohkd+jXil+BvwPEGI/9/Kz++XCWruhI+bKS7Bg87VkdX7aFvj3ovUp53crPcF/b56h/1S7xD8zfeObB6XSvV+rWV6FMu8El/Y3HrhHfrmTuy7s3ftaXMBeOJO1sCOW0eJHVVQAJDRUGDYPVqhynLQuDATyO5eBriwQ+GMNPIa7TqAPGjvikufbJKivPVLJrqvBdYqoBoKqjTzzz9iosiS8BZLXzg7aFuELfTH+ZMbNeFXfl4ETkbCGihXFFjLsQrpqfs6qRto6ckHMJolU6uh/MSmUeYcBig0JjDLhmvzptFiEEghXgscIz4JPwi3Dd+KvXjR4P9u18BQyf4sGV3Iy+f0pG2LOD7tFvJ3CBweP1UMM0pf9z2KnwcRagGgmtmdmfyipbnDxoyIHBqfAffpV+3n/vwkZHTdBRR4PBsaAEHrB9f9qSMIa11rUjuDh41cgtdGXWzi2hV/6g9Gckl/V2Sbx7J7Uk2OqVj8EnBrHos4K+6xIeSyAKC/FCxRclFc7MuC+zD9xVdDbxKRHjyvgkeCyJAfty4F+zR2pzbYfLthPjXklxYa65s9PAAb1Vow0AZ5crMqgtGqrGii47gEkIIbpDr/B44brhivySiyK9/5bjzDHntpMjcQXDEoOPEM9JPB5H338u9GZRhpo7BflhTlZw0WBVgSGAdL+KBzk06DvFem1nZkeORvf9GHIrOSwEhLcU7Pxg/32PUV6bTE9iMDQ66hF1tFp5F1xbtWdgdCKVVYw8pz+4aP2d+mLbBYeU7NYrD2JZnuoIYAWDWzmHwWqxtsNOnbG3EX0XDAuGhUJE33XZECGib+S+lXtzRF9BgiMwQ/69G8j3QYhAC+BDemDt60FCIDrArN0TUJ3WDteJU/sJ7qJjcP5TlYb+RlnTDkikRwObht7rs8tK8CJ8LvC54O+AtG8SbFlzuf5Ri0pN4kHiY7/Jczk9hP75wFRsCggZhd7ZzljVthrDcRm8yrDXAsTABgQwslHOdkMEp+kuV+PEdziYzXQj4KJ+DoUKesrT6rS+X8Xg1B8XJlVRvaYHqTCUz95xrXKQ2ALIi2tV69bbatuSTjSzLz5v9qEXB9YKXfVyLgbNZ+Esd9q++fVL+guQNiNZkKPdd6FAFCL6HmpnG32ZUeJuEEMxG1AQGdeAT8AnwXMpUnCoctm+q1wS65SKZScrlrm3bgO9GYz3OOCILo3yWln3EoRgkmBHtCV0jAmGrwUfG64BX6Wr+u7ymoOUutq/tlM730VJhT0MJjyuqgKQ6qqLS0SLWidvMdu73j7Fj7vdofU6Vc1BV6fdodfC5WrsLjyd8zjTNTtTHcE4GgfzHcr4uxNSeUIZM6MOk5ZYXtMVFYYShq0mrBAs0JB4VmbdyMeLOpA8y7n92+TmVKWCBvGE/Xcn7QXqCgmMFVj1Rk47JWTtDgEQwkq8UMTgZPetNM+y0RZ9mbG1/qYZZc+ERQvQA/FzSdsfWTia55yMlxChyqC86rW++BhsVc414mq7IXWFiAGKjBzpuLEHsDWBJuX23hUkWBkeKz43fhJ+E74Cf+fVU9ONmCRFw05nMSB0zghVPPi45rmlvw36apuejFU+3oHxs3dpP6OE5rnJ31SS4P1PpVc96AWAPQW0uftCVc/96KtelfcoDcfEkSVOiPJtt+Eip8UJCpIymPRf9iek9egBw5IKt81ZnLuV1vvMwVEfD+4NTKpEVTv77WFTxqfO2BSrDuapZSqDpm8sAONTax9md55AKLJ2ROsv4qF8XijEYF/crbaxZGv3zei7BQwJhusnJtF3WQItjJ+IH+uRgkOi16noo75USmxFuW1jcC7cYFJLf6NoAGyqo2cigOX92JISYz0JvggoFJkLLEvwJPeuKzGyIKnHO8rqRJfLy1xuXYs//P+4/Vhlve0RNdBrVK19/MzoW+6+cBiAK7lZ7ayNN+Za7xI24HBMH8mFoJhezRvvbhZriRoUBDWE1HyoalqNJJ6FYdBusBujPIKjpwf76aWm+iRHetHCMIzdY4XHCX1nEnCOGOyhwSalKqx/WI8R9+Yk/SWMNmDOaSbjXUjrjIO+WyD9443sBnmhQAsvH0wfK3yu8Fjr8dFOzRUG3+ICbYmjix7Ep72GHYCjJRh2JXPeCfgElypIsNsbwhhejY+FpStWGesZJ8FB9O2nuBK6CvmjIy39rdBXraQfemQM//HZyDcJtzX7MkBSnWsZ9iRZ/iNV0bTm2VyVPDavjH+qPT29OCuHnNoER410iBMKQIKiY9NfhDKRbzktVrg1mCTLCQqCMXRUT6nVdmE4iuZ4pTR6IhV2F9pVubJM7Xp3OzJImqEEdQm9YL+v2uSfHaGHMVi02OvfXiyrLlodT/5x0F+s6W/b/+zzHH8Hhoy+oeltzgeByLQEegT6APxrgY8HrEtBQx2graJOx5lx5S+d/jRIcNuueiQfzz9yK/vxFYhgi0rzGayVAcFFGsveFJjL7Dn9cKVIgvGB+NpdsUrPZ3kESpe5SpQEWKndcvq7d20kaxtRF/uOxBPtDlw1/lqvoW/sjMjOMSEJfXf66+mfY/k70Fe4dDVHNPSFOIlsGDaS+wfEbEfqaLySilLWoObHyOL72jjV5pp9GIby0fqMrVVZZ4m+5OOdVCsZEXXdY6UxiTJF1gejbEGDXijRN3oUV3sw+GJh8DtE9jlmq870N7lc7bssVN2Qwb67whm2QBF9N6Z8STKKC98rQqaF1yfToX82cm4Myo1sWMPguewcigo6w1E1dWaUBeKoxXa00OopB5KzJ9e6QIxHem74zfgSiX+TEvJ49NJiP7KJyu5Old+uPGhdNCC68tn9Uz11r6X2HQ7S832od27oyYG+xdFbOzbUDfE7t757HsT/Rv1zKM1XbfKpbgzrvKvtAcPVo+1yOMdR2ao58PFNVUicCthddSJuq3gtu45psVzEuwe7O16ocsLRrEJfv4fd4aFicGuDmN35Q5Jg0fNUVUt/KWueuUge2aKv+AcBsvsVACQqHK2/cSFCxOsalg/GX7v+ufXA8j2qKu/l6+grNaWzqTkidBo42MYBizjZ8pqUFzq/pWK7hTJaCQIEUiKJqwV8vCViWPZ4pK+QSPDBTtIM6Hlala+/qj6ib7bvWh7O5vY4qRuVpVOgncK29boyLLGYNVNt4zLiY3zd6faEiGeSbxB3WtwWV0A6HEHAANAmwHJbP9XnRiy7cnS/goBbwBAw69biM8M9PhJKfZ2axb790xc/E1Y7ggYiW2p9cpcQp7Nl5FK/570ujc+L/uu94Lpc8+PupzMSFKT2rVU7R/o7KL7XuqN4GKp812CXTn/HWUJe8r/o/0xh71JM3YpyJVpl24jK58AYoM6EJZ1vCJkorOu2PAP9QvprTfrnpdkEaVai4npQ83kXYx5wlpK7IWkm1oyy1d4MOR4pup7LN1aO0APIad8hGOjY8gGiFnqPR8ok+MXS9BuFGasO5udpYXAqhkXhZoMjUTRxuGTZ42TiK/WruT9Z3Wq8LIsI1kg8uPwenxtaGL5Of8meBeUTKJt21MhFgaaYmv/ZvIsr6CvsIU3+54P+QloFYthQwurG2TGAoZn+buF5rTeymoUD7MdjkWbZw5ZFtaNyJMmlqsEeEd2iNAn5UbrDwVmC1B3QHvXUcidfFSXnusqnsEjeIpY7Gq+27PT+UsDqpK8LkQuFJe+4EPNvUGhnoxZ9c6qNrHyO3osilc2heUaM7lf8eIT1V6C/CH/t+uf6KYwZX/+xcoQnzeaCTsdVS5TcGHgnwQK8vRoIYVnwc4XfG34F/CqiOrL5Tb0RicHgqqP3tgAs9NVqHt03qZERNazc7w/AnkenluX+wStSeeaoLeZb6PVZ8brK9Heq424QGpyz91fbhofdmXPLgYwK4bi4RvdFZTmO76tb1fG70mD7KTjAGFPtRzcVVOPIYD3OprytVOPFt6Bbnmvj35ZKfNt+xrNtN6wH3lJhx3nK7lvdaNVJ2pvL6BtzPiOmfzG7mWSxkvtC8sNKGqONSaJvLEbHzp6JWC8f2/IL6Ney+z9XymfR29b4OhOPdFxeqaxvkbFYoRKAU1YsDy+VDQphckhWlyABMa7EG8GT8En4zfCdNlNNqj+Do8gEgQkvoyZkTxaibmQ0MSPLoBpJgrG0d8Zi5bufNYWKTpbU463z+l3SPKghNi8pu0BfDlzpn033qHIkqvpqFYbbrR28hKZxHL5oC7httIVC/7zfUH/8t5ssJZ98Lv6smxZNqMbOqYimSqr30IV5h0xf6YAv3VYqi3WnxVxt0Y1CE6C3Uu5U0e1V5RJfNeRLbGh+TjWtHv5V+XdOFwoA2TtswbCkXY/iLr+hXJMlDJZH4ovY9oC9qHyW6Btv8HgswDH6aH1u65OXX4hZ/6yqxXfpZ8OQMhL0ojpCD14rK1EPNpXETFhU8NfoS6Vk3ihTUbbbM6i7J8EGlajXrgsExo8NXgF/B1wwJqfM6Fs7ZFEyP6R28JhnJQZHsWJ/87d4nNXmg10jzRATTQCk6HQLg61VmPbp1yS4KD82sd7FdC/WIzE4i0WIK225hr5HtU6LQnxrcTEeGv9nUWfDfXf6GxlwNAAHmJ7mkh1Ee6W+/4GEbVXT2M3C4fsfQW3501mR70X8VnFaqcasarE2q4011G0VNbp6Xe+LaYlvW7kU6SI+i76VPdgqE6VrTc+sl/Zdj4TmOQf+ek+pSneVlc8V+kqJPtXrEh6PsPxi/LXix4rrsOk3B/ZUCbDeJE7EkbbrQ/E3S6NtEKWt5YMP+87Z+BTSf7ViwvQRLcHwXOCx4INwPYbMkQ8h4BHoHfD4BzE74HF3hzUi6ISmuAMXfZs9AHbdaVoQNMNdGDVtZC078Gc5bnZ6Gio8efbwqGLjn4m+Nf0NxZJrCn1zmdabr6C/0t8+HGMp0t8YgBStWbkY4fHvetCRJRKh1RkWgeO/9ojVq/YUla1UDXUrvCiy/vG28sNXKkRW/9U1dOo/c7O6v1XliLd3Uq1hnPQP9cf4XZWhnfVm4ruSgr7JQmw7BLToG5XPqYBA32oVSEtYPsIS3a8+9+gjC2L8iaudEY41vT1ZVPmqggBLvc50pEh05e5FWFSY4oCnMlu1WmjVHdqvVifQCMuCz4WfhE/E3wzfnDz8BfRyCahIfGQKpESnUm2htiUjiAEY1dEG+uovvVJE7zyYQUtAEZqYnFC2PsiDz8lsbSPlR4bJzFA6PLAM6B2p7XxmtAzwGvrmHxyANwwbvl702ign0oMB6nmjVDw4/hjMieFVq5l7W726H+fjPIS7IqG7DY3HEyhhY+5AG8x3AeUU4uicLQhsa/b9WiqHLOsWlCiNSv1eVpiJ75KNsjE1FfKSIkqUdYzwwNLRV5p+2xtZKKzL9niE5SPgJ8HHAo817b7AAWDZU3DcaqNVU07eKiiBXJNkA95DjAi2sHtRAWjBSIXM7o/klIl4uRKvhE/CB+HC2c2dd6ubIsXu6PFeOGmk9+YQMB5MN9t71PXZAGLvwqSILjC48ogufZFMY3CDwTDgNtyX232vUrVDpUrv5V5PeL+kgt7GQOvT304/9bWUqLzqlETf3fdqCwf9lVPJIMB0gtzaLmueQa0JeTCw2InNTTW7MNxt6C5O3FX/TunSHVExGOZWj7W06Ks6W41IUrEJSHNDPJQkWd12qaQDGXpj59dMeUvi6+Au7NC7/zgyXrWm32zPTQ8KIgCH5RGi+xU+l0L/7GqVI8iNpsIYNwMX/20swVpqaLVjRdPF9BgAaLcBw46m6k5HuAf1ztNlgBJ3i9+lpZkQiGBd8LHgc6PnFn7HV35w33ZLYIYjA3gEYzQwGBbOd5N+aPTX31a53E54R1bHIavC4IolNx/NbTB8r3iexlpXhZbevJeD5nKFu80GCSb6jm2lAACmEayivxX6hi0pn7ed/m6B2ix6WXT98Bj6KlSpTfiAos/2tdKVptucFWfchiFVDc2mE5lV5w621Zqo27m6HYMtBsOwoVQ21EKDRF9/ppewV0nVNx+Dj/50S2iFK+KbvK5K9F2OXEZCIbGH+UJUY6UfmGONKu5rBFZFAzAva1iegT4QPxdIGwBnhhoAxF6EHCBAwV9Vj2gp4y5aZ7cvnMiHJTB0VbyaK8+p8eRWg9J+2Ue0McJC8Fzwc8G/N/p7oxW2F8COvuk7TAuodDlvmOa4pIJGjEWIY6b89IkyQEbQAgWH0PeQ6ps7VghuMUs05ZHKmLtbA71Lmu5564MWekN5qqjnqF/XJLt3N4S+9tm2xZr7BoCA2wtfL3q9lte2vLZl2/XPMIYoPvoOR5EWvlfFAlSroK227Yal0HZyU9ROmbdms/LFz+cFPYdwlRmrGJzKz2Bw240qhmespiQnPugqR8fstZn4SvRdk8455KAj9XKJvhJ6Y8INX/McJVrHFwox+xX9WvBj333hinMMUp01Wi0VUVPxEi1TQ4M2n49zX1tyIg5M1RexvFAwVCFMpGxQOCI9WEJCfq74teHngv8OuBxrv8AoDcBbdGSnY8an6O1MHCE5UmEIwGmEISycOeiO2fvyXzWVeDdiW3y7xmC1od4ru99OPCJX0Fdoj8XldeWsFasb7SqfJ9eEre9Vi7684fZN2xbRl743CmUQsCO34G57iaKVzYYVo0qrJy2ZbjN+gM0s7xqJp8OQdC19z0Z7zrX4hEj0dZ6bQ39z67QfVDzIxMLCWU+oUqmdK+47gr5QQi8k+juEvruHboo+IuLlY6NPiPQX8+4L/wRp93tQ9mKaJMG7rFBpzx2C64xfuTeDJUNbNSAQwcIQt2d4Iq5MC/PGsEV1R73Qy2MDETZAJC5gOCAQR4UxwP5VRR3irtJQY4UHpRPsO+UQf90Mda/o9tEe+uZi0nbbgC40uCuRoMIMFVrO+17V/VGVDcnxagtJ+fyKBmCNhrbdszBvjDF7ZjYna8Ssmbm6qiLEqpF7ZCfgd3j0O5bdqaApaOawEdAa17RXpl9Vw+ybNQ9H3V5bpcv6gcHQUOHqHvMAy9ALiYYqmmef+/JBeWviCwAt+uZXUzQNvBCv67asvPyK+udy94UQgJb9PgPAfqrExVnk02XWFetK7o59N6QTOTTKzM9OXg7ClA9LHulUjkjIK8V4JHoEWmH7AkhaaIzZ8EVxBgCkmI2FIaCEYRa4hgwEACtjBOQqOFh7jPcuwrqpK1M3/gkYPIK+6rDhuoCuZ9Zw96jDGo9zLtbpR5tVrW1Fdbx6vUiib7v4S/UL3ygHBS307aoo2ywTs4bYoUyEJSFWva78nYVgjM5aMuhgBdq4U1OU3IjBgzUfTYi28lUwsIIZlPZaeVNqYjJJoKteWehbhaW1wb5h3+h3C+hDb9EZ8QCjARiR4+6/+LHgx4qPJfk/w9ia7vZ1XxdW7b0ZZkmw2A+YAoOR5Qrc7YEtI3H+0Tp2HfCsdYooxiPh54LPDRfGhXE7ZgT5waQKNiRkBkRiROYNGRH3ZB20AAbENcCe45kAcAUmwBCvOhrvg24bVhTNwD0tdK/eXL+JNLUW+pwe0PGVHHe2stGXCyp8VFuhr4mylsz4XlWJrnJW0RERUb8YTb9boDjFxAJKJuFJhfO5TI0qv7liiPVvZM/2pYD9iNtzleronHSzcVURU+pyQa2hwmCwbaiT6F7Q36ob3RVMlHZ0W1roNoGzqaPUiC9o6JvjgCX9bdEXdhIcGKXOORf2B8Cu9GZCXpewriHrn1P2q9PM8h1KGK+5SyxtPTZUkDVu9lxluTSPaKGV2oQjtPApTPFIK2YtdEBAYn6lu5X7PMdZY4ujc0NCToQ44gFiYF6IkSk63FIAWIGAgQDWHYNBI6aqm+NxFqCrhT4nP8mDTzTUvuL8OrLjValNa7nvTHNlU70OO95Vx5HYi0b/nJNeRdPvFjB7PqsT9FQSfB93ycWqcJAGsb4Zo24jmyhYHteg0WJoZmSl0XnodcKQ/PTX3cBlgJqDtnA1RYVbDBZZFY++VdHAzgqmheSuK3uupIJhJ9IToO7SknygeMGwb4cQ1Iijo6u741XMMblxbfHtagiOnidLc6DH7v/8WA//5+OCSZBDO2L4ilbzDSYWbTvCvM1RNW2VRLbenbCuBwtYTTDfMwNnwCOCdclaaCQRa9SoOPLMldZliBCyAYaRGBk4IBIvgSkwc0jhTDEwidLnFDE4Eab8oJO3gNnl2b1v+1ro/a5OYrC/BjpVp067WxQu0ZfDsOa5cjixe6ug7yQ8t603fBpjyskQUFU+VxDYci8jGEl/KT7uVsWqCKiqztb459epplAeQWIw7rGFvXsJOhg26RZNrbVCC8MOBudP0MoAavVcPnkqf3cXLoV6T8Nga77JawJdTVlafGFfH0j0TVhoo2+m4HKLBYm+rgdcMa4IGXFPAb2G9cn0i/BjxZX2bWox/bdLMY+52i7ZreRN/gtmc2nSKbcjVPI2GyZe0NTOagzxRJ/Kt46IkQSviCsDcaK2BwlOz6tRqR4KpQCIIbraMxIzMQZeNuSFOQRagJijgR+iC8G6Z3vO7yMHDQ/6a1oOz9ULHsHg2+U6+h5HjQISfdPZfEpDXz36SO3GUDFfyqaxqjbmvQobbhttCXqThi0WcCCtQ1bKs4Ogq7SiwbDVinptFlmJo9xWw58s88H7ApMcm7QDw/La6kIHg0FTLYxgZ1nevBErmUnS2SKDEecm36+vYFBbb9F3oZjxKqHvyOur6K/MszGbFS5i8EK8LGH54FL/3KvqlsRVvutyEYNkW4WbU+MxSJBSUWaFc2WUbZ2tZiE2hVIZnMxzmd5zvK6EK9CSzPWgaYqqP8N+JLseEB5IvCwhIFPgZcPlEZgZHoyBcQVYAV6RfydaDDtbPQB1fIxFiG0WVmZSjupaTX4+DMk3/Sq79jaOV+qFppg3fqpYddZF31wmRZwH3LNOplNJpyImvgA4orcs+FAPei1zcsE+yz74FVqNRl2P2s+u33UXiVXphi/LYj7Gn4NhB4OrSzIMSz1UVwNf46Xxrh1X9lQgzg0aHFZq5Pa+VKmgNx5p0bdyvILG6hxHuzAA7x6LjAxYaiCUW5YdxsRveaGwrIxPwCfBWuXfKGsxo3Vz1qMBmHSybeiO6WXJXOam1JUrwIBa3EDQjhbakqSojP91g4kJcUVYEVeOWugR7xU5ROJ/w/5FIXIIiAj44mUJ9KL1O4RHoAcvD8YX0zN++imVR8LgjJrV27H9ModIMLyNB5/wbNfExHsWZy2Ulcpn6ZbVpb91H8q/PTcx+1QDvWb5iL57yK8cSGAgmY/Bg+jbDSKyMM/itSMkO5dRkXgk/KkbMOZHITvio7VPasGAYT/Quf2a45tVwwMtskia/tnpTHUXuvZ474zSXAP5ykZDmto5gS5w9LqS6Fshrqyq2mgh0t9oBs43MkKjaZ+NYwRwMgBL/+cKzE/4ZJ0OEDqNrM4WSeqREICosQG3Unk1X9Qzpx4YL6kNU18JF8QFaOFIggmPlbsz8aWcEEeBXb0TRyHya6OFeHuF5RUOGN6YHgwrwwI7FeZoEmbYMVgNAtA7YZJgyDrt2l/auqEZuYa+dvLI+Ez3Mgb0DgNhtxtV6wNlnOZSJQX68u6kH3/HILdto8AYAgWhfz6cWgU/yyTSwuAR9J2N3+0QxDGMV1F8EIbBZm/nYpG74ifglICqumiBZh72r6owGIQ9eETU+cD2llEorNOcs82DVZhEuqtIfBF5OXBXR99KZG7qtMtCoC3gZqemqQKjAY6YPUJOBuAlLA/GJ+76ZyqelA5ptf9sfwAAt9tJREFU99lrLS20kg56Qgs93roAYN/5uRUnRaWveVaPh3Jvqeh+QIgL4Uq4BlxZ+mH5ktE3lAwmSxx2L2TChV5hIX48Xusa1megBy8fgR6Aa0mFYcfgsdfvpIYuCsAoD76qf76o1i4glo3jRVsjKa6MLrWt9wq0lVTNNpsdtVZqDjHTC4SQlvmW4rfdF6GFKx99L2LVlBK4bavtPxiEeNA8/ANi6gAGditSvbRaxy5fj61+o8E4JWCy6MbI1yCZdz7Sv8zoA4mdfTPxlWrn3Emf+wIcsb+BcWNiBoZ9jgX0zdL59ckfMQU0PZg+VnhOpp8sqep0FqpxLbRVpuXKtb5aC50s90eSTlgBkJj42BZpQJRU0tUoG8wdLa+Syx+KKmigJZLRqLuAAQXb3kORIw0aHV2k1Ij8eC3rsq2/w/rc1r/D8gzLg+nB9ARcAFYEYlwFBkO90EWBrPJPiwdDi8HvCz26y6ici4tAIy/Rlbx0oClDLTxQxmnL2GcQShNXmmJCkdwnnqroryO6nrAcrCeSdUixzLHQPGG/tw6Et4S4G4JsZxxU7qibHNgvoybR7GIwtDPTgDk5cC9KuO5brX9u+wCaOjpwXBRhC9JtAg1HKhSU6Bu1zZn4LhRAg175Z7vZUdwQbGPcAm5Mu1JMU/8I+psHW37mKFJA0xPwc4Gln7oZQAM5bw+GyvXVxNcCvy0t9DgJriAv7ytc7AqcVdBVpVnV7DhFN2M5/ekoqGUkkrMUbMYmrhTNwLTAQrwRQwBC3oYX4G2aNCjvjZB/v/Ys5L+3dQnPdVuf2+MR6BHWD6YH4xPwBclXK7plbfvAk3Zi0PylJQaXg6DA4H+sVMpnIR30teKOGjFh9W70PTB4X9SL6SY7YaVxIpdrKp61rkxtgfz7SorKtnDXImtdO+hRNQjDVa9GZNxMmEW9WQeDwUCFVintw/AxsfViqadgUvMuOjAYxKM2o9fGnqHl7ZxTbcjyaoh5td3Cjr4U0bdyfpY2b6fPWf+8LikCGJ6Ez9Uzvtb+Vhe00BW+OrZbS//sk+Cu5DKFCrqVNtzIFydF5aDyJXtmRUFMDPhBuARaGPdELXFoHpFIrHxalsh0LbB/aYGBcEFgwjVuBvL4e3usW0Ti58e2PAM9mR5A0WJBDOsOtzshrrlvcWslBsMxTrupPP7w7oSKvSD9v9I5Nwdt9B2E1Xn0LS/PT7iuoVrap1MhOZXs2KxUKZbwtSVYKWyj75ABTyMibQ1dVXDVlhkJoyHxFAy/T6ylg4XBoDkhO15aSvTzQFht5sf3ior60v955IVa6FtF+rb9V6EXIFt8aUufSYG+1dNu6W92vNrbBUKmJSwr4yfiR5n/Od8zIaC2W9E/R06kjwYQKugT2wve4odlSavQXo5o4OyHxYjAUGFwV3KMXbZbBJG95VtEY+VdqZ/L9ly3x7p9PF/P57Z8bOuTlw/GJ9Aj5bMsCLEDwyP24EY89B23sp/Wb1txR20AUs2GT6Hv5WEl9k3y0Fc2mpywIvcNh59nW7nt+9oZfBJ9u9Cr5vKVf/rZKLsZlKAH3oqO145Zsno1VWxQ1NDk8VAoNSGz4yktMdjoj9fQuOx6sUIRDVAt1P0aCgyWmmdKeyoU6OsQ+gp3g0h0ldE3Ol75OoZ2ECJy/lKiSjxtQfixwnPx0ldV0nJWC6FnYNvcmlBtWglpGfaCFjLgBe0IEYRwMhjJLl9Azr43Az6RFsY1LC8MAZGZEEa00IhMAAGQ+JhE8njNyuOkYxHYDFsawQ/iB4WP9fW5vj4er+fz9fG5rZ/b8sH0ucNwiucaZMNzGOyJalMCA4NhEuFkDVNTyjD6jp6aVT5r3s5gzP7ibFFJSfv6rVuC9pQkykw8327u4vGqHINrzS/dHCAwfAuqntO/1ncBk/0c8Q7rRh/JelRttrVDVHt2VipF9NR8UMbaHl5X0e4bNc8t+sqlWBVldKS4ggKD5Z3mhM9VkLFq+k1XIQBA2u9h4d0AvCj0V/0t5WIwrmPTleHCXS/oc8IBQAtDYiKEErdlxuYRkVpWBRuM2rTlKDABIa6ID8QnLCtvmHyYGbGrDbO0bdXB/BVl9H2FOGQQAH5vQMiP1/Kkx+e6ff5+ff7+/vz7++NzW39v6y+mD8AnIAk2bMFwdng2MBgszL5Lbnf1sr2uRqS46mzfLIdnC32jt3OWNIOHpHauPLBgxx5tRd+hXxbxHcSqtsWS/Hm02GlITfNkNBHLi5KTOUB8mcVsKzS51UW3ldTqayNmSfWU9rJOutk2Ri6pFN0Zg63LB9Qbhc9zRl8stxc0nhLEBHDtBkewP0P5iNQUHyr6YrL7Hn8uFGjhZACO+TdqDB4GPMJ7tiN8nxjoWYYhSSKbHaFP6KgdkSgbbcwSjGlPxSW7uxKshGvampAWxpdXa699TrHM0uUBmBA3Pj656OQVOA3SEOgr0N/If2/Lx2v99Vp/fa+/vr4/v7+fr9fjm+mD6QNxTZ7SMMKGqzWKBsN96++fNQ/fLvkj6ll/B726VPS1qor656Fu5qkZayy3yu8FvH6Pq45BMYiOjgSVg7ZNSIq5Fy5LnqV6DnJbuUH2ntQLbvki2h4WNWvOVi1/bT2lVfPqcS8dj+7mFtqAtMbY7PB438spVygjjuhwe66Jb35oYd9VMDs5V/srgPCVqfpGIshY1tyuOHPICQAsxETRuRXxscC6QCWpUtc1uqK/sxjslL93J1owIWqtme5WGseooap34bHKdwMDEYTG+xoRVsQn0iPgGvCbkDhqoWNXWp+a8upDC701WuiiGCMgBwZCzFaZhMF7zpevQL83+tro92v967X89fX98fv1+GtbX4GegA/AtWHD0k26ihyUVDg/hz8FvXfXOWWiK+S80VpTMpfoW2yFtM9KMQPlOAZnGfQ9BgMjpzTG1oXjUUA+bPvZr7p5rwZlKktXFMcLrPB/noRhC4NB88+qykiwvEtK06/FrfVrK/yTia6qPBsVQwUAib6vQIFxC0kXqHLxVt2dj0uXq9Sx2GgK++S9GC/Rr/ZB8GzyPxN6t+rIYYJ+/26GU65hfQb8TxDD4xBXgmfcnRBiMFLYtdDV8BhJzBvBOG2IBEyIEe8IMUDC4I3j3rvpvwsyA7wYA+NrR+LvQN8bvbblr+3rM3w/v7f1M/oUFHHDAIAM2T+rCDqq1NGw/wnuOBj3J1eOz1/yNjntyafPsEbEkc59c+GsrxaLfZ/0jIuldvZr63JZX4c82CXD7qtQTKv8Cbv4Rcy2YLi1CvvtUhmzNJi7ozrVfrKnxTJLS1Fn+yopNAiWmdG3cryq0FfQ34S+KQV6zjZoB1VDifq5dWjGsFQ+k0i/hSunFNBLy4DHEPTnNc+tMfiCKVoAcAha1spmZDVlMEcZt1cpl7f4ShC2w7M6el0Flp4V8V/cmnB58IuYFo55wSOlbKekkTQ9jSuWxOCAgITwCsd+cytyYAwAGyOHPV0w4BbwtS2/Xl8f22vdwhoCPRkfCFCmsdw5NWR1dIbhFnRLRdg96FjrdbVXpsps42MdPudN7ySYTAW0Ogvua0tl+o3WCj0C+NROwLf4YY1YdrtlRrTZU3koR6QLjVBiQyUqDKtUWK3zdNxw+3VWybMs41LRh66rvFZAReU22wbs91ihL+nxvrKrGGJ80Y6+Ob2G71bs5Nk4Rvvez2NZsNNxIqaF6QH41FJw/MGgI4fXdv2wDh9pw4RWxiD14oCt2bGqzupK8acx+JxAmq1EoIWyFpoegTYM+d3zEV80Lo3jBkRIWhAYAULSRa8EMVQpE+IcyPQC+Pe2xJRQ0UF/2+hz+w4bPDamwLgBPUoqvDeWwa9QSoe6Q52nV4lf7E3cd9cVW2jqa6GvRrQ1Cuc21xW0A1m5CuM/qFCnCOSt2aEqavRF91RTid+I8sZG8NsKLLbA1UfiXg+HvkeHRlsa78pO3FJhq/UKhivAVn2j9pJgFXP2J7aK5dbbHlYy6I1VQW+FdnuZzD6PGuJ2Rkn5XCa3gtomVtxI1XR5hKGE3qNvIgEIxcxcK8CK2BqAY6snaKUKn36qDVVmSW0uP46JADCkglZrPDFlqxOtjr6REyPwnrsra6F3X+iwMG5AIh+WhPLaybkXlsAFMiICLwTIQGl/wsTJEWJe6OOb2Bh/bwvADsCBXhv92r75ta2vbflgCAYVhsLWe8AwCL10vjFLxt9C63k0cm1ZpHvJm+LDiy17ZRcm0Vdey7qpeMiEYVEudUq10NewB/uNd0pa6zdoRoq1mLDdoXXkdnuoj5bTBLplxjI6Wb4XsG9korkmQbS6C4IF4VaGCuhBr7xNtaHSrpGOWNBbKZ8r9N127vsdaEu7j9T9kapmtfV8sLT1FvdboS8i0xJoYXogPqIBOO+8y8eOhFdkKmponNpWf06ZgfO1cMxKNgBXWSsNKfTPp52zKtdoixOvhE+ij0BPpldYtuykZ27LauVyk97OoYTwjMFRHb0ChEReE3TG0rx/Egzwe1sCh8BrClQPtL2+PzZct23lQIEpxIUeQ97RIT+0CoYBTCQ+LT76zgb7Tr7kmv5eiIOaQl/zWhN6a5637e61ctKZir61WOlF9LXEqUG1aHYzbWl232kkbquFO/TYOQ0ZaFS4bTE3Wlw+0BlfdVy990qt3S0PJVZVx63YKol8GfZaNS9KXDTQ97UtEX23gJY/2mn0tf3IGBFwDfsmSGNZoE+IBZA37jmYm7DqtEhJYFgyAGcDsAWlA8Zgs8dW863s6ItCSZuOEwJGDMblg8PXQYITZDZa6JzsNx9BBGIOCBxVyoC8m2WrjKYSg5dYCTIAI0SHLMyEGAAY4DsQA26Mr4DfYfne6LXRZ/jmbVs/Q/JzCGlj48NBGhUYBguJB6WTzqJ87PlPe5Ip0XqmJ1dkMrxYCy466K+FvjIAScY7RlFnRodptSXVYi36KhrLYXvwFBBajkW+atpx1zrdPVVX7DxM1QXMosJW05W/dJW+w2nL6mFrXvF14O3lvqjmmyqzowq9AAf6aj7PB/ruzs8Y57SytwAu+lZqZ/VOpdtzpr+IsCyBFsAHQpUC+n3W39lMGjIXh19bi8HVfBQ4IWxJf6FmwN3ZLoROmZH50tOS72gUFDPwroUmfHAmwSEghoQfhBDA3B39YL27AjK7Q2cMzjPUoYtGYEgwDABLmn85IERfwZByosIrYEDamF6Bvjb62pbsmfUI2xKYngyAsAICQwBe9/ZQTIotIYYG9k6RSEWBbKDvYATU+7KR6lv/uvT3KDaSMGvPuaEeB0F/s0xlqoJh9L0CvYPlNRwytSrdlBez4sccgwu6VjEdRHvJMlt/aStmyQJRFT4rYLMKnxZ5j+eIb9tJlfteR1+5v1xxvFwWUMbgB+PnqnlgnSXEGRQdgluHnBT46u1pqHBfA4O7nYRj7lVU0PX2grYo/s/yT+dHV7IZuDiIQIhPos9AvzlagmlL42xwc6Q4oPPnWvFggAOGBS4xym8bmQEXiCHT/NqdpSMPBoBvxN+BvgO9Nvre6K/X96/t67FtK4cFGEIMUgJ88UGFYXfQcghxllklsO+Lzm7Js4168taNFwFg2PcqFd4jgOXBFK6m5VW27B2ywMjx2kt22ItqivWqlzgxNtZVd6iOpzuvigWi40k82hqiWHRWq23ooOp+OBu+1cyCusW3C70whr6VnzMUWAvVkeOqUvlcuT6UpBwoJqF8MD4peWDdFehxi/iW3QJ3B1i1c1/se0G3DecaFR315Tk1ab/t7hLiQrASfhB9MH0zvQK+aKGwBUqv3P28d2U1ACRdNOw8GLI96eCilVI6/oh9TAyVASFERy3YGBkgMH4zEsB3oK+w/N6Wr215bfTr9fW5vSAE+mCC6Bcdh/huFY7tShiGGolBgHELz0N+VVWZzIHVa9VXevd3csZ1i9ghwdDDSCTmgFjq93jfabxop1zLj0iDsoqaboT4Oo2q3G6kVyoMZ1FV04P+0uPSXb4MisNl1UQflsu0mmlkPMOoLydCpdsOKA5NBvpK6M0X5lse0Ty36Nt2w7enSGk/n0R/iXEN9AHwWEyXq0EK+8+RLmwf/z0eiABgDjBDfxVxwpPUU67rVmEGloC0JhK8fHP44nUN24vy3gxRC+3AcP7qoj0YAALmfQokDNcBAAvWvwkhcEzdlbsZdZv4DfDN+M34HfAV6LXRa6Owff0K34+wARgYDJDcrKtHBMeX0SLl6GaFbTELfQcClsZzOOthSHeT4IziEs5raI9JrwLCjsHxsEzBUfacLSc+FUW6lrD9YOequ7TQVg9tG036IYfDiL/0iJzzqR7UYFdcVt9HUvBjNXJJdtLJqOVg6vgzUcdbN0i9daS30Ldioi36foelQt9K51y1aPlDpGKC/lLdk/q/hEzEtAA+EZ9NCo7UDyr+/KdJlwQHse0slOi7C4bAtKz1ZT8jc7pomSwTYSF8Mn4QffHyxdsr0Bdz4Phd5Y/KT/STvtuIuMyAh9FAwnD3JggRIABRCMDJPwsCQAgYfbK+A34H+mbaFT70L/79CNv6iwkYCIGgCBSuqHD7xE6EiKqioq8PilPDY0an9A4SPHhhsgeXGSiz/nmchtaNGCzBR99Z6PXFQq8u/rUK6uvaY1WDfUW1IPtTfe8WRlaO0101ewXDVj4WMEwVjrRPQ6JvaFYGIPAs018VfVslcK4zs96Ivltx4wAl+qoOz1Iq9FVvcO+VvAqQeFnC8mD6JHgusO5hSDkD8Szo/nGQVqOSrNmvnOkMFfRpHuyYe/3pmLUNDSs/LIDoisXM+CT8DPTNy29e18AMGGgwI4cYOgAChuO0nNyssK9kI2AABqDAvCAEZkLAFPELG8MrIABuzJEKxyAlZvhr+wJ4rcD45Di8+VUGCkNDhbPcskg6Uce9izMjUcx1qdJPRhlMSd2qW+VUOKh0bWnKfhzU49aRKxSzFRVBHUgDG4bVwoNyXYMtBcuY7G61qtOWCsMjcA69d6QuL3JDPvpWras+zxJ9VeKbW0yxkdErZUffCuZV9G3vvV4WaAk3ZB+k9TetGIiXlenB+EHwWKNnD+Sikk2qyBrRWk3Tka+9fSuFVm7anVCEIcmqr0i3qtbWO2W8JAREXIk+Fv7i9RdvX2ELuGyBmUZcsYQWmnlPcZU10rA76/hPN17CHLNJR9ct3v8LxBiACSFmjd423OKPlGsmaqq3mLQSFqjU0SCpcCuDc1eE8M6yZ+bJT8lpwB4cfQPpJ6U4GBy4cMKKa7g8NnKxLnio7lr7KeWgdeScA6161UhmK7+As6Cf5ev3unTlPkxVWzltVcFLU3Cujo27RAKqFXEUD2IJlu0iqUx3RVyGXEKcUN1I36pXuZUWfXMxLOphuZZFYnoE+gD8XHBttgGW3Sr+1Obj/aDpuiwrGcDLzp6Gg6A7M/XJXNAXxtDpmODuhdUoyFHCK8KT6JP4a1s/Q9gwbIiBykuVVb8cJVnHKKkwwGEblmLRI9iNwRSjlRDi5g0R/aKD9Mbwe0OAJaaSjlHB/+LfH+H1gEBPgKiOXhMGA8ABw62Mv6ipVzq87npjANJPidj7SNkByVef00wCLBCTwCz0jrjw+MxeNXC27Y5Yi7uqta5o6H6yrvZeRoKz2/ilKrm0CsP3im8mk6y0Nqka8b57maP/WaTpt002mf2Tq+ySez+9W2hLqu6KrXocidc16p8RP1ZYCUBAo0VtHRnRP1+kqnNJtZox42Lc5G5I75t6HTNgNg9IErwQrgwfRJ9h+c3Ld6AX4Su+7M7q/qi4ocL7nwAZho2PU00SRJCpMASAFTAAAwGkICUMTACPfC0HBPheOdADYp6sHYMBAIF0/+e7pKa/w45Rzrs6Tr3bBizEz4HlXZi2ggEwXuhU3ivQx5hyynHX2gu4/R4oOR7eWvWnay0+MQynMnCNSHsvI1ZqP35pJJXHuPjeAxYGV7rf7PMcj6huzxb6RkkbxqTNfVsn/7R5sGzUkgpiK8erfEowHHnLqYdxD4blg/HXCp8rLEuBvmbbwierq3++IF4ccJTZGKSerGYtIzsuqOXvlWhNbWZzJOSV8An4EehXWL95+wrbK7w2ag3HvRY4YzCIryJHDEP5cTquK8yQSfCKHAAQgACQOBpdAuPfgeC1kpgvPvj78ckUGGKmjhgcLI3AKbjc/qTf6oYwAqXvD+0tpNl5UEpn3oz7LvDhfnX819Wyzsb+Wmrnkhx7uNvV8XqhVrX+RnasqNZxjGKuMclv1BIr3qnblirOHk0j/SQrH5ax4+GIjGxFVRWQs42l7JVqZ9h1uT76ykXGvrJMq8zQrKIy+g7auQfRN7NzafqNP5Yl0IPpA+ivFT4ejZ65swQo/7wv1fN1cRJmudIw4CpMaCQn5WnpdW7fA0F7K4QQEFbEz4U2pt9h+R2WV1heLGsdtHVJdXS2ChetNXl2wIp2iGk69h2FgWMOy1hn2vXhm/F/XivJesJr/QwUs2UtcaEHQLyv86qRVzc6GInUx2kLR5UF0MSKq+sD1d12a0T0vZj2fqYOCPRlhm2jaCGL/EBe2K46WmKkzrOOs9WN0OsX01TK8mxxysFjlQvOmn7b/jjxTiOiomz7zTouZhYGAxQ+vWpCD1myJc1WybZOaymvWnwhs+Ed2Bz0lTeb/3u0C7xHUdYgmnpoaOAd9FUFG6U0xi0IF6ZPhI8Fn5r+dd5/qsNZs1QYWWXLUhFUzag1QoKHja1jKmgvQRIPFYP42e0xRUpMajiKqfXE46VKloFwZfpYll+8/ubtK7wovJAQQfWFVt1k/MilEZEr+uh+tRLEPRyWfRPDwLhFjTQAALwY/3db8PvQ/3yEbf3cmDmpo0OG4RjlsD8EcLmmOxRHI4YHZA4ax5uVi6diISXLKPRXFja1FAb6qjsjgT0SrdnWT68xiL5d7XSUEZ/nLK1P+H5cuVb1P7rIgK3Lfbty+zz9VCEDHliH2qlVR+/dEx3o+VA4ubesa1ueXTnbQ4O+LfSCbfcF8QQq/XNuq2K9tWOzNt4q9FXPVvS3vvFd/0wPxl8rfq5mCg5H5fZuImvJUMYru0wwjWQFAF/KwnFaRlAhmoGrFxNx9kkQGD9x+RWW32H5CssWtlBvMDm1vlZJsFayTFgjNlB6cXIvCJwweNtHfwCg/fd3oL9fC+IDkZm/PxhWDhCYAsMaTZQAhInGSSQuHo7oZ/sCbxmx5Tu619pw1Gagb9mTDvpGqTCYuUDfbf8dtuyRjmXuoblsTe+AXt8DyPKuUsWyj47QYt9gXMldObksKUa6WPXKCgc8sHQY3s8q18aH45jbDVgyq4rsWa7+Zd8y+i4UVOjNlVfv4nAu2Z2fQ5NkRiW+XSeAdG3p9uxIRX+j8zMS48L0BPxc0h4MhZdyuRw7l/GqtXao67hiJNmZNCyxSLAe9aMYc3MW5x2AORToOzDFzqH19a1iKW0WmHhwjh4LiCvSx8K/eP0dHl/b9oopL7zpgBuL0bg4s3O7iWF2il4BXwFZ4HrcVek70PJa/o2P1LGwhY9tDYAb0wIHDEOJxGWjSleO0Rz/HLu3gdyT+mt0322tgp4baOJa1/SrXxvShTviYmDkgCFg3AGp57bju0PXR9oRZaGvo3Oedb51wLJtwjbKpB8qEg8qh8axecRnypcqTLlbYXUjLQy3UmXkaGsD4bM50miuKqejl5OJhb4q9IL9tHm3+Cq5ZcTG51YlumEFzKFrScvUF+LlwfSB+LngY0/B4YhEQbtk33PqqLBPZM3afILb5b7HEZbQuSqFusjqbWc0Ni/OuMgCoTm/73k54Mn0i5Z/b8szLF8BX0zIYeAL73nWKJH7e8tFGFKO+InpsfLuSXBgX1T9YNhrzAEAG+PXttB3Ov5ggBDowbxwhGEmQCqQGIStpHqOe0Kv3G+hte6ENrtnxy7s7MV7k/AMhMfWM/qGDaPaOc9QvUieIQXpH4HepkumNrJqruu95diJz1lq1HbvMierXl3qJVNOWyOvY7aM5WyPu7fzQofaOf8GV1nSZRr5KjkBjDz8ltn76KvWiZH+IiT98yfhx1pseSQB7PROvb6c0CFH+Jf9cay/7Z9VzZdswLXul0ygdU5ZtR297A2I6mvb10e4EKwBnkS/wvo7rH+HhfiFRUosnknqa7Yvsue4PpYQNzHc2+CYsQOZmTGkmyg0YFvA70D4WhCZAwbe1i3QI9CGvDCuMYROIDHAAcbliJU3ibQ/rgzD18a2gnamrth4mxZ2Wn5YDf0dDzrK9DdsCXEj+m4bVTrnvcvWO61MH3WBamg5yuRx9EUaAifLgF3V6TsoWdppx0jcyggwXye+ql9Ym7RLvURepXHT+nq1n12MH5HaetWgb/yhelp1m5b0F/dpMBNutZKRzLswxn1LpfKRGnNZAj0CfQL9WuDzAStBjCka16S2CHpv9MesgdnC4O5+u0Im44CFMNG0zVj6YVnimN9zslAQ2on435XwCfQZll/b8r/b+rV9v5atqUOmbFW9XbT1ae2XIdU4IerWU1JoWQ9IKIyZOhaxhfCSl71xpgPcAr2ACZfYTw7bGpAXDmugDWlhJMCFk1sW7P9lRhShtwASj2MPChie0kiX0uzuZxcNcsq73JB2qrMt9WEMAw4Y7b4++vqSMXjc3Atvht6q8DkkrjqjumsNPiuHC84m5BqRthJrNrZ8rblJ4Nz1o+52Boy1vuqATYleHQRXRV+pf5adrJ6e85rSTNWUyK0bN2VWmKuFASV2YvMrrx9MH4h/rbDQEQE8C3vNa9Y1xtXBn/He8m3A2px1HoCTjCuTZ83ARBBCsSdSRtymRVyIn4AfRB9hffKyBqJAATcurCz9NkVMsAwIztIab7BOmJF2FJb2i+z6H+2+u5PBQYIRmBk2pu+tbCvwsu0wvAC+gFYASls1YQTjjMdb+pI57Grq1B+ADMOWRvoOv6r+672c6GOoG1GxHIAZ+EVhS+gbXa64jIm0YKMdNqehF1z9YQHSM9Bbd0Zc64Cxb9M1FMUA1+wIg0Rcle7HO2D9rY/ED1CDcG+ZUpURtfVvyupkm2Qjou9CoYXeLL7ppPW62vaZqrYszFt2LWljliT9RQRcAz2Yfi34seJzTwH97u1/bk+QMBtSbLHNvZ61P9WpWgIiCKEmwX4Ekd4PBhiYuVUzcKYkuzcWrIRPXD7CuiYtNBprNLCV0lEyBoPmQ0GcMHjfM6cM9eOEwekSkWsmtoyAsIMxlF5UMXUcbhzjB5YthCWsHHBbeGFcQ9iAFkACJGDmGNiEOwynBS0BbHwgcYDsvXW05VjW24esHK8PdKy/fvlgnzolEX0huj3vySYDYwgI5QsNDQ0SS6vRpdt1P+cWegfpl64mbWqrIPkEIXYm6HFsHvQXUztTtqjbttVTWjdqWtwstvQgCHW5NhvBuK/yiyMZfYlCJr7ReTgX85UcjsiZCiDaw463Zr1Zf63W0l9r5UFLWNewPpl+If3XA2IA0loHqphCNIejsybkK+TYx2Pp/2xMaj0G3KKvGR2505Z4SeKAMyr+rhABBGvphISwIn0s9BGWZ1jX7bXRNt+4IL51kAAcvhv6XsIpxgCVgFs5ypdjsqhXoAEQGV7bArABEDMQIzMS8cIBt4UW5o0xaqSxQGKAUjtNNRIjHE7U9lYP6Sl4zs8+XoZ8d3p55RJbukk86przfBH9nDfcNgohaZ5nHYgcdpWnmxFnq3HonfVL8t2IqlbaGXxEBzvAQYs/R97XRa8u5667D3D/qDvsq4VVR8feYpV6g3JKkToYyX1TvGyEN2LQ1gcgHnKry5FqPPWOdnW3cgvWreW2SENc0bQy1Gnh5RGWD17+a8FfKzxiBsq6ebVt8Vvg3GkvraT0vpsWzwgKVEaxG9IFNfKIZdeR3mSMFaC1wYCZBK8Ea6BPXD94WcPyHQhpMEoy9aX0jbKUVHktmTcxrGDYWunXozyDhRjZzAAIW6DdaSoAUEqjhbBwQETcmBaGjMEZiTeIOzGlPpXWYmgIcfmcxR/SiOu6SpVnCyo/dAnsPZSZNEZyTWtSKJ+j2nnf6ciy+1IJn9I5tooPURNgzaLvFPQ6gaSqdMG4azBWx+2syXaWK/uOxOPf77i6osVgdalRYXCrLKnEwTAVg3O7UvMc0TdDb3VV9TR8S0r2wOqKebnhQy77ZlHhrEJfiGP6SfzXCn898PPh0d8KXGtTrns7fxRZJ6QOQ7Lk8DzZwSBe6bBbeWpKxS8Nvcfvln/vGTnkJdm0iYgr4ZPosa1rMqKUsDLxMZehfuWy7jhebJ3U7iWspm1rp9rMiVOiHI7OzriF2FqI5hQkZiZamBg4IC0MxNGbC3fbMlJi5QUtzmjOtWo631JnIdTVEo+hryk2BicSTCzjgDt24kb5nO2+0vTQzjuSyji4Wx25F3p7kR7KQT+LNbQ0seyAw4x9P2GnCVWc1B+WdON8gv2CWuHyzVa5H5wFt9qT9iGPmC2qURE9MaPmOaNvxjBoHlS7SmibyJBPKZV+islUteUqrFZHLDVDuYyo6yRkWgItvDyY/ovoXw/8eOx7AJMs3d5CcVbxf54hwWrhLo2+AufDdHQtnIX0fpQoGGe+HWgZmowct5jWy0p2Y2xil8VZ4Q4dtynEB9HHRo+wrtv3awlQJ6sbETns2smosBADAth7CTfTsep2KN0R8ZgUUszRFmihsAVaIEB0Bl+AgMMWcRcPGCbgDTBeGVJCad4A9wYQkpEYk6P2fkdVh/INDGqPZ9A3jvwpQ6/E4Ay9XV8tSX9FVSb6ZnFg2KlnFnpHcHfQBNgFNp8mOq2M64ot/Oum/uhKL1C7Pt3NRgnlOsxCYmfecDyt1Eft+Ppl9E2uWMkF2rqDWLNSreUrV/k0OD1xWmzPVnSiSteVTqXck2H5xfSvaP1dgPYMlDmxkrhANuD0p5YRPB7D7NGcHuNy6Jy5jRuKiTjal5YNupKP7qpmicEATNGfhyCIadWy/qZK2hAhQyyebYX+EcKK+MRlTb7QECgmpXJsReq7Dmx+h5ITS+UzACzRsIvK5g2SDden+PjkKpVOjCqO6bQCI4X0/BgRiYmBFoaACMARaxGAkLe9hohYOwzvWy0VvlogkBjiVzCsaq6LXVl6NSRYtqticNl0oX/eNzgq6O/RFJrvIt9FC8NKl130PQe9li+0erxFZd8i6zPjqhUHjFvxPasrmQpAGoRqFZZUqaxL6hprqocq6eg6EJDY1EhyX8TaZs976hitqvpP30jhLCXBeHQOaXacsOKtrWtYP5h+Icbtjx77HsDZfUlOvn4Wjls0zLXtmeoflbwjK4iQ4TCkDIQkMFgej1JicyF3ZRBu80LLJcIGQJh8of8d1iV8M0a+Z8+hxZ/SRAQChtNNNJw42TnEyI7QuxQuVrlygGaUS5dIsj8GZoCIocl8yxAwEMAGGLXOAZGYSSTMOh5RgmEIuy6a9iClOMC2YwXAzdIhd7TpjyEDr/oIVpaF9+VMVeyESZjZpIw++uZTLQy3lcjy++8J9C0uPBWD1DXrWjkm286Aq6nuuuBO+VW1HyOXCx121z0Gqvlt5mvrpVWV0yOTYJu7F72S+QiidHd5knyx5b7OSBAGEe8etRbZX0qCvXDpkmYLGSP9pQ+mf634a7f+/qkNFc5Juybwc2BBqX+e3o7wHaLyVD8wyc5qk7TQViWIuCIuSE+IWugQcAu061zrXpSXFsu6CoarMhYSgwRj7CweWy/rqhXZFmA5GwoMTupoOqiwjAaOumwOgIAcv+0ACHmDhx3k9lGkPKmjJ9YZIZMLLQVEGxhOJQc8onP0kap/llX1O9bAsF+PyiRGoLcqVtXQis6EDD/nqkX/AXqkrRfaJGVKLSybtv50CvtUtVUIH4vd3d8C96w4qpLMcgJw+JgTjymryui7UEBiouR7JdcHKZFqkzm1TKR1/E5Z8pobsQzAe8dMIuuHAIBYTOQ7ynUuxMvKyy9Mu/8uC6wVVs3suOAU/oEdfx1xgn2jcNAHRAiXAXjW+dkxD4+koqzcodWRTohrysixruH14ph+mQxiZ33qLQyDhsRQemylYrkvbou+Za7yuowwitjxxuQSg5GAGSUGAzHzjrsBcj6enJ2jA3L3hZXtHR5txelY1j8DHPpnKcItRZ/ofVOlpcyoKqnqz6Dl6JwrYBtxU7B87GEYhsF9mN1nItvym8vi9PmijPhetcWYcV/Ms8RgaCaKvIXoRQ1oBVQA0QMLEDmjr/r25Vvwv83u8tQfXY5h26itKFOtL2kJyyOsv5j+WvDXis9sAB5wEuo+69sRd69wYmsHv7Ys+wSHMiP0rk7+EQZ8dMtlve2fTsZpKNcUOS80IXMyA9MjLCuv6wYAkQdDOZq7i+7WPtQisXqh6sNUadUcL2tH/PwhZUlAkUv8UKWEA4MB2mxZ5Q1ksa3ClpVE2SWwKdlF3yP3JO+dP4A2n0oHM/0FOLivZDbOBORrOy3GPOts5RDfcQ9BeYnDhqN0VdNHSWWRYRJitblxJD4HwyMoPvIYxReHsFNh2DtWTwuubdjiiy1ZAAFU2Qiyk+ADfasFH5cbh7Trp4GEkcmO5oWJT449iY/tkiLd48L0YPqFMfooJX8GgMDDe/a8gdRWNNrbyGgv2dVCT/dhMAzprSIzMZ1znK5csUQwEhDiivQJ9L9hfcWxSwBBS/XcXxJWDpO5cUuk2djK9ujYelWptNDZG0tqoSOypg8yIMhZOK8kEtlNGHwg9E6FQcJw1QfL2jrMie1dfr2S1X4MFvoWl8cZNeca27lOPCsy5PWfvKbDbNZb16AXjDEwwla7mNTlxFVzp2EYmpty2h3UUc9aJf3O5C5RjbXSp7JYH+fQNSi1u13zsPSslqck+sZW0k5B4uDRVU9LoR+c9cCCcpRaaTut6a5CX1EPr2tYHkyfiL9WjPpny9n1nx+/q2KwFGsrpDgxaf7PUWwAtnJuOEg5m/cqEdmyoS79laOsJaSEEBhXhAfRI6wfzFvGXYIAUJKGcYdJ3yskSquvLvXYnba6eBAVyXK+0LsRME27XNqHdue5wwGqwmAoYVhcKDrRtOevBXsjor+DocDd/KPQy4X9krjvbxEuzBQk1T9kdtXv4y7cBL3WxFpJO8/6zHKcpFqoP6iXttrttn5CAWC1UpxqNc979pyjxTL0VhpiowTOTvWgZhSvRFVTVRwRBHrtaTe0qvYnNmKazUJlOj/pWWZfMnG8HN7148I9/Jc+mH6t+NcDsv4ZtIndB/kfl0MLLRcH7bQoRXooZxmgJoPbEZb1+kDbIveR0OO+7Nu0I4aWk5JjMNIK9GB68HpkpCRmXLDwT86ArgZTNotlb+g3Llqpg45yu3OXM1wN4udKXK+jVd/+nSJXmuq8ZeHMzoO5u3pJx1H56IxaIDQ/9oevUOSIvsZzqpb/3ec5iAfjKTW6blZTfq0WTHZdkcdJqk+Ij8vn8fhETuNZF/FqASQUthwxOJeJiJtckRdG4vwFVY76eYWXt/dgsbmWyoxbC0VWO0dPDmy+1iz+U7LpbHOzOwaDbQNsVco8QDwq6D2Uz1n//IH416LnnhyRStP7boS+blfubPTXrjyuO2H5cjFL5WgTABBNC8JBmhCfRB/b8s1hC0uIDsBhD6ervpO61mqCGwkJzWLF+IPhw1XdR9OTPL5rH43WF/rodkAEULXQojelmrrBYFFSNlp2z1Kyy2mrarSpxyDBNcfdj1sVFuiLKXMWAwGFOUO7ZyrWkMDBXfWSK9DbNJ1+WJw4ipebwiWpXc/zE8zYouMnA7GMl1V6yQHkbzmirwTdNcQfeasxlDlco+yGD96QA4QNw3fcYgtfL4q0OAQM1bjNjl3SOBotvgEy7aYy88bhwz/g4K3F9R7OZblkpZxL99Rof1v/UN9RptKcp9tZwrqG5SPQJ+HHinHrhbQEKEN0Cs1t0xsng9Wf8nn2I5WrklEKXyVBKZBAZ8CzmyQ7rlJtiHBbJmqhaaezRf7LstNHVXGICVtlExOMhLwgPpE+eHmlSl4vSnG0rr6upErxCMCw/4ickhpn6aELneNFniytPJeWYNMdunTISrcpMVipWfzedQYddtvAbaVArn2sWml4gMoMsuOVWlVSRPe0durxcfXmicgiZeU3BkJW/g3rMY47IbckdSR+CcaUNE6c8biMIK4qtDDETe+JaWFcOIIuLkxPAAJcMGdy1R0G4642gXljfkH4xu0b1+8QYXh7Udz5I/tMpXbLNXTCXQK0o37TSDaSb1RPw8Jp2jNQWsVa4uu00lYO2jPf6W9YPoB+LXv2Ky2dZJSWd55gunfjsa6FjjKCweW0qBuAOQCOeEFLRBzP8FyldM5Oy1IdDbZOpJF6S4aqoTqlGQIBrogr4sr0ZGbmwBg4g3b2xYjiZ58v7c79Prdcedx7WYrlZGuJNPpWluDKHVpxihaAWg0wi4BWNuaiwG64lYhbcOJ9immrNe+uRR2NSx0MILqbgbIFTSW6D5SVkerP4a5avgXLdFz/XMYWkQYMW9UOSpcuzxvmyz81BXu26Saa+wi0MD2ZFsAn0ANxRVgRCQEBCOtl8j5lcHb2ZODA8GJ+wfId+AtChOFv3L7p9Uq7b7V7X+Z7RAQAXfks6W9Xre0/Ft6zQEOjlmu7NFK/qrmpPwdK4b9J//wh/Z/L0BXC0rL5Zg2zJW+NIVZdmsR8KgB4qh9EELlktYlCmydLxgup+bNIZKbU43pl4cOdIJHguCaABtGjFvqB9EB+Mb84rGHZcIPdlbhwMkKVIpRcNv4YezzloPT1n11sbq0sbRNQcuIDGiuOG21CGgbLq/qOUeKgMukL9K1jhHaSqkLvlCssAPCG6izWYnB83XRoTNCp+bqe2fdqHmhLKWmaty2Nrg3G1o3XCRw0k61ps5yBznEUqWo248Hs/J2Jky2McVeAB9Mn0APxibgiPghWTLib5wTNGxjhQGKMBq8A9Ar8zfzi9SuE3xC+w/aN22/aXodqOnNQEvv77mZmlt9sbEdal9s7avVq+hMpddGqQXecFTjQW50iSpsP0l8Lfqy4LrC8MfuVF7OrIvoYzN+fEdqQUzbgBiaZyHKz3i/RSHD+TZi00K6vVk2CpSK6JMExGhhXgpXxyfRifjFtyIucquRa7JhlHCTOMDwlMgAmiwrzbpRqXRjmaVPh/2xjMGjTnJsEo/zbRd89O9XutDLgj7PFUCID4awOqzw4I8q4lVdzZ9ULjzBdqxW/sFWgdlS2XZ0Hl4/64B/znJr6NIy8mNM1+5+AZL3Lg5cPxifQB9In4YPgSbgirAQoWG/1o9KuyTx9cRAH5hfDK/CL6TvwFy+/A3+F7Tdu3xi+aXtFKD3AT6qdK0Xu4W5dLk+b8KShbZegxGAQ89h+th2Eo+NZou/xWS1hWcLyDMsvwKh/fi5JBV1N6bp3dQN747Q4xaA2FuI/mSGrPz/P54IeP5U5sUqCwQDaERIcJfChGm69CxCBAJIWGnFlWjisAZmIIU7K0l0QDmSqkRhKlfKU2ycY86bJvdy6R6C6aGjXv5WtlyvoBoPB4rVS0q5PzQkXfcO2J4ksHaaGFJJlcNGx4SMe6wao54iGB8fbH164jHg1j3tUjZPdtrCKf9Y7Oq2gztJqqqdSUXblNKa2ohqSpIPVsvLywfQJ9IH0i/BzwSfBSrjQoR0V1dU/9qrzfxFAQjIG5sC4BXgxvwJ9Bf4Oy98cvg8k5i15bKnPIUdGReG0g8jxjWhhGt31UN4E6Zhw1PTX8hLxGIbQtwi9I6aFl5XpyfQX4V8rPNa+uTRvyYDl3gxd4JxSWVe14TBCq634ZuARA/Aut3pBd83DlWE47y4MwhVrnAQX7lpass2VMAAvAZ94kOAX4M5+VVpQfQx7U8Xw9e7RFT+tUitqW3LVqRaocbf0dhbFCqtwVdKboPPzqWouA3ah5b4CfaspQLXvyqW6hNhYON6jn5jziDEjjkuuwVXUIPFtk3tUt+A2MVG+i39m1JDBX0eUHIOxxSekitU+V0n73o9Qn7QRHi8Ppo+Yjpjwg/BzwY8VVgG9MjjV02fuP7Qw1gTJgfEVeAvwCvxVITGEbwwv2F6YvR8KWCWGkHYTtbrQulz4UFphMIgX6lBhB3qrYu0UtNDhfoUfKz7j1r8IMfvVeAyqvzdR7bQ1bjk9v2RUxIfh9mbbkcPXw5DGQ3utjQWvXA7F4EpH4io1uh8Q4IqwIT4Rv2sSnOZxjCNbTPcaBoPrxTMoV8AbfGtok3yjZbHSHTp9ge0QMtD6OOsez2mqmLHVPEv0dTw8E6kN4nUUGoiOrrLVxAoVXCYTeZ1RwZiHu1CihYW+s7jbvUSvxzbQqjA8qENWYfj+BM7G/V5JxwECeqO5d/lg+oX0SfRrwb8WeCz4XCBGxcS7zXrmZRltoy2ZDzBDCBgYXgE/An9v8GL+tdFX4G/mLw7fvH5xROKoDQLYv51w3Hk3e+igzxSUGAxwwLDFJRx1joO+uViytT8QPxf4jO5XOZhF62e1I2EXIMejgMbFd36yEnVVCfnaqwAg018ZfVRW++dSUbZCCAPbBEdrDdc+1WVIUj4ezcABMDB9cfg+SDABBypX4tJPwSAceexemSmmprMpB93TUgxsC4PVeUGqztwxmSKFxtA3S7ufgUTZFgIrnRgHlCQ4/gkCZnrzV/lnD33dmCXj+LVXqSIrasG7IxhsXTvoO31apr4mVZEeoRcRpM55+YX4a8HPRRDfBXB3ucqVnOpzG1PIgWEhCAwrQwj4WuAV4GPBLfBXgK9A34G/Qvibwzfwi2NIMQeOqmkC2F775LPJeelU/47LxbS2D/7qhXZ9BlXjl8xkEk/hGpL++dcKCx35NwbjWjPadUCxtyFgt/4ekBdbMkismeHQhfK5+M25MwKAzxmrqx0R2lPV/g+q5HwdSADlXr+GFLroas7YnxTG57wiB8QX4hPpO7lDIxNvmKyDUNiD7RabDHZn5XoNlmR97EGINTMwaA6QHQzuzd0SfQ/6e5xFsJf20FtnnEDffCSCLgEH4YTVeLWUV/VI6iD69v2qVPQ1LOtOJVfMseMymNnjdJ1RZvFGQi8tsHxEFSjSJ+GvBf9a8bEkVyAJvVZaRAtZrTJi2kSCHJTBgWBheDK+NngFfAT+DPgV+BXwY6OdEPML+AW0QXjx9kJiChxtJfWMdC6NTCiVzJUJjLS1h/P8j2G/b10M4mOMBuDlA+hjgeeyb3+kVScPSucpKRFWHcyrt1Vw0TGDtFrsOHtgeb0tkvS/82E4qmBb4NOoySkG3FUaj6fnb+V03kpJgqGIR8KV4Mn4zfQoLMFVvpgojnvhj810jryX+0qRGHz6rt30kFks1pv+PIu++XjGYIgGsEZHPYWUXfQdgRClt86b7S2G2pF5kQTDmJcWnEXi8TCtukx5CzG3Rq1z/gspQu/H7oW7UIG7dZ1pNW8lyjET6OTajgL79E1p5uWFYA0QAr4CPAK8Aj6JvwJ/BfwO8OLwBfzN+AVI8IKwBAzI1SzUZsEbDNirmG5j+tVvq7j3hvvmBF6yleRt/tz1zx+PZP0FGy/e4Z88vnORNfE5GHyUaTJPQAFYNfqGPR9C8yhWcbF+R28R09XZ1UGXZuD02RAe7tCVN1YkwYxADCvhI1Tu0JH4Ci/ZjoEQ3oB/qoy4qKAGA6ZI7ypb+1KfUrJQxS4pF4Kgv35f/Pw+I+grzipXtfGjUhctkePE2+xaBDp+7FaLUz2JhZs8jiP24PFFpArhSl+GtdMjUXbpTzW/CnH1AyIAx13fhc6Z/lrx1wrPBZ5rgl6JlFpuhCb5xrxfT5uNgBYIjARpilkY1g0Dw2vBj8BbgK/AXxt+Bf5m/Jvpm5EAYOO45QOkz2RB7cbDoe7y/RDBgGEwPlXH8VP2AbF+EbgwLUCfCB8LrlQYy/NEbS1lzhp3dYxU2XNLgmWjEqcHMbh/pIepgQ0GPLuvUbqqgdVucHCVWiuagdUIvKlupNYTnAIhrgArxZjg8M34jYjJ87AyEJZR/6WS9m02sEq6wKD4CpW8UBXHfWlE2q0RuiWlVHO06oHpo28WhzFXYUh7W3sZEV55QqFaGsCUAlPeWHulZ5d0xF0MBg1Hb8dgsGG4a23xn5hvU0cqiO/yX7vO+WOFz8cBvW2gkUztdxynosy4tArVOt8fYmAIgeOfkhDvFmL82Ph3wCXA7tsffiMECEkXjbA7Nu8NHVllukHtle2sRWL35lro5d2DrQDj5cH4BPwgPNJPugxYFV9FbF51NpvVFR5sSB13dLDhcuVHMRe0A3Jq9uZK9suHcnH4ZuCEl26jjiu1JMHyJvJc/yR8hWgJXl7MHOBF2fs/iH3KLLGznx8PcCR/Ouwm2LmdZJzwgPt4uTUgB0G3T3/HU/b3lMxKGI9R9+EWrinVnbBsu2/iN9X9bLuqyJi7Vgf/Gir8BzEYShi+CL1OyVSYmBZYHrz8YvqF9K+d+H6u8PFACQBZ9AjGo/f6b0ucMkjCNTpzDMJsRwyBHwyBcduSy/SvAL83/Hjhc6MlIL4A4Ov3GjZM6dsZF2DxNBgX3kPt63WY8rjKoID9eYwumFr0rbwdMW9/9LmkKK+4/2ALP2V7anP7JTcliWxNvJMwP4vBqbYsvOtlG/BaASaXezBgnVVTTrZnR1pp11DCe8LLjSWvQgQCJIQn4cb0gugOHULaxF5icNZFW4GSs1nLnWKno5KcmNQ29MgSKxipxeArNv1xKYmsqWC33aT1qqLUjldN+HJdfkBboDLvUb+qtrYBSq1jYUmFxzFY7YYTMVxlO7GA2YferoPbiLt42kfhycsvWH4h/WvF/1rx1wM+H/hYoEXfgo+K32W/9d/ezYzkQVzSfwLDsn9LgfZklnQg8WegjwWf3/h84RqQXgAAv9e4uwPG7K0EAIy4W2RifPwYNLRxa/1FUvNJZvQlsYMTxRyfT8An4ue+/2CUEyrMo38/ksRqgASD4LU+Epv016i/UUH70bpm0qt5lXXOk9VqoWVGjqoDVosHgRZhwaU7NKwIgfDB9NyWD4DACVf2CLy0fifFSzbKFBuw5HQlOg/Yxfdj6oqDwXehLyFvgIjMItWAugRR0Velvy36Oq5Yxd8SZspTOTrclz76ngXdwfLFKDqFwXoTRuIOaHo7wdQHYbWHzQAQd/o60PdfRP9a8L8e+OsBHw98rlBZH3nP9iNnGDA4EB0vsnM/7SXKqSpfBADsAw93MM5IDCu/NlwJV8In4eOFj42W7+W/+etreb0WAMgkeO9j1n8cerVuf/Wx0YlcL76yjL7H17cwrowPpI89/3PU/N+1EW0/K9ZNUD3AuSs2rAPz8I1fiwO2dhg8l3AjByOpVxkYfJDg/F0hHrguMZgRV4QnQWD8CvTiJaTAYwKIoXiFPViM1Py7WvufM6leMcS2n0rXMJkikcSuDEcOLDsb+zncxbTh+X45MQJwk4Evlzz+NCKOALx1hlOykEbzXJSs5qOZtYu+RJiPBhaVFH86b6EG1AaDoVVODi/+HBi2OpPFys7d1q9e3p6FEqQT+n5E7ruj769nQl8URt/AQhtXvWVlPWue8mUqlyEtEPgAYzxocdw3lx8rfq7Lxzc+v+j5TY/v5b/D73/z9qKUKXonwfG7xuK9MwzA8CDcNsfTtVTuXpzeyAPoCfgZI74au3v7KKyHVsV3UT0yqlM6H/2p/M8V3+0YYVsJTiasal+j6njxw4BJyXHrjvuGXo0EQ/kyxCklNUfEYAjFajdEbyyCJ9Mn88YUmEOyGKdRFzAFq1CsuV5vDtKj5naVMT0UEGJ8Kn7+4YoX/ozntiOIaYmOxLwh7rvztrupDKLv0PMfVgXLyizlB7ixwirxHR8kDt2q1BL12UoVrJmEofIldrXHTes7tbI500iSy+oSp7ADvbEwEtAK9ACKSTYq9K3SVKXZYGw6ruKUjNnGvHCwfmlWI4IUrbQAACCnCWpdeFnoueCT8OObntvy3+Hrf9bvbwob6Ric+hl7MgTDUroJ4GB/NSRswOnHGmgFXAE/CD52/XPlCds+ByifW/WOWgTtPuQ2nriN1baA+Y4EW9PoCwAAq6KKGdEza4y28MOyyDEYOxiarokGdW7QvaDCGYOPoRld9WMHCB+BPhACMzP/RmamOJXsy8kcM7q3tidvc5nBFNTN4mI36X/XR8mX27O8Sb6V1umsk7DY81n03a9SCutA6+hvoxhJS8AG5nPQe+45W2A8AsPdLQV9SPY8pDQF/tCFY9BbLnQi2eK4oxH914ofa6F5lpEkqZ5BdCxx94RbTCWOpbnS2B1NA8ACIcDCuBI8V3iuy8dvfP6mX6/l/3wv/0Nf/17jZoXMKDE4VlC6+vf10thTnoF4LzLPdv1jYVwQn4Qx/4ZDf6tVDhiQWVxiYnOiv2/iuwO66E4NwU0NCAA3pKI0t/gV5HjcQixHZybBMxgMkQqnwV2/UamIJgZ+BYq7iQEGiBnVEbSYUcgWYiNRZe+2buOgI76j+rf0Zh485jKfzMBARSAjuOg7nYxzYCGiI5BVpw3MbYsVYIyLaQtQgzWjBaGEYWVVUarcHaXLkLfXgAxE0PUusR8mRVvjE+gJ+GuJ4UYK+kI5e4ZGh9dKS8uKTRrmjUanITzqqNcFlg1XgsdCzwU/f9PnN/2fbfk/36+/l+9vijDcYnCWw/O/F7vR9d6X3p0F+kZOvDCuQE/A565/zv7P+ry9K5Ctz0Mqn+XvLlQ3Curjz+aWvKZPST8OSJMVwPBHGJEp36sKR+OEraqvZ126ymVvuWNSnR4LF2IAfAIEoE+GwOGbo75ZxeDmJgpm7N7uzYDnfydTer+3imoGzp5uUQsdS3r7rhjo27/NAX9ao9vH7/q9NyZk/WzR/8FG+2/H2b6pWvQoI3bAOctoNP0ow+LN8kPuXaegNz9JREYCegA9MO5rBJ8rPpYCfdXFek2hNFZqFtaSPDhn1WLFcdZ/S1kzhKywLEgEK9FjeXx80cdr+T8v/B/afi+vV9xmOHp1GDq5cvcRbydgf71bqZ139EWEqH+G6F6zLIX+OUvXAH9aJlKmDJQcC3xSo5JGCXHZisaAL6bgGIzoLS63djoaI8FNPSJJVqn3TswYYUVYER8pQXQAxgC0ICMDMQZMvWlTQaVq6s5MxT5mLxU2VLLtJcWRYYxx0Ff1w3rHXiOyMxF6EQGAIe9G9adN1K2YdLDjvbL/cJ/hudizc3tRX5fBRcwsYINrMrDQFxfGNcW64McKjxWea0Jf1bJoSWt0s05JaUOHvSYaZXhbVXWk0n6vS/ozGoaXBZ8LPr8iFX79N9P/LtsLt62nKS3mHEu7UKOvqmlrQw9iAixcEB+EC6Hc/qiSG0H3nBS5rhrOOZ7DEgB8uK12QIIU+V0c3CtvAHhk74S28IgMBoQVWuj5qarCYIDaGBxPMWJ0h96YvqKyDjhwAIQATMIkPObDMhX7eMwvqJz15Rb0dcRKNnlOsM4sBnLH09GQIXH5H5ER52EVfS/uPqm1UidvmSXB75ZRwB5G3xR+SoAEuAIumLINPxeM3rbUJNxoRbdKGrhrpVrNVtspGdfnqfkaieC5AhESxgQX9KTH45seL3q8Xn/T62+OyTpUEpzD2Uc0ZG0iAd2dswBjwOiBtWJKu0174k/LCv4zchgiDRy19L5VTko4pZd2N2CQDe0AbI0qmUJ6Vi18JQgsXz5Lgq2z0iuPEIE4MD4XfDF9MjPjiwEQd97MWXHKxRhtvaCtqfndaDFiDB6Uzs5Id0h0wmLxW/pqYvPlR7mixr/3+fvOw4aZ+S3MfjaB2j9Nxi2+IJ5hpr8x1gUfCzxWWBdd+Txu4fNxV566tMFM475aYXmVoUliAyEAwQpAT0DCdYF1wccCzy/8/Kb/Dsv/8PffGL7JguE2ZtLRNrdlLOiFhL6HTgKiMd5H3J8KENKlAuPxJUJKLm3jsUy2lcXYgEHKzfsBnzNEH5IHX2h2VoAe1h7FWj9qoYjOlSwEYUsOWa/ALwZgAgyvGoNBDmKDE/+MtHknYBB65+G5i8GKHxAZf+4kLEJv3Ik5LW6GUcpZmB9yhzbb4j9gwLDqdXUCff2Io7LFKoR6Ah3GzcDvkNPoC8SJ/j4Jn5Tob1R4VgxYMUD2NMx1DIwoE+eKgZm0I5JUtUq+ChUq6kaYPLMAgBAJeSEixCfRx4s+XvTf4fVv3r5o+6aY2KDd5qsatE5EX6tjy+ibWW+cHBCZlqiTIHgs+FgAScGhW0Q6WAFALyNVIcZGC/uRZm+GGqd17XF9j+M2YHFk7ZTwZYTmdlHT95SW7tBWbe3BKkdH3RYCAALwSvgEfjE+kV4cAjAzHouAhMEyBCVn6shVTk1nUzzV2sp3Tq7FJnVFnf0lQhxuIIIEV6f6rUx2+9xtWguOVs0LWroJC31P6BJuT0P2JhnJ19HNjuI8w4TEFN1ugZ4Q53qIe81i6e8KDb7OQi9o6DsoXeNx7lIo8xO0DanMjDAreDGuOZ4LPr7hSfT5ov8nbP+zvf5m+k1hQ97DJv0NN53PpKbCccfl/HZot8on/+d9A4Z1Ueq66IHVdemalbtSTE+1GPY1XKnhWCNh5Qr/7lq/6NHAA0rjFpV927BRp+KNBWK4IwIBPgk2xiciM31BAIYXQtgzJtLBNTISF3ZNOyMBOLPPgIyYQpUyw5GXV6SwdIqXnH9LX2hEYI0EZ1fzE/4g/hGnt3AK1dqB3PSq3+4JadUMe+vnSfDlLk0//0J6/lbQoO9OfwFWxM8Fs/Oz5L6+83Mbx2JJW0+X/o5boCXfbWEYNOiNZ9NSIwBFhHtEdXTM18Gf3/jxTZ8b/U/Y/h223xS+cfsm5pRQqN3VMUYAxk/PCqmo1M6KUWDl9FKelDZg6DwHt0Abd/Rn9dWO+BAuw39Vbzs4XvqwCnoEktXcWMfZ5mA1bTh8eizIdMLPK9YaSXAAeDC+GF8AK9N+r8gAQYSH7ny0zcnQ0uL3iYm+8/GXUpyclEO9GgEAOqK8KgyeaUhXWsb62+MOLtaAepvfmVCc3iR6hw1j8I3BSFpPrg3ySfTNxZAAn4gPgue+0w7aDrd3ye2LGsl3KxiGxi0oMMA+0SedLwEArJAV79kzCx8Lfn7jx2v597b9T9j+jfibwzfhBhmGfdGXuQJ9q/eCBLQArkn/DI8VcF8SBe7b46fk+rfUapX9wTNS4A5xAVjf1vWOhqdIcLTdYk8RXVcyHJJEEEOSKHAIwAFwYRAOWQAGDBsJoh25lYPehr6WOGZg55RJgpUlWcJgca1Hf1X0dZM0WWf6Z6ekVT5XlTt2ZaczaplSGS5U/VIP8QYMfhP0gs99AYBiABLgivgkfOyRpl3/5yuaxurRT+minYFVZaWWabAkIS6aDgAEJBK4x5kw+xsvC64LP174XOjxDX9t+PFN/w7Lv8P2b379xgzDSk+x/rHfQW30zXeWB2EKCVsh6SSe+x7A4GIEaWsuRyqH8P1IkQNrXL3hy/tCMG252QmrEDU3ll6yl4fyYmxSljigxEBHwkSCV+aNcQVkhtIYHPEDMgyL6FVpA/sxbyw/X+5RzDHwqNO9RoIrpyq3V6amtE3KER+jpTk4g74N/b39a9JvUAs6khOWU9tIi6DBsIXBRbEBDO73wBe1ht7OFo7qXkHfSL/WyLTwcL+q8l5Zc0KFwac3ux6XKcfFihC36sPEAQwMjt7RADsVXmBd4OtFHwv++0X/+0ow/DsppTkgs77eVf4s0TdZfOWSKK6Kkk/cpP+z5fWm6p+xwdqRVhxvgPoSrc6LyhU5olzKOgDAXcDr6h+LCIESYvO1FQa3l0RvLDl2u1puhQSL3YKPG9xJ8AvhCRGMMcC+Y4m00AAAcDWnCE7sPYTjju/TVE86WHUmhxvzZepgXEZE7IpogH5msY77t+UUXbR+3N3pMB7pG1Vz3Bn0PdFouxISfDdhsOMsluSumGBnDI/lKkl/asuXqjYkgBhs+iSIe/2uggFDOUG1ms8UQNJ4umaR/gswD8ZUjMihSyoXu8MS3Cils1gYHE3CIVLhDQmjhxp+vvjXC//9or+35d/b9u8Q/obtN4YNedMjhvVcchX6ygjgtCoi/FiFWoLquBVoQHEcfatTu9xAfzvW6B+hwoGB8J0MuJUCVpuEWSoGV95Ydymiw5aLSBIMHOjJIQCuAMAAxxcutamg5b7/oYxOWiuzZLe5fLrnlm21nc1abyzMOoOdBw9uMuijr9O92i05Z/7SuSNbp7r16+h7bmDUuxoAuEFf1sGaCu/D9UyX4Oy9uNALzQM8mBaCiD5a8LnAskcfSWmTKjhHqjHqWAv85T646KuAaFODROIKhkGNWuEagznAukDgY/fVNTpnxX2FF/61wV8b/b2F39v6N4ffIXxB+MawIQcxMPakQ6lfKvetOPEC+ER4Ejx3p/Ruys9KrAIWskrls3Ph+PE/JV4qyiDM/lNSs087IaWjjrYqqf50oLc9pTZXf5yJBMcslYUiOu9WJyzHGYajFHn8/antVpC2s9t0L3zXWqEmZ1RjMMChiJYpOZse5ho66mjtkuq4bSQePjWypYyCvldetzai1McLpSJaMxUDtFT4sljDz4mTBvfttIAY6W+KPkr65+UokR1KVWkDamcFS5UbaAy7vSUTV7TjeZKEEobBgI10qppREeI+bxEFcYsaaX5s+Bng64W/Nvze+O+NvgL/DuFv5u8QvoAjDAdg1h0OtJTRACkrGUar/LH/oDr3Vrefn5WqIj4oryisKp99+juuDG9L/hD9LVNRFtkzqiSWd0kLhCpIV5S3OpIV0ZIfjzXthCQdJDgwBIQ1ekTHQS0wGABCwpIo+/QHkOedd/Lg00x3EHEdX6EpHY/Gw/bnFoTTuNj3wqhHZbeFpWqv36jhpqWGbWp9D/pKaTirY253yoy7CnbFN3aMj1IPfSPfIsAFY6L/pOdcm8wbUVrK68uUuriCYaueEx6/EnFbXaAl7c1GDKZdgx0WWDZ8LvAK8Fj4I+C24a+Nvzb43ugr8N8bf3P4m/mbwxfwBjsS78s4GW60098DfRfAFfBB+Nj3H6zykamPQkXfSkGt4t9e/gz9/WFx0FN7p4YK2qK/Ay7QejKsi85TqRKhiL7Lb+KwFSEQ7GocxBWYOQ1pYABAwKT72TXSUOqQTkxw1/22biS7Xa3ylBzkrGFpMiwYACyP3Jb7DnqfvUmUPMzOs53p20hm08aFqn68SrWaJstKjXSiq9PXjs+QycNxzzO8CPerVrEs8zgeNfQ6OpVt9cYJRxXVHhel4txV7o4CyXaicsAwwxLgseK2wSskQvza8Gvjvzb4ClE1TX9z+Gb+grABvwDKZ1OhLwDEeRKfSSex7z94h2+BFEl/R8TRc/x85o22A0lbU3vXu5mwDme8s4PPYb2jNTRM169hsHLEPgkOMR0H4B4NXFHh+P/K/+UHfKFH1+4z5M+p87QzkQoSqiJ6ZNv2qbCrLBfjm5vO5DVEaVRWTb9ePZ1TOjr2XKhUmm65Fqmx7L7ci74d5XOkv5iij2Ch5H6FwgAcxCYzIzOsz5JHrLb1PVyjv1adRXaElunuP2K4bYXBAAUMxwHzQlg4EeLA/HjhtsHXBh/b8nvjjw1/b/w342/mhcMGKIeZyIGVGPCCuAKkVdF67D+IBNt2cifZe8V/0f62SFfQuqW/vaexHk120Xe+9gnpmoot1fRcI8IdWtYMAIEBoyWY4MWwIgZO7tI7Ukfehnsq1EzsYHfRivKOtfKcBvgm6HVkij8cbUkSzPng5IYWvciWt8pFOB/s6ml1sakq7/l1dJmxr1ieHfNDGyHvhkZYKblfVZ7PIRwTqIx4PCHqfC0niuomB+2+Ux2w2nIuiWLhTYbh55rQegkQGFeCV+Dlhc8Nnhs8X/Q38fLCNYS/Gb6BX3FOK196sgoLA/AjvxQ6v06v7uWEjExGHj/WMDj1ipTjbZrotj+FZ76tTiZa69MXlM8TMpJE+ijc2vZFSNJp5XZFgneqjdEba0MgZkJgBgLclcwxBklS4QqGofw2MwV8q9zlxlydvb6SGCHBI8mwHJ/nn0RfVQasAGdrdmN5LS20s13SyGudTEx2/PDQ3XWLa+kv7GQLaGda654AuZVZ6++UVLgI2nR/V+snMDiLMwcmwIhKaUGIMwyvhMuLVwz/z4sowN/MxPyC4q6o+I0r4nOBZzQAD8xu1vpAPXL6eVbUtqrK35IBtDcrEVfbSqHfH/VP0VAvDOnduKuOOcfp/zIJNjqGkLKjIhADISx4kGDKAUlwJKcUVBhKGAbhNPsO6L1KwgagV/4enQcMP/AKJ3RvLDuKemTjWKv/Pyyq+9XF9UE3n0ZuusJgebbdQjgdv/BxKyplAzJ89DWl1T+3dOTKtz+uPa4mmbeOMBXvVZFnKw9tveaIbYIQRxgmhJV4XZCQAJg2gC3q+xTCH62/BHF6hGo/ZhZkBhp8dZ7b+9ZPb12cTXVDJoiGHYPr3ZBaOfKzqME8jVcUEYSQ/LCsSKQKR511n59cWgVsE7y1pBzxOEhFVhpPabm9k2AEiJUigEzHEalwtXKKMHP8easZ8rSMzBvn/bAqmBzMSVJt0jDexDD6XkxwnaULLfqju+Pbd/Jp6HoFpYZ6XZgvScdnFcjGWGr7cAatDpcfxBVxJVwJEIHwMABH9J3VL+W5WHXHhQHtolPnXaLivfVY5RNvYVjv206IYwBxmu6IAZAQ6JsAIgZj4DaiLCoIcUVYCJblMAD7d9T+2aasGrcdOCVbaisx+Jx9914WWsoPMmBFkzwQEFxhsHRzlz/OUeHML/bLIwnGFTlgBGMkhgBMiQFHKsw5ufFOhaPICUEmKpru2K0y6hnU88NyTGC1lJEzFgmWWv3x+Olx4nvuyVurkFEZSMvVrV/1mdLT+WrJT8xWekhciZrow5e2P2oHqgpV/XP09CmYFuwzUhvgcV07XeeRGNC0vYldtc2Nf5yFjVy7/YR/e/oOkUUr6fkCY2AKG78QQq3LxRUiaU4LI0Id0iz6a/qUlQW0+1VikPIN+mbgP8iDHQDlAEi37oY0Im2mSZg3flTMexJ9632CY2KsY5UkSPCKEJgDYmAmgOh71aqjATIjiXLOR+lnDMaqKI1q4ae6WOTVNlgq+zSMOTa3qGaysUn0Pf3Yiwtt9J1zo9O4aYHB2rPtNtQuCqcSfg3KLW+k1D9rBuBqlqjSbqhz7tREfDF846JMNddOmPny9pYPLAwHDMczKeiDKUAIDMTwVXlZx31rCNOqqExJJqqakxMJnP+DJL9HDddKAM4lZofadXcdZ8BZRNlB8Vas0OQ4q4lrEwkmZALAaPNghhqDIcUEA2iZsM45Mf0p+6WJvjChT9ZlGIOj+H6/g6imTvSzz7arf1bqHN4Pcaobgxjs9LPqjGMtjnI6V/asmHr77GebaFYz0au36uDr4K4MU/JuUjWIwdZblxgMorfVMp8Q8qYOHDAE/lzhFfAVALbj8r0wZp1EtQGw0432t57cqjEQtDW8SQaZ9I0N7XItF/TIekdxvJKpnm09j+78rGWHruOX1H0aen7Xhb+cSMpBuxe0gcF1Cg6BxLOvckLHO1DD+XrUfBdXsgf3MBjKnGJdGbf1nuOd05UYGvJbvuXGogFQDbYShi1pNcNdm3EqdgceW8pnqLpNOfOw0D8vvZ12HLlR/Vj5mvyAjHhXOSpDRx1dhxoTEMOywJMhMH4G2JKVvZyU0pIIowG4VUtkGbe2Wp7P6gYM6g2ebvonxXhHOwBPqQ7OWFttXXGLwQqmTlqCew0Vrlg5Hmm/FgmZEFeCwLAhrMAvLjA4WoIh/QDQaNw8bl2fry/V4CuB5dl8U4MJMQwMBgB1RhsPaIFrfHfIkg32Sxzb41aUH+rVIc2CTMKwSoUdaXF3hOVDT3U8As9W3hKz/LJHAEv9c7xsfPJ5n+Xvhw2Kqi5diq8AyTDsPBDC5JO1LPhk3gK+AsQYkHjhUUxY5fOLzGHZR4WNg6JKf1ukTIULpXSBvu8A1x94ocY66Wd3Q8qiWoKVYmIFZzFpMO6tYLR8XAKgu0PL5ghh2Q3DS4xQ2t2vADEwQHLL4pBm1QzDoHKUHxMfKsaABEosUdTCwzsQt3tGQTld5N/SKjkKnzapco7oMr740HviNnp6xkhrlKJmE4N90Wz5IxqXvlq7Z0720bf+EyHFuqzJ06fWP4/0qZKw76pr2YbH5YctwU43wIBhMJ7PyF2v6WvExxIV0fBkfIVj8FRW+Vaqx+vz2tb0q6HvkOAYQh81n1Z2lbUN6YC9MeMCsJoD66JY3DS30pJgVTU95Q5d12DsUSimuiMz5YuBkAnidBcxGKLDAgnc3VXTsB8ZSvB7u1wDElDtrJXvi1GH7pws1yK5AzYMw5h/UJdRed/RJJrunRkqeRv0tpVors4TCbM0BcaUnXscib0yAw8kqaARcI3EV0SaDorMDj3ldSUTNehlbv2S+yFDrlgKaksprU6M8ncAIDwU0c8NmPnv4zFm/+fk/FyQHCMsu6K/arugjYy9jEl/r2u/r0t3wNTla0fCte5ud4TlAjKvx8iFVockPe2YaSdJ8FRVVZcIiz0KAwPU64DCJByKiVK12/2AXEH68SyJs60oW9Jq3kPVXF/FUu9VTdCp1NZYDy8WUFofA5tW9IFcrA/LSmbfiJHKw+/AOb9Cqwn9CHG0/uIKaZZv9z5qezASPDAYpzQ4jV4ETnWqPE3NVcoxOB9W/lmRhBAdiuiof5Y6wrgekuG/EzkNGyjtmX47nf/jGKxmcfbKq05YsZbarV+jv7csAP8hahwAyCQYoLAE78s9piMpBwtFNAgKUmAwiGm3yc7xE7fT+4RPMrkmHqaqahDAVCoMLfQ2c/2IodfySfa7dJfMoq+DF+bkKTC49Y4G+438nALmulDUQiNEA3D8+mBYN1gFI0E55UktdPZ3HUc+Czj1G+kZbq2qzlHhEzPqkWGp0RuvC3CIqmZ4EdBuP0bE6PxcrYpk693nOXKDKv11pPVensLgc17QeSMQ5yx03vuMDbh4yiX9bY+3Us0ZyvYPZzHK970yrzIcsKUlmGQ8EkiykXTRqd10BOTzKCnL+GudckEauaqooYuUPePIFVqvUGFQzJMqIXY6OQi992bGMFu/Q2YVOvXlPvqecmj/mRUkAADhnvIQkwF4Tv/sYrB/iVNgVk5zjLt8xxyVRcGpBFBFd+hdiYfrws8VA8MrMDIAZPQ9DMBT0NuVBjIxhFEMnhIHnrsY7OOU9cBliK94StV2hI162YfxWz5KCzV993rL3GtVOILNkQQXpugjHgkZGFgqnAufLFbMwAUNGn5U5yb0CWXmeA2NExDMYIM6A+iJFaMYUa3+A6mCWOqzF0B38JQi4x12i03HkRtm+OsM+Mf0N9EAjDkX7Hg/5LzZYnA+qJJgcMHjfeo6a4ifQLKRWfQgKtred5Uiel1g2+CVgn0xMxzC8pHegcH2J9FB3xsd3WVV1+NBfXIs5KbFxT2qacd7bdgEF0sOvhUiiJ4FRqN7RmhEQkDIk0IOVURKbaW5j44nitUOXST+/ZTs09nxzylWiOxn0+0uIsoK1XYRNbQgLgJqe1ucFQWqa9FoorwcoP9wpsVF8alWzCWRdXZQusr5rrH2DvH0FrsvdLI4DoqcNwdnpO4lVj0cin+zUl3V1nBiRiXDW00OO90QLpx4DhhGWBZ8rrAuR9qNFH00YDW3VKR/Vt6Z1Rlg2B1KFBjfjOFWwy01WTjOVzWWJ0s9op7N7tD7iERCjq5YG0dFtDh76KIPqtE1A78bg6/oS50CpQ0SWnY7xiD1nBJHK2wppfVWeps03MZru/KGhpTn3HsL/0zpu8tBWtSKHDjz5KYltVPRR4XB2IZev90ROW1jGNkuorrT5OOyj5Xu3JsV0euSQpIA4LWlUyn/RtON64riE9FHPyBcBbdMahqtUbSPtFNxwO9eR5yQKbWzg8RSYRengHBYpDhuWbhn4MC4YxcVsUnx0gKJNT3TeyfNdpB0m3NJT7100FyBxuefrgPRuTTUnWDccbEutByjXBnthqbtl5VYGKycbS8fj1Yy5OJwHUFfefbQP6taQV8cLFQhuSrv04xBHfiInBig7XYRWZw5mQRhQJrAYGJASgk6xCmULyUYFvoRPP5HAa0j/kuvxDHjanIhEcf4J+G96bGMHIOCdr6t1JxQsAhzSL09Qy6wzwJIwJQOxvHHwDUGh2Osl7k49jovWxZGxHSgHRZLA6n6l12xWPdh2HEXOge91amgHRy8ticT3VCP+6b3BoOjeM5i88mzfkJiTyh9MocpB8TXOmvqqzycuw6xs9g5W88PxH0oOwWVQyH3ocJgs0JM7tDbhuvCABUMK815uwTab/B9U+E/TbQx8LOZsGYVL235Csu7I1uu/rpSOSnscMscM0IjphTQDAw7Fd4xWHa2hGFokRiGfbJcYqTKaZ7ddcIqUJPmeqVeosKw7581nf0Rekr1u+VMN5zyDtPVxoaPxEryLAOGT6tIu1KY7esf8b93rAyUuBQjHmmqzhOSqfwUBrcdm9XxKlriXh/qeKQ9QXTS/AFEjxmyH+w5w4Hsrbi87/98L4e+Ph7i4x0LQIpyBwC3pPuEjEBptQSbiDiaKaxrofeNGcJe24GpRWwSQA3DIHBCTH+j3ZkrPGyUnWjOUjt3FweOD5GNK6ZhuJQO9F6zuapiTb+XzOpd0ZhuF4bBXod1I8FkDdy+9LtkMEVrcDMYy2KpWi36VpJgq7a7SLAj42RgCn1Hqq2DO8Z2cc0kmAMExukVt9ufd1/1pkQceZzU8bflk6z0z2ykCZsAYMeYXDUJgFNIXMTjNhrpkU9/RI89OPorV6wIn8cGhXH7PHZ00U0kUuHTMZ4eYTABZNP/8s/x9zCIIhXXBw0ARkZ+D1ccs6UHvXdZZO+69pZJQKPCoMIw6G+8Kj8SCZYvvBeDBxYr0sOW6x+ggZOUKpik296NcSyg3Z4Cpe5ENGJP1ctoK4+qEhWDnc7AToKRgMIxyG633Y7QXx9Q/Rc93uHB8eCg7wz9hf5uSPOkdhR9T9tFfMdsf3EnB1xZpjADZ5qQGLAMCGaEiLuGLroEKtAIcW5kXAYLN8RxogmruXKm1jD4XEMDuOLcdfHFaa3/YdOS0frJ9wjm4wILiUEv3+ZRGSTEb5UcAaxICEDLPc3k5AHnIGTW6dxppfW1tgqPoO9oExoGQzk1tQ8n8WCCV2n78/s5KMZXOoS+uQ/jn/pbcnpcsu6v9+heTiifzTWgTYIrG20qb3j0+a5YxZq63Zth36MwbohEiACJ/hJG8EXAjMG5WgQGmYJDwDBUhNh5AmB8ZgNvehzUqyneg7rWkt0uL07LCL2r+mND79WB3L28e7N2DefWW/qKqmdKd8q3RNb3Qj9BgmPi7pG9GUwJu/J5UPNjfeyeR3TjNDQ4E1pP4dzgm1oKnDSvlvn2AY4JVg4di1gH2O3lJUJLu2/9g870di8/tPmgX/lbE0E7seNV/o2sf7ZlTSUKR/xQ/2jbMCKOC/o7uzQ4wYnP02g3l5ZajJIr1n6OMwYnErybh2srKVis8eQANWXmUVxKJCkUyPdYBw3/LHAigMk4PtXo6UtCc8SV03mn9TxWJ2C4R509nf8MBudtM5jx2NiqgrYRA/Duz8KBjjRMXbFWrtIMrJ6dknvWngMyCCS1V1TTMZVyZOLbvtTCr4rSvMcXlAf/QTJ+j5bdtz0ly5Sp2STulh5cTkttpQAYQl/5fOOQ9ZUS6p8nG9qXe3hszJBP7luFxx9H+VqfRmnSNPVstwjhxL/xeoQcQHL7XVg6WzVT1Sz6kvbvisxU8q69sKYU7ye09FZK7ftevZWwjANDgELnOSjdNWhWtMI1p1H440aOXdqZcCgGtzS7VveiaphRhPz+3wHDzqaTgXuo53pd5R8q5IWQi9lOWKoxuQX5kY0z/YE+abVWpFrfXSBlhRa6rD/HIyXiCwCR9coCggdDSzVs5e25b/nSembWmLQ/kJYH38YHGh6slxGiP7d/xsT4E6I9sanh37qgq6HYtf1YNT+nGpSvWH1NpjNdiHYchsD7dni7Ucey4DpTR2Tf4841U5/i+6K1oty4rV6r7RtPRJhJyHYT9Ob76j7w7hM4vQyq1MVd7YhUw5iYqCuG7T7wTO/t9J615vmaXbqWH1D1WNK658nxRwgxa88uBQ8ujudLQB5UuN2M4Eyq54ttyTtSefA9fMCphJSnV5+9Tm3/YXLnToL28HCvko6KdeGpETUxQrIB+BWAuU6SI1ksNPOdM/nI+bGYQy885dlxfwVQ751XoTTWDtq/nT+hB8++q+/tdzclg2y4QrcWfeXvjFz2re0MuLYBnMW8tqXZqv45eS4jHZDQm9JSHtZfAABqHLIyLxHLpcIw/LZbPPER+VIvfjK5N+zByiWz0uvebOjRH5Tryuf+XkZTJFgzHvdbHMvOPRon3YZ0k+wbc0BkMfGFAIgFCQYNRKVMmPHuoJjqF1Wbw0rHovFZ7l4SfFRbukZXftH1hQQQklNqLoPlHam/nWJ3yZTS4saHaUKvbf1tC//o7OU4jw1eda8UXHbEahL3RMKD+FYm0t0YfPDgfJwOPR5Aj6upBkvn3ztFs796PBgmWdGJzoie3Hz72SQ5spnSSG139aojs/bd5lRNbNoWNdQcYcP5iNWE2s/dBrxjsCTBg1OHLCY9RlsSXNGvd0w4b3XKPdeinLssHozieNyVmZrXZlmF/7iR+ERg7dSqSP/djDroQPKbU1F2b6kyAPv24HfoKKgObVLMwHnRHeORuDkVPaLjwRSm1LCN3UEa2r0Nrt6CdjDYp9SSPSkWxyoPLqtyAGB2ilOquntCs0DODAdqyuQC73C56ndj1hjcU8NoudsqTW+5pgSFF8meqJXogyQAhGQDhi3gKwAhLJRIsGUGfqu0lr+Ja1V+PG5/lQxyJvr28La1GzpmtpIHZ8EyrUJKT1Sir2OnO7USxxCKSKQTtDXbd9X0Z06FhZdyANjvzgkIOv5k5Xg5ZuKtyRtcL43mQe8qOEt/p0SOaWxCh2drSPVgEb0OAIH3PUoF6OY/UwE40nrkF904Z43gUDuAR9FrfMR2S6oa5haDQYFhVQZvf8TBSnGgHXvbszDZLT9RYeXWMd8N/R5nTRukLJg0p6r0w0wOumunLbxv0Vdj2M2RwPAKEOjQRVca1JGoPD0qaTIRdIUrI29tpObrm7FOBSn5MCwZhXWD6fbtU7AT5SjoLh3+rPgY7PypHm+fWG92yxhcMuBTAwJ92vrDMoe4bjRwS4IBDhIMUIAuQGEMhuScdajOqMBgcKY897Pyz47mr+gVLqSZqVsMBivNda8/E7ffVZOK4+NpRn5Uumq6saFrwnCDwR0vXa18lGkkbgjxOWEGCICBIeYeDoUWOmaFANC+zfZTBYHBli906O0Z7By5Pt11MfhG3bXu5RuKAmpnDhKc6ymvSj/sb2yKuCuXN4VPwPmNWhMfetWze6RuW/isCro7+EbCk1rx00z+gKi7E1aJtwCSN5Y2BaRtQ3aHrKKqjMEAFQzfJbMxFFk6YFxS2wKDAXQYlhdKMWb8TtPykoHv6Dzi3ji9qtWOF+t1wHzgw5jqVW4jd98vTJWG/qqhAVF4h14MwCkYKcQIJ4QGLFsv6J/hWxYhnnIusWDvZ8zG9eZyZRbCahIW6fH7ohiJqfhTFitPdTJhqTWcEKlhHi9fHGG9gObRnNG3guE1VWQNWVWv7ZdsC1uf8gjhvh5pN4LlHgneJ7ky3GjPK7krondjsIwMzhgMmQrn+XFEneXMI3evTqxhbG28U6ujoYDh43KVpcFRjymqKVF9HqfXav403VKlc3IaDMYUnprTsv5sZ78kH4NhbDuH+qxyyjgeAAA4MG67IpoY4n5jmbCmGjRFgoTnlhMPmhWHNMlNzoBZ+YGtgfq1GXvNtd7RhADNnrBOtSdO/aT4ccBVmeOIAb1OGUPmGXD3I/bczP6Qjto3bFTLvZYES0vwfhUCcJrqagw+/ow1VDAs2eTF2bkV5wmfQhRFUezDcFmzZ6MdnkDqSnw94fgTmJI/NV8M3JqOwTBmEnYtx534IlUp7aaZdJyfjyNhj3rK+uewB18G5vgpNSn9nEb3Xro7BF8RqxKLvV1fL96rmlYV0dLyHcSGSGEzO5APKvHBpUO1LXP015epp2RmKp3EuypJc+uoVd5CA8A3RkqBi9bWjbVa6HMeVSekrL92h6Z6rqqNwULVXPyJkDdsqJ2zrnF7/RZOl7SfraLGtGC4V/PINoumAnmQkfzfKrZ6fFwdfUKd1L1qZJNNPe8VKX8mSWZgBqmFJgJAjjuBFk6qtY7qBrmxNtX2PzWV3dUZdT3X7n+jXhUIYNM7P9u9WF7qn8evkjKuf1bt0F0/Z1VO6HqrCwUMCwCuIoXPQZ3l+Xy6wq74jlRTlRy1lSFJIFhGzSNzyK9IUVkZgyFpznSNNNgwPDK6boRw9Ssqn6oeRiVgOIqSvsOodshY+05MHdK9v7nF6baMGXxcHT1bZhy5++7iFvqqEhvlRH+T4wXtGAxQU2EQD+fisLlYw0gkLvyUUlC9kXbOLGc/Y4s5t2ZCxfpbFDAei++odbti//Adc4v5yueun5Nh941l4qMcW0HYqwMsAtvH0DcEpUJriDhH7k0QM2KuaFo8UnPIwiQScRjVYnGJ8W+o85PlZ4W0LRl6CTGwm/xSq/ZMmVPS6Zso8zNyY1tDET5/TgZvk3cDcPwnVNDHbJNOQTOfzELaOyDwdheqEaOj3pNrX9C5nR7US27/kP3BNBgiGwdPjhuWBVrtsc99jWySWBHa8lWWi0c1oKiF1RZuK/HRtyvtO56an6R+Y0RUbw6lD8IoIv5hxm+ZF1r+mQ/W7nt3j0gLv68A/FGJAsNK65oMIXH7z5YRBHWufVPhn5a7xs/buH4lUw8zTSHC+rt7VOx/pmKCbdRZffQpTxc5S/7B5PPjcjGGWK+z96Bybqz/Cww9Vm4NlR86BLKC3hIcuzsE9gLRHFJrNHkVfbviUdWGiHWvGlz/tiRY4gSWmCHaUjC4MIaNjuOY4VL+G+hzD2hPoHL57SkQ6FZynepVNdyQVOsNl5yTMw1pw+AdQc+z7tNqospC2pttjwgMLnhwg8EFDAMcZy+y23frh6fqbwvfhcHdWOT0r9E2v8kvbERmv5Yrr9KhoyrYeZpnQbUDQ+A1/V3ZUWDo7SoNOBmvOkjf81J+h6g1k+0OrfYqekQHiG7RelRSdUnplgVyIV+KA7T5lHXtSbHmwaJM5a0Wu9FUYnnPziBoNy3J1NZ75+R6KNx4QzC7qtA+kGZXQZvmvvO+BnOq6EeS9Vf8TscDEAEzoPDb2L+Cwjkru4bk/87uNgh32JJvlLYz9/rMZvEyXPbMwP+XiYq+A4kdlfxUBfqmF6c5YalSpZa+EhZ8l3SdxQZ90sYHUNofqfHUB/FtxI2BW2/quqoDg6GB4Snt9LuQOIuKpo0LiQnDWbS38TP88nord2HwSE+mU2do7jwn02VclhOZVUwJDICHH1bYE1JWqFPCMLZfZdBCgX2RUP0OF2twJy6AYxnRXjWOwW+CRtqDkf6gjKyl2nEy/kAs9tj1LJZpNwZA0IgDtryrlfYEHrOGiCf8I/xL1EoGlwWDopLgeDBjcEwKI0F32x2bJesFhtBENEUpMRguW4VnL58DbAuGfTfptoYs/wmGNik/xoNPtti+ixEMdsjxWE8mFjcDrh2q/pwDH4fzR8dcXLDDZKLCUPJgaOZfM+7TyiAtHuV1YBtBX+faFoOhQeshK1Xl9jysbnyrYjJKN9T7nD7DF/W+WvR1kdWz+8Y+556HvK+FxSalmruk0l3zctG5yoXsLrmlzoFKdGyrjL7CHRoLk7Cooapn9kPG8t81ae3KfQhXlIeKR8aQrfd9nttvk9OeXzD4TC5eNeAdo9R24S1cQd8REa7O1b7oeU7kYpVROWe1akDdaKct370cBu/EHt8X1+nAuz1sbil/r1zJCqWXb9hj5paZXo4od6uxKglq/m8IALDWq6fTb1Glv++TK4EHjrQrIHWLJG6WjSQtUobpNx+RfW54sCLWIM/H73sALQbXRHlMIw2DqtSRedkdkl276Uml6ECjquSe3Khdn1NKiyFX7BcpPv9Zsa5ytiAsuzTZXojBvvsADw3EVopouRmkoMKYh6X1wxfn9ny9tK/8nHWnUsn6LcbpKzNn27rOUug4JX93s3D8sFdXJar38QD01rzU0l3vYqeidL9UM/xXbfsWgBzXx51oznezcg4K9D200G35VtEnEWt32FJk8BN7AxIfdetuaBpEGYqpagabzzux/3BRdnRjpcHv2vUjc+StVu3RJB62hlD/jMYU0ZZ01hxT0Ue8Z/Wq9IuBUz6sSo2cmiiRGHGHcD42b4D9oxMKwMZXqykMzSPGElnBAB7VUK0Wu0tuzIswO4Xe1DSfqKeriJ71Uxsxv4oyapINvSpQlk1rcc7r1oR3dFGsu2qons6bPLauSGsJFsf337uFmNIti6yT8fMu81PKq6LcosuxsLytfOYT0121x6zCWm17F84h8Wlj5Jk4H6/Ff4KYLuX7i2hJsC4F2p3swJQMXRharaDmO1mp8bKPtMRgKPFSIm5Rv1ZYSkuLrZLdqX9wrtMTL7vzxUVyXGn1ztXwz5H2Ocv0k9aGVKqrc1nSs8N6wHzskmnsB2z5elmBTX4Gauegc/y6XHSb0dSqe83Cv6X4nhstdDmUFTb5DneGkcGvlnE7YsKwSu6hr4oYUeQqcgIULy7QByj41ZodGW5UScpdYfCtMoSgWplpzI4DifmYuUDTwUoYFhi8nxKRrBVtkiQYSuB0YHjkNt4UJtTKucSNpbdpfQrGZqfBG2z1z1VbTp33u6AH/XeWHvqa0NtqhV0M2gH4BAqOwMYsb74oflbxSwu6huxWx7MWOkBNgo9vW3hEVx2D3vN0huCN+F01oq49lP7HbjRFh5FYa0X0Qteyit/W4JqJ+alkyJFbldMXWjLJTQsYPjfmm0VVBe1X1OxvDzzLmLers4vYJIsEOxgM5QCuVNPdaCXdgnttPqxaeSvG68a4cicDsJBVgK5S8z/VCXMgzLcQp4ziwrz7/VFywpo25g/5P98uU1w2D5pq5jhj3hAuLdUehQBqSFK6Sg1AIogHxW1pKrXZHkq5HY+b+iY00unUpR7OgfFwVSMlzyhQ3jqrOJU3kOkEDvXvS3ub09jZlO/WcH8aL5UEx+kPqYPBoIGEaiGuYDjKgfo/OGGen0Z6WRHb8rf34Z8sFv11XOoGpg9h7cjXjOufex3VzpYbfJ4Q6VDXLXa3mIE6ewRI2p4hHdS6VB58Q0ZoO7ty+29EjFJGaNZMD+flisXx7VFAf1Zo/1cf//HZ0OjJpSeZJ5VMIMBeyckgJUgOXMfl+Xeb2b6t1gkEqqZNq0zXt6b6V0l3T9x79wY+V1t3jE3pn6cqv/377NHfS/yz9pFmcs5dgkkYIDojo9OXrvEgivqSZiemEStLPk5lTHA+ZWDwYHrn6XTQXRnE49sxWG197I6mQPFK5K6s5OflfKP7hbKGk8xy4lXaK4CmM4pMzWkFQBpzyBF8mc5yYCUtgYPBLQw7bjXg0p12LnVm19OmqO7ZQckwTDY6qIICZQFm9c+HC/QfVE1bpt/99psoo1P0V1RiZcJ6g8/GCZEaY0dxNmL0zZcXFtwzFjIlMRYUViUEOOKRdp0zV41qLqmzmKqWv5SQ0rFGO7FSSj1n/ZXkHbk30nWlvhc1b0+D9ZaclFms53/6vfht9eT9dl/NqQJ2+yszBIDsEV0oovcE0a0uOhcoGsrGLKFzrtTRYN/wtP2rt+i/uGnuOammzW7HZLEq/He/1kTfH6O/J3avnzL9GpevRbkx0L5ZLOcFR6jMoFafNRymqstvlDaXG+5bAlcjtfjzDbPhDIqbUO3DcHnY3Ezi+t1VjjOG/Bg9tazCg25cP+C4NLUvxdX1xBvs7h0JzFi6U1lDvZ1SdgwG2I3BkKcRA4Oh/GBVJLYClm58947cwhRN9jJZeUV/c+Unqqou91u8RcaAzzP9jiQsSyqW/b9EEIKdiGNEbkTleV+wJPkrGsfUC35YyvEqyCNagi0SXPU2o5TjwfQ26ezicH2ZctdNOQuCH5dZN66flBZWr7piQfMS/yG3337y7eyRARUOpOQ47LsYHC+RyOp4V0kYVnsyuNiZemTvDtS5Ij79rQ7+QeWzv8EuGOjbhV7dIUBvq01FaRhUqn78M2bDk3JaC70zXS0URzC+lgRLOthi8FHJ/mNwZrwJsPVcV2A8nIYEezVAeYNXOny73uL/8zLBg38Kd3MmLHEIIMT9GMoog2rJbim6MuslipHBnJee9SccZ7YMzCUMV9Xm39DopZ1R6sNkdqiuut2Vi+g7uMANfE++4T8bfTS4RR6Moe9gVfLgMf/HMCSrZ+Ps1norszPmCV30iBxq4TvseJXe2ybBLcZ7KFW3MtiZ8s8LN+dvS3ybTK0wlMs1lnOXjGm8/+OlXLdJM/N5k3NZ1UkJA8OeGTIMt9NLrSWucuOUkcHQ5qEsqTAIGE71u/haFS5OufSmqkRy8fZ2zslIMtgfXuC29NcoYMpgLpRzCYyHcm5oxwfXKPuQW+ujTtU/I631Jcs4gs7GtM2LkSH5gN4qKYdHgu8Si2u2o9RUS44l6polwa1cROKjngGnrXY9NFLnfyYMH59IM978fFiFy/TAdG0VPi/dekJOLQk1suYCRYWSATOA5pDVElzYqTDsbPiorXwQIzrqVM/AKM/oPouyNzIW9WP3P4T+1zQ8Ps5ZnX3pb5c0pvFtC3fzZ7XF4uVli3OZsG5IwTGIOqNMsedvdZeMVC5dsaI032eTIPptffYHp22dvYjBMEuj+9PueFW3Rmj8WUJ8oXXP7hsxeNI23yZCeZ99dzRcqkDWRqhhyemH6hQNBRUu6pGzZ2O/PCbDxhXZXwvqdyQ3d5rf6fYu6c5IE4vs8ma17Y/O098RuYa+ZsRRdVwBXa2k8dwuOGENLevuBpj7oonmpFjeDmihU2eRg9grrQpJajFYHXZvXFXE+uvDExgMJgzDXQrtP+GeVnbAxsIf8HwZb0J0L30labzF39reDEPVFn+dxIWuraQqQKg3FBjSduauB1ZrJz4+tAaDyfB8rtXXe6ex8XyWNmB/kHSUNFoQlGoGbsJ47pT2Yw/hMACrorpA+03UR+6+o66DlXJqnvjOWmt25+d8v9e8oMfl3VRVATNXCz2L31qZjisWNGrP/U8Fg/2m2wpvFA3hFC5rLe3t+OBuQNQZlXWWWyDZghO18h+A2yuiOxa5GDxULQAMP+1Z34VQ/KnTXxSFY0nmnYgba6MKdOWfsE+CLQYD1PgHzUQBJRLXH3jzmFRIhmYsSZPzPzZDcivqF/HH++9nRDFP3YS+k2bc4e0Ix+X99te9ITca+L1N90jw/uVjfE0lCYYWg0fbdTFgXPGlrNOHqbB6uQ3DjvgI3YHnt37md5mof14yypaK6BaDo1RInBOcN9XuP7rkda636sHUOSR14XUsWHk36zhl6j8rWpntyhUHBahhGEBH4pYQFz1pzMa5G9ote/IPX/9dkRsx+wTxBRss1avOAbwhPQYs900EYCIs9C0NCPlV3UKCWxuX3ARJrbl78AQJJrFJsDyr7s2ghSSdxGC/h+MlT2OwbKg6NdL+8I1WE+vbPbRV8XWnf3qtX4h0uQKAwIciGkoeDEIZo70yebAG47O3XDXUYnwqQAgt9B7wnzdSPcKV8sDAFnRbFbQ8WG0bLDEYNNiuKm+lq81yNnh4K75O+bjPfmhOCo72940yrv4dI75R5nyerforDm0pSEZV0Cc2yuhi7S0Y7CNr2+0KvG9XREcSnDEYYCfBFTPuYfAPGIMtjSUMqKOrSqb6Zn2MvQq6eDyYmHMkU9hQTPM/TeqMGXhgMJS6aLBVoPJPALC5ciWzuab18hl9xZ+KxBmN96XtLiYh1ivZFdHjGAygQLKzG5J1F20+y6rO4nLbADwl92ZStaROD+J11fTA+jHx0VdVPjsuV2q11kyyp4KZtgEXJDiK7hilYXBLmtsutlODCo01lJY7Abct5iN+Tum2P04ZXxEtbiQpokmuxOPdCXjrThx3EeVunQYVhm72SriwSlDv3q5scJ49t2XFOT+y2bacyger0jOAQrat6hgM7TRi0ZcGiU3meq/s+2cgGVt0SBZb9kPgaI8EaxgMR6osqNXRoGmkMwyP5H+uJzeDECsPRLW2vuHRd1S1Y5+D1TF/e4b2lLMnqPq0b1xk3DvT2rUNA7AKNi3FrDAYoMa/UqedTnntYl3moJsEHGoImcXgFoGUFWtHp10TWcTDG6utXFtSjAbRzuLcCJMepsIwEmjUUcHNarf2H39C/QxjSHx6W6rr+1mZWgHyMBi0yCJd2oF6usv+UNzP9r2sK0DNUiqlFXV09aeKwQAmFYbm66u6MRKhVdWTDpbOz39QqkGesxY7n63UP1f4KhcWzWNR0k+q6Ktd63XmAgb3lc+3AHzZyowSYH9SheqA0kr1eEzVolV9vnR248mq/vb1y4bUoZAvtDrstygPipqxbVReG3cPbGevYojOfH4jHTbXocZqWrlHfYCc3xKRtD2JRyrBMQPzCRmrudoI8uZNIW+Soj+lIlfoddurlH+HDL4gWXj8FZdnU7uUTxmvJuNBBQwtPa8RRfszTohc1Cn2D7bViWo34n7q4/kOLRmZ6z3T5rWdZNsm2v4MjgpNuTKBvv9xMqJ/FjKpgvYVyxWzzD2oMlRUFBnqRcFYTzTi25Jdix93K1QLgPZM2wTRhBCgDklqFdGw+2RBYxK+IiMfRvdmi8IKFc5yTw7LEa0DlNMxG8dbaWtqy99Ftc/BMV9eXohui3FYvLiCB4P3TqFV/jmql5uWIFYqLn2JI78g2QeZbLJLgo8/BQ/ezyrq6LY5q0IoEauFE5/vXmHDp79Elf62BQbV5ldM16fR148LKg6OWX+nvKN9MTdjAM2AUQYLt6eSJVjFYABFwVupo6t7mGLD1Qogt+hjcHscNJ8s6D3c6rMvb1/H4KrC6BFtqHwrPJs2Rk6RFWsyVS2Lnfn6aPem/Bs9Zfv4BDU1lZ1G4iswdB3CYg3HuC4xeH/XxXh3vrm9jGKDuwC3ToZLlaBr8UWiwCBKWdAbSgtx6lOBwf3Ku/KfwuR05XPPHtxqOlVl5D/tIYz7XkkZ2eJ3viclA5aTso6+B5gdGBz7JCFWurxXVHhveJT0KH3QTMvSHqxiLcAQBsPA1C9rcDC4rTCRYLks0JloO/UMZac6oRBW71HHZgDowHCUS9G9amei3DjuR6S6iREa/ccFhzAYugrO8l0PXdLtmqb6Vl2XkHb9M+QJvdGrD0hNgivpGnGKP0k51f6I0t5Sp63GNYmwriSjndqTwbacSCT5yRdoVObAUmmc9azanozon8+h9bnwX6e8lXPjLsX+fsvzmbAs5lRR4SjSQRoa5XPrwNUVWYOKstVZq88jOli/TBeDW0X0gfoxWqnN3tVR9g5liJwSB4NBG23DMGyJz+m9s2aXjGFzL2DfArcjqstZqfUrGgbn1g/NygCgNjA87o46KPW1tzKlIk9WS3ZVLfTgWbfV4k8dI/8oIxzM31Rz4oGvSb1ZLQW0fuSczKbFcOivir6y/u5D6NpSm+99ra22M6KEJIGNwaBR0tSt4Rm94uhtQ3UTBgmWp7qBSTCgl7Z4cPSIDluuLZFgKx9gT9nr9eGcOChuwrP4fRaMfaJsmpandOxSnHvslpmV05083ZbsOTZ8PUOpKOwDZ6GpLqnwT8tIo1PrGFMp3bMEV8HBaqPdfRQszSKMDYZ35KocHPZTfOkWBX5XptQyGsp42wvV+/NqWvpi0eaWV4+cYcAjk/Vb00MO0r6pRF1dRjCuCNX91IoPXs8FPcaDzY4Z0uLcBLmEgad92OT8jpyRO3cpHpkRLqq7f2bScZo+VCwJg4sHmMeV87p3KdTOXbXHZb1I1e7+R6+0hMD82/LDyuLoITIGAyiBSWq+aPUblzVXp8Zjf7tS3b4UtTPq4uCHLTutzH414+FexZEe+sZLrIgjWWGloh8R28bcAHD346TCzlompxzAYLV+VSPtSIfmzpNgGLZ0Ffdo/RZZKqUiulJZVyRYPhkDg6fcpC2KaVbi63j7Kw/71FXz4X0wPChTtPgm3L0hj0cxng17MJQwrIrQVEMFw450l2J+gbL+PxbflSlmQ4XrfNFWDyucs0ykaoFbgNnq2KwGIwVoBQh8uGWp9trKrJvLSP3zyAsdVcvMaJ4NWBlF37HaPHEvKTdjmLLCjsu1+GhPHHW3PFtZWx2CPgLDIxicKmuMcPlU5Y3VVn4Ng08qeMGG2yv25vazam+tV+b0jHx/iNSwvBVFdHu5fH3xvEqFwWe0xRiY/nxHoDo0R2Tr+58TD/DKox67Vg9t8jXS1/ugqL6FFlo3cxqMfCSNYjU3FszvhhVw8sCyHLUsBf7ptM8jamfnvk6j75j+GRIABz62nvafskYldUvwD4sJY4Yi2vfh6sJwF4OlMRjAC0li9jAYztDH8TSNndSSql7rHoXwWJl7tJoT0+JFtP4jvE3fO9KnwmC/gsP6qxuMr0+SR+thbCSMiIZ/elrKcaRsopKK/YOdPshn5Dc3NWBUDHYK+/UPAk+kv/5Eof4YIdztw5Ea5jkTb1/t7OFUS3+76Ks+4UnMvns/4BGeNKagPynWcl2aaloMVjs2vvJ3MbgumasvcgfaavMGhu/J13G6qouG0rm2YkNvbyfLkMl84KqTMotG5aiAakRBjwo7fdBgeG9Iv+6MnqtWO09eDga8ibSUQ9deJK9BNUULIJEzdWUDtpqOEB72fJn5EonBrbSo3ILE4GdbBSA58g6n7is7Hc3hbnn5IPq2igEV+Np288ospBRM1wDYJ8ESgTrpl9/gtOWQXYcfQ/lwfQdpEzKL+gsSHN2hj+rx2C24ar2ufxSDZ8HgjDpano3yVjCesR3qcmFw3QCu73Mebp5MrZd2YVhKE+FWVKuMBG0ddkPEcGEQxfRfJ+Vn7+3orlhnEfePWaZ9kJuCQPVpHL9bntfQXyKgJlK56kZlHv5Dz62jms331Sk2oLI+OwGuScNAy5VaChkhwcr3PLvjoY2v7e5M4xjc9t+ZVIYxuL7xLKnDwhvLUm7DEAbXE0RXzVheaMLw4Av1xWNdY6z6NJKNX3gJPC5cq1fozpVq0yUS+zAsRc9lpsKw1cn9qnMwLJNhIWHq5+2P1ILegsWaCt5OhkvtgnuCtyq7bz2NXItNqj7wrHNmdxuGeGGFr+7TUPYfvAjMtyhTLc/n0xUOXhgCHAM8cIPzYartcoeG/D7Epgt1lvfm6c+OIdlKdaTdaKEtU3XSTzGjZKlXb6FZvwMAUdpVDbG9x/Q9o3ZhTyq4HUXfeEo76/EMmknK71fS/rPK/LyQ/a97ydWmBzYw6JYpe1JuzyB3MSn/lVJvMjF4d/VonIAev2TqjF9bd7R0iYtKBMtNGpQC8XgQmx9YoOWDWarnDeaW8e8ok92MvhX9dVZgDv2ty79PI/QGOd3bsQsbFXRysg/Fn5b8cd8rR5Qck92tGowIpU61tupY/E6K6K1dvWYPGS01h0uCQfDgM8oxzcupYxW2Ov8mGdRy+/d+VyenvsQfWz2oyoOSuZa+V5pZIXe2UP1UPvxGB+QQar6aETYsuK+2oLz9SYZL3stehku1Tj361p9XGQgLM3B1iUqC4Rq2yTkfNEoWJeqfp+THvoWyw6P655k6T3fmkDKOeVXCiv/JsNoVFThHdNHvaPc4mzerUMZikTaLp3tlZBsYu/gEBheXu0bie+X0Zzx14ZV7+SOUvWrdWK55LlpSSgX1UAT2gKOcsw2DXlvu4UHfvfoBPBytfaEHLhmSNkCo2x9V0X12KXCbSO5e+V5lZl91DOnQP/8RuTjntNZfNfbX8nzu168NcW3crwCAwa31IIWkHNzlpyORbnsBbwAPgwTvRxrQ8y2vPRL8DpnzjlYnGnl2Cs7bGn5S1Bmwawn7sZ5IGTHYO1RYNtES4qnH/wOf/o0BS2Aj8RgE1kk5ujV0LcEtMJ8gwaDx4MFRFITCWSqfb/kM66fdu4uRDivHh+lvW8Ogw8IJ9O3ZHQ4VNIaQ7bi591yB7mzKqq6cI6B/anb2pYe76dDmdt7KEf3jcinYqbZGn1CPvwHV7rqdN8k5zZ6q76mOO1TYr2q/ZG41dv3z/KOqBFMszLMweJwEjzfdZuG4ROI19H1tOvS+6SsYx2BnXE0pn42rOq2ox9sVj695bm628QkKQfa+SRoy55n1c6KOY3XVOeO2N98N20nh6BUmO4pwipmw4I48/jlr5Uzh/2ihAS+nPyJXOmNdWx13nLPkJUeJ4kxnfFZDqHcvQy5XfhNdGVzFjqwVtKqm16ZWdsPWmSsfjL/byNTxRE7q2Qiu6V8o0HfbDvRNpxo3mpGBamxfKPYdmrwFn4ufM/36zs9QvhrlMYqHY7U48GpWjI+eAIyuS2b8nyG+GfiPdINyAu1NKQYDSs4/QfpvzPjxDxVfeX5LhT8jljLZtV/oKbRyJVj7ZNWFi4ag9sZqOyMkO2e9a4elkUQcMKaqMfw29kvGbuDcfUpFdP4TGursk0iHugEU6JvVzkEmrp+JcbJ60qW5bYFT1tZ7An9HCnTL+/3f3+lQIg7cs23M9el9okOsFknsbYaoGVnPOUIPy+EL7dTf9vDPiTXtqjTlOlrPVluVv2G5cMIO/SOgO/pkFP1z5aW/H7dyd4AYeKVPVtUNJXdH9VlYy4KjNq3wObEvPxUgkIMnpRbBVwO4GoVxCazA3hQGO5BZE+4AALBtCXRf4YDetlq/IbPDxfGDznX9wEfEUdY69ciS/p6DIzXoHVOv2pUc4pFOZMKqqHD8M/93vJ4b5CpN6SXf6B4fzM5h/U6bBAc5OSq+0Hrne1roE8ukXp3jyaXn276zWr/k+aSbPyhTz7C/a7IcflB+OHZI23jrc97yVZf6VxlVVTc1LpbhiSqP6wts1T+iX2h4U0tvLHDVBR79tWHpCDdq0NfZ8q97RxM2XWMNcYr76j15h9wKdgmAlQ0i3IcYy8v/1pe/ScY/+APtBkiw/G3t39BKHqCD2zY4ZWBGC+3gZfvJDGpZf8S5+s/KuTzPPyAXFy76tkhRavqr+UgDKG7SlS4adL9oPVa4s0A0LEQARw6sbKLu2qrVI+f0z+dkSkM7WqcbLtVFOMdVtoLe7PCc0VdNcuA3dKOMf4/nvK7+iLiGFo0Ba0z5NlETWagaYFV8O4EcecUMIghrNsfGkoMY3Lbl3JSj685/BND3RwKoNwm28BIqq1tVwH531u2MzJ7vlnagvrM/nkL1pmrfIsabMpFYvnFVLSwqrHNYHgvZWPVAo+ps01qIYXiSMTJ16AdL9C0Sganlf0bPUc3CKtmVxytFdCiNwZW0teXjRTGBuyCsv6EJ/wU3m9W77PbD0mCEsRkBFmN+xJ44xJcmsya7j+vu3ZBUaXftBZs1Tt2e+mQtO66VI7qanlQMht67GcRg6xZiHXEWq1TQchi1VrdenaY4MPwDGDz+Cd/ysQ/c0Wlz8rvgtnvjskCjTI4/TAcrAAWJSxjW96uW91o+ob6XVttb+ejo6DYSAlVnjYcsjzfE12PPP2xf6IKWr4jOUu2SVIUkqdXKs5nyAujQqy6J6E+HDFwhuH+251LaCZxDm4qS698SIQY9okfWEVfKdy+vMBgEFZ7apwGgpsJTGAzlfLdX2yfBDgaD/bHJdgdF1weK3+rI/9Mr4GnpcrJG/sC+N1eeanWt72AFFf0tkZg0DJYFsmiceGgdUzF42XksJ5yIxMW12nvxHZXbq7q02K72pJxw+A6lv1VlDM4YHEU6Q8kaQESgxrMZd6Fkw/9Xiq4yecPme1Jm5uceA25u4GRUUnvP3k5/8w9ImVZK+MxIM4XBaj1ZFOBsyH2r/bMMYLGCkS2JBupR/uxScGeufJ+8G+ecj8G6tSvf5j9kadLoqPVUlNAgcYPBylUDMFy1K8XSVDdbiWCNjtZQGUffIc1Q39GprJzqAmpzEn0tVOhKi8G5wlbtXOEulJS3KqAKlckmB7dErN9jkXfhwA59n4YBgmFI3xd4iua1oKCevdyQC8DGeO3HWp2YVWud7alFikqFAepHOYvBVn+s4dKNU6pIsLJJcKOIVm82SqOo6JvKLIy3Tt0rP0kuu3etXOKerSNtZjs0Kd1n5a8wun7O7SjKGAzzMAz9HJatpvrAMwSIXleH0bdT2zT37co7nKq66DsuEoNz5RXoQoO7ADX0+svxLlnv3oVWwxD6tjIMBPfE4wzC5000OgHwHwglepP4C5YRDParGmzRMQkrq4Qxqup0wPnTucSB4RPdcBr6h4jamemnfUtXnPonn9iIAqOhwuA4ahnDXs8jrYx8rZPK99GUqw4IR+jjv+CphTv+0oM8eAobZis/Laq5t0JiMHC3OmLqHXta+rbMvaIO4J9HpZ/VxvdU0KqtqCvtPbTP0Y+APv3cu4+vC6tTmgrnEhWDRcmUlEO7UT3C8kTHfLm9wlbOqUN+Un7gIYz04a5KLBg2XKY79g6qwfukr3h1f20dmNpV3K9Gqu+qfFTxC4wYgE9vYX6xnijWNGtBLxhq56pXrf+zqkuvcvqqVf147iaPSea7dhJxjIuDUP43UiosGwCWOtgz3RpbxbwDfTuwOmOEHqlwpKTVBCGAdBMrXbF+EhKctu7qxpXh9APy1kf983dtvTXDuV1RL7e66NtJCE7utnRdOqw3s70+YIx65x2U3a5zVhPb3QtHQm9bskJfy0QtT/lPxjqr1Wbqny/q/xpptxT6k+KkNOEACYD3B4SO2XlEfpJJnGjLsqtbWujx5+CUbNOAmFNko0tszcB+l85N9z4Gg/Go27YGi90iVyyj3aqmhtY/cGFhvTU7zluP/dUweHRf4XzW/C6MbssuteG/XYuvUVv/uCPiklH3q5Gmp7yu0p/ay+sOV6l5VhV1vihgLGaqe8f/ZSbWB93BPJQ/Bd6GCtqylrWPvv/6tVXYRTmN9G1E8i39OdsZhHAmP6KqnbaknbNa367uNDrYsYty48d8BVb/OZh6ZZ3hwzDoSmkPg6EHw043ut0mBBn+q0La6aCgcwpqTY6dgC/KgK91R2qsGqYKWXzXsB/THlsoPgOBA7grFPJRBtF3RKcrlXxqeWv1I/cDhllXrD9uObtRLE58ugYpKswXc9yuhZYXWfa5i+ibD1owrDbxVvkZwCuYxD9v6J7WXkQ5wUE1QuxhMNTq6PMmYe1mTwObDooqW/A7Y25gcDfPG0ffbretNdA409VXJ6V999iawtAeD7iOe9sw9HyGLimTHUT0yzjH1TJt4QF25zphXZ+nRujvrNrhltkzTyu1q5SthR5Jk9nFYF8LrVwotNDxQjkzWpcM1gzGtqmDuo1b5I/QzZ9farz7Np078m/WJsSDGBx/VEjcRVO9/E5/Ff3zlPPzdbmYguPQmQ/zyCn09aX1sTqt3LK067Ud9410+TZTbq5n0APJROU7XZTWUdY7kvbMlxH0/QHpWoLr8lPh2wMze8V9bVECgm+B3vaSn4ThwWnlziRE16zmtxvd3yrOW+si8R71q/tk5Qs1zJ5FQS1kSOtwD32HxLFidunvH5QR5j04O43YrXzfKP/4vcHTAo+uoq/lj9YWqIoNznuz02PzoHYGPBhW/G68HOnDCf1wXcOAJVgfspXm5HIylDYtZVG/qxipvoSBScqMPMnXOnrptj8jCD0+L9+IuFbNfmITS/4JKOs8HGfxBJNIrCbAKuhvpfYU157IT5IvkWS3or+lVIT759KFCiw8NN4O6oQyZVV1MBEATQ2rapKd25yaCT2Ftoa+6b+G/hnsJYKx80ShhW4bTYXTsBiF3nEnpDZgui1TnT0dawSj3k4/shnDuNyepdO3/KkkWM2KpV/uRgVUlZ/YdsMRG327s5IXAOpjlW4uujAJ3gG6E5soyObOgfHPyNRjGX9lFgcqPoHC00rZmlDWWV2oijU8AheXyBk/HxH0t3rLfyBTt8NHg/BIbcuYWxgZMFwTU/dOx6cRk9G6xFcN9nUkNG7bZf1FJuPqCTjE9/RU2aLvIPS2p6b6M+zb+w8D4EE5px0dsdGmkgKDc0OmjtpeNPgY3O0qIcr9kXqa53v2cpd1vgmlhsn6mboH8XjEOfzdci/p7xJ9k/hiH4PbYn6FXam+rP2/dSIODX2HxGN7hl0zi/perlRoXnhZbau4L43by5rWqwXQCTlxVdpq4h8Qs/snxADgWce/wkI8EDCeW7ki/sLcomvprJGcsi1QXGXwCed+LevLUaGmhRaOWp3U0KfQ97h6BIbhMjgNI83tzMbbrL4uOtZ0fBQnyPRluB29l0EkHnGAaDEYtM+2y9Iqab/ZjL7yqhZ9u7ZMh0GaxwUOte+o6TxWF6r1y9+m+/EbrM53KdWk8nloOWUk4mju8cxGPtfp770N3Ud/oQLggvi3ZNxfqsizV8zJs6uhdnwMKm3OYXDVSgXD4xjsH5cSWMdgVe08CGBlux0YhhvAw5cf0ChOIHGnoqar73w46pPxthgqyrlqDNX+kn7XDlZ1FuhBxx//VAnDlSN0brqubRbsxwtU79F/8pbmtrrqxm0Ybpcpz6kRd+7TN/gO+juSb7Ib73tPT9RsKhQPai7Qjpa8sw/Sf1oMsbmFlvjMrDJ+hZPdwDjpIHZqyHPEFfQ1Sv4Bu9qfaPdP3easYN6NYKywfQ5HlwgFB3LrJ3uH9nhqUAu9lzzQ92jysjoUBmB75oO9OnJ866NZjDvOmOdEzmz1qdM42u/PiGuVyQMnemKgr2XiVTT5Y2+nFTXGSb0qMITQGMDfBI3jrPz6asgZslG82cr9IGfZ9jkhKmaxSjtnzafT9qd/BAb/ETicwrYfk9ir/O/u2ufHjI/BIBBU/vN70b07ceqGh3C4s755xW811Mk2PzzLyzkt/j59Rw70OlLjivune9zH4B9C3/Ea8rXdZ85hNL+HEMsGXGqb5d6T1pCyoKst73TrRq29Ywk+b1TouTx01QnWQRmPJHWGrbrP0EL/h8ptuf0mG/3hFn9AzuSlmilvVl5pp89VImsTxoI94GdsPa32pFYAdtx068vLzg+N1aoJNRJptpJ80L9kqObS27Rt8fA5jSiw/xlvpD3b9rN1/C6LFb7QQt6Ivk6xEw2N8MkxhcfxFI6br+y4PHZL6qkp4vsOm/n5daLUgM1ooR0xd0aa6cx7QJcDx3/vqPz/l67csgp561LGrHyY/r5LBhnhoOcamJ/kT68Ur3+MXaY7G+2j8uCkZRW/9bZKv5Nmtu+gbwSI/E9v4g5b8iCJ6lTSW63urTTrlPHw53bQRw4u//2kWJ+H/3G24Ioa3Mpi1P9Wj6ZnpLAEN+arWgttIfGfnQ0n5f9XQd/bmY4xuJKuSaWrhR7uVfuvrpaMLp2TLhI4iiVDOsvTwr44o+30403frjy3clCwcnZcuKRzVeUAAIAhyH9WMb0b1XNrH+OVvRbk2bZAF9d87pvrDAGqzRjOyJRSxTx1AaoJjz60ClvnEud4lbo5nR1wz74S0NZemzVC+4+OmtFyJYviPpnzifWvyR9RQUdx2u0+irf3+cI35b3K1i+61fFWR/x9kHriPKgyvkg0fS8GExY/5DeV/qvtDdDtwxFsaez6IE1gclPY48E2nrFOXi24ea1/yDm/0fFpH0o9f/deRtC3e+q08rk7e59DX7vade5Rtg1A75m+b1onLTx39lrooaaK1g7SW7U5b07UhoTJEkwEYVPmx1JwfM5q+1weuS1QZ1guwdishWxGfnRNcMtDqLiF/ypH9pmujoztwXBSbAiYWp+xNph10NWv5659p98fx+RsJGgURy7DcH3JiKlyLBjJhwm5lMklrRRgTm1jdtOOTHkdOeJz3/Z7OVFhcsIK3NkWAJrXfwTIGv4FPzOJqzq0K023JFgetLJzmGA8kygucA3e9SR4PQl2M19rM7g6xZyYak/C2GlA+vkl4BW5F+ONsTGh2JjE4Fx//KG2MjcA5FJSAOFg2ueqAwVSqqB4igTr3RjnMF0Mhh4i6pdor3giKPTWrRQGm1DWH5fRt7vfzzj9rS0UPWN59yszCvRU0P2GL++S9AOifh4WCR7HYLWqwdpATASlHCS46vw+E+lTai42sgxqy/TQ672k8I9UfuNwNZhov/xdMnsvamK1Uxic6hvSwTinOoqcE+s/ha3qKmiBwZIEa99FsRqQhNVSPkODNFIdDeLFtRrpSgan2XOssZrGq85I7KzXEBp4qyRY5WxWZ2bl+ka3ztkbnZnkCASADgCPJBAB6GlOmuc+JYNZLYtLGuI4UvIEBheXV5YzN4uWPF4x6eJCAgh9/XNVp/NnK90F9e1ajZ/U7voyi5rdeqAZBt3yt4jW3EnlsIrBsgn1I/a/zu53P25GmZQikEn9oWIwQA3DZVd1GFanAnU8ENZTK5I5RWRR1v3KNgaFDE6DuRKfpI782ZrGqwUHDOOFJYNw2FmmtKvPYfedixpWKAahAODBeqW7ubNQUv3WzNwr3b3uL+endEqqqJllHIO7YkVRN4Q4keBN5yhKWqLqh9VEVyw27LPkN0kXIH0V1omGBuvpPoeff1CaHiX+8ByyxjdQ8t/F4NJ6ZHz+WGj7LOp7nZ/JN1kVcDL/WFUNMpnry+Wp1bx/VokMVqnz3T5Q/zRpCE/JgOP9jxuxW2VFp/kBDK4pICi/R9o6JyqynuPBXUoN+tR5XJgyU7p2izyPjMCwcr+ews08/r5RrnZ+8I7UYie6+s/h6ONiLwTP7z4JGoEb0am0NVgiz/6Ts8qcGxJdBdUJ9P15uT1jpSVvRd82wOS6yfmENA+tUUHP6rtnuZGFwVUakK501S/jYmmPKwyG/eGoGAwlXcgFcg8lBgNoiD4fQ9WqgE5/FZbu1NKhjcifMoiOVP6PWin7T2D8MbrWis5mG04g7IhevSo8W+Zt6GtqoRXrDx4cID8NNMf/oYg25zTNz0gekRkGu9cep1wVbr78XjlUFNUeUNqf0Lzikb0crovzCdy14+HdD3a9xwVuCobvdbq7C4l1Mmps6NtiMDTQOK7Z1los4pGqPQpV1ZA8OAVpKr/xEffcXHwOxd8kXf32j8kt6Jur6nkMnN96cuR9dQ2ZTrvymN9VS9qeY6rHw2DlTzFBVUgcxTHA+YZS9QhohlKrpGzxiqiL+PeJGpI0eAsT6RRv+pZlPeOtDzKoUmIYUvDMOLnSg6SyriV2mq9HYXP59RXKXWscv6pzGKweUaqa8bU2Oz/5RalQZOmi1bP/BKZ7Wqbo3TvEn2dnv+peeelA0NFLVzKy7fE81qodmxarb7tXsxm/a+FlSxKMKOF7MsmoBLGjvb9PBfgOaUe1ExbcypQiduQDadNROWffJweYpucjnbC05JEt+tYFpEWzh+LKtN5zDZ/iyhcxOE9eIy7p6pOR7/UH5vSWClNvQ0NVpCJdOdszA5/mRpU4WHhujht/BfcbtIYXo12ZpcjDZloLOeaAeV5uDmkbWRlksZY7/jLIls69qMoqcXGv/MguvJpzjFxVXxlvVeVVh2enGpXoq2W6cgJ01WsdYJ7dSaktExqwyMd3t/nGBixNI4PNVO3NRpH78sMYfGMl51uvaLSmhW4vuWQAdt3XRyhyd4CO9+3G2fkcU39H0z/f0IQ6qi55AiD/WPLOLvruYUXCZNtYf/OPShEN5afRRigRnmfA59C3+7rbZD6qdDUrjknL+nPQG9yhwrc4OXdInYG+U9DrxNYq4T8eYq751//b3rUuuarjakFnzvs/78w0OT8gRtZdsiH0rlGtWpVOjG/Y+nSzHHpArJebl4W0xlWnr7YKy8w0crDY+HXEBM2/bAFZI+ZljL7jznVjfoxOPselapCm+vwjiVhWgyU5xebnOZdbyHyJwDB5hKAvNvnYMIwxOKsq2CZZUtVFFhpD2b2U2tjnmpr9YzjJzX49c3iFzAI2iSEJRuEpi8kCg+FbE+xfbQx2KwxLD2fkKj6PRJRgsoUWxnS6GqWZlw+DKjCcEpz/BLZ93Qd8A9ke/eyzKYrsd6UzxYzTlu51uoSBaMOCBoyTW12frHGECqvX0IyjNUjKn5ZOi9NE6K0l0HDVX1v3xX8OrI3h25CCVF7BtQcNRHxCzILt7DQECzHnUHP9EnwNOu0MzBZhOK7sXmcBNvZ2rZU/ocFPpILhmj87KyTQE9q4en1Csn2Ailake38jGAyI1QZubvBC0jI67iy9RaOIwp1V0sp9Tu3BGj8X0VezPEfyW0AAhkmd6wosEUd45ILD2ZtuLVLfJj6q0+VgR+rqGJxKb5k1d2tWaN5o+3VXqUlD5DjyzmhackoyCRh9aT0ZAyO/rk7sOak5OD/3WCkHUX9EWSw3Eaer5YNU31Im/cjE1kYXx+AeNWX3reYhPn4dUIWNuXW9v1/ZOykn9BS6Dnojrl+38AgpQytpwDcokTv8ZNe6hmGjnWEYXPYE8xCJ+JrDGIwr3HmKETRhkNgBDYZVgeZ7sU4ujevKz/FuwrzOXPeOvjJdKQyGUxX+uG+lpBwAwgd4njnasKxOoYgHQZuclK51EfpmLc+1VrTC3qAQANtGeZIhcvtN9OxpZGXEbPutV/siRmMNosiz5ACfGat1uIFbDScGAwAQ6E3cPSf2n5Bwa2zs6OENeDwjbqjsm5xMX+nGRJgsd4/vKc0Wzb4X3MOlU1KV2DHGOj53cqOcUFSVZK3YOTeESFrTwjmeQQFMy6LWqOjx5RhMmxsLE4kEOc8K7JiQnWKxu1T1AWcNs5UmarcnMY0TxAXtQYiIqbhyMZUVSU4JGHc5u0GV61boE1abLRr353iafoBU6IpmTNayI0WC73nlvImLtKVZHuIpHqzxMRZquNMIMchPNV6pjbrfI8WcWS7ZSnCKXPSNdqmk85WXn30C2OlA/kpjuzbQOTmpmXx4PIUB2M4kQr4cZDqDFh4uHKScvrwz8axYvLzokbXXB7GJYdWWTawhwhs/qQxLA0s/T2H4qozvWnSzfuuRJr5IUywEtXbdtS12IyXQs8LFeGlMBuKSDw1dtDRbWWfQ9AXDXddWYVP9tfzWwwdnnDJSvPH9FFeCc6FFx+zd6AMuZHU5v0+uUdmua14CYdic8U+Eg+ODvGJ5/giu/HB176qtogQD7HqwMtLArLL3JdYmMC8uLtjHnMRePSHsnNMT7M9lzjvYt0vHbijEnLnHMZhsIkWQnYDERtOk/5+9sKTQKxX8XKZgtVrwM0Zl3GFSQGsuzsafqaqKTLjRVIZ2zTGkmrkmJVKJJhH3pj+3UY6dxHcrwqoBw/wREp/FMfj8aaFVqaMwzYAx363qQta09hQYz4Xh4FIZzEtq1RyAiuso3kSNwc1SoN1+RjDYgG19j1+CxEejJiBpYPzp1uTOXEFEJz6/H1jYTzALgckQtNtxODWGVuBsbMXyVJSTYvy4Odo9pq01XXdjzHDFKyqpUEC0SINnlNZaZIZotXCcvBVjedTsySQhMByPJ8JwfH0aingwoEyt+RkMxSWtn7N03MGqQPHRZDtT7UNnPVZtzixCSuRjruX5aegb2UcLEyyEesKcPEhfsZll7+GFuLWZnWpDtN+G9Iafvl7R8E0e5j0WV5gWIJfC4CDJgVH5LcoDlY8/WSTzXqY1QVTh9pSmWHMlWOjMdBeRYx92YNidyVRy/P/RVyjlc726quwO5S3qNdhhiapnR+ZO/V1JkVwcqCX6zV+R4bL0rUPM2UU4smjHRQSaiGPHrVavlUtyO8sTMu6XzvesSK1p0kPHSCstke3NeiJOy0p/3XDmWATP3JfMdVzsCRaVA856hrSZZJy90ZaLu9OOtCdXiHw+75GeaZEGlXWRBiHzCidxaiUbxmq9ktzNRUaB/Y1EM83p7tLxZTxC4j4Svb+ai9d1/WZ9EDUK1mBMIAELu0Ijx6L9Qrc3r9k8sKX1ydeB+psNu2e9LCTARvgtR/3K7hdaVzMz19ot350EyTe26/ZK1uX8x3uFy8wmmVsZDfmZ+SaZ4NLpWaS39nzau915HFfhy2Llg9dnLc4/48FZNH3NEz6z/8n/72lZFwpI9wxfpJ3Ft3+VGvSEd8efWoBVSfHlnRQtr60YH1cNfcuY4pyDSgtJsSCsWnfxdR8pQ3S28ixlZW0gojoz4eIyzZ5Mn7KDPKVQLLdXZzeqmkRregq5CYmo6T4Twj16OI2FMl6hWU6hkfMCO8VHNCVOQqw2YmcK2ngwuV0dUaqC7IgvXe2pKX5f922qmoz3Ch6X1Uv3e3INcKIb5Xuk3Ac8izQM/i4JYpe+5413LGrzpxnfg1twUbm6wjqBIMC/FAyW46Jtli2msZQ7GbQEXMMgiGa50xOQeMp4s0LVFTBMApqyD5ZpYnyZWHkrg33AnYKBy2wAoPLAlmLCAMIy+tqFiTpEws32Dzv3Dsag4XQZ/Fe32wUNNVSmkh4yWs8MSu72Qj9EWzSHrrLNRKNlPf5xSrmCDJMaNgYahmjRlcIPM2jel4hlTxuIqHO4Y0Gknz82O1PKC/h9wjZe8u/P0UP6HHeszqrwNlqYM4h/jpAbcKP+ynjm7vsjHkDt2WArZSq/qafptVfK5QGn8dzpKNQ2uOU0DE5Va8NwK8OfitQsUkp0mD6WriN6o7ZLuP37B9BfhOG0s/ySYIJQuzc/qFHEvg3JiQ1aobdN+KcWVqCXf2PgsTtYmQXpwylvkEhgUKG2IHDaEVgXW8VMH/AswxSxw+xErC6FvSRWK1I7HUQoayUTi+Hw5rMA+maTjicZT+3R1O2pRu2QMSjenZzrN1HePx8sdul8Hs3bnz6kVLYTFuqcQt6RM+mRb1iAg41irwr/3KqaKOXjuKqGvp9LUI4ILF6mEedOtsvJJvHZ4AFWg1saWUQ0o537qz0WwxQ6SFt/nMdoeqeL0DfsAwoEYc3ydTd/MAE8QXGsArPNbuK5TvAjBhFEXNmNhOSAL5YDyFMrOnekhXHh/ge91DbJkTLq0nFuW4ogMTzVOj0oFoggOh4+FpyrYOfvcXVfFNXFK8erlzSaYlkihyGYihXfCPoWr1vIR59ph03446283be2SOjpqcyIvou+kaZ3KiTfmE3JVJTliNnainQcjeYSEdmNqAqXRX6O6OSkr4imBIYNDIYkO1ulmFJCfJeKGAzyag5dPhNE4kdRBOqyIH2bydq9KoOQLS5MoUEY5ktX1HEN3HUxOOjN4ei7LtBOH3H0vSLdlTYQA32BzRh+KhgYe+rBnjssuNTj0dpX0KPY0WfGXgBjEQQRuif/uEYcTgqqsEbYtnxu/lXAYOiZgtEH8hR+UEv1xYMbNeKMSbVpj8Ew6cyjVn+N7jSk1+wEWSTGxI9pjRMRxUY2vo21pAnNOs07ZnyJPeIi+uKnrkBfe8vY6CtWpc0/9wZ2FzCw3AaEUsZn3Cjum9ureIV/ij4a8LIC/EYfWhfY1s6pwD83GsqKZQpoNMTffGFEd5+Iwa02zb9rY7BorBb73J4CSYlP2dxEFzIoMKxbpPcPoXz3UzyLKge5Hd01gBwE5ln2+REk3kkXv0q1XSBzc3tPTRXWKm8fOPqSMndSKmeTUYnLlrHer1oLSn5f+8vOLo2SIg/ak3hDnP9nuN8sevVXCCilxEWMX6H4eSRXRmvXoKyXgvAULTKL1yzW02j7yAFvprB2tuU+5AprtJohGkBGbrvzEcpZth1efNWl6F0fzJUwixWOD0FE0IaC9/u/7f64VON61/Esrgdrf2bNQuKXp0+3R9+Jxuc4/3HChWLBGamdYr/9muJ79ESMyja/tPUrNT1kwHpvlLxeq0Y+YG5BHaQUjLnf25XbXgpDrcxuGyEUcD0xGMwYK+gBFT6hzjUM5i1qq03VbhNJ7YMwjOlaSL6C4kwkNbRx3J1rzL/aln613iDGOnCVNyhlcssz/nKPeSaW51bmRGgWNzrymmzBGtccaUXE3bh2ZHuCR6gbSGDBcAx2z0k/lj5jeQF8Vs+6QDsWzLktxwPhJxa2J4uWPOrdDHAHEyYjghj1RVXDQW2hQYRhzbzsNKRjMCYS1RVXEzXlQLP0YuGM/pSA5On0NYzPDs2QjTR3wGDTwZmpCQcubF8acW0HHNGeMO5kz8wZCNnNDLU8c+gVgdxosWa+qi34Nhw8LjHRFQAsK5DBppqIU2elqEXpmsdejFfALYiatibW7FL4kcgxJI64KwDDYOHBGegbh16tRVLAdbK6DWn4JMKwoNqajZJfDbmHDCdiUeenmEQNOP49eHvgYroB4wkVId/o50VDMKSocTJgm2DzXF/yUadnuRH/JIXdJnZ9d+lDsbjluUBT/LhBKYTbn22kFNlyPMg5Z4jWrb5xPL6a5wTr52PnPoJj/jdc2E7EgRRi8WRqnOITWkbfeP0pGSfSEBfl7Nc20UZHXoptVhLOTenWaeN78Se4wEgVoXtRPw75j7PAXwrJjcRk4NrCEN9d5JSUZjkwTNM2ma/VT7hhEOlAKnrZrc2tBwND2geM4rCCFGki4gAWlI1qlP6I+SFkGH/TD9oMbG8aYra9X2kwsHyNOvZ0Wt169KZJBOR7+IxhPIwrQo4jQer58ae0w++Phh9no1kYtn+6mWwG8b3DCVdr5xMA3rDR2eK8S+69WEcrPceIn2IAZQXyL8W3EIzPWhZoCTfE8lnupF7SOkkJ1ooFhYYpArSIwba+HnQAB1u3yYDeCCcPOt3DT/UaMHF+aNZa7C3mlHETVsg9Fe7XUM3tRaIANC0QB1q/Y5bnCGk1pLDQsFS79mfjpylIPMux2tWZj5z8IzQ56m3E8Sy2G8RguMBw4m7wkBWaOZ4072+wQkxcbYLhTeTKMUENeFxwTDndp9A9msAFreyJOFbYNnqYFRjn9a21yrrPbjBxiRv1FFaM6P9Px2QpyEScwThNB7eSueE5GF+NrvqWH9QQnlgtRbb4oDrku32xuUafYzB3aUAs0HTuy43h2qqI303p0kRpyV23a/5SisgeaRuNo+/4CyK2zaMnjV3o0Hs6fReAFpDrhde4HeY4csUivNMCZ7dlzPD+IFfe1gVODdjVz3A0EABoR4YNbWmEruCVQiiHOwmDx5rXbm+oweTSuSPRdQ0ZxqRySTYoO1WnaL57gi3aoHvcn1PIXWN5KEoBs205r6Q/m3LqSVvwhWCFoK6P7c9E/bViU74hiYLITzwF/YzfJu7tz6EYfOaKNvelYWJ6zhaO+gKEnduboJc+v1Uj+x4ejbLljaPWxk+3LQXLmMmN/hkuKeaU3ticly3nnGzrkPj2+bPwADAuuyqfwEE0csyngRilGBW81Dl45stsMDEI9MPvnGKIBm0zH9Dt0JdAb7BavH+7lEdv+gECq9dotFkotfJcgGhwu7aQb4TEGH0jd9JwImyNKBjEBpldwDUm8/XbF1i3X5Sti3PN0zzF5XRXRD2/qVqqdXr3dS6u+IwFbbs/ZHEbyrRthSZ1EsP4xnas0eECiXNIumfgsfhyp6ibNYCMPPUcwVmjglQxD5VHSM2JNlF27KrVoyKuaG7wjqNxE3TE0C0WiFCHx2H0hXxa38Fl+ZX9azRa6E87gY1M0AuAtpqRh7gV9oU1Et84HIBHEDGPvuSbxRYR4ujbvhFrCK42Lh23SlxzNOlw/JCxWszc28Ez7PEKeZlLKSJz3NZupGl3etUHLw6HVEi+ttJgGvFwLU7TMfhAnctW4yy/ry3Ni0Kwrf6KTwXJtpnhDmvksqbxHXqn+htefuw2JJD2bcNgMIdh6Gc7uae7cGewi0Irw4iDrlGyU4iDbM5Yo6LicsBwy1TFMnK0V6VhMK6fmHwLsUXZ43RaQ+U7IfgoUhR8JI1V37NIxwWCcdPCdXFn/UKSL+ow+j9yHaSWCqYguGAnKGB8UkJTXYo0PbhWU8bw7pt+MWiaLj4Lypm/ZjFtHzS8GBx1AY+NUZAmOta9CT8ZHRO/0XoC5DRRZH82AYr/a81rPaCR/VV2MElfkdE6DrE2kXmIBG5gD9M5n7rePw4b69r9M3oovlY+KOPtc7pO79QW51+hYJ/5evjWkJX147iZU50sa6Uii/T4Ju05VhwjtL3lEOivkMY3mvqr2Z9Bv3QnQsKdB0qWiD9+JjBH763NDMuEpcY6MaemTZrVMQ66TfISz7fV4iyYWXjHYNk3PIWwsgvI1M+/H7GY7TSOZ64dmyvE2hXFRpeycswUUhdk1cAbaShO9kQZfVv7+AD++G0+M2XNOJdlpVa+ZqzWlqs9q6uQ89nL66KcNiHfJyJP+5KRRIza604RV39FLZ8jLtnvPGg3ImrgUdMcWAGO8eQwjvh7eW+wrK/TEuvuBHK8NdgGBHgfIff4L3uQ6rJxM+y28ccXE6E1K/eiVcWNzEE6eSvJghJYpu4ujb9ro2M7GeOqYcDV2ptY/3e15LjIEjGCxWueSKb0Nu3OShGDU2G0FPNiDpFTH1CGYA9N2yMi141k6NREgVYt//M0XmIr5tp/WLvC2liytI9xH9fpBQ9Ar/tTllwOfEU39MX5arBBtcBGZeUMJOd8EHTP1pPo61qVjWCrzwzY0VsaiWWOiW2Kr0aRoLZsxtBIAWu13WUU+nP24RFyw1VcYb+s19bUiML219eqDMNTNHWx0VTnd0j7BHu+t/fxrpose0Vm3ET3Asox6IYQA30HB1WDtC5ziFTAnu3rTPqFBY+1Hc0WoghMr/23BZASLL7CU06splS0p0ycbvlwBbspDKue4ml0VWhV2ISi7xIZxZBa2lMLEfpar4JzOCL9iBSKCknuqJHN8A9D3ywvc40i0xdAtuYLWlfDpHGLRve0zB4yBwije/ODYiLc5tLs9MTXFglZpQWq8Vmu+muwLHsNE31XVIUJtdpudpwbpgjhJ1NR7jAYVfLuB75u3AccCf0YTmssmn3adLfXr2U3laQE0QI80k/3FJNqMwBYtm0vfGrAeMgi90kpwTe792yKoMg/m0aYcuFwAYSn1HE0XIfuDouwLNLYRwuuaZdZpDVVeKfUePHRx8ZzsNfTyEFBKHIFYc6PFlgAojZFznMuq4W+onGRT68RYJxdY1/PlSFSdhSam4N9GbgPWHs+QurtH+17cZH90nXzywVP2TTNlVS7gzaIGjVQ9Zf5tuWa3ePU4ilbI4CFt25ThKkVBKyse/t/ROgiVdh+6iECnEHFyMSShtCboKWfkKXRtedpTRh/xikexGBHjZ2yjui5C7gFyTzbR31s9XcKA+H7KJ7GS4ihYSeRIhEDER57TMX71f0dkqrm8VkDHe0QA2BynPKIBqIG7hZrCHI6e2cWDrBHWi9U+ByqpcG7rQNXNDQ9oq0swI0EcAUS0fiRWZEONIs0N0cfzypMFmL8VOyPQcaBWuwmxPwqK0Br34jdI+kz1z735OsHXj+dJziSlAN7JEHRieN789JdbHsNIsFxcdOjMWm4G9t5RA1pwNsG60/3jKizxidLVnnB+RLbfI5vmMipHU9StlMcbrWYF7+GbrBe0EFX/7A9P07uPs96f3e6ev80ciHq0g7chsT3kyD7z/AazBTWA4d8CpcvCXhWOoZ09iHA6xv6jovC8c6I4Vdrfx66h15L66AOe8bE7B0a0Q5JQ0ES2y2wi8FX81FwhW7s6PuZrtd7XXdr7rLpstWG7iLkNlJxzeGA5y2QO1prmpAbqCU9GE+PtbBbntRniUfEbGHZhZvtDcch4M+f60fuOV6YJBGvuEvcOMa2BK/hfNoNjf5IYKqIJzUNP0LJWSTPP2rxOUf4y4llgIyCzSd+HdnJNo4eiPXHzZtuhavX1+0NBmbZh9F7Qmo0g+qfvhsGQjdlGt/EANABVVkO47mgU95u8Vny4sifWHbc3gDIarirvA1x8WfT7waaNkJUYSwrH8Nc4eCu7cNnRART8NCCQDg9yoROJlH5FOHJstN8JuQHTiCwriM0QsLeprBjPJgg5fQRP/e9sXsWgb6PhAbMSD0B/Pk+VzkJq9s2OUrwbFJxM4M+q1nZLWG7zhgSIirLzS6PmlCSqH8XxcIM2h6aNmk17X9c2ZroubCcNc7onJPEsoUmtnHW9SjZYHjbANYTD2zvb/DMTJxxuyPVlq6gXv/CusC2I9/nYMi6wbYfj9w/5yVImyO9FV5nhBZrNWt0UXSnDWHay+IiUWPpZCr++wv7St7eL3jtqtjyfr06DoKa/GTq+PlUYRocBNFMj0x2j+0ePdBP+prvIKj7jiC0JRXatK9IgrtC8rYY+yiT64iq4QRmEIP7JM0XEprThd0oVBjxVhbs8H/L689IBV1jXJqaa53F/3C/9xs2eONslNxrK/Xy+CBmj2pl4hE6mGzXL/mTq8LwyXWFLc9n/DP6bKdV6ANiFqLIEv1Eu37xLEbeRcOX3swj3pA7keyz+NzGLr7BlDFjhwzY3r/ba/n3f97/9y9YVli3E1k5+uJKIy73oIdD3g98rn+POgHgt38fouD2mY7WeRuJjcO+kcfdAmeuMfhca7HP9gqwLactGgDgp5s3wX7oLsQqX1aZixErFzBvylVe6U81ojRrlVQe58c/IsF0es+5nOSyJGLTi3dD7tvU66hVo4hkZGKT+XYd1dprb+ZoEaGXj8F5bxQbbIXC+RWCMeno59v6s0y4BpyCozmAW5lIqDP/EiExYm7YQt7f39NYn/jq+TccFEVxcwoq22fGTvsH8Tmae6qJGseQ20L6mAFeK6w/8J/f/wdMEgOeZ2qS9AAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib\n",
+ "from torchvision import transforms\n",
+ "\n",
+ "\n",
+ "def make_depth_transform() -> transforms.Compose:\n",
+ " return transforms.Compose([\n",
+ " transforms.ToTensor(),\n",
+ " lambda x: 255.0 * x[:3], # Discard alpha component and scale by 255\n",
+ " transforms.Normalize(\n",
+ " mean=(123.675, 116.28, 103.53),\n",
+ " std=(58.395, 57.12, 57.375),\n",
+ " ),\n",
+ " ])\n",
+ "\n",
+ "\n",
+ "def render_depth(values, colormap_name=\"magma_r\") -> Image:\n",
+ " min_value, max_value = values.min(), values.max()\n",
+ " normalized_values = (values - min_value) / (max_value - min_value)\n",
+ "\n",
+ " colormap = matplotlib.colormaps[colormap_name]\n",
+ " colors = colormap(normalized_values, bytes=True) # ((1)xhxwx4)\n",
+ " colors = colors[:, :, :3] # Discard alpha component\n",
+ " return Image.fromarray(colors)\n",
+ "\n",
+ "\n",
+ "transform = make_depth_transform()\n",
+ "\n",
+ "scale_factor = 1\n",
+ "rescaled_image = image.resize((scale_factor * image.width, scale_factor * image.height))\n",
+ "transformed_image = transform(rescaled_image)\n",
+ "batch = transformed_image.unsqueeze(0).cuda() # Make a batch of one image\n",
+ "\n",
+ "with torch.inference_mode():\n",
+ " result = model.whole_inference(batch, img_meta=None, rescale=True)\n",
+ "\n",
+ "depth_image = render_depth(result.squeeze().cpu())\n",
+ "display(depth_image)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/facebookresearch/dinov2/notebooks/semantic_segmentation.ipynb b/facebookresearch/dinov2/notebooks/semantic_segmentation.ipynb
new file mode 100644
index 0000000..60dd3ef
--- /dev/null
+++ b/facebookresearch/dinov2/notebooks/semantic_segmentation.ipynb
@@ -0,0 +1,1476 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b470389d-a897-416e-9601-aeacb39cd694",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Copyright (c) Meta Platforms, Inc. and affiliates."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb5c8577-7dff-41b1-9b04-2dca12940e02",
+ "metadata": {},
+ "source": [
+ "# Semantic Segmentation "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "febdf412-5ad0-4bbc-9530-754f92dcc491",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "\n",
+ "INSTALL = False # Switch this to install dependencies\n",
+ "if INSTALL: # Try installing package with extras\n",
+ " REPO_URL = \"https://github.com/facebookresearch/dinov2\"\n",
+ " !{sys.executable} -m pip install -e {REPO_URL}'[extras]' --extra-index-url https://download.pytorch.org/whl/cu117 --extra-index-url https://pypi.nvidia.com\n",
+ "else:\n",
+ " REPO_PATH = \"\" # Specify a local path to the repository (or use installed package instead)\n",
+ " sys.path.append(REPO_PATH)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "efdf378b-0591-4879-9db6-6a4ab582d49f",
+ "metadata": {},
+ "source": [
+ "## Utilities"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "90223c04-e7da-4738-bb16-d4f7025aa3eb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "import itertools\n",
+ "from functools import partial\n",
+ "\n",
+ "import torch\n",
+ "import torch.nn.functional as F\n",
+ "from mmseg.apis import init_segmentor, inference_segmentor\n",
+ "\n",
+ "import dinov2.eval.segmentation.models\n",
+ "\n",
+ "\n",
+ "class CenterPadding(torch.nn.Module):\n",
+ " def __init__(self, multiple):\n",
+ " super().__init__()\n",
+ " self.multiple = multiple\n",
+ "\n",
+ " def _get_pad(self, size):\n",
+ " new_size = math.ceil(size / self.multiple) * self.multiple\n",
+ " pad_size = new_size - size\n",
+ " pad_size_left = pad_size // 2\n",
+ " pad_size_right = pad_size - pad_size_left\n",
+ " return pad_size_left, pad_size_right\n",
+ "\n",
+ " @torch.inference_mode()\n",
+ " def forward(self, x):\n",
+ " pads = list(itertools.chain.from_iterable(self._get_pad(m) for m in x.shape[:1:-1]))\n",
+ " output = F.pad(x, pads)\n",
+ " return output\n",
+ "\n",
+ "\n",
+ "def create_segmenter(cfg, backbone_model):\n",
+ " model = init_segmentor(cfg)\n",
+ " model.backbone.forward = partial(\n",
+ " backbone_model.get_intermediate_layers,\n",
+ " n=cfg.model.backbone.out_indices,\n",
+ " reshape=True,\n",
+ " )\n",
+ " if hasattr(backbone_model, \"patch_size\"):\n",
+ " model.backbone.register_forward_pre_hook(lambda _, x: CenterPadding(backbone_model.patch_size)(x[0]))\n",
+ " model.init_weights()\n",
+ " return model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a5724efc-b2b8-46ed-94e1-7fee59a39ed9",
+ "metadata": {},
+ "source": [
+ "## Load pretrained backbone"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2d51b932-1157-45ce-997f-572ad417a12f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Using cache found in /private/home/plabatut/.cache/torch/hub/facebookresearch_dinov2_main\n",
+ "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/swiglu_ffn.py:43: UserWarning: xFormers is available (SwiGLU)\n",
+ " warnings.warn(\"xFormers is available (SwiGLU)\")\n",
+ "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/attention.py:27: UserWarning: xFormers is available (Attention)\n",
+ " warnings.warn(\"xFormers is available (Attention)\")\n",
+ "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/layers/block.py:33: UserWarning: xFormers is available (Block)\n",
+ " warnings.warn(\"xFormers is available (Block)\")\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DinoVisionTransformer(\n",
+ " (patch_embed): PatchEmbed(\n",
+ " (proj): Conv2d(3, 384, kernel_size=(14, 14), stride=(14, 14))\n",
+ " (norm): Identity()\n",
+ " )\n",
+ " (blocks): ModuleList(\n",
+ " (0-11): 12 x NestedTensorBlock(\n",
+ " (norm1): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MemEffAttention(\n",
+ " (qkv): Linear(in_features=384, out_features=1152, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=384, out_features=384, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ls1): LayerScale()\n",
+ " (drop_path1): Identity()\n",
+ " (norm2): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): Mlp(\n",
+ " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ls2): LayerScale()\n",
+ " (drop_path2): Identity()\n",
+ " )\n",
+ " )\n",
+ " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n",
+ " (head): Identity()\n",
+ ")"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "BACKBONE_SIZE = \"small\" # in (\"small\", \"base\", \"large\" or \"giant\")\n",
+ "\n",
+ "\n",
+ "backbone_archs = {\n",
+ " \"small\": \"vits14\",\n",
+ " \"base\": \"vitb14\",\n",
+ " \"large\": \"vitl14\",\n",
+ " \"giant\": \"vitg14\",\n",
+ "}\n",
+ "backbone_arch = backbone_archs[BACKBONE_SIZE]\n",
+ "backbone_name = f\"dinov2_{backbone_arch}\"\n",
+ "\n",
+ "backbone_model = torch.hub.load(repo_or_dir=\"facebookresearch/dinov2\", model=backbone_name)\n",
+ "backbone_model.eval()\n",
+ "backbone_model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1c90501-d6ef-436e-b1a1-72e63b0534e3",
+ "metadata": {},
+ "source": [
+ "## Load pretrained segmentation head"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "d0bf0b7f-ad98-4cfb-8120-f076df8f8933",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/mmseg/models/losses/cross_entropy_loss.py:235: UserWarning: Default ``avg_non_ignore`` is False, if you would like to ignore the certain label and average loss over non-ignore labels, which is the same with PyTorch official cross_entropy, set ``avg_non_ignore=True``.\n",
+ " warnings.warn(\n",
+ "2023-08-31 06:29:03,743 - mmcv - INFO - initialize BNHead with init_cfg {'type': 'Normal', 'std': 0.01, 'override': {'name': 'conv_seg'}}\n",
+ "2023-08-31 06:29:03,744 - mmcv - INFO - \n",
+ "decode_head.conv_seg.weight - torch.Size([21, 1536, 1, 1]): \n",
+ "NormalInit: mean=0, std=0.01, bias=0 \n",
+ " \n",
+ "2023-08-31 06:29:03,745 - mmcv - INFO - \n",
+ "decode_head.conv_seg.bias - torch.Size([21]): \n",
+ "NormalInit: mean=0, std=0.01, bias=0 \n",
+ " \n",
+ "2023-08-31 06:29:03,745 - mmcv - INFO - \n",
+ "decode_head.bn.weight - torch.Size([1536]): \n",
+ "The value is the same before and after calling `init_weights` of EncoderDecoder \n",
+ " \n",
+ "2023-08-31 06:29:03,746 - mmcv - INFO - \n",
+ "decode_head.bn.bias - torch.Size([1536]): \n",
+ "The value is the same before and after calling `init_weights` of EncoderDecoder \n",
+ " \n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "scales: [1.0, 1.32, 1.73]\n",
+ "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vits14/dinov2_vits14_voc2012_ms_head.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "EncoderDecoder(\n",
+ " (backbone): DinoVisionTransformer()\n",
+ " (decode_head): BNHead(\n",
+ " input_transform=resize_concat, ignore_index=255, align_corners=False\n",
+ " (loss_decode): CrossEntropyLoss(avg_non_ignore=False)\n",
+ " (conv_seg): Conv2d(1536, 21, kernel_size=(1, 1), stride=(1, 1))\n",
+ " (bn): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " init_cfg={'type': 'Normal', 'std': 0.01, 'override': {'name': 'conv_seg'}}\n",
+ ")"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import urllib\n",
+ "\n",
+ "import mmcv\n",
+ "from mmcv.runner import load_checkpoint\n",
+ "\n",
+ "\n",
+ "def load_config_from_url(url: str) -> str:\n",
+ " with urllib.request.urlopen(url) as f:\n",
+ " return f.read().decode()\n",
+ "\n",
+ "\n",
+ "HEAD_SCALE_COUNT = 3 # more scales: slower but better results, in (1,2,3,4,5)\n",
+ "HEAD_DATASET = \"voc2012\" # in (\"ade20k\", \"voc2012\")\n",
+ "HEAD_TYPE = \"ms\" # in (\"ms, \"linear\")\n",
+ "\n",
+ "\n",
+ "DINOV2_BASE_URL = \"https://dl.fbaipublicfiles.com/dinov2\"\n",
+ "head_config_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_config.py\"\n",
+ "head_checkpoint_url = f\"{DINOV2_BASE_URL}/{backbone_name}/{backbone_name}_{HEAD_DATASET}_{HEAD_TYPE}_head.pth\"\n",
+ "\n",
+ "cfg_str = load_config_from_url(head_config_url)\n",
+ "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n",
+ "if HEAD_TYPE == \"ms\":\n",
+ " cfg.data.test.pipeline[1][\"img_ratios\"] = cfg.data.test.pipeline[1][\"img_ratios\"][:HEAD_SCALE_COUNT]\n",
+ " print(\"scales:\", cfg.data.test.pipeline[1][\"img_ratios\"])\n",
+ "\n",
+ "model = create_segmenter(cfg, backbone_model=backbone_model)\n",
+ "load_checkpoint(model, head_checkpoint_url, map_location=\"cpu\")\n",
+ "model.cuda()\n",
+ "model.eval()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2dc1b106-d28c-41cc-9ddd-f558d66a4715",
+ "metadata": {},
+ "source": [
+ "## Load sample image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "44511634-8243-4662-a512-4531014adb32",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAIAAAC6s0uzAAABamlDQ1BJQ0MgUHJvZmlsZQAAeJx1kL1Lw1AUxU+rUtA6iA4dHDKJQ9TSCnZxaCsURTBUBatTmn4JbXwkKVJxE1cp+B9YwVlwsIhUcHFwEEQHEd2cOim4aHjel1TaIt7H5f04nHO5XMAbUBkr9gIo6ZaRTMSktdS65HuDh55TqmayqKIsCv79u+vz0fXeT4hZTbt2ENlPXJfOLpd2ngJTf/1d1Z/Jmhr939RBjRkW4JGJlW2LCd4lHjFoKeKq4LzLx4LTLp87npVknPiWWNIKaoa4SSynO/R8B5eKZa21g9jen9VXl8Uc6lHMYRMmGIpQUYEEBeF//NOOP44tcldgUC6PAizKREkRE7LE89ChYRIycQhB6pC4c+t+D637yW1t7xWYbXDOL9raQgM4naGT1dvaeAQYGgBu6kw1VEfqofbmcsD7CTCYAobvKLNh5sIhd3t/DOh74fxjDPAdAnaV868jzu0ahZ+BK/0HFylqvLiAv9gAAQAASURBVHicrP1psHVLlhiErSEz997nnDt845vq1avqGrqGrpJoIfVUomXUjSSwDRFYAyAJQ8jwx+AfKMIORzjCxhgThiAc/mEby9gNEcYOhMMggxAt1JJopJ6kVnd1qau7a3j16s3vG+50pr0z11r+kXvvk2efc+/7GpxR9b1998mdw5pz5cqV+IUvflZVzQwAzExE8jMR5YfxfUrJzMAoxph/ijGqKhEhIiKamZmNz6qqqmeL6uzsjNAuLi6++PnPNU2z3qy6bSsiqppUzMwUFCF/nqRNUdu222wTGANQSl1Vh1deeeQDfeYHPmkmwXHqYkoJAJNKHk/uNA/SOdd1XR45IjRNc3Z2MpvNiIh9x+xjp++9+/Tn/tovv/rKYyMmDADgvd+0681m45wjItXEzITmvQeAPLMMECIa/1VNZOOzMnMGDg5lGAbml1CU8f3hT5M/i/cMAIg71ADu4WvE2tAHImIenoGOLY+Iy5+UYy5byB+OL8cZTcY5/GsTEA0TpLG+Y6+q5Ricc7nxZNp13bvvvvv9d578uT/3p1999VUzQ63UkDxGXfmaJBlTDagEgMaQfHCVwopdUlUwrw5VxHGFyKaYadlQAcBMzQRMCBQNyAAN0gFeiunrBBd5LiMQ8kMGo5qNcC5bI3JjgwPSdmAc+WVkIuiHatbjWjN6mDG1navqrk1J7T/4f/3Fv/W3f/HBo4d/+p/4Iw8e3COPH3548Vf+i59HqjtJ83lzOj996fEnTk7OPvWpT3zms59su9Vq0zbNiaFmBul7J2LmEEJKaT6fr1abDz/8sG1bYHLOzWazGr2BMtu22xDDYrGoqxkmapctdCrruF1vnj1/8vTph8+un3z07KMPbp7xAIBNlMW9xz/2tf9OMz89Pz///pvf/gv/x//DT/3DX/vH//v/WD2rzh8++ps//1/9O//7v/DoweKf/Cf/2OuffDl1aTF/8OGHl//6v/Vvf+ozb3z7zbf+mT/7Tz9+9OrV1c3rr762Wi7/7X/r33z51ddubm6IiBmlLzH3d+/+WdM0koyIRCSE8Du/8+0/+U//s5//wc89OL+3Wq3+6l/9L9rt9vr6crvdMiMRrdfrq6urjIWU1MzEehbOxJmpdMRsxh0zM3OWEgR2yCCIqAqDGFFVHUnLIIKRqmYBWPLL2EKWt1ks7whj6D2/qaoqf+6cy59kVkLE2WzWNE1Gca7jvUfEGKMqZAnZtu1yufTep9SllEQkN66qMUYRy882lPyMiISWTAGAAMEMEIHQJEsaBSa6WX1ufu+HX//U9eVFx+rZzefz0/Oztm1TSllEjMQ/Ch8zBDUAAEK0QiJp/8BEZjKOZ8dl0rNqKbVwmHgPW8D+vwCg3VE5OXm5E4OKAABkvTggbHyYOb8A9/rpvfNqVjE1909WKL/z4TuX3fLvzWs2QIP1ev38ydP19RI7AQCtwjWqgJ1yU3fmgbEJN6l143x2o79V9GehaZlAMyKJKJP72Eimj8m/psk5d3NzU9d1pl1EFBEFy7gfMUFEiAZAZoYAZpJp4v333//BL3y2aZqUOk0xS20RdY7NVERhh0tTVe99pnIzTSl1XfI+eu/JMEXxvj45OTGDNkVmIKdZsXl23aBBAcgMAW2iJku7ZAKx20A3QXNZ/2M/OdoCgN3yflomFkD5XL6cjKqUBXcYDXeP86i23uMfNEAzUECwXkYBEYnAZrORZCLi2BCJiBidJGFfAziQpCbBhyQEyGZkCEmsCnXSLTsPBiklQoeIznHXCTJm8QVmqIioCAB4CMjjACznVc5lYq8cgug2vEwo4WPHoKohBCByzhEgMxNR27ZZcGf6Z+9MMctuVb28fH59vbx//xQRU0pVVaWUkCF/O6AAcwshBJHe/hYR5zhzEHkCxJS2zOw8ISKYLW9uPnz7Q29+c3mzXi43m5uL5dXF1cV6vaZBU2U15IgREQnYkZmopcqHzPu5L9XU00lPMBBjzLOezSpmFhGH5L1XTYC9QlJNAKSqRMAciEg0AoCIbNstGA1CBnxweSLvvffOer2GQWSlFOu6Xq1WXdeFEFSBmVNKh3gcCxRiepAtBnicXwZKP+B3cqaD0VYo5gm67xARuXJeYJSLn1Fhr1artm3rup7NZsPiIePUZbMgV67rOstJKExwIvLee78zEXJlABhH248qazVEA8j9GpCqWo9WVQBksmEllusA6Dj3o7xTdnE3j/QDxp7cSjBOZFQpM2/jt3IwAwbHARjk1swAQPrZ6eX11ezMhXmz3XbhtH7l5ZfjR+9XCCYCTE3TnD+4P6/q7XKzWq027ZZrbwZd1zVcgWGMkZjcuPwtx30ImpEOEGEknRH3E0lUmjYZi2BWVdXlzfW9e/eY2QYDPNsviJhXaoMC1swkYD24VHW9bruuu76+ZkZH6OvKzMyiYf/5CNuMcmYex57NBRHznsCUyIHRYnHy6U+/cr3cDBMxM/Heu+iyCBhnNMxryocT4jiqhkswTrj0d6t69xv8ePHd/2rFV4OwuIPuD6fwux1eCaIJfBBRTQABEAx2smz4FoioqioAWK+2GYNmZpZim5DVBYfKMabZLMRuk1Kaze5fXl7OT7iNMlucbtbqXAU2GP6MbdsyGpKicY9PZEQxIwEj05F1J5i9bXYlmR0aKLcZNz00jrF/SQlmRjRtsySYLkZJhuyy+dt1HTMbQkrJCL33SZ1tLdsXiDifz/PCCJhiF5vmJGnMBnTfCyIAMHOMMYTsXMFRQ5sZqKBDBSPElFLbtqxudX3zvW9/59HpI4/k2UkIzhMwKEivgFERiIicJyQjopRSSgkBFycz5xwzpZSWy6VzLlQuhEBERgAA2+0WALz352entQ9qiYgcc7dtzQBUQEVFjBIAIBGiIUDlgyNmJEesqoRmqmDQNI1DWi6v33nnHSJSiQCQUnKON5vNdrsdBOCoZnc+oVEYjoJuQrGqirxzhpXIAgDVZJZ17c6biIjIYLr7Kvc1trmD/KDYSioa36eUMqbyJ/nzrGVTStvtdrPZbDabqqq893kFzMwpdXkBX9f1fD4Xka7bdl3Xtm2MMctqZkbk0jgYSXR8uQNUroNgZjrIP96tYXoTYWykVDeHjHBM6exxEBQrCtjjsh0HmRlOpLftPicoRfp0AEeGRAXPA4CaiESARLRN8Waz9p4JjVsMjhe+Poe0hCSgVLkFzjDUm2ptjOubK1FtfO0UYkqCDEAE5Eq75nAQpSzAnlf79W7GfUppdNGUCngsbRu3221VVc651Wq13W5ns9lhR/lzRBQxRMpOHlPKHRHjem2bzWY2WzgH3XajqtnDs95uCp00kv6eK1jVui62bcfsAMExKSgCv/zyy+/86q+//PKrmZhym8zctm2hP2x4PgKW/qFUcreX0li5o84h5A8qFLyxY8+9AZRYK4h1WvMFmaGsf6h1Pm60oLpTxocUVXSBiOi9B4PLy8teE6DFGAM7QU1d8q7y7LebjXeokjabVQgBICG59Saa1qImEr1jJmBGZlTrHDqRpAhgBAAK2c2lar3n4xgoFF6s3I3QCRjvwO8I21vAaCJCxOhQAUMIZlZaikTEzIacFzF57di2raq+9dZb27Q+P7u/Wq3I4ei6JGYAcM7N5/PNpp3P513XmZlRT6ghhOCCorKyoaZos6ZidCj46PTBaT0jo1W8Wa1Wq9Wqi3HdtVx7QjIwREPspcQowbOg6LpuXs0IcLPZ1HXtvQ+VIwJBI6IknWPIDnDnHAMKGSLGGJ2jZlapzQaWtFH3AJiqqGbJwYhoJt7joqkR7fnz58vl0nnadFl2oXPuyZMnZpYNPkQUESIa3a4l8I9yUwajQD+GiaYclU3WO1mM4LDyg8ITW6J+pIpye2hCSPkht5OHXe4hppS899niWS6Xy+WSiEIIdV03TQMAzL63yQDMLDurswUWYxzleYy71X/ZL4Ie2JEEIBlkeUEeQjAc5kWY18EfJ/TQwHDYpTmUFappv35pGeiIrp7MCmQhIvQ/a7kX9oJlpFsAyE5wUBUAIesUbrrNXJsGg3UpuOrx2b3Hm6V27bUkY0MyV7m5X2jlaNFcPr8ANVDYpsSsjM4ROttn+ENSO4TUqG73AbS3YTbajKox+0My2pbLZV3Xw8p21x31i2EYpYNn6VQBgIiIkAiWy9VisTCT1c2NqjZVbWaIBqDZa02UeaGHO6EDVFVVgdhJ55Lj1DSLruuc8009m89PMiLbbp0dMgac+UhEnAsDdi2L6RHl48SxWLsfwrDQ4sd/mvw6KYefjygo6typJ6xnltJimHRRUtjkzYGZ+TFlokKK5yOLQigYqRdeeQ+IHCI8efKk65L3PsYNEQMAKgRfmQJzYEaRTQhVu41qTIAU6hg5NCcACpSINMZ1jG1weW9JACCvsCSbyJYFLdItPujSWDmKwaNmxN2QmYDoEL9mdrQtRDQDM3PO3Vyvtl2s6zrXVzBiQEEAEImA2csH83lzfvZoXp+IyIcffmgs7737wSuvvC6WYoze+7quiTnL64cPH8YoALDZbEqLPMa4artNt4mSkkYzO52dxjZuLm8oQVy1cdtera8363WULqEhIwAQg1nv4mZGMzEThyBdzFYCmqCBqm7Xm1kV8kso9u0Wi4VDcs4hjStCUUtni/nZYl57B70Y6geZFU/XdZr6LrL/7NH9B1Xtkezy6rlojG3XdR0RzGaz6+vr7XabPdUiUkrwUXEWIn4PFxPMlub+WEYNOtXfYzuU9Vn/YTaYSt0/ipry5fhwGMAx/lquMvNz9h2GEJqm8d43TdM087zkFemthxBCXj0PW78dFBy6m4IRoQJov6wcZYUqDIsfYh73j8V2m4O7HUkEU8uwGOBs2UOU+9tB4Bg77ANHDlGD/ZbwbvE9oguKTssPJ1bXDr+Z9wDQALMrwyyKdiygwNFu2paCrx1XQI7Dq9W83azW0kUFAAQyF6qT2s9OF7UP1x9dXG1W5J0hbbrtHBo36f5wyhOayHvAAP1WzRiwcBRWiIjsVcHM1ICZb9ars3jmnAMyZiYVIlIxVUXILmdEBCIkIkAZF5fzefP06dNnz56dn59670VSpte8h5E9cmbEzKomIpJ2M8rIMENVWC23dV1fX61+65vf/fZ336zremA2MVOR6JgLs/qIippITCK8ex/xNgV2FOCHRHCgAAygkOC3UKiZYWHu3aF9J+3fRgZ3fzUUGpxSZQu7l6PRltmml6Aw7EcOu1CzGT17dtF1XVVVkTFU89W6VSWPDObVGBCIbR3NV/OuTSnidrMFcu3VMjjq2vUs4IMHc41LAI2pJXREDEYKRoYGJnkDmizT3IH9tGdTH+rgo2xyiMqSz80M7EhrR02xAV9QvkEiRFwul0+fX+RVjoJleeecU9hsYxd8MIQoycxijHzK6LiaVR98+M7f/Bs//6f+qT9T1f76+rrruu3g5vHeLxan19fXeblshKCQ15FXV1e/8/VfUwBXB/a+ruvH919eYMXG3XIdqrlsu9S1hrbtutVmqYyOiIjMBJHZqXOuD64BaLtNVfm85MpaYb1ez2azEBwzDjuF0nXdvG6c54orAADQ3u8X42KxYEcB/AiTfqvKzDkadSH3CkAXJ3Pv/Wq1urq6MkmqiQjMYLvdXlxcOOfyTmcWaxPD6BBBEwI4tKjKT/IqPJfSqwy4Y8aseNDocEcP7iyjMoNh5TN+O8QEiA12bR5hXuPmxtfrddOszYzI5aio0W0wOA/Mex6De1Q1pdTvLVjGJ4EKINoQk4hZrZqK5oi2pGBagGIcuWE/ZkPIITYlU0z5qAfadJmxk8myW/j1sosMe6bWrIOh9DyNu8VYeg+nEnKCUzNDyHvBaGaK0Gnyvlp13dPLixBcCCEtW3T8IFTPyD+PqGZKaGgJkiKE4B+cn8/Jz66X17Hbdi0mirFzh6jND6Pvvnxv5WbJvqtk9MCMNW2IqkiqbRtDcM65GNNms7l3756pMLMTVlLVZD1W89o662AiIuuNOAWA5dKefPTs4cP7i8Xi5uY6SqorD+LGeIFxdQ4AsYtEhMhmkJJ03abrutVqs1rdXF3dPH361JAQ8eTkZLNZzWazbEOoqvdV8LzeJABQscE1jvuTKmmFMtfAx+kt2JfdH8tmd7Rzx7f9qAztlkCtkVennxw8H/75AoVKD/mh9s2/7s9CcswdDCJ1Pp9fXV21bXtycpaYPni+/JVf+sY2dpvtTahO0GpVFVtG3RhSVZ2hr9Vwm1QSe1WTzUsPT/7IP/ITc1+rrAGRGEzNVAFYLa9vjnv2RuMgl1E0TEAEx5wZR8tRUJfi5rBy8dN07eWcq+s6L2EREQb9gQ4BIKVU1UREMcau69wZ5QhHInrw4MEPffUreYlzeXnpvM9k0DSNjXvJO/Oot4RSSufn5+y9EgiCCaCicyzb5MGhaOy23WZ7095c3Vy3Fn1TUR9FnJe/fbglDPuUi8Uia0dVRdWU0mxez2bBOWcmnhgARr+0p4oARQTREFS6tpnVjpAc4+DLJSI0DwCttnXwAzwJwJJI08yI4IP33l9eX42utfV6fXFxEWO/Vi6pNFu0IxwO8VWW8adSZY4Po9YxEAOjHFxaLMtgzzPPoxPb9stt5FQOsixd1/Xh2UMIdy40xGPn2L2UUsZO/io7pcsBZCsKhgX62CAacD93MlCF3mnTr2vBACE3i4gZqlm7i4hqUtVscJQe+2Fevb7EApKICKhm063xF5FL2K9dd/iCfY4uXdKT1nZ/Imr25xQ/IWIUkQDIvOy26223mIkCLkIlYg9cdSUhQtcxKkLSZIqs5J07efDw/N6Dd5599N5HT8gxKriRCEZLCvblwoQOSkRmfO9HPE3nkJIg4qZtQ3DE3mLsui5jK/MPI8kAdURkQBlgxEjmQA1VEQDB4MmTp5+4edUTMrsYOykOtORIvTxCMAIQREbElHS93q7X667rRKSNSVVnixPvq/V6vV5vnSNVzSrfhv0h0C1oVmEEhdIqOa0Ey2iRlWiGA99vieZJg3cr74m4779Cm+zH9L9m+/Kgr7tbLud1N33f8WvmTAAYvDWHumo3/uLXHAzVv/S+evLkZr3edl0Hc67m82dX8Qtf/MKrn3z03e+89Wu/+q0vffErX/ihTzVz++7bb/7CL/z6K6+9jBS4jTfddQMBQJ8v26TcSouq7FiSgAHYsIkDCqZIAmajD3AYocA+lx7C55BHflc2yoRCjrZwVPKqSIzROTfu1QFAjiIezGVlRudINSH3qBSR7XbdxvbevXshhPV21cXIrmd8731WwKvV6vT0VGA4fmOoYoT84ME9dHy92ZKpgBKxI5+27er6Zq3WpTZBEhAj886TQ5JejiMi0bgQtBy1e7pY1D70ER5m6/XaOVdVFRGpincVIopIVVWI6EMwM02JiDNv1qHK7uW8OBt6IUTM25xmliOZVVXVP3hwjwkuLp/F1GaplePIttttCGG73eZApBhThuqEVUtxf4zO0cxGhtnDGqoo5q2zvEc0WZ+UaEVEQyu3J62IHL6NHnrDa5DeY8miOP+6F0w3iO4MumzlZDVsgw98XLWP7WTGHIUbEYEaQrZ78lK4dzIjIhECAhD11iFAJr8Rhv1qpRiz4Wif9wp73ITpwTusfengmOVxKTRdK/dKtpBFL6SDdyMc+spLTzLIK3siutms51XN4C9urhofqpMzjWlW+QdVc2nblSQ1a5kQwRmSmUOIErmqzk5OP3zytJWubk4cmiGAiqAZEanpMFsFsEwMAECEZiAiaoqI7DAfdhjPumW1WiI7P7N3XRcBgM/P23YDADc3q7OzNSJmVjEzZmaGdts55wCIARIYMzun2y7m4AgRXSz8t7/99pe+9MXZ/RNZx8yrvq5IRVtSlCw4EC2l2Elq15t2G7uuizEN+Cbvq36JPPDbiM5sSeTVQCZiot6MHck9P0PhBzCzDJMSzSNxjIxXVhgJ+pCAjgrl8mFPpR2SX25zdOUfHB7oqXIwXMp/Rz7cp9fjCzU4YICJZjpqzyEiImlhNu2RCnPXxSw4zCAjIskKbX7v5MErL73yyVcfgegv/vyv/+jv/5rS5vvv/8aP/ejvv7lp33zz6vzBq1XlTlGdzoi6q+fvXm9Tc6+O6y0SgvWbqBlkaGAgJmIghQVzBCbl1KxYHU7Qp6pIe5GuRxFalhI+UBAGjZ9OB7C3CBhdhWbmmGPbhhAQMau07XadN2VExDk6OZtXXWD2beyyYx8RY4w5HLJt281m03Xdzc1Ns5gT8ma7nd2b55W0bluqPAAsl+t5s0ADjQkNmKCqKlZcrbZAaAjOuS7F4GoAIHKZm1Q1qagqO0wp5R7NjIiW642IuirM500GRTLNGrRpGkk6W3giYnbtNubWvPfsMpBGP7PliWeF6gbDIoTwO7/zOz/5kz+pqpeXlwDQdhs13Ww2FxcXGfje+3EfbXSAqSpl3BogYHZZEhJosR88SGUc4pAniDYFZR1nOrpw83qjR2/2HQ5LPsVeyORfR71VMtG4nD1kt7EmFQeTsoAd/8zPOc4OEdu2xRzzCJBlaekrLgXXOE1VBRiOE4jm4KsegEnEIFRO8oagI1BznjzvjiPbICdHrX9ozmYdb2YGMp4SxH038kj5o7qeiE3cX96UECj9W2WxwrXZBwFkh3OeL0A+WwEABqZmCQDQWkmg2AGst5s1+wDEqI9PT9ak737wzJ0GY4pq2iZWcFXVgoApml1fXswWJ9ebm+E40Dj6PXtkqiRwZ2sPdh8Z2J4YLfckEFElAwk3bUsAjsO6XWcvNIKNMQIiggRJIsCgAIaoLOpLVde4XF5+9NGTBw/vee9VRTVtNi0zV1WVophZjHGzaa+urm5uViJiigDj6SY2056DFMEIgQHEDG2IEB615kCXU7PoUCmW+DuKWhj4cALqEuVlF+OvJXUeUYR4RLKP2vdoX4e9HNZ8wXJ0vocvD5U0wB6rmPX+ZzNVAQDI8UEAkGPRMa1rODtr6p/5v/yFP/8//RfuLcLq8oknfP+DD/6f/9f/8xc+/7/81Gsv/ebXv3/v5NGs4eDdpq28c6KQxNabyIaqhsNeOWqmxkMz+cVnvbeUOYr0El82SpCPb7k/JnUrbAu4ZZ0BCI44n5UPngkgdREIY4wfffTR/XsvbTabk7NPfvKTr333u982hEePHsV4+tprr43yPaXknHMuqCo6NrPNeuu9z8kZ5vM5ejOmCnC2ODHJK0u5urqaz+dE0MW4bNc37TLzRh0aRkZCJjBEtlFWYM6P4fvFbn9mRkQYKYQ6T4cZVXvDq0spa9YYYwgBBte0Yz/K01Eb5TKbzfKh3qqqvv/97//kT/7kl7/85b/za1/P4sXM2ra9urqKMWY3/oAX2kmzAbwvSA9wIPrHB0mmlEYxmEUYIgbnsSz5QB4CoJbSoBQXpRDA/WQvk2HfMfKy5fKrMgVHXurkdg5X2IjAzGrSi1BCNCQkMwU1ZtY+INSC92TIDm0I0h6GR6Nn7i6ZgwpDtNRRLjsK8/Gl2d63t8Fh5LhxEVzw4FS4jkod8nYFgpgRMjkGQ0XXqW3atmI/r2rq0im71xb3vq/rTdsBcSCqnEspGaCrwtPvfT9u2lQ3QuBKbi9HMJn2qI9HYtXhjHaBzVtgBJxUlsvlvGnq4G1rowNtNPpU1RGnlHL0S84tRZy3LnqfErM/OQnPnj27uV55NiKK0VwI3nsw7Nrl8+eXOcCk61J2RCPCGOljQ3Yb0711ZKnqAMBMmSlUrmsTohuttqOqd3imSSqWo3AoX040621lHOdUBx/s8N7m49pv6mMUJNxC8XcPL5fbPrlTVWeOVQB2znWph2HeQ1qtVszcSXLED+6dB0cXF09effXVJBEkLU5mGNzy5no+q2eh8o5St1HcIM3W65vLy8sYI9NMokaTxjsTNRDEfMw2u5GyvaKTUX0sUg4nNTEyjuArV7s1DcBey0Wzez9laZi37pqmyf6qtm1zngBm3m7XSdl5r5ZibK+uLtv26ee/8BlmvlktY0yqimQppTEgNgvcHPAvYM+fXWxgmw0gRLx//77XGThed5GcJ0FntF6vzSSpIWFC3VoXQbliMWEAYk9oyOTIDASp32Xcxs7MmqZB1y83x/1pX1fkuGtbTyQisZMqNJq2VVU751PsyLsUdb1eT9ykWf+W8koVmqZ5//13v/KVr/zhP/yHr6+vnz9/7oi7bUtEXZueP39e1/XgrivDXBRA4UgI4ceUYW13zK1lBEN0iA6R1dGAhqjvXf3s98CdU2S3HQsyrrgBFam3wzzlrXQbz/hlcgOwvHF7OJ5DGV6Of2T8bCtkUVmug6lPkTT8iQQEaEpIeaQMRqaEGILDTskAVJDGDWnVPjx5T2Hks0cFwPf5sXjY++ro7jgMboO9H/dOH5WCd09nl/7F4vPhlASW40SAqKJgm9Y6M3LVmrqa3AkgErHCeWg+cfbw+fX7a4hC7Im6dYs+oPMpxXffffvRo4fX222Y1Q4OZC4iosFhCA8MhpIVpX9Pu5QapXvBzIB6az3GlCpFJu/9drtt29YxjU7IEfGSbBQ0AMAppdTnLNxutyHUH330dLlcPnp8r9vmrJMhxvTRR0/ffffd6+slIlZVZWZ5dZu1b6ZGzAeTQA1kl1DQ+i3t8jwoIoYQujaZCQ4T2UEpb8kPKQMzAA5hdXcZW5u4Io/WKf/MxHBb5YPB7ALEytlNPrxNl8BthL5nr/TAnNS5pQudrPDGh5T6rAVEUNcBAC4uLtq2bQ3dzG9iWpzfW3cSkX/4R37kvadPX3n94T/wB34cw0wiLbfta3VlapV3to31ojo/qeJmTTgzYASVZJjjn01y0tN+YIowXZF/zNbvhG/vAObABVOIHULp8Kuj9DDyBTPnc8AAkHeOQM2SxBiBCHOiCdY+dyxADrqpqgodry5XH330UV3Nzs7Ozs7O5vM5kQshKMLzJ09yJofVanV2diYiKanDPpxeRBi9im7WN11qQ90I6Hq7TaQcmByTUCA25HzIlQiVHDMTubzqErOqagYLGLddZGZH2YDOme8ogzY0ddpaUgGAnOkCABC5qup8PiKDohREiJh911dXV5/73A/+9E//tKq8/fbb19fX0B/ZoKx9MxRHaFux4WrDJsXdpZTXZqOfbA9pOKjWfUHRr+/LPaDepziQZc7RcdhjSRg4nicu3hRElXUYly8nn49wGxfEo4nQr1KGsy17egERjbKPngwQNKchATCJKW+fOOcq522zVlVFzdHU2dyx4UiSqmbNXqYoGWdaenrgTudcqcrNbMjNhVOhfXsLJcv3b2zP8sXhnETWwaZKBooQnNO8FFZIAKt2q9tORFz9cKYKwg1i3WrNsJGUAKqmXm+7um6ePn1uZjmLM6ruKeBSsuj+jveIvIkHY0IHJWjySzVERzgk7sgcfnOzOj8/n89OsqcrR0CUvmsARTAi4N7jDabg2DPT86fXm81WxACgqqqLi6vvfve77733Xs7toqpg5Difbx79/gAACLwLi0PNBIqIBiBiRLv5mhkRIJloBOw320a67EW2YfYaTeAzioOj5HL4ZvyqbORonR1FHCsFJU4XZEU7Rz+9ayH74gPb/Wm4o3m0g8r9sX0AQBxNUXHOg0JKKSVJKYUAV1dXqpp4HpW5ab76B37/vZdfWyv+gT/4k7/5m99zp/yP/GP/+Gpz8/Vvfmt2erI4P5GlkoeX56ypvZ6H64un9Oo9BPPEKpHADERg4p76GH8A7OPoBbXvPtDUeoxk1t4T0uW/1vNgyYlTlBX0SVniqCqqeeeSKAGq9LuYOeipaRoRSSqnp6di2G67s7OzbInO5/Ocf4qZU0r1fPbo4ePvfOc7mSlijHkflzyJal3Ptl0rInW9SN4DmqKtus1HN88jClXeTDzmgEpHDISATKyAyAoAxEQOgHKPAJDjgEIIla8dh8y2+XgoswN0NSCTFwVVUIUxczJ7R8hUHMIZOY6dv7y8fP2NT/7UT/2Uc+6dd97JWXq6rqvr2Ztvvrlerdi5lLSqXLnyKyOe9g+nHKeB29BtRgAIk8QA1q/MeslW5NvPLfT6ifaD8obYwGPDgXHiA41NVWyuAog4qGEsChT6CRF3ef6HlkfHZK6/W46bEXBWwAzGgEaIYIBEDAhECN4xGogIgnKRSX7sbrSddjxyi694wnF3F8QjknGQSAXcwI5ss97eRU6bZ9ivo/NoyUCSJDAFQ0TxIECdQQvapVj7ugJ36twrszORzUfaqndRzFehbdvVahVVTFJKXWWNywH4tm/pHLFKdr/mN/37cRtmPF0ABUUSkaplN5GYdl3nGavgus12s9mcnZ5k5s84yUTA7AF0yA8NiP3uqST13jNxXbubm5ubm3lT8eXl5S/+0q/XdX16ck5EKgBAOeR92HPBnDM2o8HMALU0u4gop8BlRrP+MICqIBIzxrg7Rd4/aJ+t5ZAhJ+VQPx19f/h5ydXHlNxxQhlsveNXIAzNHmnztnIb3Y9cUUBgX0JByTlH9fd4VGnIoZMDRpiIyDl0zs3ns2fPni2Xy+r+Irar07PqP/qZf+/t974Yk4o21zebX/67/+Ubn3p5s9ls1upD8yu/8jcRsZ7Nnd54hG69bG8uSUUNwAxEjWDwByJkIyEnizjYAL4bp7CfBLSUEYdCcALDjwX7HeaOiBDBaPPlGIW6aTar5fPnzwU1JnPOxYT5coLFYuGcOzk5yTUfPXqUFLzzT568LyJNPX/27NlsNnv55ZdtyOveu7VVQwjMHhH7nJGSTBWMGLHdbq6uLg0AHNwsV5eba62IHWkCj+SBzAcGY4dEAApGKNIfJNWcedh63RljXMxPK3a9ywoRgFJScgzAlWvm83keWx2alLTrkvfk2A8r4OxotVGJinQPHz788R/7CSK6urparVYfffTUkqWkz58/f/LkSVVValjXHgcHOOwvlV4QTbfhbrTqxn2rocVdHQeYw3lKgWBmKnvyIafYMjPivUGOBDaO/3DA+1S3E3Rl5VEpwr5uHoE5tjl+OESomRJkQxEwZ8tHylIa0UBCCGqJJBGgp/7w+qHVMrzpp1uOeaKbByV6XEnj/lf9v3rrEqgPxdxfpUwMqcNeco6QvLDI6zZHCJpaSaq67lokD0CrFC+vl4yOkSoXHlWnF6uOokJF6Mihw06++Y3fruaVmCLiV7/05f4mDUa0iXVPU5DtTcN2yc8G0Q8TIE5Ms+xKrkMgdFVV3dzcnJ+e5V7Mdhc8FJC1IfxKAMjXIcdN1PWsbSMYSbLvfe8tImZ2VJxaVtUhO1uOvRqVUz8wIgNA09EcQ1Xps4Wo5cw4ORn9mBd+QhylsTJM9lb8lR8eAgfuFLslEdzd/rHuxlXUXYvXSe9He3lxI+OFhdf0fLBznM/AqPaZ4q+uLlJKs3YTqurhif2zf+q/V83r5aar63MACBW27cb7ut3K4vQEIHWdsq8tXc9mM4updowaISX2PBhfuTs1RNCszWB6EP7j5O/E/oB9B9Jt5tQdbR42CAUkJx3hsF+Tt0Jns9mbb765XF0DgSDHtvX1XBFSyokFYwghk/Gmax0HcpyzT5jZZrMZjOZUzZpnz5699+775+fnq9Vqs9mcnJzl/MAUPANvUwIDIt6s1l3XzU5mrnKtdp1FMJ8kBSRU8C4IM8Nwls8AgVRVkuYbMHIAdt4FyMFQDrhqahlyM6aUENj7SqXzvjLD8eqCEMJsVpfaYiQeGy4b+PEf/1Hv/bOnz5PE9957b7lcAlDctu+8805d15LMBTfKmd+teXQUd7f8OdG//ZEexD5pz5j4D4a1rBZpdKFXe2KKWsjkUm1PtFo5hr1RoWSf9lh54liGwg1eNlU+lCHZ1isxBQMANUIk0rwnzSqS6qqCXv+hmtEx4QO3CLQ8+PKD3Rz3/QovIg/xwDLeNbgPJTuovzeYYUAKMG5dSBQDdc6JqYJ1JqoCLazAZlU985Vv+TRUJxAqoBVCMmWw5dV1U7vmZNGKXrx38alPvuHgFsordcwOGUOyMETMWeNHzMVODkevCjnqxVchdtvcTD7/E2MXY6yb4cIT5zAfAxg0hyOSPotKr5WZvXPUqeTQza5bi0hdz4gmygyzY23wMmXJxcNVBIM/EBVgyPYyhGVZsXQbT6nfCp//hrpnr5RhnP9tykBYuzcDOo4YQ5M6R998rOYoShHmMCQAGcaDhRdaRiv7sNMcTwPQX+IWQlitUtd1Z6Fer5+fhub0jYfPLy/nJ43zLJaQ4qn3KmDzoHKNpLV3kkwDWdw6wCYE7SKqaRpOIvbOHoDhkjEwArx1JXFbOaosp5ryFoD/Nyi5BSIiJBhkdLYvEfH89PTBgwfk6Onltarm/BJEtNmszCyfOanr+sOnH15evH9+73HtcbFYIOInzj4x5PSoZDhhnN2PdV2v1+t8cVlKiRwjqpm2bVsxP3r06EL1nffe/ujJk8126zw5QnasKaEaGBoTEzvHVuRPUATvfeX6/cukkp3kOJxFtv7ETkJE55xSXn+zcy77KnI++XEDGBHHBLEAIBJfe+21+/cfrtdL7/1b3//ezc3NbDa7eH79rW99y3u/3XSLxWLTbvNx4QnfFfja/XkUdwdqe0yBsBeGqYV9P9DDuD7OfewaLNWODasIRNxJ/IMBTCgQCpU86uD+TVb5Y0ahYlTjmzENy/hhGR47wqqM9FTLM0EwI8QcPatJfOMRkYnytYY25LaEQdMTUS+TR8gUi9cJUnYL3P33h4bCHkyKw77Tj/uZ4JigDfpV2XQ3elKy71rVcmJv6K+FRVOLKsGz8559yIfuVDW2XfBN46uG6hsTJVTVi2fPvQudpG1Mjx+fzuvGKY2iiYZgPCTi0uDaxcSraSFomBmBh7RnNi4is5LDfPDLkBBTF5k8mK02W/an3rm2Ta1Axd55U2g1JtU0xiLkiRkAMzd1SCmJdPm4cEq63W6///13r6+vL69iVVVmgLgLIiihqTpkIwO13ozivPwyRQPF4USHCiB4IhIBIq+KGSAqgLRLUkNsRJjdmjBOEwHRZezRflQtwAiKPeukqIOIexw1uvRHJtkL1BpSJ4781reTgyGpJEczM8r+9tyjIo0DyPtPRbqM/EYHAdS/298yMdqxzWCy5AmOB1t78pBxzLtNTQTAbddrCFIUk2wtIZIqgCIjq0FwFaNDgOvr6/a1R62tzQSjnp6eqoBqvLy5RkRy3HWd976LknM2+ao7PWky9rvt2lWVQBQAJBxDXE0NwAgN++iYPY/xyLSjn3OCTeohnP1YAxPuxOmeK2wPQ4WhXaJ7ovVz3h0ENsvGIgMaASKgGLAREZr2LNluutNQzVnBmQdCC0Shs613LioK6cX1h8mWqmeQ6Fu/9Z17955z7Srvuu32q1/9oYvnH7399tv379//0g995fR0kVICpKTivXeORLskVs0aSpXvfAVXVH20Wn+gjr/15O11wqvNsxC6GkS6YEbKcI1L1plzXoGNfHCMwJCiM4FETX2CiNfR4aWmp8+vr9Nift/a6Cgw+U5iAmxFqaqU2LFjF6KYAiu5KBTmZ0yEzGb9FWjeEaK13YZMX3nl1YeP7l9dP0+qz549u7y+Ruab6+v3PvioS+rZVU0dJbF3bcxpv5TJq6qqqKHjCvMuGCaEQQ1Dzuo1JDvs8UkDbec0F5NzpZm3+uO/NuzyjvLQmEu6GJmv6HQMOjEzFe0Zdhev2vdBo5jNRnYftoN78sfMsngR7fl5Qn6gRyIoR8kzUfZm5jXGXgiREgsCADgBVnHEV5tN9fhR5Xy32TpHkUg15YxaiEjDNZSIyOx2XRRXOkLRb/5v/zxo0pH98kDVdhkaUBH6o60AoKPgykeKc5YuHDrJP/V3GZY3CWG/2s7olt5gt2E1BjpsChAQCDB4BZWoqcbk3WobP7y+qkJ4cDJ30L3EuFyDbe26DteA335ygVx5RWhXb3zhB8KZuQHcezIIRsfIXmDU3ipztCtGnTfu3fYHl4eYOhxjp1UBKMaoSt77y+urugl+iD7IiMmKpFRdmYKzG8Q5F0Louu7p06fjAUHcWZcvVHYqp6C5vE3lnEPCkWeq0HTbiIVUncDk0Gg6apGVkn18Mwr6yTlUHAzP2yyyo532PCMAOOWZfX1vk68mL/PNB4efFBp3L4b5aPtl72VrI2CzfCkXAQhEhCJqhGNCgJzyafyTmbMPdrFYAAA5Pjk5SSktmLsuLZfL+XyePaiOeLFYtG3rBl/IHdM/BH6B2cOA7ReltMPGyzKB6u7hzvqjQB9hx94pZj8HbjabRTWr61osqapzoamrtm1F5OTk5Kd+6qdijM+vnnddV9+/r6p5k9i5QEQ/8aM/9ld/7q9fXl1XVZU5sWs7QCOqurZtqrrt0mp5dXHxjGkGRO+/976qOnQ5pDl2gog+oMTWPAP0m5QuEPZit8vc2q7bd6+u8/n+qqq7KDAYnYOJQ+xcN5zTpSGlYvaLiKJYRMQ+XTxo0zSn89njx4+TxK7rxOyjjz7K0Z3vf/jBk2dPfRUyNznnJKbF6UkOjQ4BKRuomkSimTGzGIQQ8kUFoxIdV35jXrydvJ74Ng9oHvbZv0zjM2lhbOcolU7I6Sjz2uA+LIdU9ntYmDzsCfYj4nHSr1l/+etYb1SToMpIo4df1VyZ2Kcwba0o5QqYDsCCt0djlVi4m90m5RDI4/vDmmWdyaisWAhlNxI417axbVtZNDF1wbmXz+/frG8uJL7z5ElM3byZicRO0qc+9amTZu5G0XQ4GihQeBu5lDWzmlRN4w0NOfp8lGIGYGYiggiV5+VymR7cc3UwM/aOUxaUNhnASP35spDsKMtR01VVldu05SA/Hh+o+QbLUZX2oVvqgCylBKMlqDQuhA55Y0ocxblh21spHocw9MT8MY7o0RaZTK180/fV21L9G7Xd8syKCNve6ZSrFnlZR0adoL5PhQM2upTLIcHgJjl6qqrkE3ZccvhYM3/OTDkdEjM2tVsul8OGRRQRlhQ7UVVFCCGkLpLjlFIg2qyXb37nu4jYxfVms3n88NFXvvIV7z0CxBgd8e/CQNsbs5THOW6ps6dHp3WGmrRPD4fScyijiwJKH2QJKCLK6xkRaRZzZIqivqpcFYwwJRFT7/3Nzc3pfCZiMYqqzucNeXeiJ6vValbVNzerT7z62quvfsLMTHE2W3zitdcvLr+RL6ECgHyPrJEQUdQ2pY4cKUhq265LT549nc0rRIyChM6AzUAF1TonnofgTgBDE5HI7GezWUrJETnnRKJjTClh3WUDazz64pxj5/oTaRkUogKQE1RVVYXgEVFVwMTMHHNo6sub6xC89/69995r2zYleXZx8fbb75hyXdfZr25mIbj18uZkPhMRANu22+Vync24DN5ZPV+tbnISR0Rk50UE8kICBn9uj469jFRjGYc9ckepgEtsTuRqyU2HCn6PRO7YQP04sTdp+WgQ4sc0sauW/2+q/YIhJfPEIoL97PbmOE6ZittuYF+I3VEOdVD5VVbktw3+tveHNxTuhoEAOl01TcZcfqKqbdu2M3aO265bpxR8CM6fJjuh4MjWcSNmEIXZzOGDx48Y0JUTyGUCmpEsxoj/yTTHvxHRTLIas2HrPrt8s7uPiJB3YijfV+p978dzznVdVwqmkkydc4iSPxyze9+BtjsIdzcHtCzgiKjrurx/1u85keVOVTeIaEpQeHfNdhedTruA3Zgnv45/jvMqEEmTOwAO96gm9Fc2cnQ8++1PwTJaqSWKJxpl/DefK9CewHfXj+TSnw9htt662uXnO0REl/oAOcoOtIH8cxSo91Uy7drkvX/w4MHy+iaHzmqR7qAPF8ioV6t8iCkBwKd/4I0stNEgC1AeRnW40T4xm47g8dgeGxwTuIfNHv+paIoOJM4OSlM3Sc6SvcuF2yNLFQBijK++/gkf9KOLZ7DumL33Pllyzm03cnN5vT49cc6Rd+T1ankzm81OT89PTs4CU4ptzgZM5LabzV/+y3+5jSmEOmtrM6yquuu6lDpy3G1adAoJVOHZ88vvvPl9RGQXzJIBEPkczaYqxCASY1TnAImYsWnq89NFG0VVHYV8gnmzWrZti0ghBGayvMo0MkPvKnKu9p6ZQVStlyd9ZmOzUAVmbtutab4FOa+wU0oRAJbL5fX1zdXN9d/5lV/13oPzffJ5s5S64Jv1arlaLu/fP7+5uZnP55/9PV/5zne+4z3HKPnqpLqe5b1wZhdjQkSRMd39zlbeccc+O5f0M0rO8WW51i+/LZuaUNRRMjv86ahKhluod3woA573Ce84GetgBxqWd4aBmWlMqFD7YJ0QoiI4R6MpMxnennQqrqKCCUseM0TKKZTuSdxvHw8+NNslzy8VzQRKuzcHqXMOJzJWzuV6u3YULjcbXN/cq84acSfKD1wTUvvmm2/ev//Qd3q1uvriV7+wOJ2n2O3dgGFFutExJ/AomsctDYBSjU0cdFO3ZF+pPwECqhZjZCZAJKLlalVVnpljbK0/VkXlhzCQqQ6ZWcrBHIXFBF4Ax0F2KH/zgSgtAvdHX7qZgaKYGefLy/Qo4QIAFsEXEwwd1cdGaZ+ddEIZk/qwTytj5TJbdVmNbPohFJx/qIAtX6d+4Iwq6QQActSqITLQqIBhWEAfXs6xG1iWtuP2FQ20p/0Ik0FKyswnJ/P+grwB3dJFMSV0OZeTmkWV7DD07F59+ZUQwmp1U+6ebDYbM8sJaSegG58PeXsPQZajUUb9N61WgvRu3Tx+qEPsyWF3ZX0s9LSZGQiCG+UmAKSUyLuzh4uO7Hp9sd5uwuwEkFJK3oemaXISjHyI1jknqkzkkNq2rUJQVQL03pvicrm6WW1eeumlq8ubfBwsxsjMqmAgQAYGHz199uFHz957++mzp8/Pzl9yzhkpYb7xDfKoFDoUZGcGAqBMwIzMPCO/WW7ynjoR1fUsm4A80B4Nxy6qqkIO5CgzGgM6T6paVYGZc+Ck995MVYwdIlqMMXukr6+vN217vbz51b/7a+PgQ6iyk7mu/JMnH33h85/92te+9jd+7q8Fx1/96lfPTs+/+c2/X1XNYt60XVosFuv1OoSgqobALmT9EWNEMgNA2+0ZYeE5LBn8UCVP9GspHkclfUg/I1fuqasDorrjzUTEvWA5ZIq9dmh3jSANmeSMUEQYoPaB8k2XBg4Jh6MsAJDPOpeTLXnwkP7v+HNXuZBUhRG7wwzuryUmO0iZDe/sd1wX9UddBsNABsTuQswQSQ03KaEKromIZjWeVYsFufb5NXaGkjO/us9/9nOni5P24sq1bVt2POJ79AjtqzrUHMx0i5MkLzgGjsrb+5iVygB6i5K8OOc9M67X63vnp6Gu2naThbgiqO5mfQiO0sNzWKd8eYtEy00PYfdDLFy+qS2pxE0anOfAzFQoJwBQzddj3b5y0h23lBVKBisNC6Pdm6HscmvfXUoitj79BRYvrfh3WsYZTQCV94BJpygeDbJy5IiA2reQUZ+rjSGXh3CYGgGD3mfvxsFUtZdk2SzbbDb5+tg8KUYih6q9uxvVUtvlXfvl1TUzr7art956K6X06NGj1197DQDcsV3tCZ2Uem4y4BIpk5x2vSlyi949pMDJ9K2E52G1/XdqCaAPDylft13nqvDyK6/4cP/k5CTftB2TSpL1cuU/4Z1zGpOIOF+ZmSVB7xFgu91eX17MZrP53EJddQkANMYoKS3Ozohovd6261Uzh+ChCgGNHdfLm+3TJ5f37993viI28gERLWdENEG0qBYGH6NIJJo7ZlVhxhhbAFqtblIXZ7NZ3pv3zjNz5koRAcAQakNSGGW0AgAaOOcco3cNogXnCbVtEzMyo5nmfCNdih988ME3fuM3va/yKtaH2szYuSw2QOF/8i/9jx8/vH9z8XSxWLCv6rr+gz/x43/9r//XdV2fnsy3263jQWugiykCQDLtUy8CACnuDqeo2XHiKfm3fJ7EG5d6Y3weWXgkzvFhJJ5Dehtp5zaSG8uLKONDhdcPuKyDAJa3GJWJNcmicjU50w0O03HDCjgT/KT9w39vW3GWkIEDD9ZEBRyVeLfOFBFv0SYAvalRNl5Wm8jzfn3oXQuwza6+JBG7pgn32L96MlfE5fpmcTJ/7ZWXtusVOHDjHirulwJS/f9uHeLBIMqNwAyNok0b4xqEKXWxS3FGDXmHWizjdgtR2JubGeIegQ6YOAKdPSjftghGzWeQENGwDwHg4abM7OgeW+jbNwKQwbyYei2Qj6xpEJFsF22Ixa9U1CmGemsEVtndAIfpWnY3OzM7ym+IiHh4RA8HA2Wc2lGCK+YLcIsX7u5/dw/9P0OCfrAhQ68y82q1atv2/Pwciqg0iclUVIzJ5WsDRqrLKY4/+clPEtGsrkfX36G74jb5crdsQtyTAtO5HJSjOji/V92LFYCpEaBjRt/xV+oztu6NX8BEBJjq+ayqKmZGUuJKGNerzfLmalY3iEYEXbth70xwvV5KSsHxdrtdrVZPnz51oZrNT4IPZhaCG5Jm8PPVattC5VNdhSp0AO69d58sV9398+CcQ69VTSpgygAQo4bAHmdVVTkmU+y6tNls1ut1XmEjMpGtVzeXl5fOufl8Pp8388pxzzIEgMw8n8/FIGlCBtEoEhHBh3CyWCAaYYVos3mz3dp6vXTe+yrE2BHCs2fP3nnn3d/+7d9erVbMPoQakVNKVe1BzTv46IMn//P/2b/yhc//wLtvv3P/3um98/sigux+4sd+dD6f/5X//L9IAghw/9GDfAZ6UTVt2/q6sbZldmoybkNl7TuifkJOJS0dStQR6RPJProYx/qlv/ooRR3TDVMyPuz6kBoPSfTW9m33vtR/igJgp7M5m5ooMiGapt3tDgpWbs+NczGzvXTQtw/mEIxj78NIdhV039s8UdhHG79jvnd/UjKydN2W2TEEUUZHRNF07sIbJ/c+M7/3reVzI3v11Ze92axulqtrN/EWjpNMKcGeq3kXB7/r3giGYyflYa9RAZc6UlWxSPc4LqxzlGZOf5E2icjZ4OSc2EP5vGBKKaVdR3ef3xp188F7G52KuUjvSchaqY/czsLdeiWBuDNsyUCOIhX37bKJjD7Kh8eoqt81L789+jwq4CNsZgQIBjvXdGlFjqx+KAgAcp7NPR4bU3znMmZUpuKUBRxbuE8gMOKrJwzAfLaciATME+WADiQLITx9+nS1Wo2kwsP9pvkWATMDsOAZh6tPzYSZz87OYLhZ0rMbDb7buHdv4rd4uj5W105+OorWiSSdsO6oa8sW+jrYe3p7OOMOZcRIzOvtarPxzrl5M2tllZI6HzTQW29+jwnAjBEVCVREzDunEtUSaLp49vTDp0/e+t7bP/wP/v4vfPHLzlF27zNj3KZPfepTTHR9fS2pNYGrZ9fvvvPk1VfeqKs5gkOvzmFUcYGZKgCrG5+kcey9d0SwXK/ef//DZ88uiIjJf+pTn26a+YMH905O5tfX1ym1MbIBGgiZkDlkCr72vlKgNm6jtG1nqhqcn81m2tQMJgLk3GzexNh2XccOnfB6vW7b9p133vnt3/6dm5sb771zIR9qYIdmFrttUy/A4GTeMGEV+OxkETz5WSNqi9Ozn/7D//APfenLzy6ev//eBz/7sz97fn5fVW9urmbzk67det9fyjJw2s5veYft1TNIQXhWWKsTqhiZcWy2FCOHlScqsGyv5O7x7dGDAAC7Xc47pGhZBMyUoGf/3WnaqBIMah8oqYoSEZCpabkBXM500uyhB2giWo9ykxX7viXvlI3s9YJ7iBvbVwB3zKzJ9Y9CuxQIJX49h9V20zSVqq6ub9b3qnkTJLYvh8Urrnlf4Tq2n/nMp5uqXq9uANFNsD5IZBiuMdhpUBjShI57sTpkmMsybrILiIiikdDlmsSQLdy6rmZ1YyDOOTJYLpf3z88dh5TWHLylnmrNdhd9WHGursTohExLiVaA8gi+i8QRNHrUmf3gKKbxZq5ds7TzGQLskUzZaTmGQ4k8CRUeXbWjfTMoEhsnOBn33W+OUS2WGncc2EQlH7ZGB77xfaj2upYAy5ke8thkwOUhrnEMipAFnJkR9ZlE224TKpdD7UbgjL2UXhYzG3MFm+V7HSylxEjjGmKiaMehjtfKjuMp8XIoOvcZb4zPl8kn48Bu0+hH3yOiakLniy72UCYaY8S6rtfbdkS3pM4754nvnZ1vW5nXjaoHCwyRqDk9Pe267vn1M2S3Xq83q3Xbtpv18urqan1zfX5+fv/+/foLn3v+/GmMLQCIxHGXh5k/+donVqubpx+9f3X1/m/8xt8/O324mJ9V4XTdbnNiEF85FYfgzs7OiRD4gUhkRwA6axZMftuuzayuZjF2MfrFYoG4aGZhu11fX1/HiAAz733btrPF/ORkYVYZ4bbzzy9bREQytcREJ01dVZWIpZQePLi3Xi9Xq9Xp2eLi4mKz2Xz44Qe/+Zu/uVyuYNB53jMREvkQHGpczBoC+Obf/8ZPfu1HGe2N119DRERG9s4HF6qH98/F0Azb7eav/rW/+YnXXt50sYsCJp4qEWGHXdd5cl3sqhA0e+xu2SraCfdCahUCdupKseJehJFNxugz2Jdvt8kHMyNk00EUJ4HdftBhSg8AOH5sAY5Jkvync0HNpN/5zfdXqwKGUK2fXZ+9vKjZr0Tz4skzxxi99zkhDOxLhrJxHHVNsXiDQgEdjrwHxbHxIyIC2v6945gXgXbQQgHw3ee36ePhIV/wXL7J44wx1k0wkXUnN0IX1VIcnbBbAH/5ldff315bCPcfnHexRQREdCVcEBH6wAKbSK4REKMKMd2L1DWzMbVN74VGRcQkXQ9Ngaqq5vO5cywigJrHLKKr1Wo+n/e5eQugmOmBbZTLXj7nstiRVemeIYmFthvRk+9dKUDcX9ozvimF74BCHhPzHv476XFs4ag+m4x/eJyeDz4sR1vY9YIKiIdXY96m2l+8i72+dNraoVC4u5EcV1nAZ3dQ0jm3XC7zUeAx8A0RD6dQGEZ7+MIxdhpp7GsyzsN2Jjw/qXCE2wtJesi9Y5tla7f1TkTYb1eO7gQdj0LVdY3AQ4ACiuRUcagiRHR6ehpaQRKRlqmZzajr2vfefqdZzC8uLp4/v3z6/Nnl84vLi2fvvfde6hIAfOlLn/uBH/iBR3UlSiEEk+ScS6mrQ1BL333z27JdLxazs7P617/+3baNr776CbRaDOtqASTkmNkxNbWvnXOqaZsqR957JlQD8T4458Ds7PQUzFJsTetmVp+ePFJL772H3hQkieRbEV3la8TGiKsmXN1cACgjee9DcEREDIgUQp1ThWy32/fff3+5vlkul9/85jevrq6bptlutwAAJsxMSKrdO29/yAgXTy9/5B/80h/+qX9YU0dEs6ZCRGIfQs2+QiZTEIOmaf7YH/npn/trf/PJRx+K2b3ze/PZ6Xa7VRATZIQY27qquq7znu3YquuQwm1/x+E2qru7jILxUM4c1ilvUyh7v63cNuyx2ZGGy9tnaWA2wJw/BjxCXG00pURKQIwunxrtL7Ya+FFEypgSAFDoM4/g0PUdorJkqANpvwcNLNxyfSN6vPLkPNLHCsnbhsTOI4BFQXbqaK3Rp67qukWoH81PHs/m1YP798/PkUklSkw5tdsuEWh51ggOEDNC0Mzy1mkJqVKXq6X+kABSpoaqqZum8cxgoGbOsZkRg5qtVuvFYpHPJ4hGLIzEEo7lMLJuxt3Cbrpcux2C/QlFM1Ppta+IEPVOCMSdhD2uPHbXYjLuZ70oP5x+REc8Ckepp5g4f6wOBoDD+KCPLXcqxV7xK5YHr/Y/p35lfdjgHdLhaBnvA9wHnSG6HOyajwKPzhUcor1Gis1f7bTyLnOr2TCBMRSc8m0aBb6I9nz4owYtt1om7uuRILXonfaSrxWwKkrZ/iSZ/gjPThIwmaEBUH+ZrjrmfNW8iKSo+U6hfCFYt25FMiVD08wNOqPk0RPWhN5uLv/e13/j7Ozk4uJqudqsVivTVFXVZz/9KedZkzx++Ojy6iI+1+ub1euvv+49b9uN956Zl8vlW2+9dfXko7px3ss777x1//794Jsk3rkayRkZe+e4cjzzrnbMItHNGjNFNJNWNNXO1XXtuHcPtG17eXkZY/Pw0f3FYvHo0QNrN8wwOHiZyFXVDB1vWk3SxRhFUuXDvXv3PDETqCp75wNrSh9++GHdhKfPnn3wwQfL1XVd16pahyoL/cCcUry6uPizf/qP31xdr5eX//Q/9ace3DtfLpfzWR27WVZLVeXrumbv8/0T683285/99L/9b/6rv/Qrf+fb3/72r/zqbxKCITx8cJ+IrldLxyQSmfs1EBxwwYSjD82v0lyDA0lVyLQpnx5V3mUvh88lBcKxchurjsOeSKpeQSBkgcPYY87M2EHjg3aRwBQBqU/mrweL2sO+yu5KljkUQWUjeSA7iNleCzBYHoe63PZ9CbfJQ9s/2jSB20RN9L14RhVNAuxak+u4rbvKgnRd11T+wXx++uhhFdw6dY7IkXMT7VtelXWIp17zag5c2qnq0c0y1h+D/QDMOa6qajab5Y3eESiWJF8csl6vRdS5PoB2zP1tfcz3bV674xbQbap3NAazPM0nB7NpVkjbKR0fZyoAyqMyKnO/3VYODYhigjh5CXvYpcMhHW1zOL9kwwDHWrcq5tt4ctDlH2M1D2OYAv+oWPnYMsJ5+ETJwOHOvTyiIz+Ml2gBgJXJT2QHsN5JbgAAbdv2piHujWqXaBB7M7mUOGUUTOmpzupWFMZPbL+UICpfjo3nZAX7kAQAqBwXCrjnTSZKKS0WixgjAr/2+idvVmvovYvoXaXWqdh8ccpBFBKgEnqmaj5vRLddl4Kv792bnZycSdqqauVYJeVj9++8846KrbZt3jRtQuWZVbVt22fPnsm2ChWmuHKe7p0/XK9kMTtnXxsCEpEPCAHMAwYkZsy3HQiCiDClrUGqgmuq0MxqIrq6umjbNqU+dO7hw8ftzbMubkQUEVNKW+2ck6aedWmTAZtSQrST2ZwQU+q8Z++9C66uw3J1/fx5ev/D90Skrmb5pJD3AURPT+br9frJk+f/4r/4Z/+xP/rHzKTdbpoqrDfLR/fvxa67d+9ef9sEWkqdmRgLM8+aoKo//A/83q9+5Ycuri5Xy/U3vvGNn/0v/9pv/Ma3BODRw/OYRERcFTablsjJXsDpNNinlNGlPDnUwUc5ZZ8jdm8+lo/gFsH1saWsf/TbnoyN+tyQZgSoqAKGABU56sQ5FyEB9S7SpP2uZXaR7k4l7c9UcW+mh0w0+WnCUOOfh+pgfGNmeMupVDiWlOOOMnJ9+QYAokoFgGqiukld1Hi/WSAREIQ6vPbKq/bKA1KIkgg55Cs/RxlRBlKNToxJl8PVBTsH9bgHvKtJRoNeB9WmaZqmweIsr1qCIkRNRUXEe++QE+okjvo2BOzPfIq5QzYo0WCKSUxMB33MZeWJaXMHGsyGW8RxlyligpURVWXLL9h+MbU9Pr/jkxcsR6lwn9U5X3gyqXAI/Mm8Dlv+2GlO6iBml1avaDebzRjqPLHzylYPsYaIPLzM9ExEsL+cLRKY6ISQcIjtKkWGFft5+ch3WWEiFHD/OMquwhTUOxh6yifTyIZACoD+VuzcmgosTs+ykaqqzJ7Za9ttY6pnJ9XMRV13XavCAK6ZVcg1otW1z9kZTavKc9u2jjGl2Lat9z4m4VBVVROjiKiIIHBdze7fe3ja+CRrH6yBJlTz4BugxofGmIAQyCEEU88UmD0AAMYYW4kbICTvGN18Xi1mc++5aZp53VxeXq62q6dPnhO6R48fiHPbVnOqLBHrtmukxoUagAiQcKeuLOe98tx2m5Oz06Zpfv3Xv/7GJz+VIQAA3vuTxWK1unnppUff/Pu/rQZ//l/5l374q182jefn513lLy4uKu+32+1iPo8xOseUL1NzOSMvMBESRBGT9mQ+a6oH+NLjz/3AG1/7iR+/uLzquvSv/mv/GwAgom3b5tNxMGGHAaElEQL0ocmjKii1wqEOvo3Ny2bv0o6Fbsj/Hiq8ox/CPhPdVmfUU2b56hVTBDH1BmhgKpTz5BCpKg5ZVnDwBiOiEUo+Slh0SkSGBrIzec0M9iOZbxs/lgs1AMgrQJjuAU+V8YFA/t2WESMj+3eiQgiEyRRFCFwraSsRPSrYw8cP9MG9SzMPBGqQ89eUevQA1jC+6esIlNq3NO3HdbCZZf+M9362aJwbjmKq9gYTIgMqEYAykQBst9smVMw8JtfOsBmobW8ksEcxVDwf0P3BRBBYkiRNRcoIGg7+TrecS3d02WyvIAq/NwLZgbt4opwmKM+goyLD0dEBD4VKHfwi5SgDj11/bP2S+v//WHDMlblfpgbvYNXVPnhiBkTmMRJ7oPgpCx0+c4G+UaFaIaGgQBMiEvWp8MeArxKJtr98McjngnqHynSm2aU8JHejAr9H28/VomhWwFBKWyLnqOtiCHW+/iTGGIJT1RRVEohiF9X5ysAjkrFDCGgEIN4xIlCfYtkxRFVtmobQ2nZbVRURx5Solaurqy4KEQVfA0CMURWa+XnbkSk555Jy05wb1uwrDKRmSJ6wZqpDqJm9mTG36/VyvVIC57gKDk/ms2ZWBefNpGlmROxvfCdpu+2ePrmseQzPYWaOra5WKyBCpzkTuPMUKica0aByHkBms5mk7vHjx3/8f/AnfuEXfmE+P+m6zrlexL/+6mu/9mu/8Xt+z+f/h3/mzz54cG+7WTa1r4N3bKAnMcamqZGormvvXWZA3hlLhI6a2puZSAemIbiU5JOvvvTaKy+xr/7cP//P/ev/xr/5iU+98eTZJRGJAlqEfQV2lCBHuWH7q+EJC5S6c8IXE516h4KcjKEUMoelFD6TRo42ng2jPulAnsjg+J3NGibqj0bnDByG46UyqpozGEYV6+966kXoXpkYH1b+8kIL+rLaIax0uF1mgpoXafm27so/CS0BgEM28wrMuG63l+tr8ucJBWeniUG6tkIyBCXcKeBxrKNimMxBBfJdrWW1En87OwuRiPJdpIumSSmZKDomopSSqXniJAkRzSCf57m6uql98N4XopCK2IEjTuZ9ENzlyRm/MrOUJN8YNZD73tp3v00t/bdW+EiPUj8CjWFZh6PF2ze2DxUwTqiwLx8flpXbK8GFByvyu6F0UO7q1I7tkUwoe6zZv3wBpT42i4g5XxIR0X5YnEgqYYiI+a7M8u4mAtB9Bdyjr1B4uP9sZtmkG13ck5olX9iQzgURx8srx8n2kdv7i48JZm9DRL5ApmxQVfPWJiHlvrouJxMFMyR0wbvZLERl81VlMxVm8AAJsSVQSdbMAqI5i13cNlUdY5vv+4sxsguG/OZ336pns4cPHnddUoXZbHF+fk7Y3L83V1iJxM0GiWryC/YOPBoA+UDcMAXvmn7XKcX5fO4cEapncwyzOhCaiHjiUAXvKgDYbDYiutm0rk751LuZVVVF4NsONpsthx5L+f4VMzM1IGZmVTGzx48f/8k/+Sf/w7/4H77y6idyhXtnpx98+N5bb7715/75P/3P/FN/crNZffD+eyCxqfy9s5PNZlP7IBIzagiRmfpVRy+RgQjVJDgPgOg5hNBt28XJSdd1qRNXVX/kH/mpX/21v/dXfvbnzh48kISikYpjdYeIPvrnRJVOvi1fTjh3FBGHIuuQx0cZPmlnUm7TaqUpUPa753MqvkspnZ09qJwHXQH3/MjUHxGcaIrd4G8ZWKGAP2bVCwW/YwEKVYUD8PZgx72Rl/L5xb3Qh1I0z9EhrS2xoxABFS3Jqt3UTTg1BRdwVrWgZubVhDESuHHTF4aAdSuChMfJ5Jjn0i9txdYvIuZwc0TMRzKy25mIYux6t7MomAV2NgTp9a5mAyLabDYpaVU5LW6NLYmgnGQJ04kTckJMmWJK26LrOqCdtDW7TbvsqdKxhXFgRDSxzsqPD78t9SscLI4PPzywBl7QRpu63w8bv+3XcbQlig+HMal5u/nyuyuH9gdkX992O5721iHLmKqOmQszq9udAzhQnHt1yvma9UuUTLRHsWajWw939zTcdpzjgFz3UFBSVP7JMVm+H2w4+AuDe6nPtq0y5KsBRHAuSDIRA/bNLLAycBIQUK/JHDk1REiEsFgsVqsVk54192K39d7PmyqlVFWV85UC1YIu5HSP/VGue/ceVO4kySq4mXpZzE9FquVagm/AKXnyYWboVdgoO3Bxu4lV7WusVTqE5L2r6xoNVGLlfAbs+dn9qlpd3dxkQweGS2dDCHVY0Eq2sdtsNiMMey+xAQKqRu8r5zjG9tVXX/03/rf/u//wP/qL2db/Wz//X/1DP/m1f/1f+1/96B/4/Wcnzc/83/9vb731Fkv85Cc/+ejRo0ePHl1ePq/rEGPsdUnGT5LsvcjIpgHLdfDOOU3RMbqmmc1ove3Oz8/+/J//849eeu3f+Xf/vS988YsffPDBQJl6iGXYF/0lvZUqzQ5s+qMavfx18Ngd8/AVsQvwAqLjNla93TTMnrE+OwJZf7Kgi312MxHNAlZEhBmGXZ7iiqRdnuO9ZgekTETBoQFxtwQbBr8z9UdhW6q2yaR20viFl8ITUTniJaGhZxOBKKrQASjC1dXVvLqPjAnFI0OrQNQROpPhaAfu1Fs+CNF2HRHxsBIlhiRS3siAiESYI7vZ7SKfm2Y2n88JMKWEhDq468wgmYLsLu4FNSInIt5Vl9fLerZAU1AhMAUFtbxrZ7QXXFoSaJSWmcflEWUjVoSdi0mZ2Po4DjSA9Wajlq+N3MUCDDIO9j2u/XWbfUa8Xd+KiGB9CGyPNhwucbIjtF6OdqKY9xC/I50jmB5HNXEGTD4cl+zjSjDfcA491Y5u0mIXZ5+GsDB7tThnxbDjBBp9OAMIYJ+ID/XNdKDjOAx67wUAqOXDQmKm0K/s2m7bdtvFyTylRAD9xhLuw7nXqLvHfvwA5dxg3/Ewni0egTD81F/5rHqYXltFabC2p/Y77q8YDrFTtHM8aBwRO0U0pLzm1/H05uCyYxSzpJoXwapgpMiU1iYiPjhLPio7RnJElSdgwEQQiQ2MT/yp4bXExKFCxBRjZx0BgHGSTkQMVbT2XKmCsfNNUzUu2JmZRTFfLSAmB9uTs1NiL5Kv/nYcGADUoqk1FZsKqqgqEde+IfRmkZmNLFTeIYgIkENq1us1QiRgM1Yx75k5VTO/7eDiaq0KCBUqBPTOjInq4H01BwDPDh3MG/rj/8RPf+1HfiiEIGIfffQ/evXll1577TVJHar+o3/0j/zar/3a3/75X/rlX/36zab7o//oH/nEG6/E2CEqxOQUZy5AEmMfKa1Th96ZI2L2VcPMaEDOzbkGteB93LZnVbXeLn/gpQf/0p/7M3/rb/zsb3/zm5//whuXF2ndboN3XYpkYEm8c5SMGWOMhqaMHLhLHQcvItXWDIG9ayVFNQwOBjdkdk9npjCzzG/EBakP5iHcntytPNde5oef1B+59VCu5nIYA9TzlDfr1CdA4OhwE1hAZsS4hZeAXdcZQYpdxUFUraKmqlMXe21NJGDMrIOuHR1oo1vYBl0Mo1trSHZ7VOmWpozkBILj6nHwNpdb4LTnWOrbINrBwcpL1VEVdremYoGHQwMoj8EZztSwVQW89kpEta/Wqy7N2b90/6rhpQeOMvfEiKEVd2iOAfRyNQck6xDukXee8rKViHIMQp9RnXMuuui9Pz09ndWNqiZJtJ+8wsyw1FsAyATWC8G8W5ZjWqzIvGGmarsgrwlZ5GV3eboLEZk5J/RPpmjgve/atGm3iIyDUiktrPLPscCoY/oyvT9rRNILulXhmMC9o/4tivkuA22fRves78lPhyOZ9GiD8wCL4JH/NuU25XR3UdVxyZLTM8I+/CfD3h//1A8xeX8bV98xztu6e5Fy+O0I3h1N4u7UbzESw7zgHd6MFVLqRAQJnHPENYmjJIb5Pk1wzrFj75iZwFiVAFSCAACIdsCOGMDUkhqpahXCbDZjRnNc1/XlxXXui4iYMptjU0MIDgCzkUqEkN2wotBPRAHROefyRiAjICMg9Ulb8qiaEEJd1+160253N4oyMzsP5MKmFsmHNwJQHzSeUmrmM+dcCN7XfbLYT3ziE03TAMDrr79uktq2JQJGeuWVVz796U//8O/5fb/0S7/4y3/3l//Sf/L/+Yf+0B/83Oc+651j5wNy3LZ105hZt10HrpQxocyRAhiqEDlPlKfGDtnXm83m/ORs1XYPX3v4F/79f/eP/4k/9dvffeul+y89enC22m4MwAAEjQKmNiqRenVVUEliYmYSk5mBY2TqRIBdHVhMxQBUmcjASodqThG072f9eJesFWViW8MB49xNq2WFwmy1jEYYbv/jYe3iiM0MCBlZVPXgEuKRbPGW3u9QtLeNdjw3u+vilg3vw5d7fPe7LBPg2OAWlXwsy0wBVNVl9zCoI0xoqprViGTRSsN1hGZmYIUVAKOjIMWoqtkllZ1yo75k5nxVXFbMs1zqGhFUxWwMVJoOFwavGhENTAv5VEDlhmkoE4GIHO7DT1YPGfwFKBkRzKKA5ajRbdt1KdroOTzmGJw0u5OMWSoecy1iv/b9eG16WF6kcmkTFAO7q/J+y7m+4oFyzbkdJoM5JP2SH363FHpU+cHvktbNTESyF1qPff6x2vc2NQyFs640uY6O/7axHbWQ7tDch+OfaN/hWwWEEkGTMo7XDABVrUM0ZnSejTwQR4lVVTEFR55YgRQgB1sgszNDh2RkYIbBEaGkzp8szIy9qyuuqjqJtW13/3zRJQBA772IqQEZUyBGMkMmU8k+WzMwQFNTRMsmBCM7T86RIwZCxwigRIhggJrzeIcQGGabzTMcxFYOggvB523dHOadZYUiKlA7hB9777PrOl+HRUSO0NAxs3ckklLqUkpf+vIPvvzKo9c/+cov/MLf+rmf/dlv/9ZvffGLX3ztlVebe/e5mWWBdlKHCNJJ8iAhaiAEJnYuBK+QKcSiSn3StF1nZCnFL3/5i3/pL/3HP/MzP/Mz/6d//+IjiAqvvPp4tVl77wyFKlIDDk3bdWJa+5D1FqhGBgQEdiKSr9F0zPnixd7KHG1+UkMwJcAjCRRvo7dR+95Be6Uyvk0DHb7BYSUNwDYoURNDl+UkmFm73aKqcwyM5Khp+sgA7V3XvQs63waGxYChGHNpN4xvSqf6HXr6timPLyepN+9q5M7zpbdhQQAYnJkoWDIjMBFZtVK/dF8dgRoJIKIwqijbkHg532uB45lFgLw3bP01y2lMzQhGRKSQRhBkX+5isZg3sxB8tltxl89v3we7PwEdcoPlP5fLZbjXkGOQVM6KAdMxFVBS20BJmHKQNiEBS5L1er3tWudcviDlUJWM6qeUwmOzvbm3X7mvf1uiihdYJ31shcPKL/jJ3fxZlL2Agxck6zuGN3meDON31ZrtuR1w03apuDF0orFKaQLFlHAgNhxcxjt+Hv+H2SMDk/Fn7O/rRSyavFXBl7O448+jb0oUqxmTQp+JFqHnUAPrvWk4jAlQzFRARBJxMuvDXrz3hB6AMK+eGRmZHAciE3HOEYHEmhgcYZJ2ubxeb5an/lRSt5FYN3PvsGvbyi/A0DsfyVJUYiQ0NEEgUckpbchyP4ZgqCagDOCcD5z30Y2ySZzv+yUiZudc1qCp5TIiRETU0IUAAFnU5LzfUYUYVPOpIUZEUGvmDQ6R7c65nPpfVdvtmgjzshhRHj++/7Wf+LFXXn70y7/wi3/3V3/l1//Orz5+/Pinfuqnf+j3fJW8FxH2rtskIiBgrLw5R86hD+KdmolGRgpca0xEGtTYaHtx/Xu/8OV/43/xv/4X/sQ/941vfOM/+U//v3/jb/78J157ZRO7dRfJcQIwIGIvUQmAiTEpM1kF+egX5cjhptGYum2bN7mTGYEqgiIo7kIcJ/R5hxq+g+/KyhOuOSxlcBkWxSzpEI0xaE5IMd6bN7OqlvWyD7hSAyDnwuASn94qcbSUCvLwp8N52cGe8ajLj04NC4/mx8i6j8vucGjW538FzAGimhIYghF2KsnspfOF1Z4InKo5TAiQFA1c3ugygEnyZzPbrNfZ7lABZk9EKaa8KmXmEDiltN1uq6q6d3Z+cnKSUsx3X+dwzTILyajPxtWkDbsUjjjXDCHc3NzcO6+Zmcip9tEZhLur5svW9vWuDdtlBgCm/VUEy+Xy6mZdVR6Ru5Scc6bpbmiWxWyaam5ED9EgAF/MV3lY7UVU1KFiuKPyYeOTRg76Gons+GJrj2P1SINld6UKnwz1Be2GQ5qGIg6LmaGwoyf97j782J5usRjKoe4PGDMV9L183FSmqvdOW3tnIhwYCqMRUFqxAJYvERnIH0SiWlKVJF1AREQmxryF3MsipczfiETsAI3JsWNCR+wYY2w3y9X77767Xi/jw80bb7zhqiCSCCD43r2MiIGZLCGyAuVAcTRM+dJfBEJyDIqQ1NQUGdkhM+brPBlzKgJiRnaIiPkaQUSXpwDgGIfU6wqIKKmfYTYmvPfMfRxo27aLk5mZaRLvmcAq70QsJwiLsfXeE2EIzsy62DpzIfhPfuLV6ms//tqrL//Wb/3OW9///n/2V/7zbYo/+KUvnp6eAgCaVgigRrU3x+CCOU4EZgDks9L3oWJ0rqbUJVDU5aZ24Qtf/sKXfvj3RI3/8X/2s89/+7sAAAytAHtIER4+fFjXMxM4nddx2zoXNryKMYpI1dSaZLPZgCgTMaAhjPKyJ4yBZEYqLbXvhGhzoWOZ5HH/gpwDCj9SbrMv8wCSict3RJMCcOq6ew9fbkK1sZtdTYOsCMbxEFF/p431uvuw3xcXcWX98Sschoujs3v484Vb1hc/fVk2i30ctalaPr6at1PblKwJdDYXT6jqECOAECioF3A9dAih2DIUkZwoChEJHYAgIhMpYj5KFGNUQ1ALzs+b2WKxAOhPEo8HvxD7M7o7YTosdjMW8x4zEIL2B7TX63VK2jQVUZrYdIwoB9LVDo5LISJYfyT3erm6Wa2z60IBEVFEx9jl0qyD2wVxEUuX/Xj5p1vXlxPhfludo7g8fDkxMqC3k17kMNK02TtZrk+qONoxL0KsExU70b7ln7d9dbTBnjULsm7bdgj7PKI1x696KO03eDjrEphjtVvG2TvJJhO5zVY4+nKUPrdNfGKyGAgAgHE+TqmqSIRoaKPw7f14+XNVHS+vDJWD5MWQEIgIwZnlc9eWcSJqgbBfQQJ6XzHBzc3V8+fP5/M5ETx9+rRt28zjr732+v1HDyU5M+M+INwhIpEDI0SMTjiBmTH3R3pEwPoIMvAMjokIHCMzsiMy9SEf5hY0QBu3p8wsEaP33hEDucp5GlxozDyb1U0dUC2l2LbbGLuT07lzBKDOVYNHmjNrMDPVtWNyjtq2VVQzCVUI7p5HntXzs5Pzxy+9/Pd/65t/5+/96lbil7/0xUenp/eqGmMkFEnCiN5bPnyeNIs+I0QwVe1A8aSpNzdr6NYQXIddQPkDX/vh//df/AvPn15cX19fXF2/9+4HT54/f/rh02/8xm9dPH3KQJfACqqA1Ul1fn6eUuq6aGbEXM1mses0X/lqeeFpgOZyhuRej+zswrt586jRX1LsC+rgw14ynogQCA1BEQiAAQFUElSOLYmJAOe03gzZDZOjJo/lnzpuSYyMM478YF5lfSnS+PdC+5YZHe3uYFQvKlrtwPTPA2AANCVCQFMzUWtTnJ/fh8WsAwVVBFAyGVDpYPBu5dSSvRdINWfSoPG6JLPMDL0mVkWDummapqmqyswy32ZmUFUDIUaAne++9NdOhSYCDHHq2+22rutCN+7uPmLAMX3f7tseBNQfKDJS1ZR0025vbm5UwDvqkiCnqqpEpL+Adl9Wjsg79qZM8XjrFHZtGtmxJI6HYvoFGeBQ+u/T2ADeY8cS7mjkcL6HemJk1JENjn5etjBh79K4+VilXo5hbCQr4PHukY9X53d2VMLBBsVb9ljU3DsCvntPmm8NOSxHZVYZZXrbJ5NRDb+YmmGOdCpsVlWgfsAAQxBKtpjrakYuRAEgIGLCAEBmEbkjNgRnyjWDc44BmdE77rotIodmBtqpViLN1dVV27avv/7G48ePRfJWKwzWT0oiAMQOvXecLPXxksiMqpgQmDiRMZJnch6CQ++ZGFElJwf2TACEZFk6j3lnnXOzukIKYpmS+/fM2DRNCM5UnOPtetPF7Xq9NpPZrAYAHxxYBqAxO2Zuu62KInIIQRG896lr2WDx8FFVNWqwODu79+jhr//mN7735ncDWPXGp0/Oz3C15ZSa1AIzzGpoZuA5IAAh5LRfIVRpC2bw/KqpZ9DeAHT1jCD5z33y8edefwxJbLlG53Xbpgg3N6v/9C//lQ8+fLoRebpcRoTltn3zu29/8NFHbbtlx2Imqst2Q0SOyCx7E4AHi4pskNTDnSojrZbUUuyoghXxqhNeLnnwRXQw7LPk8I4Q8+2YWeQaEZHBLFSklnMZJUNvrEmsj+LGcufVjl0OsRv/gaTNSelxn0/v5vHDCneYv8Wvv4uFzfj5pOWALJiP/CQTVdIO7bWXH3FTiQnlFaMqOgJEBXN588YMRgU8psTCIb+P2zvIJQAQQlgsFjnBpIjE2I15ngEABycZWaF393E5UkDv5QZrY0dM2+12jJ0bz2KOn1C/QNghLG9OA4zKz0Ssjd3V5TURkSdRBQMREzHngsm21A0jeib3Iheq6wjcj1pzxc9ke8Hsu0+OLgrHCodLqLL+LfbveGEOwD5B3MF+h50W9kT5bfnVXZqv1L5HLYyP1b6wTxjlm3zl5aEBUc50WBvimL79KDzhgGcOFXj2OUPhKTmoooB4R5DUpMdDWEGB3+knQ3CfWWHQKO7ufUQAADJgAAGIMcYoXdclZeccuoZEyTEAIHgzzAYbkiAykCeMZqJEgYMa3Nys1ttN8JUops1mPj9rmvnZ2b1PfepTTD7GGIfc6X3XpgjK7IiAuT84k/3JIqAmhLk2ODZHyI7YgSNzVQDQ4Jzz/dk/7312UeZ5M3Nd16bcdqISU9upRJO8YaRqAmYhcGw5VA5ARaJZ1XZb59k5BwjM/XZyHaq2bc3MN40omIFbnIAabDtf1y+/+oq7qKrTxexk8fZb37t58uS5c9WHTy6/99b66QU8edfM0PnQ1L4K7H2oK++5qioOHhGb+UwU0Dk1m80WN5V6YlCr2Klq8HXbdcDO++pB1fyJH//9T5Y3337ywRXK1tEG5Pqd3/cLv/iLz2+ufue7b7774fMHjx+YSYqCngAAGMkILV/ibACGKACAtuOOUgEj9hvFt1H75M1t8uEoKRZdFBJbzTwiEaCBKBo4JAUI5CCp5WWQqHOuuNUnB+RiWaZd3yK1DocxKfvSph/nqOBLru8ntZ9rtgDLNJPd3aU8wloihfKNvcygyNluqP3py4+4DtpusU9IoGxgiIbmRDQnl8kNjfFWlpO0cW/sF9u01ycni9PT0xz/LCKI/eEzAMBeFAJAYbgdYrHAQX5Q1WxrP31+Uc/mTdOYRiJGTNlMztPTnBNkmPagnkdRBV3XrTbbzXrrnJOeihiHqxe897C7FzOPYg9nh8QB+zQxGfYRlbn7mwAywU41SlluY5vDaG3bj7/Y/zwfz5nmbT46i5JoxvmOGm5fMUyJtfyk/HMyi0NbodSdR+dbVEA1s8HmzVGUm80mh8XCcBx5zFTVG1+a3ej5oiY4HNIEMpNBqtrOBC8+nwCthB6gmAECH1bOZXJA4hA+JUx2kCysn/78/ZhmtuvqyqkKM4qIATTB3yw37TZtt6mZ195XjEG7iJRvBKzMMEUwMPYOwYuAd8M1Pkxt23YpqiEQq+Bicdq27Xx+8vjlV12YiQi5CgUwxy6bAhl7YofeIZERYgh+HB4GpvmC87YTGgAwYx3yhXQphBA85wwq+ZPK+ZyKi4hAgcAIDT1FEecZUBkNUKvai4iphOBEpMoNJqHKqySJ1G035itEJEDnHBMCoQtsZqCC2UtqBExQM8RESWfzE64CMc4cdc+fd88u//63fu28U726CesrIgKjJM+3amjAjERUeSYiX1fsnBiAY/LBzMQRIrr++nPF4FzwSqyAzXz26mc+88l7p87Lr7775k1MEPjx/Uf/3T/204Lw9d/6rW+9+b3/9K/83PnD01A5SYqIsU2g6l2FO7MSEFFMzSz7F/OpvEwbw1l2D7tz7UfEVylGyiUNFOeDx2ojWZY5K0bJg4QxxpwVAA2cd13XOYZ5Vadtm/mHmJxzdRVms1nBQTZ6iHvtVdoNsrfwG9mkjwUr7ikYJ1Iy3fCmdwWMnpWjYgcKaVb+VOqmnfFQxKONSVcy5CfV+r6Seu87FQKtnH/v+bMv/6EfnZ2ftilmR2KURAQgZkiC6gBgu92GELLNCIPII6Ku65i8d06Hg//L5fL09GQ+n4cQMkTyrYImfQJu2xluuxlORNgEfJNqzNy27Xw+J+/IwDmXV95jI2yTADXKcWSEbivtcr3pr4CWBNb76kZ6UlXal5WD/aiHqDrUxLfJ9MOaMNLWx12XhLdYdoctj5ryjsYA4A41fHScR8uoAyZKYiTZkvgm2q7kH9hHNBT8PPlXRMYwuv1x0mazyWfecD+WxMxAhy2gMVq499XtBa2UD+Mg+z9HY3F/hV12dIj33RvMh5OPKNoJtMs6E1Yva8aYhiz//fH6PBJiqus6dtE5R0SiyTF47wlDTLpZt/MTns9PLq7bpmlUlZ0LHIicBAIMzAboVdjzNncaYzJTlw/jthtml5I1zfz09NS72hQQnJoQGaIRoRk4RwjknAuBRrz3QRio+V61RdUQkQ+MiCl1ZuYcMQcmzCYUIjqCIVgEYoyxjZmoz8/PYydExM537SqlrUNwZDmkwyQKQBOafCFSpoeUutUqet9VVTUCmSinsjBVTQgA4AwICciACYPj5Be1d55rU6srQP87X/+t0NkMXPPwtZxXC4EY0bMLIeQDwVA5qCtwDD6AY3AOmHqCyxWYwBEwggI4BzFCK3px/WA++8T5/fXFB1GBHRDQvbPTL3zuMw8e3PvMZz797/0//oPnT69f+8TLMYqRAvaBS8w+gXkyVUECRx4GN2RVVaWuYsY+W2sf0XaEDif6ZuTcCeVP6Lz8tSdaA0TUMW++GZgF5oqcRxF2CQXNpIuhqdk5tbTPDsWpyHIAQx06SD932/PIREflZ38Gp5jCHWJ2zHs40UaTr0rVcFtrKKoMhkBEmmRxdhJO5sqImrICFgBQc2AKIISu67qqqjJeEXE+ny+Xy3y01zlnpiLRORdji2rnJ4vF2UleqgIYY39bXjrwiw6rQTt0rOfRl2HupVBzzq3X67OzMyKyJDlX7WhxjIuEEii5qW3XbjYbEUEgRUCcBs2qJpFIfOSY9m2aadJXWaaNDPuC5e1/ow7O7ugJTZdKohznhP5uM+LGnw7otdyhzNuIY53+JRyw5SEopjCxPR1Wdj2pXJqQdyihiUY0szEtaBmERUQ5Kf9g1fYg6jNY9fo2p4EeFSpAv6jFHF6MiHmNS4RjzHHvnhncq7AP8zG4D4sCR/ECAkZHpdhoMRzirmwfCnTkrk1Ri+s+EbEPna0qM0sphRCSgHO0Wm43m6hqMYqZNU2jgN7n25TZsQdE6xN6O/QOQbK/Kp9lmM1mjoAZU+QY3WzWnJ+eO+dU861R7BgA8n4KkmRxD/kIQL6qKN9tAUDEQETeATMG74ihQ46xQ0DCfHu3EaEr9vLz1nXOY0VEdV0BtECoCsGhafQOZ3VVV5zaTpWapmJkonx/AuRs7Zm5ttttSimlKoTgnOtDxUGQggII5aQhDGzZ182MlXdBUl3Vb333ncsnz05do9GeWmoUa8gXB3BNXjlERmCq64rqAI5hVkOowHmoA+RU0maAAExA0F9UbwD1AtZrSqlSeqU+vcTLznDpsUvx5ubq/vni/fff/eEf+qGX/uV/+W/8V//1z/31v0UEL7/8yrZL6+3Gh3obW3K8XW+qKqctaxExeKfKkhLRbovLzBA1ryLKxMsjx9m+NXyUII+WifaFQab3NGygAGZaVxWbSkyIOZabsrvRe9/FvZUoAIw59idqrK8zSA8isnGxcexsRSktx3fl4HtV8QLadzJlK8dTdnewIQgHNUMIQgoWEamN3fnLj5uTedtumDnf7m69VuzD2RwCr1dbZm7bGEJYr7aPHr4UKvftb39bVYPzANB1nSc+OT+ZzWah8v2dvoNPGPZu/526745KYTiQxbvJkOu6brPZjFZe7zNRmWArF2ZKKW3buN1uU1JyzmzcGAYYwkTHZ8W9HgdouhffA9ipT+DBU3qr/Zi7MD1+aHgEwgQUWCz1Drs+MpJbl2h0WGdQyQQgh12XK2wscpZP4hhHmi41x/i+5PmJLBjxAvu8cVv0tZqJaoySUkop5esBc+IFzP7nYx6zQ8YeNzLHzZtjDHzXaqD3CA6GIJQ2BBrartmj3H5oXZUMsjM4OK+/cyMkYjmyV7U3Rr2rEM1MPMP52VlK+uSj51c3q5Oz16qqikkQgRicA+cwMBB7A1UVQyYM3pmZiRgaMNJmsxHmqqqYIIQwn8/qplIxRHPOMZtC5jtEBGNCRO/IMSIaABLkHeJe9BMRo4JqTMrGiBqCA1S15NghGQNkNZwnKyKqJiJtG4kBTSrnqoq6mDS1oB2gIQmZmgkB1qHyHHRIi911nQ/syBmIar6+SVXVV67HshojG5mCKapDov7+b1BVAVucnl0+f+ut9947uXf/wzffac4fbCSiVqCKIKjaIVZMDMjMrRBGQXAcEUgdm1MQAoeEwABgjoRJGJkZuhQAoPa6arvL67O5f61ePF1dX9VxNmvW7RZBX3np0Qfvfv8zb/zAyU//4a/84Bf/9t/+xV//+jcWp4uH52c3m3XlsY2x4j5VQ55yjBH65Z0AEJjpPrFNgmbysw7Z1KGQMIfEfwcLjD8RIBIKWE7RSKYmOp83KKpdzBsJSAySvPeGRzgasj1ng/OgfI8oYGXYUK5jhGi3iDjcezk+939+vJkxvQCwtFF2DH7QRTnmUsQlFUMFNSXbWHzp/vnsZLGG2B80YcrBHWC96e9ywPPDhw/Pzs6ePn368OFDRLy4uMh9Z2dIXdfnJ6dN06SUVJOqDGIaywXW5N+7jawx1+jEKDMzNVyvt1VV5agK55zmq5OgPyMIBQLUbL3ZbLcdIpJzImqmzCxSWgO91BMRz3TbkOBO4turpphZ7jZhfdjm5P1IQ6Xhkn8qHybAxP2MMHd0PTGGJvba0GnevYPy5on9h8I2tD1MlTQ3aXlUeEcHedQaG4Yx0MDOcDc0E5H1ZgMAzjnE3UnH3Fke29AIFibsXhclO+2hYz8oGocEbeMeUo4hGMxfsyGVaWlJAIDtn3ovUJBt0/GgV/9veQtICZLRq5439kREwDz1m2FDMMRZ6qIIPHhw/63vv/f88uqb3/r2H/xDf6zrOkQKVZjNAzMzee8bIgV0ZkLkmRqRm9gJgVBANJPYqvdMII68d3XlEfucVpo6ov5EHyJyTqlB5D2HfPefiVl/KaRDYgbnCBFU1USTtMzs64qIU0reczYtBlxA7gegT85x7/RMNTnvAGCTWiQ9v3cmIsGx8xz8PIdkAkC+oxBRJUbPtfOUd2qj5FteOiDrt5ZNASIQGogZKwMroAqqmeq23XIIGkJiqu7f3z65uEYy6NS6pIyWEJkEOCqYU7G4WfoquLqyzYaC16pOzLFxwCEgow9QeeYqESljWDQgAg4ocVo+r/38fvCyxg8Iu3ZTB59ieunB/cunz5aXFy8/fHjv5PTzP/DGr//6l37hF3/5N7/zPQN48PD83r2Ttm37BQ8iGBmSgA3EDJkBSiN4jGDFodj+dYQTc3xkipJoD6sd4eKcsBpQVRezuSOWQUQgIjB578tUlKUQu83HWzLs5M/JeCbj3I1qMpGipYO+pgvfnXw4ZhwjoulUJR/222kEZs8cRTRwOJkxoweOIoKgKAYGINrH1ZlDZBG7f/++c+7evXuqenFx8e6774WKicjUmqa5f/9+YJddwSL9gZBMFkMIxpElOQGq7RJZjCIVCh1wOJls3nZdBwDe+1xNkiEiSL/vkK/gyG60zbbLVmHOyJwbFN1B3kwGIJqqIFSI/X1U4xhGSV7iu0TMHtYHoQPHytFJmRnktOIHODskr/xmslKcfFg+j/9OKKxvLV+FsSP5nTOgaCrbKP3dVkWn00UbHDBqSf0ldd5mH5Q7+oeKKr+X3iGNZiaW2rZ9/vx5G7umqvPlWn37uZbqcC8wAgx50IZNJkJSG5J1W39XRzlUy8ftinVD/jNvMebbL8r6uAsJ3mNFYhhV6hiXlNE7YvkQfRNwIeZUkYaI+ZZ44N7cQCQRqes6MwgRVRUuFotZ1TDTn/kzf+aNN944OTtLwgpyctIAAJFz+XrjnFmLPSEzBHQxmpkIIgbnoRIRMOOsfVNKBCIqURIzo/MAQGiI5gio3+UkdghiqgpoaIagBH3uD0eokLMIGEOoQlDHfQCLKCAhIRowOwD4vb/3927Xm5TSw3v3Ea2qPDNfry436yWhKCRHOKsrVWAkx0TIxOAcg1rKOZYlAlDTNDnlsg2XrWVq9yBArKoKioCIxAaAmFQR6GqzOX386BNf/OLXf/ZvdIRgct4nvM804RKYAyEV02QpcV1XwN57p4omQFY7hu0GlMA2UNdwD9xiJmjJkgMA72A+q65Dt7qpUR/V9W/GNG+aqCKpa5rm9ddffffd92bzmgjrwH/wx37ksz/wxne+853f+tbv/MbXv/H06WVz7ySE4GufVLquQ0CHzsyi5uvMAXWaLOhQZB1y6yEFHpYJrdouwHa/msGsadCADJIlA1CwWVU1TRPpeOOIqCZ47Oo/xN0lCjAE7gDkGw73dK2ZKQIX4zmc+O1Z+o9E0ux08G0rXTguA8tOqfYkFkU6jaePH87vnYGopAgehPKaHgDAENQMzFze63327OLhw4cicnFx8ezZs6ap81Gi8/Pzs7MzMkgSiXFi0RRDF0S3G9BO6BzRvoeDLkEA0B8niFECu+xvHFsYxbyZxhjbtt22kdmTR0mmpgCITChjs+N9PkDQny8BAOz3L16o7OlU2wUnj0Rpw2oSoF8nlaqxmOBd1mVZ2e64Q3sIrh4HdgjAssEhSKlYE9Oui33FD6qWUgc77OxANN6AZEVE4mQKhwEUx6ewP9qhqV1figBG+dpX9lzXddd1KSU3dykNzmei0dk9JA4iAGDyh1BFxPGYWWmvAID3NC6txlkMKplxvwAAueMevEzc5cSz7EipD+8sf7JhrxdzYP/wa15fDnbtxsw4eO+9akqp88xXV1cAcHV58+FH73/2s581EzD68le/8iM/8iMPHjyIYuzwwf0HSKlpKsaAwGrJLAIAogfzyhbZtUigZqzqnIEnMHaAaKBCkIwsE7LPl/4SMTNxPglljtgzMpH1fkREyycgANTIIREyOCY0BGIMITDnsK+YqY6zC5KRge7fvw/npqrterVer2dNM5s3zXUwSMzYthFQmbndrDpD5xxYp5acYzShbGIw9+FdJpI9ZAkE0fodFiIGU4uS0NjYkSEgSkrIJIorkUeffuPs9dd/7be/Y/PTE7MYBUlcxYgoZqrqSYNzyYTBlMlVFToHroK6hjlDZ5AANp0st1zVsHAIYESqQm2ChL6epydrZqwUz2bNto3eO6v8ZrtanC3sfeikRQUfnMn2wel8/sXP/+CnPvkHf98Pv/3227/07e8/e/ZstVo1TTOrGwVLKeUFCQ7eGkPLdjYcOGZKeivJfqw80SKHmru0EUcZrmBmgAYMaAZ1XesmDR2RmVVVVVVVZ+k2CWA2zSIJd4qLcTzjQ57x5BMr4rmgUMD71XYJ/MuyG8zBknrizzuU3mNJYJQSqiXUlz/1+smDM0T0SC2aEgAAqRmAIOQ04/1tSO+8887l5WVVVdvterFYrNdrE3n8+PHZySkAmCTchUGBSMxeIxx81GVEFfbycMDW/jjHoY+OxEOjjIi6lLquq6r+guHdbNHyBn72nHdd55xXNVVjdqoaRQDA+9Cr7SFyC8Bwoq6KgQ17Kofj1L0/C+07vhxD7cZPj0rnF7Q0dyReHGIpPy8CE/bW0+O9zqVqRERCNwEyEUFxz2DZvg43cIwNj09cKNcSjHlrCgbEHeWokv9F03gJWTmqIt4CkTDnWjKzrHE3m8319XVwvm23OUjYrA97M+tzvauCmXVyJNUoHDDwWETioQJm5hh3rryyBbE0GbkNK3tJVmIhn+gzw7x7nT1G5Tn7IWxVcoBV7quqvKoC9EfvTs7P5vO5SPzwww/X6+XpYtF1nff+ZH567/yBiHzxB7/4+c//4Hy2wLxoZt+225PTivMSHhEVDfqjuaZ5m0acc03TOOeYIEay2ofgYrvqOgFgSck0IZGBMFf5Ol7HObMeVJ699yZiLGaEQ7AYoxFB1KSDcAAEMwFQ5oCIKSUzUQWRPkpDVVPqunYTQkhti4iXlxer1fKt77/1/vvvM/Nytb64eLbeLFMSRE5tJ0bE0HWdSfSeM9yqqkpJUkqa00SAgSAAG0gXE0MQ0qgRknMBBAjzaYvUGUKn2qp96ff98NPvvfPeb3/nldqJilF2DpIBJsCE1CEmgFW3TZt15x2pOtVFFZYKtWPn/n+U/XnQbEl2H4adczLz3ltV37681++97vd6ep2tMTM9AAhgBstgIUFKIglSAiASoMQwF1FeRNqhoGxG2PqHfzpM0iFbdthhB2WLIsV9B0hRAAhoCBAzwKzAzPQMeu9++7dV1b03M8/xHyczK6u+7w3pGx2v66u6S97Mk2c/v+PEy/l84QY/8bwAACIjOEELxkC75eDUCEjv7RRb6xigMTZCZObD44O79+/dunEzjB5ZCJk4TK3Zeur60dbs+KUP371//+7d+w8ePHj8+PFyuVTdxUYSwiQUEfiqBoU16daCFitnTynn25C1deV9vfHpKhnZWhOjt5qUZ42EFHIe/WgvbcMrOWHN60SkDnilp1fJjP82AhtzcArXzKQnHmvbvNgqG00gYHPXXz4Cx46obewCYHawB4biGJzBESu7HlITZWTFOwNoW+fHPoa+bVvmKByefeZ2N2kBQCWZHga13ZLJ/r/an5zEs85fWlPmVQk5rDyriBiEjTF+HDXb0HuvVVwkpJtzuZwbg9ZaY4nQAIYQOTI6ZyLjxXy56EdrNStS1C4jgFblgYTGADOTIaE11Y8lIqD+VwYfo6esLSGiyifhkEyzFbtcWSpFGF9yyqSF5IxJAgAsTEiXAxKICJElSR2VXibBpa6ymWJKsFRdLAt4wVVWBSIykjJ9JkwtGtNTogpHA6lgWidcb63PSfSEgs7peuUBpFbQpYG29uktSTTK7Fa/rqctlNQPZhZCIvIhGCCkTb1tbRigsNMRCRDA4oSRY4yf//WvQFa8VJjt7+/v7u4CwPn5+b17984vlvBkMJsNx1L5c8Ne4PVL0pdSfSNrv0pyDGhezxW+K1VnDCWaK+7uollqWRFkM30xPyVSxEciogfvv3c3RgBummbiGmdsM3Wz2fbWbMd7/5GPvPKh7/j43uHRdGvPWjuOy8ZBY5sOqQVjjSGDzEaCrs4QYxyFu46MgWEIxoBzLo4g0vTDomm66MPgewBo2yY5ul1wDo2JavsSESEbZHQoorkgCtUFIhAkkmUi8r43xjjrQCJH70c2xuhnjh4RQwwShEP0fiCivl8YY+aLReea0Yflol+czR8+fIiIGPgDT98+Pj4+vThXpI6maWIcW2cuLpYxemvM+dlZ2zbqIOPUdkWbyWA0RuaLtm2ZpZcRBQcigyAiDVGcD865JeOZxf3v/thXxvnjB4+3ukmIXnreNVMAsMbGRU/OTdEaMeHRPAzouha7tu/vb5020DTgLDLvyjiePCSCrb196AWUgsMIEu12F+6/a2P83nfOHmxPX7N4vrPP6Cy0h3vte/cfP17OdydTs/TiuUUcyJ/359jAh+fjK3sOu+vj8f69hw8fjOPd4L/63vsLsfPBd81kcX7BHJYwYiuRYhNsLh/PibFCUIVFVL+E7N2dTPeXywtCNhZAIggBWmayzoYwsvKVGJxpxjEQ2aENzRidCLdm0RqcL2+ayc4AYwgLii3SxANZ4xsKjjpxIY6g8a3sSWYAFKAU80qKuyAmlxGy1ggLpHbjoE2xrDGwinsyBwmKV1Gn0RjdrpINcRZZgVIIAKBGJOEqs2f1vfr5RFILoo0Ez/Vkz5rvIeJexNHw+/7i+MVnp/tbPURvg3POMmxFjIJBQNAQIAGiIxtC6LoOAHRjaFXSs88+i7zCplgJ2ooBQZYi5TNcpRcksQeC2SbWq0gS+EauiNA8FzREGmxWDmWttcZpIQoANE0TQjg9PfM+KrTk5brYWr/bcORittLq2UcUFCrWmy5Afbt1OYEFpbaUHpVfoXbDgto0VEayMch0UJqTYnqmUMvKhU5ZxAIAmFxvI2tjxATcTcS4qh/FHFMkDX+iKYPJsVguYyk++TI5V0xX1lE2FOqNl9I/i2BGRAIEFgMrK7kutAVYYbmICNUVONYiAArEEFX0qmlojBn9cHZ+quj8TesOW2eM4bip7BfK3Bheea5cOtL3VbS3XEJrCsqKKiCHHuqdqdNaf5lXrEZRSPFRnW1ntgsNpFZuCETphtpEyLl2Op0eH19/+eWXt7a2ptNp13XOpfRgPZDUKYxEBAaYAzMSkVWYaLSIEmOUgKNAiGPXdWEc8lCFiFQz0NAAIlprnLECrHgXABCj5p2t3C0iwhKJSLM3SumU1haqgqiTMI5jytUK43K51BkIIYzGak/xj33sY9/61rcAoGmaBw8eWGvB0KNHj0Bs27bOudmkBQBj0CNCbkyOiMZa56JG0Ms0EhEjM/MwDDpORyalbRsTmE9PT4HwA889d/q1f97s42w6Hfs+tA0YiILQmqWEaWuD97OmOZV+C6EfBufckgLw0nJnJ620nSfyDTrDgRAIgNlg7BzKxMynXVxetAajDe10etbPp7SFw6KdNB++fefzX/tS99wHiDiid5bkIszExXkfGIDBIDJIO50c7u0v5/OLb3zz0dLPdve3t7cf3L3nnCFLghw8G04iShs7aiS7JlfJUBJpEQN3bUsmjMNiOp1ChCgQPABBN5tECTF6RuDIYz80DbJlA+CMDcYgIVrbQGPJDBJVz2YOBE6BIrQpdc0uyj6qOfC/8dA7bBo6TzD3Nz5vPGvjqkp4r10CcMWw68HAOtsvD/LRR6LlMMy2Jk3TDMgGDTNj6h+l57K2EIMYrLE4jEstN/Lez2azg4ODpmk4+FoA6/95vRZo4/GXX1hEhDBZ71n0lhMcGcUAYQ79sp9MJoQUY5xOpyqVZd1Ism3jfbg4XwzDAECaRXJ5jq6UDeWbIgDKQSBIq+oUQMYVWhYI5M6XmS+rby85xmWt9wgiGlv479VpwBtjQxREWElZZlSAP+HCoDGpLExEsNISrtDCVM7XM2Jg1XGvFifqACwaKCTFcVWzVLgq1iqIAc2NKu9VMqAuU0UtY3ScxV8NlaZSPmN2fNUvxcIGgQyhEAoRiDMpBxA4cvAcI4F0TYIpmHRNTRJlbFr2etlJnlPBV6JXD9skDOSiPOmSmMrxUB6hYEmYzdZCvVgJ6TIYEQHk0iimrK+e0GoHA4CC4KbbUJv8AEAz6SaT2a2bzzz//ItPPXWjaWdb06nLoezij6lj3kiggRIy0JAmeZEIETAYax2EQN77GHokcc6KaEe+9OaISATaKYElEqCGpdVBIhIRTaEQFXKleykiavy+73tr7TiO6jTu+17LRt988/Uvf/nLzrlbt25puslsNgOAtk1NC5bL5ePHj5um6WZT771wCCFYa8d+IZKSthBga2tL599YG2OZVUTEpmmiCJIw8zimmQ/OaVoDR2Dm0/PzcQgHBwdwdPzw0cMWYH8622o6huhBFmOPrVvEHhHO43K77R6fn+7v7SByjKExjTOAEAWgIRfjOCzObDtBayR4BBAeYz8YCZG5QeYxmtZM7MQZhCBxuTzcnR7tbT948P7u7r5rnfjYNE046XdsO/e9lyhEfYyRDFo3BP/m+4/NxG07C4QX84vdne04BkBsmoYXXjddCnVEMIYpJxWqUlWc1d77rmsJ4+nZOYdBHA2DFzYhctdNQYCE0ZAACEForSEzDEtL1jkHCMGIM3ZiHCQVzRIhIRhnt7amidozFULZ1xWLKCRas1C8KpflSgFc7n+ZzZbtrE8tN6Eqkn2lzNp4BDwhYnylbBYRtIaB9w8Pjq9f9zEM0auotVhKTvS2KCzCbJ2xYBJ7Ojo62traIkL1J4cQUjY/JB9sMTfrx9evUQu//Fktv82ImkJcIco49k3TtG07juP+/j4AAbAawSLIzISJepajPz8/Xy60IzeGXA5Yz93GnNbctnDStbUXXrN9L1EGVnfeuKGIIDKAQBJCQGhQp6jkAlyhWzEA1D5wSGL4ishoEZklRK0TWzwKkHdaUWwBAKKaTRpGreuJWQpgCCKiFMEPKKQ/8Zr0XR9DynqFgtcIpGgMiKiA+ADAOdaAWZYnAc9c0HopY51i1gak8o3XpBLyAjG7EpcqR3FxK2cJIZCsBOoGyWFWv6rl2wx91TMPAOo5rxfdXioZV+5Wi+oYvZp6iEhka6Uz6zlSLP4i3fUc64wxhjDlYKvvR6df33FvZ//6jVt37nzg5s1bCsk+nU67pmEARVdW49WkPqzRAIn6Y1AZMTILEBm0HiVZgyiE4kfbda0x4L1HEkCOHJ1rjMFiLNIKSpDKshKBNhYUEUWQrr3rfd+r3HXOLRYLTTIe+9RgA4AQzaNHJ8Pg9/b2Jk17+/ZtZj47uzDGhcAh8DiG8/P5cvTGmHEIalL3qOtOTdM4a5WDuaZpmkYkOw+YrW0EEbwn0rIMaRouxIOMMQ7GWUTT+xERD5575lt33zt7680XDq+1LDvTyQTdlNw4Bh/D9vY2Bx8v+sOdbV4soWmO2EMTIQQwDhoL1gP1YBtoe7AWggdhGHs7v9jiAJGgj9dnzXyU5Rad+ovp1lY/7xugZ28//YWvfLXZPVQMNjLWbs0u5vNROyMxL2McBZfjeLHsBSAKt207DIOoZTIE72PxlIiAgu/6MZYNqFqR7jIt8hzH0WD/znvv/tiP/cDuzuTN17/VNZPzswWQGXrf+zEwEMEweCLLnufzBQMbQ5OmRWTrgLxMuglLCCEYZECMAlakaZrAXkQE1kTdk47Ccyout3lOEdIbd9v4Rps31Jdc/lD/W/O3+syrRXKWoJcj7mkXG3p8evbCCx/d2ds9GZagSKXWQlzz1KohxVoHrIA4W1uzyWQiIkrKmeEGrQ8pPOhK0Xv5uPTmVGQwrFymWuxv5vP5dDp98cUXvfd9P969e1ckTieTcRwRcTqdRu97P56eno7jiMaAOu6sDSEQriqI6uxcIkCUHNRLFjwRaH0wZdTGYrhUXv4rvOi1TCrWEkmWooAIyYqO6y5Q1Z8q/zMWEP964XXAtTAoBoS1lCcQiAiFuHI/l8EUnpIXGEgbrGq7kix4mKPaCVKl9ulp6XJcLdzGrqgXFFe+hHwOAggIpxsYJACI6+738rmI0jL++lf9yeiE0trMl9y0Issx54Jaa6Vx7BkuESrkkrZqXdI5dT26VIezLs1MBhPQACgBiph6rxKhITSGkCDdA4EwBS8AIWd1iOL/MAsIWGdEqKxCGbAlJSQEQQC0ZKjRiWmZeTrdun79+rPPPnt0dNw0zaSbta1TdytVMh6AraUYhRmRJEethAiQ2BqVT8aN2knFM0fmiCjWEpLVxAXnDCJaJGutPgIJtDk3V2gk+c+o0bioLlC0HGHpB/VDav6ztfbi4mIclsYYbbBBRDHG4+NjY8zFxcVisbg4PRORra2tYRhUbBtjlsslALTTCQCAUAihbVtMRUdJqEy6zjnXtG3XdW3rm6ZRwgDiafa+FDAcYwxz0JcKnjkKEI4+EpE/PmjvPPPul7968s1vvf76m4ftZKvrms4Z5wD5dDKZts04LOddN51OmtZOPRtjmq4DY6B1YCwAwHQKMcJkmur7QgA/ABEEDzw1/XB2eiEv79v9yfkYxhYX47Kx7njv4OH7927demY+Xw4QwcGFBCMIgnHwDy/mQHaJ+PDiomnBE+3v79977x4ieu+NMWJoGAaMIAK64erNhSmlMa2FTqn3oTk0xsBHPvzSzrSbOoLIy+VAtp1fLBf9cjksGGG5XHIkS4uxH4JA27lu0gByRGATZtMpRIYYqDFACDHFQTxHIOHAULHUQjUbm7EwYf39ail4ydITUQflplsY1mVTrUBfKWWvlLX1wZeSRWC9v19OQoeI4IFnuzueIxAZ50ShbNJzUy6UZioTohVha5u9vd3JZFIonkPI0iuDHlSW++Wjfp/yhuWqJ70Us1hrl8vlbDb74Ac/eHh4eHFx8eu//vlhGJqm8WMcfa8xv3EcF4sFABhy6ksTkRAV1GYtEAuV17SMZ004cUJw0e+KIFlJFFzJmPrydHOFKKpy6MuF+YnJQKzl08Ygy4WISIBcA06lyynrEJtajqIulkmuBVJ5aAmmiohi39dR4Y33Qo3+qi8aasCZtfXdIADM7tZLw1O0tZIypu51jXESAao1B0gYA+VMeCpBUN2cqtGkiV05GABRkGKMrMlo+dWSDyAGETG02mz1PGuSQcnkB0hy0dkGqh1Y5lMQStuAkolmjJHIUtUppBlG7YIqiBlbWhvRGxOv2tsiAsCYsgFTcEhymIYIjDE6hzrtZI1qydeuXTs6una0fzSdzgw59TwXzQElipBumTJ7CKAiWc1fQjGGjCERocYyE6Iwuxi9MSayFyBrLaJ0rlEtJ1mTMURMIXMGMDkNU13KnLsiarkqAGhsPn0Zgs7e4mLe9/0G2TBz0zRqkMXRP3jwgIgWi4WyI8n55BGEiPwYjTHOOYPSNI1G01UIOefacRyGoW3Htm0TQzetJrprLjcg65nOuXEctZYFEW3TCaHn+Mi66XPPHRt3/vrbD87OTvoBF3MOIwoQx9ZYI7w9myEwM9+9/37equSce+rGjRu3nzbOoXVgiKyNPvi+Bz92REZ4fn6x9WD4tYfvffef/lk72e+DB2sbsRhH7/3+8bV37/3W1nJprGWOw7znxgyLEZgvlv398wvXdgPi3QcPyLqunbimuVheWEvjOBpHZIjQhjjWqmqRPWUJoGLOk0nX9wuOcHSw/+Du28C+a9vowzAsgX3bmMg2CotrRgRlL8TYNE1jXYQo7Id+aI9szKxYibGZtDXTyDsaoRJUVx5YsVolEJE1hoSV6rwhNZ8kaxBRsg8Z0/684niynFp7dBmAqdzS5aUQsedwfOOpdmvaD4OZtYP3iAgYSUBNWU5wAbr7we7s7Ozt7SV3hDHWWh8GwlVSu+6Bcmy8dq1xXJaFAKD26aZDQSICdF336NGjg4ODT37yk7u7u3fv3n377bcfP368vb1NRMuhB5YRRt2H3vtJN2PmwNFao6UdugM3pmklStc9G3n8azHXIn3TQSl9biW2BRR0LU19NdflQ226aY0jZAM0jSGLzDKWPC6BnJymNZVaQY24AphLYk+ThGGVaJsXhAGk2PqS2H8SP8y8YXDX2kZKRUbQeDJU+kqtgkAl6VfzlK3qEt1XQiy/gkCJcZZZKhMrsspwghzdQBBeR8mIMZJhnUx1JOgoSUiEjSEAieyJyJosrtarkOq71YSxmtg8zeWE+tq8rNn9gCAG8ySvyF5lmz6t1lEQsXVNflYswYJae8sTmpimIbBkDBkiEkAdjrW2nXTHx8c3b96cTrfUB9s2LRG1raIfEzNo9nsUQazrudUtxAAogmTB2OS4KQVdiCgxGhTg0PtAAiCiyI7GGB/GEvwudVaK5uhj8N5HSTll2lFjGLyIeD9oAYUKYCKyZEpFVln0yB4RZ7NZqjQzdhzH+/fvq26h5hoAjOMoC3TOBc+IGMZeRLquY1Y/Nsxms6Ksj2PQZCtmtk0XQqfGrjZs0Lyw6dZMX9y5lpB2dnbu339wcXGxFOrJnk8mXz4/McMIPFpDwmwBJcTj6dQv+8evv9401jjzqR/8wZs/+CPPPvvsCy+80G5PYTqF6QSGAawDQxACCEAIMA7gYzw7PXn4aPLNd1+etv7WtW9cPJ4hXpyczWwzXw5RgMldu33nm2+8dePadfReIvjFeDF4CHEeoneWmi4In1zMwTrbuPl8vlgsuukEBaKEGAJUATUNAOuREyAsc0qCExEtRTt79PiTr36UQE7PTizhcn5OQAaFowcE4AjCkUPkpGyxsNP0LoYw+sV8rn6/GGOMQGgQ1P+8WmipuOXlQ0QQCzcT3auXxaGyxvo+NZuC9Uv4Epcu5wsSyqb3uGYFNX+AJ4xcOcrlQSLi2bB86cUPdFuzniIIa3TMkhvHkYiRCFcFuoiI9vj4OMQxxFFARu8dGQMYOdbaU1mzWsquz+Bmm5rCXyA7zSuNJhXevPfee7dv3/6u7/rk9vbu6enpe++99xu/8ds3bh6quEVEMql0xxCZ1oUQGET3rbIegMsO402hu8FwUzXjhtzVS5DrNuwGECF5IDdmQ8+vpRQiAotilcFGuBEFqWhem7HVeiIREDk1Flib6hysBQCOa29UBBjlpo2QpUIJTJZpKSFzJAABSjJy5aC+kqRgJcsrgVFJtXImlfkgUpu0TFT5ULwFyGvPMoQZALnyRcegmhIpfhIgQEJQKin0IQRrbHl9Mmv+4bXhVXpSeVO6VI++IYPLVG/cs9CD3rZpmnJVzA09MSfrIaImVRGtLizTWM+/IdU2WASJyDjrnGvbdnd3d3d3dzKZaf2uiDRN07YTSsUukDUwAWbdQcYYS9opICodCiAJWtT2gkBkY4xB40NRK3QLvB2pxkAIwXuF6ylTkR0qwXs/Bl+M4BCCMU7lrvex70cRidEzMwGyc8qni2gPIYy+F5HFYoGIXdephylt/5wokFKmCfu+j2N0zhWEgBiZiBFxPp9rWYRzTl9ET2gFRUQDELouercQQtO1bTsBAO89GaugtkuPCGYJ5rfffe9wZyd4v1wu2Ydp20GIv/mt39nu2t/z+378h37sRz766nc89dwH5gc3Ly7O3pnPHz16dPbeO/P5PMZ4eO24H4aLi4vpZHKwu3ewt3/t2vH09u1DY+F7llND0LbTk9PQ+5N337n3+utLfx7HcTTQtrPpZOedd+5ut62fn2OMS+YY2BtyO7tkXOj7k/NlcDR1TruEoXWISZ8tAhgROa5oTJmW5B5fLi9EjJEFbt95uu97ACADbevCKN4vGkuL0TOz9h8Ucc45BZtMNeHa4zWCMwYDIwkjCILJnBmznl1v8w05V2+rFZu9yhiVZJusabeQARC//YHF5aWfNaiaIfPK/de58b/50BdMsNiFmVua7e0004nnfgjBOKuYnZz7ahOqsZH2vo1+wFx8KlRVHK2/bUkYqXl0/ZmqFK3aFNZtQJS+JJS+HyeTyenp449+9MPPP/9813Xz+fyLX/ziV7/6zZs392MV3N64P1mTLWlkZszmdRlqLRgAVtU4kF1klLMB60NEBKKAGLIqGFik3IyvGo/qNYhIICW1llEQBVCK6xJyftbGMl++YSbHivvnZGgAILMmEspGgsqy1FSdIsDqhybBkw1tRCLFY1lZeGtrWi8955a0vIIdTUVTiRh4RbhlMMKCAiuZpNDH2eiFGEBWrUWS9hD8msjkiIjGWhExxtauMx22ISOMhpxpnIhwZIRUnl7evb6hsvWcVAiFmFE7ylVuZahZQ8EcLUsWN3Ht19ncanKUwWnWC2Twc2NyeQYAgFibtCKVYcYYa0lEDFlmaJqmaScAcHh4OJ1O9/b2VPoiYucaADAGXWMEYvSivHIcg2Y5AUDTWiCjGWGrJLsU0F1F0HXAmmJNZEXGxJqZrbV+TKbkMAycC7tLBpn3YRg04yzJ4Pl8yVkDGMdRJyqEkUMsFc/MrFIQAFjiMAwa8RURXOXnpzkp9XV6gkETwigSnXPLhBBOml9NOdWobuwR5nPNmi5jVt/49vauCC4WvbPNYrH4+te//vDhQ+fc6UXcnU2HIYDYCGaIEtG0O9uvv/3OzWvXfvd/8B/86O/53R/92HdwS198+82/+w/+zr/85V//7Gc/+/o3X1fyUQX+r/yV/+O3vvWtb3zjGzdu3PjkJ1791X/1r156/qXWNU3TvPDCC7eff/GZ55+f7B9agOPj4xdffPG1r3zxX/3aZ9956+2Bw9O3bv/6G+8t7SLGES30Q2xdE9EMHJcxPDybDxyRcWd3V839aduIgGuafhyCj9qZWFO7y2wrDygLlwxTEVWqnnnmmcg+hHE2m549PgGxAKAAbs658+UcyIzLUR046AgRQwhRwtnJKQEAR4msedExxqbtJrNpLDE4TIW8ab9kGVf2fuJKa5tIHUUpgCfMSpA2FyBQTr3U7coZ4qIW6jWPLdwA6/QFxb6Vq/F2VgK+hPPWA6waANYUUUhprxhjPLh5/fDG9T70Htk4FzgSYNO2uislSyJDAAIxRltrH1AdNXOp2dnGOeWEWn1Yu5ZF23+qm+7i/GJ/f//k5NErH/7Iyy+/TM7O5/Mvfekr3/zmN69d21VaWU2H/iMgqOBnZQAJ+L6U3OC6Q698LmlZUGwgAzn2BllAAgDanLYll16hFjDlA6KgbEaglcJqP2c9UfUdrjyQ1vCE0wvnkqhMfIar3iZFXtZvnVEfknEMKJLdw5T68D1R3SsWYflG/6TKq68V9MmRCKa+VU0JxX+QrxKVvlIZf2n0HDduUo+QL9WjX35c+VfpRFgAFXQ4XWiMQb1PmToEuCqjEtYXeuOD5tRh/jI1RzIUNductPcfsLAgAa01PFcXtN5HK9qZIUZNRUxTEWMktMaYrmtns62mnVhrd3f39/f3Z9tbGtrUbriNsdZa7VXHzHEQjhzCGGMAYEuALFzwvTE5VLyPIbA+Li+TQUAEgxg0CBVjjDGM4+C9NyQxV9sPw2ASRDbku/lhGNRRXF5QWfw4jn3f67UcPCKqmZXXN0YOepr6pRNHXieMmgKVG6gTtWjVWSn09Y7QoFUKjphIAGr8cggxyXXq+zGEAIDzxcJa+9prr/36r3/+M5/5DI/RbG1Nm8YgkYD3cWt79/W33/l3fuIPfupTn3761u3ej3/jH/7Dv/rX/9pvfe01IOgifODOtU+8eGdnZ2cymXRdd+upp+7sbXe3nvpdH3y+bdtXPvIdi/fe/sKvfdYY85UvfeU3Xnvz+PrRD//u3/sTP/VTr7766s1rh267e+G7X927dfw//Itf+Ht/7x/MpvuvvPKJf/rz/+Tg+v7Fcjm1rQGaj+NiuSS083HoJpOzxXLazS7mZ0SgoNAQgoiQMguhGsIP1gyqVXCKiM7OztoWXn3147/5+V8dx3FsnG2bcRHQOB4HTpCTGGNEQ7GP5Z7MPPpRYrQZoUj1PzBUdGUAMER8SWrUA7t8lB3KnIS1FIcirFgx5M9ZCpfygkQ2V3I3ufxcMli1RalJ7srhrc4kBAADRpGIwhgFMTBfu3bEhJFAAHzw+jq5qEcrjxLpqi86FQ+sxr3OgGBdBj/puJKb61WtM94rfDwE7/f29u7de/+jH/rw888/H0LgcfzlX/7ld9+9f/Pm9X4YADbhs0XWovAVf085LMBQPABFSIgIgpqjOXEcktmE2fivb1gDRGwI3dohWf2krDzdrLZHCwv5t5yr8tCN08pylLMlV/hsDL6cqa7I4txIzihtD57D2JgQlLVdo2QFpoqMMgivEQNkR2t+/RQmh4paNt5iRTCXpqEIpNXECnPlw6lvhZXbnHKSZG2OlzNpBSZFKgOwShPT8Rebr1ZZNDVZTWBELLRU5v2SSI4bFjCiIbI5prPK8c7LR1XEXwRSPld5tZQcpGCWMZIFa23TdNPpbHtnr+u6rpvu7u7u7Oy0k05tay3bazs36yattcoXyQD7VYy2FCIjChGZXF4sObpE2nU4Jnk5DEMJ0KpYHYYRUYLv1RLK4BsRAAY/Nk0DqZNgEsBFvSgCWO+Joq24V0UQmheqI1R39BrN5GUtArVeaOYVo9X0bBGJEbuu012IqUY8+/85AnCMTbGhY4wcARE9x/l84b3f2dkRwZOTk69+9as3nnpmOXdE0E1sHwdx+ObDuzc/9MJ3/ugP3Xruhde+8dqf+7N/Fhhe+MAHfvxHfmQYljHOmXmxWDy6uNgCjgYne9uDxKObTzln2qY5Gy4enJ0sOZw8enBw66l/74MvhDG+9sXf/Mn/5r/57u/9rp/9j372B77/Ux/+8EtHt5/+d3/6J5/9yCv/+f/6P/8Pf+Lff+4DL37+C79+9NRxJIgMaNxiPA+hf/Dw8Rh5MpkAwMXFRSEkANCmfcJrKnuh9HpudQ4nk8np6fmP/Z4fMIbeevuNndnMe+/HUcj0fa+o+iwxMHvvXbMVQupIBoaEpe/7EGTmwCLlUgIxxri2SeSn5F9pALEqnoSkAQNeJVjShtkQTLL2FnlLrqzbWpA9oQHsGvPPw0hR4RVPuGRwVtt/PS2XUEIQRCBikKZrd4/2hjgEQDEozM45Z6zkmFRMzXG0TWxEBAtXsJg1/r4xlMvvAxW7vDz05XKpSf9+jG3b3r373vd813c/99xzzLxcLj/72c+enJ7duHFtvliIYF0r8qTH4ZOtlg3XazlKXMQYI1U1lChEVMVxC8FuzPilZaByTwUqlBxbrQX2k6bridPIULZKGQZWRGoAY4WJWt+NcnS5zEMaIQBQvb6ss7V+uQCUdUQREcWLW19TZiYCIrMmgVJswsG64AHdYJdISOfHUEp45tyob4MIgQyQQWMJoebdRabW754XEOsxSJU4VkQOrG+hDQ1Gx1zr2OXm62tVO0Jq6OwrVBCsjDkiYgbMHRULMEhhHMaYtmsnk0nbTra2tre3t7tuOp1OZ7MZ2ZTLZq1tWts0rm1b1xiNxVDOBjdIgiknI7/1iiYRUbR0HRHQsMQiOFXuqt9YD+8HRByHQaVpSilAg4aYeRl6FWZ+GEP0Ne9Tq1fvxiHWJTHMrNK32MorOtdZrXyJV+7lMvnFk4/WqE6mgWoiCxCBAImAeRh8jNEYBddLDtgYhJm7bjIu++U4LBeDRD4+PHrz9Tds027NWj/2ghBiFEP3zpe/71PfNVh56/Te//fv/k03mzz3zJ2pbfyiR+DBufnFcrZ3aBDtZBKJ3nx87r75+gdfenFvunUe/cWDR3Zv188mInJyvnj4+J0H7zyQpf99P/KDxtn/7D/5X/3wj37vT/3UT33qM5+58/zLt19+6TM//uOf++IXv/Ojr3zxC7/Zn8yJrDHufL4YOS764Xy+dLYliwiwnC80HmGMCVEQRdOsCimKCOR2XnmeVyyu67qzs/Pj48N33nqDQ2waywjaVV2QWACI2TMzB46dwYSunwGox9Ezg+ucMcargm5EK4wZFGBXgNfwk+sNoswBEuup3cWc9wPIuv8S1py1kn8qrql/g82K64k1tahiAbPe6ejKyzcpEAQF1IuFhsahv3X92tbujgdGZ4yhGNNDNQXdpyQVSnSuAXW914adV4/427/P5c/1iyFi2zrvvTXGNM3Z2ckPfOrTWvZ3fn7+K7/yK48ePd47PGRmaxvKTVivnIjLqkD9dKzM3zQ72UhSll2dkKWSDjCL3yu1nifs/1UhPwAIgUKO1ukGV87bhlx/0pRipYtdeRROd/nmtJ5cRkSSa50Li1yNfO0pIpcqkKQ6dFJL0UUlXdSi5XwCAIBcyvYvk2nNFeJz40zI6hQRQZWyWL8Xracj1GOG9dSqsr68Xr2aDy6qV4HVybtaTxa45JWp5kf1oQQhUqa3yBsNjEnO1cJ8oWb5csocRgAwxjRNM5lMtra2Jt10a2tne3t3Mpm0besyMrNWKOlBhMl7sD4zBld/6vhDCMxEBokIOBUFITIAMqb8t6ZpNCEZkmwbQwjAwiGy8DAMAGCN08UtFJUyqkIEUHBbLMIVWCSqjEwGrvfehwHUigIocr1eeszYnMWrtPp13dtR4sRK8p4j50aNxqx8/jYBehFAgiAWQEGIzGM/WGvjxcVicS4is9lsGIYv/dZXb926hYTDOHKMAWTLwQdu3nnq4Pjk7OKrX/jSjRs33r93d29n11Mcx9G1bnu61bkpGGIP2Jjo5fT+6fSVaWfb8+X49jvvPLx3goEmbnpw63Dn1kvPHN/Enn/1s7/2G7/5G9/36U++/NwLf+ev//d/46/9jT/5v/zPnnv5I5/+vu//Zw/OTk5Ovu93fc/f+ft/54P7ryAasq7rphfzIQr3ff/UU09ppMA5y8xROEYWQdB8Bg3YIWg0RHQ/otae5qQHgMBRELrGPXhwb2trJiJawuRHL+q4iRgUkFgABYIfCESAWERY202C8m1dlAgRDWkFNqoKyAK0yQxrFpd+qnivyFozoppXFO1hfQ+WnbhqonCZLdQE9gSufrXVu8GspLIoBESj61HYOjfOw8HRERv0gUmEpY7BV/fUXRlZRKAI4PoBl0n/yumAdRF1pWiEhA7Yee8fP374qe/53jt37gjw+++/90u/+C9jjIeHB0IUY7TWaZi6dufWNy98Od9YIahQIU83GOsGyy6BK9Q6I7X/Kl8xZizly2+9sSSYRXi5UICRAAQFAXMR6priVpuzlx6xmlJZaf1YmWsAIAICa8blxlNEUlFsHam9PNoNCKeNYUjusJ0kFiSPH2QXdG38rYyqdb0HUQSv0DEvL035qZ6W+sX1S/Ux1g99knaip5kq7qv6nGKkSORUAl5SNtQBJmnPb9wxTaMk39fqKSxIleqZNJNIhgRQtRgEgBL+KG6IvDqV7iI6sQp5gYht67qum0wmO9s7k8msm06m021FkCg57SlrEHMkqUyFglaSGDD1REn23OpKRZCCcCcizIE5BAmpwj3V6QmwRB9i9MLJnAUAYQhZfjvXapq0+nsBgIAAQYE4gAutJlTOGGOIow5YUt1E0GSCPOFlZdUs1gVd+68i58TiWduMqk4GZa+tXp8lcgaHEQkAqvQwMy8XF3qVqgKTtrVEF4vhnffuHu/uo2lDfzHb3okPTmkZbu8/dWPLv/L8B7/0pS/dfPppsLBgFke7QdoxOvRNO/E+OsB24B3bHraz/dkuzpfLpqN+wGWPUfZ297e3Dz7w3IvPP/38H/7pn/2dt976u3/7b3/9tdeOZvunj89++id+6v/xV/8/n/j4Jz/1qU/9rb/+3/7QZ77/6a987t779z/yI6/cvf/gnXfvIZoQWASn02kYeomBbFsIIAqX5j9Z3Szw8sV2TBqJiFxcXBgDB3u7F/MTBDYWz06WCIaIvO/JNFo/Jjl8E2MAAOcckdXcdUQo7hMCFhRjjG2avJEtc2RZkyZpJAjFn4xVnW7mk5kSUNvelByueu+vSYdEutXOFRFG2Ci1gHW2CRVLYQGUKwTfkzi25pogERoSkCjSNM327s7JOEbNG2Ox1goIIam2pJcrjJLGCqhUY9avUX/O31DCVlp3uG1M65VH2zTz+TyE8Yd/+Idv3rxJBt95551//I//B2Pp4OBA1zhEWS6XTdMFXnMn1ny5epCiJa9sPsolN9USrkmjejY11aqcU3bylVdVm30Tr6NMWn0OQNY2r1rFzTP1G4HSbad+6yvXBSryqqWXwk6V8dcjrGdg456bgxQGluIYLMuKWSjWM1OsiuJHBQAghIRH8cTEvXW6WjPd6s9lNaGCktZ/Sw5nPcJy/8IRlO+XP+t3qefn8suiZrHJ1dEpQJZLuKp5qqVUGdUTrlFeWh1aRBtUArWtm81mk8lkMplMp9Odvd3tnd2dvf12Mm2aZjqdNk1jTaM30WxetYPJACCr4CweXSKyVCGZiyhQM1EG7DJGEKJwXF3ExWkcgvZI0L6BQa1zhU8aB59BJSUEHsdR87k4w6CWEiM/qAfb6211rVOSMyKkyuCRU8+AtH/1wMqGromnpg3IrvgCval3yLAkq5XVz6UCW8eDLMgCkSVGAOi6zhm7WCym0+nW1tak2377nfd9hBt3buNsNiAEgK987evz+XLabv2hf+cPjsueWFrXQeQxxGEYfBz39/d2dna2dncOjo/0Xx/D6fnZ6P3J6SlZbDrnOjfGEE7Gf/H3/8Vf+Uv/l3/wD3/+6Onbf+4v/IV//z/8o7/++S+EED/9vZ/+hV/8xS/+9leneztb+7uvv//W7/53f/zLX/7ywf7hJz7xyU9/+tPXr19/9OjRZDIxiBcXF6oV6StrhEJj23mXrbb/hqzSmRnH8fr168vFBcfQNBYiK+jeGEPxzWiE3lob/QCRDQo5G0E0vU4FcFkvzKBpNXvZ+Hx5P218eXn7bHCMb3NcCSJ09Znrd8NLUnbjKCeoo1v/jZlvEFEI4fD4qOs6IFxRcvZ+rXo+UqLM8naWqqzXmi1WXInqbzY+f/tB6+6dTrtPfepTu1vbAPCtb33zl3/plw/3Z1pIrgg4AmKMGbw3xqAk9orrUfHLU7bBUgFWwcLC0OEJMgAgIqpWAZl61kRjObOWZPnDE5enunIzu6Bm1nLJhkO5Agpj7Zyk1lcmQ82VVkAfKxGr/yrmUS2oREQgZx0XaGjRO2OukIGMz5FmsngmNh5kyIhIFBaoYzlreJBrL8IxeYqIBFfGbj3JK3JnXva91vsys/ZdFxFnUiNYTS2DvFEBQJHMdRRE2RwVRiJhRkKkUnQkACLrOnLunYubS7+KXSFiWdyVY6Y6X0RWy1GKoQFE43P6CkWQUAWUv7W1dbB/OJ1Ot7d3vNeC11Z5HBloGqv5zwrkVOCvAQDBlAEohJap+jRjlXh4WSut6HMVl5VsN3NklZ2afh84lQsXT6MuVO4Bh6zdEkLKcI7R6ytruJpTchwoYhfzCgs23Somhn5525bxcy6JJKIIqe5LRAp3Y0bJIDAhBGEG8CDEzFqLFQLHGPu+nxlDxuzt7T1+/HjsB+fc/s7+g/uPv+a+tb+///RLzePTkw9ev/Z3fu6f2tn2/+xn//gf+SM/8/TNZ/7y//kv/doXf/13ffpTs92t/a1uMpldf+oGI4Uo1tqu65qDnTnCCOGcQ3u0G95taXe7Abr2zDM3mr1HuP35L3zxz/9v/gv48//FX/5//t9fuv2Bwxs3ljGejcFubw0k5753s/bn//nP/Zk/86f+0B/4g/fv3fvIx24+c/vZb37zd5RUjo+P33rrd6DUWAIAFiC81fJtHJTru/Iq0K1bt9rWnZ49mrY2hMFae3F+MY5BxDBzyU43hvwYAFn5jPd+uRxCYLJgIMmbyGwzCHl5hI7kSnqDq7Tn+ifdoEVjAMgohOunFW/H+pd5A15N51cPA1d5MFcfK5mYWUQU9jE42/oYDg8PydnAI5G1iIpeRyDOudEHRCREQtFyCUYwgIRkJcPyiLBI2Hg8VbE0HWXQ7OMCWMG6W8A6G0ZPRIQSOcYYp7Pu4uJib7t59dVPTBsLGF977Vu/8sv/0+7BITOHSLaZahhKIxUtMghHZV7V9OmfRIRmpTuwiPIsRwCpHTWgcI4+orFG1MAHuyb8GEujLsRVg8lsZmGSUOl0AggiK5Q15tK+t0rewczHEaIE/RVWsPVX0AcWJd2sYTMBAGU/dnJoszrNs8cymf8QYhQAay0hAkjTuKKI6ODhkggUIUXk1g5lepaWGUSFuhHWSF7Nr436QEmBwdEYkzy6GkCXiAAIomA5mIv/kFhkDaUsRWvQ6rCipLWS7DoWiVzaSitxMYOFMQYUQsQYBiLbuYbYCqeUuiiCBILAEq217IubsnKHGIoxGjIIyBEgI7OJAHDZkwwiJWGtFldlsUQktZNOc8z6iixA0JTZFiT1g2hLUbUJMtezSfALlt6Cwctk0rVNu7tzsNVtdU3njDVIHOJift51nYAwY4yCBoDQAI0hSIqtaNOFAIQGTWRdwbRYyiiSeBOJIThHKCDZNAVmYJYYMbcDYQ6DHwc/avXw6L3GHY0xBOjHlHtF4q21SjTGWWbQMus4LJRlSowoASWqjIxZshKRMdqzNgWDEYkEOYYy81SFooyydXKJnnG1UxCxLf08kFQYJGWICABCjAQGyGSPCEbFJGEWgcmkA5DOuiEO25Pu/sV5A9DZ5bV9e3Lv9fmDt3Z3d3cij8v5d71w5+/91f/39Vn7R//YH/u9f/D3fO+Pfvqf/NzPf/W3vnb3wf2j/b3t7e2jo6P9/f1O8aibpus6fbXucL+xpy99wCzm88PDw6eeeoqI5hfL7/zMD//eP/yHv/Clr/zN/9dff3x6cnRw8K8/96u/67s++YPf9eqt/a233njzjd/+rcdv3/udL772nZ985X//X/4f/vSf/jPf/4M/Qjxw9DduXds+3H3vNx+2WzshemcaAzAOAwkBMAoRyhCiNUaECS0A6j6IkRGdCFtLtjX9MBzfOODhpBHfuMnFuWduBDvAASzxyIEpMkV2o48nZ4uegSEe2E5G5hCdM/0Y290JAEDk1tgYuWtai8ZLJLKDjwasyQ5BRDAKWwEgUYhWYI5J2uqejCCCBIYrD02iYxRhzl5lLUFZDxHK6oZKBowgGTay0kefEMDKPuz6no6BCSMhE5BoaZ+yaTHOoo8zoDj4ZtY0zx692fXOuMDMITpjJEYhHPwYCTh43YYWEuIQA48oBd0mSm7CWo/vCj2UpPS9QRFAReIpUS5gFmaezrq7d+/evn37u179iMq23/qtr/3qr/7r3f09Vf8LUEtiW0mkrrG/zQHkXlJYOUUBRJO6AVawK7iWKFRmFiT73CErj8VXmUWXlgVLqcxZG8l669ONWSoPrcdfBPBlz3bRpy4TxGpaKnoqjy4+1Zxykht/XuVyX/9wZWetK4pANsYpIFq5VI88DymZmIIIG4nohLSuVJaXvfwsEcmbamUPGQMBilJISeLntrLMrC0IYmQ0ZIyr71rP2KVXvvy+a3Ar5QWL7xqyybXScpABVh2NkFJ/aEQUrJPUVngX2hmJV/nJlKk0kYf3Xp17URI8coxxuVxq6xsAkJzJWYK46l/FZElbU7lk9UUKqSidhOBNBRbGIWjOs+IW5mlPJyOgmvyiPuScVBUz9FV+X5Xj6vbAGDXImlRkjSIr0EcRqxp7wmy8wiW2WDwEZp2qKxUTNta3zLOsI9VA7umpjIKZARkgl6UZbNt2a2trPp/P5/PpZNL3/bTtQggnjx6rKc8MTz9947/+r/9vX/ryl//4n/qTv/8P/MSf/lN/8v6D+2++/dbd9+4hUdu2BwcH169f397ezq2IJTtpGFgK1IkIvvvuu+/fvX98fPwDP/RDb7755l/77/7bn//5f/qf/Kk/8f2f+r7jo4PHDx/88i//kvf+5Zdf/pVf+ZXnX3z2zp07v/Irv3L3/uPf/MIXEWEymZyfninWpjFU6vQk5XAoVnmpNw1qVIQgzrkYPYKMQ3CNBYDrR8eBl4w0DsFH7kc/9N4YZ10zX56enZ09OjkVER/5/PyCGWazzhgTh4GZIWYfSXJXFBFAEkP6DHQpCFvv97XP6d/cTa4sHxHh5QqLouxWfBI22PUTjsuP/jaHinAQSG1V8lUSotWWNs6eLi5uPffcdDoVqwmPBcwBtRg9xljoNovOxIltXcC8McqNV4VslmlCUAVXrKzKI4AxbhiX0+n05OTRhz/8wVdeecWhMMjXv/71X/u1zx/s7zOCMTZ4rrcbYoHTW83Ihh6QZRKuym9Tli+IlrIkj+mGyMkWqt4Wr/AzlE27fq1kd+Maa6j/vHLxTEbaqqXmhlSuPxdGU96xPqEWBuWhXKF6FV5ZBIOev5pPrGdyxbA2XMq1mMH1w6SGASvZUzivSggdYlmR+rnVW6QpLTMgeTkxqzzlcnU+paEKScouWa2UihxmtmTJIDMSGmuspMjCaruWOdwgjGqe1aWzKtQpLLsoE+V9V2rfetPoJEfLCiJDJsXSGV55ZZn2pmmSBWwbItJsZ11N/V4xNzTIahuXKCHzu2oR1wLzxiaczoSAkU82xsREKiu4OqzW1fuyFmmhBYFDauFMRJrtzMy6dNkvrTcpsF8E1XMBkHElcQtt1MyUmQ2g0GqBag5Q43LUv9bbSv91+QAAdfWnG0p9laj3K28Eq0O1zm5vb8/n82EY0A+OjJ3OOIRhGKRpCNDHgIgvPXf7i1/4jT/+s//xH/2P/tmf+JN/6qUPffATH/9o/Cg65/q+7/veOddNW8xMBsDplou5O7K+wu3bT9+8efN//IVf+KVf+h9/4Ad+4I//sZ/9Yz/zk888ffPBvXtvvfGtz3/uX4/94mBv9/T0NEb/hS98YWtryxjzm7/5m69981vb21snJycFYoyyD09EdLa8H5umaZoGSfwwxghEZMhZhyH4SdedX5x3ne3ny5vX91rrlotz10w9y+CZxdiu4yhvv/f+3ffvn5ydL5fetdYYY61xzu3t7QFRP44bxUXGGEFRusVUAqfuxv8/pKBcchqv2PIl8VQYSP0NPsE0etJzN26IV45KKwUg6QRZUlayn2iM4eDaMRoSCSWkYoyB7Mssq5/uXyX9rFJMazGzwZTXBsoRAUrJRvVmkYwZxmXbuocP77/00ksvvfQigCyH/qtf/e1vfOMbx0dHYwzOtgpAUz8OYBN/Y+OgquYEMUW5CInQcOU23zABKXmFy+zptqu70BOuGSLp/hsvXgQbrlu0hZnWwZUigOGStN545Y0T8AolYFNRAFjVtKyaxJVDz039HLJ9sApqRsko07CaGN1JDDk0Srl3AiISaIn5KvuMiASiXkoGkAR5LRiPmh+Y1qK0mk+iF6tYcv36mP29hCvISSV0demqOqR/RxTMfeyJCDDpBYgIYqxN5l2FRLGp1tTTWxSgmoQ2zKyy29XmRpIye2vUggxgdB3K97kfMENWznTtNGOobduunTRNs729PZ1OjTHTadc2E9u4DV3nsodDkkd3NVpmRmaN3ikrLItSLi+fKefQaSpUcfSV4F8IIcSQ8vtyVzST4V2Lb1Dzisv86IgFUd3vSdYi1wJ4tdxE7Evm5VXcsywZsgYnmAOsSvdXYYIi5IqSVG5a9qbOgTFGiCREdVfpDE9mk+3d7UW/WA590xhmjmQskaaZNc72w9A05umnjl96efvx/ff//J//cy+8+OJP/uRPf+KT37O3t9e1rutS143go4ItJ/IAgNwOQccfY3TOfeaHfuBDH3zBGHN4tP/m66+fnZ+89eY3vv7bX2tbe+PmtbffeBtRgGRra2s5jETaPR3HcWybJoSgQQqofHi6b7a2tkTEjz0KlZZQEgQRgCD6Yda52db04YPTj778kf3tnbcf3tva2rKOupl5cP/hu3fvLeb9N775hnMEZCazDrIC0batc24Ioe97TG7t9Gi0jiAUARxjZEABErmyGdi3O/CSsrWm2ta0sX4VVMJ749cree/l03g9iyvtesr2gZ6TwmZgkFAEED3w9sHebG9njCFCFEmShSFhJBQDANeVBh2SLX/UXObbTEr+JrHUPEfqtkIRPD8/f+WVj374wx8mon5YfO1r3/j6a691k6lpHPYyjuOkmy2Xy9pcA4BkrlcR0PIv5QQrqQymDcZavlkJyEpJwzUht1bFW35nliIrcZXvvnKtiAjKinHXHFwrRGJG7KuFCqyPoR5qfc5l2sKNUrnqPibD35TLDa5w2i6rTTpVtXKpnLRMsjLe1J5W3afCIAB1ZrIBAM7NmhAVaCYyc0orQETQUQgAANFmhVt6ZWHJCvLqe0FWTHMCRKOyJamZCYOUURIISXGXJI6WhWj0TESxAnet6aEs2ZWzVBNSkVUiUq/p5T18mfBAZRUmwqj3Xn1btVGIqG26qR6TyWw20xQeY4xwYtkFmqaWvpIdy8ysqMhZWktkFhHNzKJ15PMsdNc8WytRGyNzEureR81hFpEQ9SeOMUru4Ou9Shctg2TEVblaAYopQjpNtZBUzptyThGNkk3VywSfdp8BhDL+zbT/WkEhspSLkq21xV+CiMZQckQnj1jy4GgGXN/3i4vFMAwQoyE0xgZhSXmtGDgOw0A82d6aHB3vv/ve23/8P/6Z2ezwJ37iJ1599dWbzzx9584H9vf3Z7MZAGstcnkJEBCJzIIGHBmBSMhHh/u//du/9Y/+/t/65V/5hf/rf/VfPX3j4Gtf+cJ0MhmE9w92kECrVcg6opTcNI7j4eHhw0eP8v7NggeRIwPzbDr13vdL0pdtrAUAcRBjnE27xWIRQpy69jHA93z3d4tIRNNMd+7fv3//3sN7D+5/+cvfAICtnWkpCmVma+1sNlMF0S+XMUZLJIRGovd+jGwAmNk4q9F9ZhYNVa7vF0aATeb0b3sUTrghwMqOKB/qzX75hCu/ufzr6qEIKKBR5FgBEaIwAYo1Q/DXn33WTrsRIwGJoHEFu14jkivkYAB1Pq/GZuuH1a+6wfo32FYt/5KGQtD3g4h8/OMfu3XrFjP7MHzuc5/7nW+9eXx8HKMsl4NzDoSisDGmBG7TFCDmckuqZrL6sXpuOUSSN2DDcEFEqBoT1R/0voUV6vlZl9+Ur7gBbZF5BFa6zOZz19fvSjqQVcj537T8lzzSBbhAU2mIyOAqDrQxRXmQq9BvuU/hmNUANHq0qtiphsKa/ZJ/EhIUAGYJvFa4vBqtJhowQCqN3fSorzaJIGeu6llEvCRDTlMftUsVAkat9DSGhBBJrFMSSq8fIwMgc6y9x+VlN8zHy5O/8WvZM/VK1b7l+qrN1UwnlFJ1otyPVt+LiLSpatO0bdNMJxNNH81JSUg2eS6MISJLtipkr5QDff0yWilxx6ywQrahjTEg2gl41dhK5Z92G1XDlzO6hWQfz2q/AGnsSU2uMrHGGOSCKorF9V2mUf/M+qKvYx+Sazc5Fa2uU3sV6YCiKUrRO9cAQYs36PL6Js9NRXgxAtoSKvIiEcB2Xbe/v+/74fHjx8OAyNHHaA1a65jZumY5DFuzyda04zD2izhpm1c//srZefxL/6e/bBsaBp507od/7Efv3Lnz9NNP37lzZ3d3d3d3vwQXtJrrYnF2dnZ2973333zzzc/961/9J//4nwPAP/u5vzmZNpNm93t+13d99rOf3dra2Zf9vu/39/f9GGaAfT8Ow2CtfWpnr+/7Bw8eKC2JgHBM4XYiIOrnvTGpV0eIXlGIrbUNuXEcp9Mp+7BYLAHg2TvPfeWrX5pM9+7df/yrv/q5N954FwjaiXZKDipKRdg5p9LXEg5DLyKtdRZVGmEy9A2NIW5bi4aCcF53JcsnYg/Um6hmxYU46i1Wi6Sa112Wo1cK4NU52ZdZX7K6FgBljRUEBIsIrE3kQSglKwkLGeOFg8G960cjcETgyFEAOblkqscyEQGnyrDEWABAxBY2XfPiy6OvhEEJfa0ZyprR8LGPfeypp65ba733v/qrv/b2228fX3sqxohETTvp+95aS2LJuhx6xgIslbRaXj2Oi8UDQITa+9OYtTJHNfkVhQLK9akcZc1ihrS3aWPSy8uuPkglxmpoi7z2xWVXhoqlYbtsqgtry78+z1eOpKazWgCnR69cx+mhtS+hnFk9IoqYssqJmiEKJNC3emCp1XplCGa5VU8UI6JmAwGLtlcmJO2LJxmBIXnEZOUSqFVjWI0EWRiAggjzGDz7GKqMHlFMfGOxaWxLljKukSBGEVtlKSthICXtqhYDG2tRb9ryE1bKFmiLOv2TknwSEeGV5yC/l1KvxFimKIKsSNSsGg1RZprSNM2k7WazmbVOrd5CP5pf5pxDwpw/5QxSiak3NunX+qcxTi9Mi5hzOLVIaU10YUlaXFM7ykJrnnD+yxojunMBoGmacRzHKtZTrNsoTEyY+InEXBmMqeYey5QSEWIT0ZchQfZ41RskW+rAFUkXKqK8UrUAJiLNwS56Q07eQpZowNZ7RERQc4UFwRqDgCxEMJm0TWOnbbO7u728mDMzR68o8TF6RvCRfYx9GC/Ozpnw4uJivlz03n7iE9+hrtdFv/yNz/36z/2TfxICMGi1N+QZA2YggKgWlYGXXnj21s2nPvMD3/WTP/WHv/OTn/DLCzebfecnX/2Xv/SLltA6QsSdnZ0QOQSez+8tl0sR8d7P53NDq3wCVYlKJZsfxmiN91Gz8QBABT8wWGv7vm+a5vTs7Md+5DO7u7tf+fJvvf7eu1/72jcB4PBwV/tiIJoQehGZTNrZbK8xVoAx48gRoHOOBERCYxteDkm/YdQEwOi1DIRAAqJVwAn4tkehRhLgdQEJ+c/CDKFi1BvSFyu6+vYPWvMHrt8TN/mDVuWoUMhsNv2JYww71w7t1nQeRjGoilq9PQs3xnWPbJmRTQFcztj4c+OzJNVbTdgIAJPJ7JVXXtnenk0m00ePHn32s58dhv6pp55Caq2VYRhijJPJrECrgMFc10WlBGJj3OXAhFRl9L+1OcUouMIbAi2IJAFSPNNNZzWuoMPzXNDKOYbZdF5x5EsdGOtf9UtepaGuurwVUQ2Vybsy7DJLqqVsPfMb35efpNL+lPOW8ZdnbQx4bbokgSgRkaBItl027lxujoiSKs7XZJh+YEJDmpcLmWeqAqsdN4XWzXdgRlqh80iqrcIIPPTex6Dd9AKnxsyIaAEBxDlDBG3rrLXGqhkXOARsGoOuxAVjZGNR8/xLWlDJSoWrjloC1XRORIqaJgVRq0qtz68Q60lbzUxFcta6pmmKGarFPJO208xblRlN4xCxaZwawWqJWuIyKl3Ry87wMrFSEj0w9dCVbL5Tjok6qwpirO+g18bKs0JkCyVLBlhT5h5CABEAzB2TIjODgJCq9cLMMfhC9iogEMFUHTUAILIvVEpk5BKrQUSQBBO+Ypq6HXLuIWaVXc/XpPGiGeirqM9Ke60UzPaiZjEzolWtSPtKEdHObLq9PTs/PR2GwRmLKHH0jBACR+HlMDw6PTt7+Gi+WAzBD6MX5MXYA0BgBoD93Z2joyPNz0j7kUEyFEPbtmAwxmhQZrNZ29D2bPqhD76EwvOLJS0uDg/3P/3pT//iL/zS7s7hdLqlsCcXFxdjCA8fPjTW7e7uOufm87m1FgEsGbSQYgcSRAyiMUgGLQrEGNR9aI2LMbIgIkUGH+H9B/f/+t/6W//sF/6lIMxmLSIul4PO3tnZ+WzW7e3ttdZZa1kiBzAIIhzGIUYiAAkxQiRrmFm7twChtTZxyxJGTFSmla+0hih3iS9R3ZQwrqKnG+KppvmaVSYxuZ5J820OvXKD8ERytmgeIavhq/+peEYAAG2A1gf/zI1rdtYt/QJyY3XMmXFKAzFGYKxLMov0FZHssq9eb/1tVy11ESnl8COqXYAIiGnHPvuB55qm8T6+++77b7zxBgDt7x/FGNE4Q+TaiRY8YAYGGscRlICyta7+CsnAXd57nUWNQMznc32ZgirCzIjQOac737WNoteW4Chj0DysHP5RayBWvCZlbxbjNVFPZQFDlagMVfiqJiM1wHXq6tBsuUNZ3WoYm/J1/YYrwOR6aZxzHDblSuG/xWeY0z1U0K5hreSkGA0crOyh/JTkopRKz0CwgrG8IDNoSVJ+btI8vPfOOYgJaYFZxuidc4imVA1Za8cICVdTABEi4OjHcQj9OHgfx5ygJxKUtQeO1prJpG0mHSIu+qVB6CYNEbWuUYkSIxMJgAFYyR5jk7OoSKCVjlUr3UQKarGmGyFzBm0oLLvcuQQyizclhKCe8LSaVS8EY4zihwCAwmhM2k7bGek3inXlyCQIIcIY07K6xhljAMRaGzjqOBEMkVWmpp19IXuDEVENynWwSQaAEH0M2imd9UEFcaUQXkWTqbzNGIMp8xqtbYhGjtE5F0JQV65IcjXVjOySuoOQSoHjhrJSlqB8X6aaI2cAlqjFwzqZcb1qvxwhhDKr2p1Jb6hLAwBAChOw2tcAGitYQ4NputZYRBIJkZnHfvCI4xgY4mLeL8O4XA4X88XFog8cRURwzJtCWLGA+l4Q1CNSXk1EVBKDIRF2xlw74ofL+ae+73ehwDvvvDPt2q5rYtt953d+56/+q18fgw8hLBf9GOJyHB49etQ07WI5NE0DQpPJJOZDN1eZfGIIQ7CkMSIQQEKKMQoZZuYYDUg37b74la9+/gtfPjjYkaAhCBn6ZWS4fu3w4OBARJrWhdGLSNQacQGOPox94KbVjB8QMmZkvri4uNZO++U8CPR9r1AqwsEYU0BcGSH7op9QwCkrLiQisCLFFakUh1ZNReX1iagU9NQUWBZ7nSZXFnPZ4zUNF0ZB6irJNrgWRXGMIjEitFvTo5tPXQw9NCaE0LomO2BWfJ4AgdZCn1DFgOzlYeVNQUUw1+dwTHI3jZWUgumtt9557bXXZrPZYrEIIUxn2ypu+/k84+cZss6wiEjw0ZBlZhYQiZGVvwOSBQaOEgOrLyvG2LYgU9HdqKpukdmqYmjkzFqNmRnKkYlhiEHEWtsk7AdhZshpKSTasAERUyir5hg144b1eFWZqDI59RReppsNnWbj11oklHPKTdaZRaoBlcpNV86Rysiun5KsWAnlNGYGMCEEY0AdWdk+c8aYYVgiYgGMzcRtYgyVPmG0GIyrhNtJ0wJAIFIDzhjTtq1IgtYqHdEFJTLHKJ5jjNGPcRxHdTuPIShcA5BWHwlAtBZt44Cw7/seuLFmNpu0bSsiWDoPZk8E0Uo6EpEmOoGgCqSyXrVipB+KjYuprg2u9O3Xa5fns8Rc084nIjK27F51MkPutWCQtABJe8c2TdO5xllH2UEdJCFUZCPKsBbRxhRuICISkASBbqDiR4mw13XE9CsUHXHlsGEuqFUCFd4Z5QIBa63COOqrWdtE9FzmKqf45lk1AECmSr5bgeuSZqdzqo8SyaXPtIaGtrqw7JpMnJR3be0DkFKppGpBjeiO6zGFwhNXW4y0/mwFxWWMiTwaa9uuG4eBhzEK+8jLoT95fPbw5HT0/myxOD+fBwYkG2JgGVfzn+uMGXQzrhSgSr9Juv6jR48MyjiOr7/x1qNHD4yl60fHW7tnz975wPd///f/d3/9by0X/enpeSRYLoZh8MbanZ226zrXTkCo7+dN0xBB0zTL5RBjNE1jrSWhKJ5FkMGQ03xARoghkHECEBlijJPp1DoaxtEJ9/3oAxwf7Tz//POz2azv+8Vi4b0HYBSWGGP0JqOpK9Yqx2icYTJgCI3r/Wgbp50KQYS0XX3kyAIEvKZuMa47aQAKDLnIJf24HIV9rU/m5jmXvxS57G/OP111cwBtiZaflYu8CHM1lPJV58boD566JoYEOAhrEjivaxjF7wKQQZDWY7cW1mRMcdUm3pr2QKyzqAv1r4r5EPE8nouI9wl4Pca5Ep+PzLxUKrTWttbVWiFUSJBq0pUaf8yBw2EY5heLJCok8Y5KNiTzy3uJUaw1TesQcVj2SuipYyhHAC1cTzPOzBGEDBEgc0A0qsIWNgbrId7LmsqGrN34UP6saWXjnMt3ftKZqxMQ0BBV7SXqD7UeB5XXVATVOVyJWwNVqk4xpJTrl+GVERpymQAYADjJHTJEhFYYQxJjSLYxxmijGxZGY5i5H8dEyO1UBPzovY/9OAzDEAIDgIYOY4yCACERKyJGgZgcL65tu+mkbRoXomhL+SAskY0xgCxCxhikytWZUoV9jFzmeWPeDCJIhFyZpvKAhQ2VJJ2KL8Cqt29elyI/MkK1rBXD6KHqSNu2KKAeIM3NaYy1joxFShiZLKztGaxmH0jxXrpGvXwp22iFf77KC2NmoGjJqQOZV2DIK40tLVulVqr1JoKENmZguPQNWRFGjCqcEpREPoEo9dVh1nToTdVTNakyUcYki5CZER0Bc5UcpyPN67IqdC4b8ErVs7y75p2okV3fs+yyy1uJsr/UGisiDIKGhEvvIGCECLJcLh89ejRfDvPFIop4Hxf9yILGQYzR2PSIwKBIgiIiKVgYlaOuOAALWGAfIhEb6hp77/6Df/Wvfu3wYGdnZ+v+0f3trZ35RX/9qZuz2ezrX/tm03Rny3ME04+DiDx89Gjv4Gj58PHJycn2zkxn7+TkZGtrR7u+2tZ2ronSDMPQ+545MmgXXgNoQghd18UYY/QX84u9ve2+772HO3euHx8fX7t2bWdn5+TkZL7wSGJQkDT4xHUJBTMbskICxo5h1Al31o4SqOSHrqL7EnBVlZCZ2xVwQFcy2EKicFVWs1Sa9L/xeJK0ri+/UgYn5QBQCIHVbBNEDMDBwLWnb4ozRIhxBEOBozGuHvx6p0UUwQioQU4QYEHN0U/F6QqGpUPp+z6GlWairxpjrMtLmLmIc90YJ49PNeI1DEPXdYvFoptNC6YoEfWQ9lXbtmX6Qk7VwcpYVIUCDI0hhItzdd+p/CjutTGMMyLtPFqgdkJga61xTUIzA5QEkqg8K8sJJAZAIPVcciqcrUEtLsHBX6V84fpR5qo+U55AQJdp4vLnWiQjonAqgC7krrujMKNKUaNaUwEgESgcllY5rqhmhD6rbSfFTDHGZJcqxRgUNRNN0utVvG1Nt8vrGNeEEATAjx6RgAyk5GcwrtmaTETkbOl94MGHcfTjGAavCbcmISMSYq4gKwtBRIImCJP3gxr01jBHsYgCSFg6JjWtlewJUKpIr2c2J7b8q7l6sq731HGEei0wx3c3vkTEZG0DEFrjLCJqsCbbsrZtW21ib4xxzjhnWpds2jL5nAu0iEhNVc6wX03TCELxTGDGkCKikqAeY2QQkBKCzWrHSrBtciLMDgBmNo0z5CJGyjk+OR06wU6nkh1IdIVEyJxnb0Xq9bTURF1WEwAMoirqNdfDGkknX5KpMamPtnEb4y/vVZLRyp/0hA6n+apU1FTtBWFMHUmAkAXHIVwsFidnF4tF3/c9EEVhIuIoIYQIAlE40X9mnoYIU/fcvDUQIAMlhjh6b61FsD7iO++89/DRg+vHR7t729dPj69fv3F6fvH0rWevHV9/7bXXnnvuBUC8d//+m2/e3dvd+uk/8tOPHp783M/93PHxsQ+DAAzD4JwLYWya5uLiYjKZbO/uhDBGiBRJkERYAiBB27YKeWYMWkez6dbjR+fPPHN05/q14+NjFcznFyf9MIcYDIjnkBN1RTcycwRISpxBYkQQQKC+783uLoXsM0s7GRCJDMUMC19mXkQAUtFj/eVlUVrTqnL+WqSVdS8yq+a3T7pP/aC0kdfJqZbBAmC03APTeSJikJiwF99sT5vt2cIPgQAIrLXIAimNjAGAUvlSsveQJcUFKk+nbZpOt24IofQwEc7XrFRIAyAxMtHKyVNgbhAREJb9UkCG4IlsM5mOIaB1mrwHZftl1Pi+H4kIzBpAFySGKMw8jqMyNRHROsUSpi2Q35IBoepAiOTqCMq1uYipW8gYfNd1HJmQnDPJKSqSkGYpUo4qAQBA8jqsNu1qR63lK615ugRS2zvJnekAEHI0ZN2FIiKApJwHktTJT5RyeqEVRCRAKblXNQlKPntDMNTMWtNq9CfNGjUmRdAhpwhJNUIoBTaETTORVXMhBkCNLrum9d4zRx9j51xk75wbRu+ca9oOEcdxJGO3trYmk9nJyclyWCz6cbHsc+2pPirqU0hMkb56GGcZwMdA1ESDMYoPjGjU4QagidcUw6qhng6ytoestVI5wnDNGl7To2vtZGO7lmuLBVZOwOy0J7REZJxViGZEdM4pMnDTNM4Zidw0ToVxcTYkVQMw5jyUPP2gd0gaJ0IZm8Vi5IF6YuuFK+JEZ8DYNRlPVXKsnqZ83Dk3mUw452nrvsPsCtDgse41QEOGKLtUyhRpTUOe4cw9AEuFYdlNZQ5FsKp8W81zoVvMcZPVU4ALGZe7KX+gHPYuF9abVKSUYNHaXqv4hsIEkG0s0Dws5svFYtGP4xglCIIPIcbYdV0fxuVi8Bx7DivFQrtBVN26Ms1IMYUjR0SMMfYSQwjG4jR2IvL49MSHwILXjq6/Gd8koqOjIwB45533nn322f/0P/1fPHXz1uHh8d/87/+2gNjGLYeFc24Yg+KcD0P/wQ9+8Nq1a+++8c7g+/nyYrFcoDWFV4z9gIgIiDE0lk4fX3zvd3/k4x//2OmDuzHG4JdAOGlbDv709FSjy4hQqsMDw+hjZLDWFjvfOee67vT87MbWFhGhNUCp/CEyEwkLbdi6l0VjDdgAG7zxqtjfBoWUM/WrK/fslRfW3xRS2aAHADCAEQEIGQQQTCbS5Tg8dXhTnBEIIQTbatQpjTx3FlfvlFHfkHZdgHVDy56enpZNmzRchnoo6pstjIYzzwdgqdKMNfLnnNNmKbp7DTmyOS7CzBwZVk4nxgyKDwWJ0MYwKjXH3K+bsjtRlUrdWqVUMYSgTjnN6moyXw4+giChiRx93r0xsslWkXOt6cwwDGH0WrRCmnKLSGswX5t2ajlq7rnBwespLuZIWVd+crMXuRTKrXkW5shi/Q2XjmB1dDNTVWQhIkDRjFUG0bwMIBAkBpGsKUTWVuVJwCf7CVMeQfCxGjkSkXPOOEttqxFZ670xZmLdwcGBIZeYNcflcqkh2HnfPz6/WGhPu5BwHrQ1ukQkopIQVuakxEGYXdO0hhoGGkcOYRDGGMWAIAhRFIkGKQYFFU8amxKSThERFdlQT3i9UmnzrPseih6Ttqg2c0KmyqObHoEWcE0qEFHXdV2nzQTJIIElhZl0K3ONtWgDQC0DKAMmImMbk+E4SkXchoEOlVogOX1BBVJKZiRXjDyoEgY5leus8gfbtu373ntyzumG0twLGT2RdS7llqv2loXZSvri2n4xuNL3RYV9wQXR6WRmIgsrmwaUdMtCFJmq+8IAph5wUGI3qzJfZtbWw2WnhBCs1fa0VKdbUwVjV26u9GZMy9HHKMAIQCKpW3CIASDp165BMU4kttheXCwAILAAxxITv8zimVPDKJY0WkOEhliQBS8Wiwjt/UePAQjRXCyWbdO++uqrP//z//yZl57/8/+7/+3NG0+/++57IvLgwQNllcr0ACDGOJlMFovxox/9qLX2F37hF7vOOefaaatSn1mUSUqMztDp+bC/0/3wpz/58U+8QgbeW56XBHJjMcSROTRNO/QjIwROrZaCxOTDxGQqxBiZwDnrvbe2GXNyqzJELvLskijM2yr7tXMUoxa6m9dUro7SImlN9F51/rf5dW2bZ5K7PEgAUIMg6iUiiEQCg0RG2D08EEvWNH5gR0ZbT1POty9j1kTgRMYqQzUwDAAIVi3UNClVBwIRASC8otlT3Hj/2gIYx7EAIzSuU9rd4HG8XkErIpACkFB4WmEKukuh0oyKyNHj9PQ0/ZrzMn3UBjUcQRhBCMMQOCdP+jEU69nkqg8Ug7gKL4mkLn2Y6vTTQZX3o7xCEcOSTcYiSq9Y7HW6QVwX9VfR34acwAzCUIRx4SDF4MuzuvKHa3i1BAUBQPvcxYwvRpgSp02FRKb4DxwFAV2TEoWMMdpsQB/atNPZbIaIk9l0GAZE03UdEXnvl8MwXy7m82UIYblcnpyc9H3vgwTPHFNbQhHUZGxZ12dRzRPmfmBrrWVczPuL8wVIbJpm2rXnpxfWUtfYprHOGuecdRhjLJ3qpUJgWN1zfSaJNId3Te0tZCabbFTpUKEZDeQ4JeVmtNY4FY3GNfpo51zXNZPJRE+zZIiobdts++qjCVjAFAJIXFVJ0RA0TRPCiGhcxo5QdsnZgi9bBhROj5IapzLSh9FyivcjoiFiEFulC1hrp9OpKjq2TXa5AaPjTyQtoJnPTdOU9OkNJ4G2ZBDJ7SwRU8m4CGQNfOW5eQIDpcpsrVcNAEiADAXJbSjrq4gkwZatHN2FAErYpa4OwKoLeBSxWdJb6zyzSEQg7cdcqrRZgnqrfPCRGYDJ4HRrpr4E5hTaZAABhe+Hy2EsaywzW5d6SorIOI5NawVosVwux+HR6cl1186mWzdu3BjH/oUXXvjQhz40DsFae3Ex/8KXvoiIi8Ui5lbNzrnFYmEs/eIv/dI4jrZBsqQFQj6MCMY5S2j9MEjkZT9/6dnb3/nJj+3udNuT7uTxQ4vQOTuEiEQhjDHGtm3n8yUYyqIOEbWHMhrbiIAxBoWJwHNARBAYY1A3j5pqpVabn4DCkRmdRknXw736Z8UJlVquvM/GsaFb/9sfGxxg7TdOCxlBNJDFzGMYj29d3z7YG2OQSl0WQgxJ/CbmAKAoqvUwQQu31AVdv3mOcK1YsP5UyoQ2hJ+eqwJoHEdKPVgUI4nHOMQYrSGoj3wtMyfmxwiU060RrLqF6zglaAGUmNzqmUGMNcwcmVFS1YFORN8PAKglfeM4Ztc05V0HgUNrDUfxY1hhKROimAKry8ywsibraC7W87OhWOjhzKr74ZUCdbUOaqnw5jkbOxYqeipPKVm7JfxZbNYN7X6D6VCVwFIyk5mZcjPto8MDABjHEQi3traaptFqCw1ShMBj8EPfl/7qOIR+9OM43rx5c7FYGGPefvfd8/NzRf8ZhvH0/EwdFSdnZ4gYomg3+DF4Zja5zHTtrSszKNFS8DCOzIwAzIqcQMwKy8EJoSyGvu8n07a2TaWqRLo8/3kxr3BFqh+lnFaynYuaT9oBqVT3Zn8fERlrbW6o0DS267rkjjZWc6Gdc0RpyYqZrvdX8IqVV4NZRJbL5WQyq85J6CiYvV6Iq7cREWHR1RzHsYjJ5NIILCImK9YirEggWqmvsepxHInJ2p6ISiNCSfplsFW/h1pGMqDGnct4KNd8g6wykEWSwkVExrSFVjcOyhW9mI31NYGNa3sk682ImOJTms9ljFENvmgkxVYuG0EnUdcuZewbhw0BRw5xNpttbW3NZrNFvxzGMcaIJAaMcZYMBmYDa7AEXM0MigCk7hcEmmmDggRgFCw6MIMh4OjQ1VEDdV3cvn37Z37mZ/7FZ/+nX/qlX/r4x151zn3wgx/8mZ/5mb/4F/+i9jVaLBbOub4fdna2bz3/zJe//NXptJtuzUSUBwsRCcOy78fBH+7tb8+mYex/9Ec+g+JBAgS/OD+nlC0I0+n09Oy87xdN056enkNu/xyYKfuiNSmkQRM5NI0VJBtZxvj48eMXnrvTdd3YL2KMWFdaXuXdzb/C2pIioqRe9084XzbOL6fVxJ837NVmdPleLnkp4Co+zCxAVCCgEVHTMg6ODq1z8ziatN1TaZ/TEqHcZz2/e3kFTNs62/0WTaP4+TqaKKmc2biGmQVABFBLCABE2BinFJZtd43iAKIG6jnlgIigRGesQCzSmojAoD4YbXZhqedM+WDwsWJIwpyVKYgKPgLIIhxigssQIOf60Rtj9AWHYdDhTSYT9Z5phDILVtEE3RHIs3hWexpiDCIiPjrnjCF1WVlHgOjQaoI1ql0iKeAN6itEEmE/RjWmiUhAJ020t55EFpFkZ6/AGVLWJYOmD4PCU6hygVSFbBMeMhtLxhoAkGg1HhCDLC4GkV6fO5s1ZDoAjMJIRp1xzmoFqnTdtKPZMAy9H4XRNY1pOkLjrG3bhgTazh0dHezs7KAFY8zh4eFsMjk7PX/33fcfPz5FMcMwLAZmhkeP5gwxRL9czgFgHKIGOE8enwJACGGMQUTato1RxnEcfUY+Atcve2Nw7AfvvSEyJtVh29wxt+yryiEVOTKHokpT7Md+8LPZrEHgkWnoAcU5N5t0k8kESGzjYoxxHAVIGFkEjLLpXI1ndAGj5O5nG4oOpNLelX+SiKytHb9iCLTECBGFMNXCOTLktrZmerfZpLOua5vWaJUdogFstdECCwo11jCv8JKMazBijNG1beLRng15ay2iAEcRIxij2nmIhkxgTasmEVYMQsnpSH0/OmvaZhsROaQIQmudzcRmEtAlEqBYGjnEMM5mM/VYIBhnnTQYQiCLDTTeDxJtMGiEIghZ4wk4QkSMMXXIoJVzeOVjKKKUiGIMmsekHSyJbPSsZb4ojAgirLpN2zQxRjDZYY6YE0FAmNBm5zmh52hNoxJPWYkWzVlrR79UyapjgCoklKxkAEOk5VkE4KW3hhBhHAO0NDHbs9HvLpfj/ftOUMbRimBg771hSyIBwRpqTaPhEkREYwMCgikqVLHIY4ygdaKCKOjQmIAT18HAZGS61RmmCTnxfvtgOmnaH//RHx6o/RN/4n/+B/7A7//EJz5x584dY+Un/tC/94/+0T9q2xZJYmQOsLez+8zTNy/OT+/duzdGi1GcwMy2w2Ieot+zsw889xIYMo7Eih+Wk6kFi9LK6XiCbuKZp9MpsqcQYx9GJg7Ode18OI04glXuyDM3FTYNhwjeta0QYpCG7ID9eRxt15rArSAZA4QBwINwY02MUnzRjLmd+spIYExdc0CdKFE3JAAmONvMGBNzkHw+V3AFABoRXRmNZUdr55QivS/r+peFcdI1FWNbJIIEQh/ZogEfW+NYxO7M5lbAteMwzshCHwNHsqWpSZa4mnkAbIyBbNkjQsqrMGSxQhioFYwQEu5jicJyxomNVZZBbQ4m1UNV4azImKrStH7z8tCNN69duGU8vN7Wqr5EIQPrGdRhlBoqqLTpYtlojFBDI/qscRyJNGhku651ziFJjBGtWdWwqn6affrMzCgGTfYoErMECZpGqQ5bMBTDyver86CR10SCVQZyKZtUHaJEMcs3iEjkmNlHGf2or6N+/hjj9vY2ORd9qrtl5n4cuqZlFtc2xpgIMnW2cV3giGhu37499kPTNIeH+9F7AD46Ojg4Pjw/Pz86OHj++efffee909Pz9967u1wMQwgc4ezszHs/hiFyWCx6AI4BxnEchsEYQ86q81nHI4JerWZmEfFeMztoYwU3CONKzXTjkJRhAM65xjUmBVYb55xzKfjHEQjFZHRlqHamCkIW3ujgXYhnQ7nWzzGXnmfzbnWAIQ2EO+e0VggzlFjKgTZpHVFSrlCSOKJV9TnHitWsXcURIvsYLRVhI6s0OqxiEIXe1NmgrfFK2lQh+HJysbdYW/dlYaxUrbdqmibFeiXk0F7q4yRIiMgIJuheR03YEQRjV1USRGSyiyMlWhsj4op9r56C0ZBVNRyiQUpYXSQWyfNqzJmrUclHhTIsIp38ZBuwgo3wcrlUTMcNAijcH7N5vfITjIFcS7ksGxG3trZu3rzZNM2Dh4+0FaBr0GRsZwGOMWVfmKp2HBFFACKUWm09PHsiwxytNSTiGock1prd3d3t7e39/d3Dw8PpdArAOzs7t2/ffvbO2yDw2c9+9u/+3b8PCN/5nR/f2dnZ29vT0CERta158823b926dXR09MYb70yta12zPD0f4vx4tvvy8x8/2tv33ocY+zicXjw+ffyIzO7E2OXF3CKJIUOmMTaEcQweM16KzuswHyfTbhiWjWkhAgGaxjkiH1gdPRKDc82iXyo9pKkusx032f6Ve1lkjduvtmT+jDlUl+XUFayjZhn/Njzk8jDqP7MMBc2R4BgNkrD4GJj5+Knj2Ww2qJTUVEHVM0VM5tir+6y8TSt9opygkDqy8ldXbKg4M9fcbpma+SqYDqh4q2IaJM/Lej1l/S9UPG5jOsqI1VG0Jubz3XTvacKIVF3qajdsLYkXi75kSKqcMDkzhDkiovdeIxkKOuNHrcqwCMwECIYMSK4PY2ayhIQMSTfRBDgWQFYcAlSLmDCFVIgIGGJMDdqEtJ4SlSUSETMwJ4Aba/PkMDAyIqp9GatD+WbQ9qWaJkBQ2CWgAZIQmIHato0x7h8cMPMw+Pl8fnRweHJyYozZ29nyfjg/P+8m7umbN7qus5aOjg9ffPH509PTt95652h///W33prP52Pwi8VCJAppklRERPCgHFDttmEYxjHotik1JLoEpVFPvd8u773LdJX/TF/2fR88juM4adxk2iFiL+y9b0xnjDHkwEaogqmFMwKoPVy2WLWHq01b6K0oQJB9v9kgtkXEYkJ5lKZpDDnNWy5ezbZpjDHqiJboK8EZJTfc0/cXbSlhCKt+R5E9QdL/SLTZ7apWG7IuWLg/5paCzKx1+TbHbnJP+LU06bSp861EhAw0rZ3ECQCQARpAC5yImkgQomXFogqEiGKFBWOMMZoojLnsBBGNSbB3qv7rXgOQEjR1zlnrQNOvIrMIJeB3EhHGFejVapyU+1VobiaIEQEhJFRAGE3VbFL02teMq17umgAgl2yVb4qzGhHNtmm7rmnbyXQ6m83Oz8/PF/NxHAEZ0KT8waQipzk0xnnvEamkSpUJx0jWmhilaayITGdN0zSzSbe7t3N0dLC7t91Nmq3t6fXr159++umt3a3XXvs6AOzubI3D0rXN5z73myKwvT0JqU9i104nw+PTk5OzO3fubG+/xj5cnJ9c3z/8nk9817XdgziMi4v5GKIxYKNM2mY2mWzPppOt9vHj+yLSWOca65z1fhiGQQgDR1LMwSF0XQeRu6brz/zOZCt6AAgCxMgchQgFCI2MQ9QaxdQFFZEEMXVUA7gkETfYu6wfcOm4/H3NOuCSQr/+iKtjw4mvwro8r08jRAGyNI59tzVZDL0wttPJ45OTjzz7Ids2S+aSjFm8d2U8+W0QL5Ue1c+yimpWhpu14xU1F5M374G1F5b6OdUHqMRq/efGhfWgIdsZG3sDAACoZGIrp6vdlWXWlPWoWNXMl2L4FmaaszENV4UNeqb3wVrSyGV5kA+jtbYhxJxuo09RwC5kzf1acTTn1FHJLOIjYyoix5hj8+qxDywhsnb00+hYjGUOEz6RtVYrNzBjRIiIrggzKwK2yrmu6wBw0S/H4BvrmqZR6KuUhsMSlsN0irPp1jAMbdvu7Oy8/fa7jx8/vnZ03Lbu0eMHT117aW/vxsNHD6ylGzeu6yscHu4S3bn/4N7du3eb1no/bu/M7t57AABDiFpRLVUG6TAMyv5iFO8HrEHE0upLCLGmjVr3uiwIRQpqZjkh3S1Gb01rjAnCi/kyhLC1tdW29vT0vGkaTQkBAEKwGzbZOvD4Zdagh8bhIGufUil/tfQtNq56SmfTbQ39lpBEjOBcggWOMaIIIlprFcokP50ZElKuEJoqyz2fsyIwARCJAAYgNcF11jELYMoY11HpS8XodS9DTilXMqvridWo9d6D90UkM7OKYcxgIJpHEg2qMS25sEtEAFPRMDPHuIKBVE1lFRpndtaKiDFeWbxzLhuxinxhgTRuqlsSi+nIIpBr3zHD2arvwZrGWjsMA+RQbko3M8Y5p98Xo6RoP5cZVP7e5Y3slF2EEAwJEXVdt7u7e35+/vDk8fn5xXK59N6PmUOmaRHRObStZl+brA+pJCBoEzIzERKZSdtsbc/293efunFtf393Z2v76Ojo2rVr16499dRTT/XL8XOf+9zOzvTs7MwY0/f9wcGuMWa5GJxtdcL7vnfOvPfeezdv3rx9+/Y3vvJbf/ynf/bZp58hz+cPHz9ePJi5FiM/vjgZwzDbnm5Np421ljCGsbGmdYphRcwwDAOCYQ5gLIMYY7wP4+gxwMR14KUxzcAh+sG0nfcewFhnJXrTOHIWEEsEFxFJNEC5GeOXHP5cbfknCKdaPJdvNkTDiodU8FVrD0KgJ5iI3/7Qp3pm51wcvANyzo4cZwfb7e7WGEMkMM4YIs+RRHnLWvenwq/gKlajn5O7TPetCt0itNQzxlxAWbWtZhRhkZjS/RJ7vIKBYnbvwLr0vTytG1N2eabqN+Fckp95YvHwqFHFMQpzFOkr/6263xmANfNwGIZSv6RPUatlHPthGJTDqpPHGROjeK+IAakpVYyiyVnqlYYYMTvPgzACSqk/Vk+7AOb2mDEyANRVqgWjSi2rGDkEVvaULBIyGoBUCzsK++C1KFQIfQixXxKRRQomDjSY3jTW6eVbW9s20un5qY/h9rN3FovFvYcPDg8PX3jhubfeeut33vjWSy8+f/ro8cOHD9uueemF57d3Zl3rRCRGD9IcHux9x3d89K233nr3nbvTaRdjwhk2bLz3xtgQRl5lyoAKYFwlsUu93CUkVmtda7voyd6qfKuImErJsxVlpm2n2tLgQ4s2BvBjAEHXWLIWMYOBW02I0YGpKFxBbhVKKA7SDU5RJFYRw/UBRNY0mmCltJTtYKfbylrLYdSUB+ZAK+8pYeJchIhtjncAgCYx5QemNH+QVb+Bsr8A1IKMnmMDHWSU1pIYrLNHRIrYWmabM26tpjeHEASx6To/n0ulpxIBWWsMstWwvQqbHKlHBEgoWsxrog4rt5lqK3q+cZaDZhulDCmFpTcoRSmps/oxJcVzjOotV0UWJUKElCJanCvMHEXcOuOT7AMDgJJvtXHomDWUq+uY58ob22i22vb29t7hwXK5nM/ni8WiHwfvfZ/TEtUA0PTP7KJSgFV17BsfvG3c1mzmXLu/v7+zs3Xjxo1r14+Ojg6Ojw53d3d3d3e3ZtvT6XR///Ab3/jGb/zGlz70oRfv3bsnIlYTo/yKsXjvQ2DnmkePTl77xrdCCLd2j+/cuNWBOT052Wu3mj28f/++YZg1Xdva6e60aRpE4RDYh2nXIWFjHZB478cYGKz2BuUYh8G3rkGU6XRytHu0PPPzs4VpKSYw97SmEsa2bcmYIJwqqRmF2QACIlcMX13Ul/k/rs9/zQdqHlL9tHkaXLrD+glrGvaGwo3VhZfldwAxZMI4OmOI6KI/v3bjaXHGaycaQ0QkMWZFonbxUi10nyQibZFkhWUoGeX6S4pRtACj5puFDTEzovbAMYU9lWdcqbAUXnB50ms5vTEdhVfW61czoJpRIqLK0cLgNqZVv1QOrqxKt1bfu9PTx4mbD6MxxpENPsagLWnTzZU1cOqzjQAACvyEyDGIcAiRmZumsWRjBkzXPROqUDoiGgPFqWAUIJPZxyiCDBQFBRgRhExkDizLYSSiKBDCWOZQ330EdoQGTBxH7TvWtu3i/nh0dHR4cPTWu29/643XX375ZSG89/DB0f7BnTt37r7/7sXFRdu6Gzefun79+OBwr3VWIjetG4RD8G1Lx0d7164djeO4HIdvvvaGc2ZQt7MQkiXS9BZQkBBVlDCL5EItUGHZXCllL5P+6nNuGlHTiYiQMc65prHF0afSAIA0jV1SlxgBACR1zq+pBapUQWWuYZWBXAw4zGaTMQYzEMpaiNdaYxxmJ3Chz5TlZC0iNo0NY3ZIBo858FHtgss6slp7VvdmNohZYojZ8xkjaAGC/tkYixJZUOlNEZLrPY7ExpSNnDoc2IxWLTmOoF5iAOAwihCiBY7W2khkrSHCEpYSSWo4EYhYAaqXqdZpysoaYxAtExtjrCjAPRbfBnDIJB1KmR5ljPGmadVkN8bE7BqBnGsiOVSviPF+GEzVoxAqxldLgpqf1GOGbG0rPVgHrjHdpJnKVETGcVQdXRlCEbolWpE1Ei5ajrW2mbhJ23VdBwC7u7vGmIODvYODg27S7u3tTCYT51pEdE2Dzr797jsGgShxKkSMws62KuZFEIAmk3Ycx8Y1d+/eXSwXr954bnFy9ujsYoLN/s1rNsiy6Xgcjq8dcgNmim3rppNmOVxw9NN2ykRkIEZW6MMggRGIRIIoHY3L8OKtWxM3a3l5uLX/YPmo92M/+MY6BJQQYwjUNWBImAMLQOprpFWlxU2ywYTXBdJqV9aiF6pv1oRZVTmyJt4A6qyO8rgIYq6Cg15d9aSfRMhQCMGRQcBx7IPBZm9bOofIxpDRFk9ERCQAEiJYFEFmKMhol1527VgLJhX0PsnKr16m8kPftCjFhS5jAnsTRFFl97Lc3ZiUS6wnfeB1fWRjLhBNSY8t816SxYqaH7P1WT4X3qpCN3NMoyq/xo+1V3Hbtnt7B/oUlc2MEHKxrIhof1AdmIKCpigekQAyCwuIQAic27AQs4QoajiuNJtMXI6hMEfF3gqBVekpHkWENFTd4SokhmEAQoVessYKQIgjIlprI+Dgdcmw7XYenZ5cv378/PMvvP32W8a8dnx8PAzL999/9+bNmx//+MdPTh5tz6aHh/uHB3tEgAQscRwjAnAcln0gtB/9yMuTyeTRyWnfL2bbOzxfRkQlGEMacYeY+U7hg2WHlOXeUDPLn4ibcnG19JfoCFEAxFrLIuM4IopzDiElVPsITeOstTEKQAsA1pnW2ci+uoOiKLLm0q9/v8Jw2LBxlWZi9MYYzX92+TDGKbSqntN1nWSXUiqj5MABYoxt2yoiSE3DQGU3rbUxlgTNjcZqp9SkOJqU9UFoaBzHDD0hpfMVAWjAVS3yElcCgGLYcUr0WxXf65hVXE0mE91cbDThaORA1loy6HL/MZ0TBb8sLugQk3FWThARbQsfYySDxpjStCCXDClXZQAtZzcALCHYLMZEJKU8Zv9cLSxNASpZmQSpO6GeRjkurusYc1FlUQtqJkOlHVNVuac7V3WgKEIixpjpdLq1teXDoEWPJdFa9Z7i6YEKgxMRnTNd1ym/0jCZtXZ3b2d/f1ffZWtrZmwDgODcwwePE6MRnk6ni8Wi67rgmXKmCGS9dtJ2Iti4bm9r9tpXf/v3/+7fe23v6P033qXJNu/7O88+03M/2hiMH2VgDkO/MMZYawCtRRrjOO+HwDFEDchDCKHrJjIG8fz+u3df/cirN3afev/du0c7B4u+X5hlJOj7niP0i2F2fGSthRCBkIAIUJPcrxQ5Za9tbPwNAbxx5pUfNmQEQK2ob8rguhLx8h14PSJZjpHjtGniondNM0Rud2a7Tx1Hg6JsigUIFS9BEuB8BdpTveCT5iGVx+B6sR0ilkLPBIWTZZtSUnlAlr4rfUTvVPq61yReyHFDSCMmALN67mqWXU1QcrKXzWZy9xVeQdcSrbtApepJUl5HgfdijH3f932v6RVqtmrqStdNbOp7KsxRsSw8AFHaUbiqd0yPKwCwIfIw+hA5Rt0t7H0Qgcg8jl6yNRxBtN0GIjrQlHkJHKMwIvrIDEjWCEIIPAyembuuG4Pvx2H00RgjlDQMffQoMfBcEf8Z8OxiPgM3mUy++a3XP/yRDz733HPzxflyOd/d3YXILGF7e3bjxrWuscJhMmmZI/tgLUmI5GzkQBAZ4mw23d/fPdjb3d6ZXcwvRAiAWYIhkxkN6/xns2wTgLcIFayKki9vg43VB4D1jbM6VBERAO/jYrGAyNrXz6JhjhcXc2OIQabiBCwRGFQJp/4PCzmb9jILwBybKZZQYe6YgSFVADeN+pxbk/ElCKDw37zxBFFMJhIiIMCgDY6ydlwEVQjaFCTNGOfUd4PkYzAm2mxzIyIIEpIKfoVVYWaFwDTGEIBI5NQzL6VEQQKHsikomwuRnbMxRjKgqp5kVCxmNs4hCoBl7cTO2HQtCpTWoupYjCEJ4NEnARxjqk+TjHijqfIlVTvG2DTOGlfMREAxGcBcJSURQQi6QYhBRCw5Q4bQAiGU9Agi5WMlY0v1JzXlRfOTcxpXHdovZHmZAnUVSv6atZYIwKARAMCU126gsemcpm1KzKjW5JTj2dIemHDWTWKMmqZARCF6ZAEAJScyjsiga2GMX//6a7o/nHPz+bxt2+VyaWj1FABQyF6Fo9rZ2fnSN770X/7Zv/Dic8+f3H0IIshysL27DEPTNUyD61oSEeIQowKMWEuAGIN471lwDAEpoa/E4Ofni9s3n/nM933mrddef/vtN566dmPWtg2a7clsMQ4P+1HInA/j/s6utRYlRJPS/ZGFBK+c3nqXpQ/rTohyJtbm2VVOsg0Jl/bpJRmcNrJ6Ktf5jeQsqbXnrtmErHmUMfrA8eatm2bSRofRB8dSOtcyM4g0zgXh+vIiWDcmoUg3W9ILKcFopNzgckbJa4AcOykvnJXo5BmmVc4IFhFbJ7XXw+JcC8/ZWkpUW42vWANFpgIAom6JFZwNXcpTjRk4Wp/IORxbdnWtpOtO0O/7vldTFRGHYej7vkiUusmoMUYkGGMMoBCTQPBBWQBETXVJaWuL5VK3X2TmnK/BCOyTLRvB6D63NoVIx9HHGJs2KdExyjD4GOMw+HEc0QVhJLRNg8W+VwsjJ0ABkmR/XfPo0aPj4+PpdPr2229/5MMvuwYXi8W1o4Pz8/P5+YUIO4POmZ3tnXEcptOpeIVuEIneGsMAo+8bZyad+8AHnnnnnXfOLpYX8+X9+w/dbOo5ep9c+sEvJtOtcRz7vteaHFNVoClhGIvaWWtjv9X7ZENgX0m1UPKosxbY+9EMBhGbySRGD8QxhouLC5HJDDoRmbQNAY0+zCYTXWIA1HJkylnEqneqkMBsS6nAS9ZPjM4l16tzrkhfzKlMxhhnrUF0bVvkAbAqYSGhQ1CpW0NEVMeG7jJmFlwFZWuFVaVm27Yh46JrbpdWkBcK935ANEXEeu+HwZMx1lqNxrmmKfudstNI51zbqDRgQwiuMUhORPwwT470idG0I82lN9pcVygnK0QHNsZo7CpvGVcR3JWSWpQVNcQBoG3btLlQRZ3x3gOTCNfcSV/HUVJurGmUzRhjojAaijHSqiYQ1WbVSR7HkYxxTUMAirKpqyw5GFTUoKJpxVy11Y+jawy5FdIc5FYxTdPEcSjcj7J/Qp9bOJ661pQjlUmA7HIwls7PzyeTVgMZzGKdBbTL5cVvf+3rXWfm87m1VgTG4J1tRZLVNY5jY1PlFQK0rXv06MFPfs8PfuLVjw2LQSL7fljOF8aRm5pFHFxnlrwEAzH6yN5a0zQNAAlgjHHox74fIxpCCMFLZA5xXI7TZvrgvbth6T/9PZ+an1/ce/z+/mxnCN4i4c5eCGOcbVtjWusWywtrLQcfosLcgcCqy4WyALjK9sUK0lgqYQyVoC0coPxUU9dlXlGzlMs8pPyKlVV9+XzJbb/H5WhbOyzD9tE+O+yjB8rqBYLW5VskqPWASyl+ZQDlJ2a2hdnVb6W0Xrin5PQZzJDLUNWzX5qCFdaSao7l13q3p0FUw6KMUbdhc9SkXN1BX2OFUlnbWCqN6jvAuhEGWU3GrHmUc1S1L4fkwkGucnN0inSbaVcJ55y1FGMcYwiRJazkB7PmrBGzjJE1DVhEWIAIfRiNNrcWiCEyhygsCD6yRVIcHWYOMfoYA3NYDLLuqxBMxK6BpWEYgLnUIhvjHjy4d/vO087Zi4uLl1564bd+6ysxxmdu3VosFpZgd3fbWbLWgESO3mYMkBAic8g8BQ8P9oyxw+Dvvv/gm6+/ARKF8ezi/HQcmFkQnXPCQV1/OocbIrasPKzrm3CVR2hjw2z8WW8bREQ0iEabx/XjkEBanA0cLy4WzLyzNevRb00nKms14YiFJ5OJgtqXrGCp6n1V6Cp5qK6jDRUwZ+gUXq8EUKLCAIAiVHJ5rUVM/N0ZlZpKrqJ5uxylxHGj1D37sIRLOO/HenvX01IkXNmelDKQA4AAcILQzEdRl4sBKjlAWxaodRGlSSKfTNd12tdBNQBlEYqGmLTJGE2ubyYC1d51r1lrcyQr7T5RbFckdeEyM5m1sFF+nZUrWEQIyFpLLtU3E5FxVlsbQqkTy6q5jk3nQRer73sOoWg/mCsFislhqp56StjGrjoxl1dQ8dw0DWWLp7ARzAXBOleJ/kER/ZCQiMhaVYNEvfrGGOYUt5pMZ2GM1sDpydkv/uK/vHXrlrroABJeehTmMairU1U37ci5s7X1+NHDVz/5CWvN6cVjDuN00sahDyJN03gJ1NlhHJhiiAHzhChTHAbfjz4woElbdblcNmh87F987sUXbz+3OL5YnJ6fnT4+2Nk9OzvnwV8/OHREQHL37d/pjKMnpBYXUwcq8bnOE1b1vhvi9tt8eeU36XvcNHMvX1Vvn8T5ZQWKuXF/ZnaNGzkcXD+mxvoQwJIET8Y4Q2IopPeCLJXWhi1XSeUyOVYFKud6X6x0kLItdZYkpS9teo8hEWvJh1h73uWnls9cjaPcSo1RrsryNpSIWh4DlHDsKmOiXLUxgHJ5YbJZaRURNqb0zRVeLwosAg8y49AdqDAFekLpfJcyLxQjvsoPjyBlSmMVfCqCX+3XEIIWcqiDKITUli6E4H2Ikb1PgZ8igIEREVvXiMh0Ot3b2wtx5BCZebFYaDT04f0HH/zgy0QQ/fDSC8+fPHp055lnrh8fTqfT2XQKwAia02SQtQZV63eTqo4i1trppHvm6Zuta0Y/7O9uLZfL33mj5zAdQ1wsFq2zY4gc+tTt8pKNKxCZSRGCNuihXrKNnwg3d9PmyflBMUoIbFJOLAAQcxhDqgTd3d6aL/vWNYFZvFfPx3I5L/Nf5GihLsquVKrKylV6aWzVWkuUWLOzLQBYa4phR0SKC6UyW0QsGUCW3AJPR41o1GWt4jaOa+2Y9HH6U2lRXMac7llRfmZ2bAwaQ5qcXM8nc9A2vuqvrvcjIubWNBiZtW2pSkdNaWzb1jUpubrrOk07UtVBR1s8BEVRKJ5eIts0jUQum0s1YCCcTDoyCctWsr86xhhs4BB1O+hPwCyMtm2q/OTk4NXXSeLTgiYMI6K1psj+tIuJWudqgc0ZFavwh2RdAJhcE1wUGszVjDqxpcit1uOLlmNyK5oimDUburoVEpK14L3fbRpDFoAABMjevXv/7r2zV24+c3J2Vqi9OPyUewELACuAyXx+bg29f++dew/uPn74cK/Z2t3dba3r4zDi6JrGtu4snIGB2EdVIAkJkVjMYtkv5mNkRrIQgoQo0RvXbNnZ8x94buK6eTj147g16Zilde7mzZsnZycT24CJwLy7s2MACZLo04bKinuAVCV/ZGQrWOfqV4q9jc9rX16K3D/p5Ccd8m3t5rWDBRDBmn7on711o5l2FxJFgAAtGWMMUzYagUoItn7BJw1MbeuE9lKkC+ekKkSsVJOVKKpxPSBJPsJc6VE/r1AMVCZLoXLO8qMIVL1n0THpUleDPGgsjGbjWbpJIMd664konKtIBRW9pYq34mxrXAmyJ7y+Vn/yIagJwyLBewBwjanfEQiNgPaE4JjcCfq2unt9DAZtDBxiDAmmAIBQWAQhcIwjlwFwjquu81PtVwIDS9/3muYzm0w1SSTG+OabbxuC7e2th4/u3376FWvttaOj46MDlHh0dAQSLy7O9nZ3rM3IGAJFuYbUbM6w9r9jmXbt0eGuwG0RefDgQQz9a8P7h4db77///nzZEwgawzFoV4+yQOnOCKgo9RX91IoOrruDVq+ZP20oUuU0zqGQEIKivBlEh8ZYi4iDD+Pj0+3ZFqXpN9tb0+Vy6f2guMf5ZZPVi4gls68Qj3bZ6rpO4aWKBayletakvpnWNCUhKLsksSQikYEiaJWThhCisLOuyOCijBbdrpA6M0tkFFBMaUREQ6n2MWd11bsJAIxBa1faAyKa7J0GgOQSBzRgTZPiBSmXzfu8oaBEcwySZjKp+SvZFVT2uM5bHnDMWy7rCtaleSBSWJLlctmPHnPOVMzgdHora20YfQgkEo0xKBKN6cexbZ1zTkenyYwbzLTMA2Znvogsl0soQGZEtoLxazkyAAEAAElEQVSCofX+Y1i8gGqLAxVjugTg9a0RsW26UjGli2JyOUmRsvoglchCBhEtJqNcq8JYoraCbVzs+57F2Bi/9a3XAaEfR2Z2rvEx6BprmXhaIMBxGJrGGoMPHj76nu/+5G984fMo8KFnX7Zb+ybi9t4uzM8uzi/spDGO1GDxcbTWGmMJUARjEC2nCkRalCEik8nk7lvvffqTn9qezt75nTfjcphM2tZZLbjRbmZ+WG7tbt1++plp29BaaRCCkIAm21VySDbF0tX7vTDt+rRK6OJVrt36UPF/5bFBKvV9Ll+BiBAiOBOEpTGz/V10FpghRmMsEWmbQuYg2gtsXfo+aYQigkioNMBVtl61gXV/rialfIgxKoPOs7b2RoVhlXHUAv7KoeQBZX12vU6gKKq1a6i+Q81uoGJYsL6i5SmyitZIgaOqA8aIDLBym8RcXK9D4owx1HadMQaQfVAwZywKR63+q+ELV4kcBgEBzIUxJcpeLLB0K17LMhDOWNPrMQx9i4uLi2EYtmYTzc05Pj7+vu97+uzs7L133tyZTRfLi1dufuja9aNhsZzPzyddY61dzi/CbGqMMyDCApBqKpbLJTM3Ge6YhZmDJZl27eHudpDgx8nTt64NA04mk/niXESiQD+OMrLJHl3YyF3MevEGXdViuKzUBuFtfC4uSsml/ukmyAJamC0GVIlEBnr73fduXL82m836fgnArTPGuMViQdmHjOtHTTDM3HXddDq11sboi/TVihFEbFyj9GmrTtX1sJmZo6eMyaU2WSJmScJVSdG5piY2FYdY6aP1dGlLNxFBBkjJj2spJDVFYTbxcaW/MuQMlGEYY0zu34JUhYgqXfSNfPQckj+AmQVWykQx03FtfblWXjWqrQPQVt9d152cnQOAZkR674dhwCr+ahKsm1M/ADOjMaXlqDGGYdXUyObSZwAAQgNkrW1bTYlPHuaCSaLDLtdSToouNi4AxJQWh8LkbGtNDuVCgpoXkcbYevNWAnhVKb7GXW2XSM5Ak9zARAaZeTH03vvu/8fbf8ffkl31gehaa+9d4YRfvjn0vbdvB3VutQICARZBZNkYDBjPGPzx2GSeH8nPHo0ZB2SC8bOxn58BYwQ8j2cMjDHRVrQIEhIKjVpSJ3VON/3iCXWqau+15o9VtU+d8/vdRp43n6mPPq1zz69O1Q5rr7y+yyXCCAzPPPecCNS1B0BBYWZrEkCJsTMRAWRjME+TEIIz8NVf/VWwc+2dP/dvV7/xvz+1cfz45tbu9t5otJ/kqXHEwETgJUhgYywKCDNS4ut6Op0F0TYnrDrBbDZFEQP45BNP7F/bkdqvDAZXR/smzfrDgfd+PB6vrq7OZtPZZNrr9QBAsRh18xFa3P5uBZos8+SuaIjHGTpy4bAAWrpu9v2RDORVfrt0f/ynyqOxL1eOr1Oe1BxQGAFNe4i46YnS+vxgeeRL04xxM6UN25FVpPloyv2wY/DBYhGwyIKHtvu5y3bjN4cnzG1lXtyeSKm2FbR6RV+OdCBboWPsLokraFNwY3x3ibk751oUEYxP6PLc0EUYaK/48GiLIAmLJ6E2lNLcEENKSzvdcL3WbdBuGwCAtdQV+WQ6SI1CAFEMgAhAiwYsi7qI+sOzLFMFuSzL69evTyaTe++6+w2ve6i+/55nnnnKIKaZO765Qcfo2tWrxpi1lSEKh6quOCSJgvwZ7/1sVhXTMviqdi7P8yRJENBZAnaGQCT1AathniVnevmx7d2dYa/PzNOinExqRHSJWezABXETjjwPUeLionY1P5Cd53TFc1e6I6I2zI43VMGHqjbGZGkCIbxy9RoAbKyvIsYcXQtAGsKUFoUtz/Ner6fuBNGWi0miixBC0Fxr59I5jCLMM5O7seSWzInZQ4ec5npDaw1DC2nunANyvtPvL8435i7pn0ILrWxd0l0rRPU+NNnaAhwTYQAECSINxzHokLTDnfde0VTUMaAKR1xhDQZbtEFrtBQnlyD27VanqMy1c/G+iocrBshZPAAba/Jezzk3nk5CEDWCbdvVtBH51DQVdm19VEweBoCm6KUj4aiF47DGAUCaJM7NE6S50xcBEW2nMxi3ZVSRsWDbc9e2ja00qVt3JE1TpQfdS2P07GNUBfTOVgRDVHpAiUTRUAEBwFhKkoTZl76elYVN0iTtF9PxY489ludNV2Z17UjrSIsMJ7BX2LDxaHb7bbe87rUPlDdeeej1rxWSk6dOVKNSK5d2Zwfr62tTnhljpG4PE4tBNGlSjopJUQJQCCI1G4PBVwS4trJijbl+9ZphROErV19ODFVc7c9Gg3yY5nkAvr5z/dZbL2VJithkqnsR4Gizzt0MrWy66bUka6V1wB7mGK8iUw9fi8IPvPBSTfASz1n6pyVTBh8gbJ46gc5UvhYSZwywaL0zEpJWHwUJHKTTzvXIB0I34QlAQw7UMZrnhw26p7q9uOP4jT+JB6D7YmEUgXlHsqPsUeqcAYiJD3o8rNUDqdaG5mZ3w8PxkHffK50GfEcKYGMwBFx8iCgKtMjcfo0YkNjGjFslmtVxrac6psiq1465Qdo6vCZHbgMihlADmKgKkIGl8bdcUqGDlSg5yuC4sNba2WyWJgkQeO97vd5Kf5Akyf7B3t7ezi23nLtwy5nr16/NJtOiKE6eOGENSuAQQq+fI4u1pOaWdihqx09qDBE1aURInoCy1DEjr/SZc2Uoe3t7s2dmU56ladpPkhDY3+S03ew4RU/GYRncXbEl+on/ZEEOEDDUoVKvIxlDaC1aAOYAKBCCbG/vhlCvDAe9flKWhQqqrgqly652Uky86vf76lFAROW8xmgxkhXRBgQNrSKiMKpYANBC2A6YaOutjbCFSp+al9e4KzsJR9JpaRxrDeLEW88NiiCRgkO19zfg0tzVcbuLGR+r7hxoU6CttRLYGWuwyVYra4xOMr1BTVXFsaK2RiDmH2kmc7xfJNgWtrORmuwBmsQoAlRf9Kwq9R7VG2LX4Yqa0n8bQ+Yx98oYBT40xmG32gJN9GlJe8o0e7woCuz4/3HR/4xNgRw7Z7T1nkvTBjYgccYY08ldh9Y3pi6ExgcDhIAIqPmA1hitWVSEFmYGxcTC0IB7o4hXeB8wxvT7eVV5731/NdndufaJT3zizJkze+MxgzCzs6nWlEXGZQiYrSUaDHoHe5MvfcsX33bbreOhe/MXfdFtpy/WocqypK7LWJgwmo2MMVyyMU0deeIcubQoivF4wgG8DwSQYcLM0+n02GB9dXV4bOXEeHt3Mhqvrg7rshhzKCbTSVH085yIzp8/X5fToihWVvPu2RQREpGw4AM78vh3f7J0w+cuaI/gKjdPxer2Xzr826WMMFWSsn5vZWNdDAEzahMXZFRJQJ9Tu+JWWgF2ev4CgFXVGw+lhoe2pjMKIem4drvSBRdjvSD6tGYO3UBeFEXYqYtfMpEXvcEYeYTW7Mbch+4443mIY+jaCl35h4jq4+r8pMnGard/mQLilEWC7k7D1BAUb0HRcDRnqigK26aHyOLVcKgYYep0i4pj03HNNXHUJjFqly/EU0XafLuOioANzEKTd1qWZb/fB4CXXnqJQ33vvXfffsflelZUVTWZjPI81xZ1eZJq/ovaMXVdK/dJ05QQQ6h12RNjE2vRSl2XAcVYyrKEmVfXckQcjUY7O3tlHSrfto5eJBWZR3ReLfehu2vN56MUF+iIokgGHr2IoBNkLIqCiHpZvz8cWiJflYBcjMcAUNf19vZ2mh3P01SbV0onlhlCKIpCA37qb9R8Kw259fv9mBU1v2Cem9NIKdO6c6zVViqR1KV1gcTd9HXtvXbvkaIoXDoHgsDW8I0jjNbbEsPqDked4WU1Iz/vu4eIRGAMxnWL843F64hoyQAZoqBtl7IsSxJblqW0Dd2oLVlmotj6mspOq10/VyygdYA3Fa5EoS6rKjjner2eiEyn07KujTGpS8g6WoS/QNT4sUdE1zj2Q1HWIqJqk2dVXBpckYbRy7wyOIQAYNI01QIBlabGmKqqsizDRc7QCle1R8FaCx3w0SbkL00EQe9PndM4sXR8CcYYQ069hJFUIqNzxhmLbQ26xM56jNDmlpcQws7Ozic/+eidd96mrjJhREPsa41qVbOSiAiFCKuqstYiwe23356mqVlbe+1DD9T7lS/9lRdeLssySeyptRNk0HuPdq66JWSyJC9FiqKYTqchEDMTGGutJ6p9ubW1debMGS4gz3MUnk5GYACRXJqIyNXr1we9rJ8n1tper9c4TUHzPAC5YaVIHaW5c4QXueOyz1b+LIH9f/pqhNpRXm5Y5D/Nf1nQYH9laPO0RrDWBhYRsYYQEebRHDRIhBhAlp7TFUDxLZGJWUdNXA4A1MspqAxinnHXvkOkI267YgM6rmBtiNu8iZp/YEvg0HIf00LZ6Z3c1MwYibUE7X8BwHuvJbl6RFUkq74MJBp20oAut/g71lrlLMYYYQxBw1SUtGUSnhkAjUlEJIQ6Fu+2BmjdfjbRJlYYBwXb8zXXFIiEiKaTma85TVMEoy2JOpbrPCyNRAZA1fDUJTGQM19k8TFzBREBGVqNmki154Z5KrnHBaQWC0zFlTI7MDSZFf2hXd84gch7O9dX+3k/y/tZKhxC8GgEECupyVEQ0U7PmkCLmOjycuy7bihAQIvARGwRMUttWZarPQvebm4OBTxDoMRUPpB1ZTUjixaJmUnaJLugR3PuWhARQ0CGAJqkXBGRpv81ICBQE/mGjuiFjuBpBVKog3hGB45R66HDdFbsT0Zp6hLr8jwP1mxPJjXi6nCwvTvt9/vOOGiTaxAxTXNW81TAoinrYMP8XWli08TapIdtvNNaiygogOCtsdaGVmQCYtMRT4JBMHVTXd1AO0WqUEFNgOwDAyIAWcPMdfDxGEV5qf7bpszJkDEEhAQgornNtiuhSSi1qa5Yk6vsnLWJYAN4p4PJsqwsy/F4rCpXfJ0gsARBFktSzeWTYnwCkCWjXkYi6OV9EFHUCy84xy0X0Xob3XBmBrIuNSJSBY+IYAgCDIdDAJjNZtx2C20dwt45A5hCwxMEMSFH4/HYZTkRZTYXETRW1aAQAvtAWIuIFm8BgDPiMmec7fVXZrWMptWlWy9c3jz2O7/zOysrK2dOnwRfAQfkMnXWew/WeAbnHIukLk2y/ODggBkIUAL38lwkSPBpmqZO2UPGzMxTdUc7g9Y2yEhcV9qjiTkQoXOpRfJkkUBBhFFAIBgQEBTPiFYYfR044MtXbmhxLAdAocQ5riur7XIZCBPSNqYSmH3qEmS4686LKVUmT89ePPfRD37s0U8+Wo6rOy7dngx703IcHLPUEEoKdT9zPnhMXUW+mqbjcU2WPJeMYJNs2BuOr+zVBbzm3GtWMSvDJE3dWr4xSpMbN26kltmjZ05X8okvn73+UpaYy9mt7GtHKRAJ+AAcCD0wGiOVRp6gExud66AiQkdJ2CalC0EAtJYEFWGqVQS5ibo2Zm7DBxbt2hiko9YabKRS+18UYLW+AISQmQOIQhuatqi3zuHG7va5E7dZawpfVCRCaBMLZBT7kAAIDAAIgu9Iv66UjUy+HRpr9YSIzJNlmv+2BnVMelrSFCI7wBiFboGljljIzjvj5y4bPXxpmAQP+aK7qnEMCdd1LSgIDVpImi74OqJNTG0Ol4iQIWi8EHMUAuwknULMmmEOIVibSCeVIN6jJiO1eHIROAw73oKo/GLbn1hZnmIvcJu60l2QloMvRKe6Q5qTUXsntfjyOuXEGUWB1lwhAJhMJpcuXFhbW/Xe9zfWkqRFmYBWUdDNZY7L1Ro6dv5SEdXU9a86ZmutsNWkGPXSp2mKxGVZGsAQyWbBXbyA6Q0ADE1jhDmFkAC3QC7tlLs3SMew7lIvdNQ7HdJkMhmNvEHK8zxLnTF2PB4bBDPsHxwc9Pv9rN8YXkRknLOd3AXbroPWJqVp6pJMl1T5e+OxNDZuemeQCzkQyAvaapwFM2tpLnbygLDNZuIWqDxOf+kJ8UR0l0IXIcsyavGh1AaNyXTR665iWA3E2WwGALF6XkeufmlIG0rO85wZ1CWAEilW6rqWCJ3d+GnnDf70ip6thh+hQRJrrd4fkbySJJnNZnqcgU0w1vqYxc0AkGWZemiiv1qQyrJEBCJyqY35WSBCRD4UarL3hwOT9j72rnd/9qmnv+O7v+dbvuVbfu3Xfu3RRx+97+67EXxVcl1Vg8FKURXWWgUbAWBgSawzBhVbxjOjQOAAZem9sdbmwx4AkAbCEY1p+BURSOsJiPF7ImpaNJJBREIBIKPHEFiQRLD2vL+//+STT8a1ihH7uOPRT5alLk3d3t4eIZw+fTpNUwMhT7Jer/fYY49dPHtpWs5mfnb8+EblZxiBGUzTLgURa5bxeMygDa9IREajESISgG5KAEEiJMqyDK0JvtbD4qvaGBNCfePGblEUfdeUYy2xdfwc/M+vfi2Ip5s/Qal26YaGRJce2H7DrVIALZs12OBYR1Dk6aw4duLEyupqLA5ClSaHBqJqgVn+ev7XeISpDdwws1UQbVlkcnIokbh7zrHj8o2/i+cNOrJkaSGgw0eWFlS6RDbP4Gji0MpPI3tSDqKdwtA0HNwYQ2SlTSiVFgNERLSAR9mcD1XkldjaT4hWpIbONscbQtuWNW5eXJ9onVMbRmJm7JQtxZk2N7fBWn2CpmlohaUuIMu81V13QbhzmcUk27gFIYSYHcptIDPP81OntlZWVkRECzqn02mer/tQ2xZjL4SgqB3YUkH0diLOsVY4BO3d3lWGAAAwtbNSgKhBXCFoUIuthjuFMWq/LeWTdADb9CQ02e8K0quhEqWiNua1TCTtFXWymAClqoBzDgidcyEQCk8mkxCylWG/rnnvYD/LsmE/mUwmg3ytrINzLkkyRARmp54VAGsb6asiR3WaJYZChHG/GgnUStMmu6pigXmvOtPCIcXQgzbJio/lpk29bXh0x6hdOMwdHE1jFkpvsU0p0i/NYl69IItABGdOkkQbZ2V5GkLQVCwiQmpgtDk0zKJ9UVuw0MJoEzXFao2ArypQtwBhXIo4i6i66UOsSVyaqeuV2iLgtgK+ArbM7Ni0rEYLmgmAqqpSraipRwKFgZtnROp8idCA8TWjIWvtaHv7J3/yJ8sa/uvvf/AnfuInvuO7vudPPvyhj3/sT45trp05dbKqZjVznucamIilRN77eEhDCAJANhFNb6FGsjawZawJIrr7cwCvdgsYDKWuTc7ScD8LIgAKAvq2jUTtw6OPPpompJUIcTpzmidBQWvtdDpdXeldu77/li98rZYd1nVtUE6cOmmc3T3YTdO0rIqt42tlPWNkYTGuGZgEIMLJZHJjd6euPAiJoEFbl3VRFBdPXxgOh5NZwXUNgWd1Za1NsjSpuJjNgMg5F7huFFPnDknellARsUXwP3zDkeZvh8iXv4G2MIekhZZcTDxa+ufCb1/1QhZpS5YjJwSAoq7OnTye5FklrAPS3AUNDiu/Czd5dlcOxs/RZFJX7hxIGRZFZpxP/NAVSNDRuOMTo0iDQzJ4STYfHmiXwzbSSwTadBVsWt7OXWHUwqsG8czsWduuLSRkmTb3QcTHQF1VNyZdNOK74+yyeGwq7oPcfP/iE+KooJMl0X0FaeFYC6uEiNba8XictNCAzCwwN4ij5A7tFQVtfHh3XzDiMRFMp9PZbHbq1Knjx4+fPn1ybW21l+XW2rX1FUvGe5/lGaKIvlQLlMNcIrbT12K1Nlcc0fvGuOxqGN6DNOk/hojqwMF7RGOQg4BK3/kCHpWwINzUCwJoY7tGx1fL2XYwmbvMaEmli/9UdqB5vCEETQIUEUNUlmVhqdfrVbNid38vz3NBM55OBoOB9h4oy3LQy/Tnti32VVvL2oTIBsEkdv5ocR6wUzYTdbUw71BiW61ynhJIHfBL0QYMKthagykK4JiRt3R2OgQ8tzWpE7UpikKNYNOpJwaAJE20zIzbyKUW/6QtdqaaxR1NjojmeXmIoKptYN++tLHyyRgkMq1+6UMdf0VIsbYi6vGw4GuRfr+vvXsVKtIZqy4qIxgFsO6/5jzmWb8l/CYLPRJn0wAqsDEmHwz390aqnd+4cYMD3H//vR/4g99/45s+7yd/8ie/57u++7Y77/j997/vyWeev3D+rE1Q/GxlZaUbJhgOh/ohz3NmJmpczCp02QetODLGMCJKaCXuXP9Qfc4LE4JAAEDlcSTQVJJ1LJPBYDAaF08++eSJEyf8Ys/EVoVtKjh8Xed5vjZcOdgdvfGNb1xdXa1mE936Y8c3H3jowQ+85wNJkgSuKTXFuBCEADx3RQAAwGRajCfTWltd+UBECLg3Hr/5wTf2er3J7n4QDhKKcgYVeu3DaqisKkCsQ+ONF0SZK9ntqdQt1l7OS0e+I4+XqPrwbdj4k+fS99CaHP3zV/k+mgLdG0hAtHaq86XJkqzfK4MPiEgIIMYY7Y+kmAZ6uI98b7wOqwWRsduuIQsdUdQYap3F0rC6b9VVQ4Qxl0R/iE1fvYabtipMlBALy9r5piueY31kI9dbiTgej9UWgQ5uV5IkVY3UtitnmaPeR1HKTTILCoS6boAC4jCi3aB8ZD7Zlj0FXli4eE5ijFntTr0/yzIQ0czhGJCey7DWn9kOyTTBWog8tOFN8fzro7TPStxIXa44weiI1gQiZynLMoWYePHFFwd9szocti0ErMEmP8s5M0/zlyYLggCbNGv2nUbL2PBONFps0JV5pa+DQFHO6roWMglSVdXSQvguED22tL94iQiwhlIDgu0SIcAc+AU6ihp0yDLuo0pBBSvWXPRYMYmIXgCFD0YT55xLs4ODA5ErZ8+etYmtKj+dlWsrwzRN1X4e9HNmTlzinNOkWiASNCHIaDRaW1uz1oa61kImgsYMjUatDql1wyw0n8COdgUAIAQEiETS9DLCjoIcabU73+VTY7WcHIgICYVESMgQ18zISKjtcoUEjMbawbX9kaKVjJo/aG3Ub+IBVOxu2+I9ec9NLayxLSlKPI+RMpnZWIo1C8pP2qLeOfFQB37ZdCAhjTGJbfDnBRpYXC1MqOsmOTRPMzRqnTeP8h2MSZ1XYt1sVuR5Xge2abJ3sF8zVHV97Nixzc3NH/7hH37/+9//0z/9U9/wzd/y0T/58Mf+5COXLl1aHw7qshKRmIntEmOMmc1mvV7POSdI1lokQy2Iguafq6JDbbVVF8AEEYXQSIsN3hwDpV7QpvXt9hIAXLt27eGHH97Y2NrZ2YVF9t2QgYCA5Hm+v797/vQJALj77rudc8BJEDaG0zS/9/77fuu3fjtgWN/aSPNkVs+AQmS6eqQBsKirOjCi8dDsXV2WFmBlZaUOVR38eDohASasfOnFN70fOBR1RYSBeVJXdV2niV1kkoKIfOiwLx/8m4vMKD6OFNULD+n848gbjhSPUcouHMkg0h4xLWLuba5kw77nwEyYaEMTQBZBAQGznFrVPHiJ9UEnzzfOTv/ZSI4F1oYgAL51eeuXUUgvcZkjlyPe0PXEdt/dGfGCasCdjmPze9o/Rd08OqxC23ShtXQ7Xs5OGlRkBDG1u8u7oZF5IIuNLEIIQdQ5umBjxeONEZ+25SPWWtNKWd/2YYVWQVmaqTGm3+9rvWmTAobzCr8uE+/usVkESIoCXkTUKYfAyj7W19fX19dD8NPpdH19XSsx0FCWp977umZEBNKGlnO+Kajlzgtp6ogInY2TToy8DrC9s3Pl2o0gnCSJr7UsB4WbPAndfm4IvgGMiGQ63wgmIGHhrmXfJdYuaWFbJtclNr2oddhmWWZtMp0V6lEEUHhCv72zt7624tLsYDzZ3t4WHp47fSrP86KsEHHYzw01fQOt9hVoZKI1xrLI/v7+YDBQzUlNH5RGW6U2GK8DU3m2FKmRjp9ZGqVWf7hQzh5CYAG7WPcSCQARpS1mUJmKi5Fg7JQX42IxXuikZFs7z9synfIeafMnrLXS9tdTDaOqGqQqaHAQ1VOC2AYCIpKdwXnqRjPyNnk4imGDJEh1XavXQaWv9z5JktTZVgA3KNOIKBJUE9CuTYlNVUx6P0+5j153nVRu8tmsUsZ59epVROjl+TSfXb1+7fLtt/3u7/3u7/7e7/6bn/+5b/3Wb73jNXe+613vGu2NTp06hYHR2ISoqiqQVGPhiJimKWhowFhjTM2B2BO0jjSSNoNFrG26d2CjNDdRkkjw1PpFYqWDQRJBY8wrr7xy/fr+qVNn5rYjCQTQ1VBsGSWVft6rqooILl++RAR1XSeWxLksTzePb6LBG/s797/u/pKrSmqLQA2emAUAsrYu6/3RuK5rJFuXM2sSYJ5OpyePnayq6sqVK+W08GUFAEJYlDMk8hyq4I21UFdB2CSOiyrSfCz+PywJl0SJrsCR4hdlLh3jl0ufETF6oeNfsXNDFHiIC163bg1SVILmY1ssakXE4eZ6b22lCr4MdYYpWlDPyjzhSwgJWyAsEBTEI9BzdSig6Y0grA5tQsvMgoDU2K/Scsa69vHQdscUJV9Xr++u7JKsZZ6z1KWd6P4zypulvKTmMLct3vR4Qxt1Zubo8povsQh2NgA6AM7QWs9dnggdoxMaySCa7ImAIgvSOnK6EIJtkQuJSEuSmiPaPlDt17rtp6bP1wwszQ+KYk/dEUgtCG0HHR4RtUcUd/qN60ZEtkhE2lIG2lKZsiyLotja2trY2BCRxJKv6hI4HfTVv6oOPWCNQbWphjB3D3AniQYAXGvlRwmhAafJlF988cVr164R2sSZupoigDNJ1cbaIXqQlFYB2rJJEGnSGpuFZ0D0ImTAxrlzJwDWlTGwaBB3JYoOr83LS1V1Y+YgbMiWZbm3P9pYX88yur69QwTD4dCmSdKCUJpE85sJWYQEQZPVyDqHaNbW1rIsS53z2LB7bOsF0DeiqKFhIgQwHds3Jg/GvzIf6vvUVtFokHVJADfZSZq51qZK6Q1L9Eyd8Ef3vMRkybhc6qtXvEZo87T1Zu89YeMJV5ePvkuFXAQfjGOL4fC4v9ERHVqniIggWiKDiIDIoWb2IcyVgKbCPnEYyGDDOkLbBhuEmFkyLIqCoMlvsrbp76s/l9YXjYjWZkQzz4GI9nZ2EwuI0u/n1tr9/f3zt9zS7/f/h7/5N9/1nnf/k3/yT/7iX/xLj33qYw8//PCJ48fznmMJa4NhMRmvra0dHBw00R8CACSDSODAaBqu4maT+i1gTgPUtiCkNhWr9hUJEDSxBmMMGASiUJZ14Mp76/2zzz4rAFVVe+9V3h827QxBWRb9Xra7twMMa2trXDcpGsEKAPQG+YnTJ55/4fmtE1uzcoIGBIUIvBciEDaINJ3Ort3YqTyTRQ7gMqetnQeDwfbuzoHsGgHNPiuralxMbeIIzLQoXJYCYV3VxiIaAkLGuTjsysV4WmFR4YZFpr1wAjo/OfKv8b8EGFHwuj85LLY63zcQQV0xHAUStTZsAAFCEVjZXGdCFkShmoPDRMQTkQTWrW0GrLNu25cffnUcQFf8IaKNqnQ8uvpfs4hIFf/atTzil3ogO+7cheZF3AkwR2dsWMSKWro5Kub6QGwNTeh0MdLAT+zONGd8rZ82+oEj1wgRb3kRpLqxvJdGK5o2NZe+Xb4fBbymHOuMVMONz/Te196HFrSI2zJTADAtmm507sGiaIn81BiDnX2J2kyTqdPqQ9PpVM0y9RH1ej0VyXVdb545672vfZkm/aqq+oOe95WC7yj6IADYBjSdDS1kq849H7TQrCJqGLu7+9t7+7PZDBEVz8QY4+sQbxNpIrua4n+UcjyfPjQ4DtxkGR3CVosbgZ1aWOiARjGzwgSGELxnTeqx1o5GIyJilCTJyrLc299fW1sj43b3RwAvO+fOnDxBCEQNSqImQgrXhA5JEJsONidOnEiSxKAgumZ3pPFnGDLQuuixcwS6c9RIJiJKU8CqE2liS845Rpu4lIiEG2VUJ6WCk9omvl1lX2+LeVLYVhDE2AR1miVAR1lRW1YfqM16deyq2DWOKJmbLNyGTpSAWbkfd6AhjEEzBx5hZuNtqL1m2EcYyKhGAIC6bYqiDG3TCw2gaLxDo61GLBpCRAnsa0ZELT3I8xyNAobYFj0XNbwdrU/n3Pp6XtYVCF699sqZM6cMQuKMcy5JbFHOXnzx+dtuu/zrv/7r/+F/+9X//T/++tf/+a87e+HWP/qDP3z2xVcuXjgvgL3BkAB7vZ5OyhrLIJYQQNBZVuMbxQAimXblKS4ImDncnmjqpbrqpCnfJ0AIwSQulLWI9yyvvPIKAJRVRWQZFqSRai0AyMxpmg4Gg5dffPkv/6WvW19fZ2YCqaoK0dShXt/cuPeB+z/79JNksRzPrCUB3/qHDIsww6SY7o8OBCmI8hMnzJZMWZbT6TQ1FgUqDiEEBgkI3teZobSX18GTNZnNx+MD9FUQ1vU/LHWOEoEAqvG3N3Rl0kL1nX4gJDlapC2tDB41gMOvbt6DINBUMXVVhJZnCRCKoXTYn1QzAUBr6rq2iSOywIBoluxctciX3hJnJ23osGsZIuKCw7PL3XDRBu2K5/mEO/JcWvU5fhPfB61J131F15LuDkg6/dHiN1GJjmJbzRrtx6JBzbqui6IYj8cq2KKrDVvPm7KPaIDGYXNnBJHXd3/bHR52bFYi8u2l50FHNRqNdnd39w8OpkWhA9MRaoNhaPWYyKSw1YWxxZoOMeW91RviGJSxKtvS+s5oHKidZzrwYQAALMVsAo0ZUdd1XRWzaOU08+Vmbb33jXtL055D0Kn6ui6rSjtGBAZAw4KeQ5AGN1j56Xg8NsZNxoVqP1XpG/ZvIITaIogE6qxhV2PrGIJH02SXTiKxRfsvKmcRRlGXSBffOdfv9yP1E1kAULAOANjbO7h2fVtxoVfWNoy1mkCumJT6Fk1oIiJABvb6jUZDMbafMyZNUySSRVBoRKy911qOKBSjgiitUhuNNmriKUBtIjS2vYOazP9OrZosmhQqWfUgJEkyGAyoTaEioqaCqMMRvPfr6+s6Ta1Qj7kL8ZA26WztgncVTQAga5IstYlDQzFNVC9NjyBrjHVJmql5oCujaqvepruT53nUDHRVtdeyMSZNcmuS5l1J4torCqfBYKC/AgAgNM6iIZcmZE2e54gIguPxeHt7e9gfIAr7GoGF/cqwf/rUib3d7XPnzly8dP4vfv03fPf/42/t7Y+//Cu/8s577nv8s8+Op5VLcjIWjdX6KO89AhNK4gxIHQGuI2xLnudojRCSs2jnASNsLYQAQs7aNG2UaSAG5CBAuDJcG4/Hjz352VvOn1aVKGqZ2mIongXdEeccItxzz12Dfu5DHfVy7/1w2P+CL/qCO++6oz/se66BNF/dO6dkRsxcTMvZrPLMIQTvg2nwxCUf9D2HikNAKIOvONTC6IzJEnDGc7CJCyKjYiqEo+lEWr4ZWt3wSBNriZVFil1Sprt/7V5L33R5cpctdH/bFYf6VwMYXTe46GGSwADgElP60mT2oBidu3Au7/XEkBAaY7Jezsyh9twJrHSxJw+PBFu3a3Q4LTGxJtcx8sHDArU74SiBusuEh0yTpSd0b4PF2HD84ZHL132L7/Q7hJZ9iCZedZIdlIM0/q5FV3OXicdxSpsiv7S1HKtvQZ3QjccjrlKcrDL9+KHf6wU1LTvZUkuzW9KSoo0iLNH7Zw+51uNvu9sfH5VlWUTBVBuuW8SVpmmaptaQAIcQqAbFxInPiXPXuUCnq4Q+RNnBAj0ICWMIYWVlpZzVk+l1731ZHlhrG4QpCCIkEkC0VwUaQQAmRIg9czpTiyuPiCKh8Y2jxUP+pSUak06kQ0Qmk4n3fjgcalxgNpt5740xvV6vKArVW2ezCtGEEHp5miTJyy9fybPkjkuXEDHNeoRCsZsNWWOcUhOisZ2kMOX4QXxM/wGhbgcCADDWRrhH6Lh2vPeIauAis6/rmtDqDqoGmc6T++YAxbE2RgGfuY2nQOcA6kwBQGVwK8xckiSKErN0BtVnEGmA2zyMRvADR/WCiEQCAGgVUDNBM0fN7Jbs2w4sdnwgtXXntQ/WWjJW+xAIBkdonBWRRgBLLK9oAbEDigglFkPTNpurajAYQBuOCSEoRIWuPxGhMYDkA2dZtrd38PSTn906cdxXdZLYEHyaJlVZEsDm5ube3l4I4e677/j//st//XM//wu/81u//dYv/ZJz58798Qc/eOPGjfvvvTvLsn1E1MZNVps10aCXV7X0+/26rqu6draJlEmbb4WtgyGuQ1NmGgQNC6HClkIIDM35OBhPPv7xjydZWo0mkWwO8RBOkmQ6nSbJSRG48847dYVNA32KNk0ms+L0mZNf9hVfXvqSCKwlYRBRc9yCmGJaT6ez8XTKLM7ZNLXMPJ1OxUtZlmnfCYIHlsBBGK1R7Kfa+1q4qquKfelrAkaiOoRgSRb5MwDQTYqAu9FfWbKAj7pUqHc5ORySeZ/j1Qyj/VFQJzJACCFLXFlXnsGlSR180ssH66ulBAbpRHkx/pYRcDExG1kOS0zoolS1VzQvaa45doZ42CrtSrjuWe3aqd0nHOaYc0Wjdc9GYbOkAXQleqRdgIU9ix+ido+dqKHaFr5jR3ZZdqxpCO344RBCfZxddOIhomqg3FYxWWvV06tq76DfX19b444FHx8SZ9olncjUuksqi6gg0rEUoaPrRPuVmqbrpsnYdM61HW2NMXme5700WupElFpHBKqjNHtH88VU7h9HG9pLl1TNr7hx0OpnmUuGw6HG3rz3NnFdHwOi1oxC1OABmFAAGWkOXrNEHhIgeOEwP2ZdGlvSFJcWSrXv8Xg6nU7VNJHA1axMrBv0+qqpQFvQ5T1r9cvjjz35/IsvaFtyAVIVSrhBsVB9zhqM3gXqgLJF2S8IS764Lg2rCdvustFvQltXFjqpgvpYbvyZNtYI6bCjMwkAqqpSCzX6RVRIqEBSTS7GnrsL1aYWQ13XJkn6/X6v14spBdA6h+P0I+liiyqjwyYiPQLqNkjyTNcnSZI0y2LjZL3i86lTuo1tApeaxdY4QmMTp/8zLjEucWmSZKlLEx1YlvX6/aExLst6RLYsa0R0aaJOizTvuTRDY4mMF8gHwyTvXbl+7aUr20mSCIS6rICFgFNnnHNZkpw6cWJ1deXKlVcuXL68trbxlV/+5X/n7/6PVR3e8qVfevHSbR/9+CendX3s+Imy9npGsiwjAZJ55DuuhrUUXSPY9nJoKAT1vGEQDgKCJEgM2BSSoiGX3rhx49HHns2yTHGhYeFS4TFvvTybTRHg8uXLujVkQETKulb4rcFweP/994/G+7UvDQERWUOmKVU3lQ8Ho0kITEQNniVi7b1zrg6+qMpJORsX04NiMq3KikPNYRbqMvgauKgrAbCJS7IszTObOCV+XCwzg0UB2ZVMC7M6JDu6x+fwrz53oXv4XU1g6xD4ZcyPAyIhnFbl+rEtl2fciZ8CAMHCBPW/DAvjj4M8PM7D/NySYnK1BuJ82k2mCC09IoQFGKPDi7L01shflnYisq3uE5a0m+6Zj0/ARSUoyrAlbVHHqUr+AveBALDghV9619KH7qQaDisSQlA+rr4751wvz0PbTTn+sPvN0gpgx8uNbYIMdxpIRKDKwxQZ1yq67CJH08pVjYsry1Ojx1qKJguoABMRBIGAgIAMzPrsSAaRUJq3t7EA7mT2ImKaJNpWBbTXG1rvmaHB6CYCZKzYYwMvhyCMiEG0ABLJorTRu+5GxGuJTg4T3tL3RFZHbUxDBqLAhNZOJpMkSRTfeDabjcdjAG0abUDQOffss887Y19z150ba6uhLhGFxSsnBfaIVos7TVtf3oRdsTXsFMsAkcgZ40T7OrfIQYgYYwSIGBNZm3UT0jQWzQDTJ6s3whjTcgZaOvzcAVOL4lnfwm0cVBUv/cY5FzyDIAKJsDBY40IIIAjG5VmvqirtI1RVlSEr7JVsuhqzptN3N0IVGmNMmmWCELQwwVowxiSOOGiOknT0zhiB9hJwnqo6r1wx1Eg1lgYgVumwxkpaM13Dvc39zooIoQFLdZhlWSZAZVm6pLe3t+e9f+nlayGAs2lNARNVFmsk6wxWofbeJ9adOnFyZ1Q4Q3fcdddP/PiPv/e97/3//Iufed1DD527cMsffOC/nji2tTLoAZl+rz+djPI8B0MJJeqTNxY1/KHIJtwpzdJZq9MCCEkMCAmACBISs7CgMNRcO4Bnn3tBBBCIEdA4kHlTnMgGENH7ajgcXr169fy5E2vrq3VdW2rqP9XmTvOMma2lsiyMIQ5ACBZNzaxOv3JWT8uyLEult5hwYBKHRJWvK4BQe/UeJRJkKt57lQtBOMmz1BpB2B+PRtNJ0u8BaMnInyEdDSwXDccJLsmIbqKD4BGoHdJJWu7ef7NL2gxyFomGbEuW4JmBkKzxEhhk4/gWJlakAXkFAGyhrfWwQ2fAjWwS7mREzM0J7iQ/wqKUafqSRjAsJRFsQv3zFM3ub7C1Nf+s+S54p7u/wi4SUEdAHumv1g9ROEVB1PzEOO81ZBW6GkM3AiEiwm1REAIgw6HNOrT9ulMSQhR4miIHSIgCRVHWdbA2SdMUkavSF0VRFAWQKHuS1tDnjr89zi5q/caYaHF2VwMWTt3c/F0yyuN6qhiOZpAqdGVZEiUxXaudZktOyADQhX0xIKFDN93xYKeRQOhcg14/TdOdvf08y6Yzz1JPpzNmVq2QmVFYQkgS6yyJoIgVEWL2LA3Q/CLqOLRIsEvE09VC4p1LixNJJbI/ajCJbFmWaeqcs0UxIepvbW1pHuxwMEiMnUxGK8PBlWs3er3e2XNnksTmaYbWtHhPzIxkWfMuYi5C3AIUgPZjszduXnASdzx+QETvg7UW0TCAaE5WB+VfhbzST+vPoIgtiohomih+nvVDCMEHT8EYg0CExjpXV15EOEhd+UZpQO1YTNx2wxWRpmC6qkySqCqpf4oJz9SWdcW8BC2x02fGHYl8MHTyHKE9s0GCECLP14HItlifJmp6UVVVvVIT2dBLhJfSAWs6BVkjCJ6DSxONNaRJVnMIIQAaJOvrWkReePnq9evXT586VQcWgKKs1JEDqI3L2Ht2xrjcMbMwrg8HdV3vXr92+223P/7oY29845t++qd/+ru+6zu+6mv//COf+PinH3/iwQfuQ3JCDslWPgz6TR2EsVhVVVnMdMuiYtSYUKZRnoCsswbmffpINPUv7TnvgejZZ58lgtF0Utc1BzAuei8XsuXVsJ7N/Jd8yZesrazW1VitEEEyxhRFkeYZIo7HY/HBWWIP4kGb9AKRAJW+nhblZDIZDAYaoqqKWQghCAeQUDddWDSFghGYocEr5eC9p7HJsiR39tr2XuVrMkYIiYgXE/LjKV5igN3T0T3US990T/rccXzor69yLQlmlGWDFQGkBTRkZvFeDKb9Xm9lSIkDaBJZoq9OFO9ZAADYSNNYUrkWovDyjOKUu9I6CojG/0xtHS1AxP+fL1xXElCnh273hihmuq+Ejuq6dFa7Zk1X3C7pFEuCX2Jgtb2/qqqo/sfi964CAgACQdr8tCagixIzyLv/bSnjCNN8gYFKo0PoAKbT6YE0xkeSuWgEL7mO48+jFw4AmgqZTqFUFH5HqjjYuborX5aldpjRA4Nt0fNgMMiTtFVQmhcDCCIawNDurf4/AmDToP1QDlQ7wrhWzXyNW19du3LlWp7nZlR4X2i2iI5VUdOtpX6/r4UuzCyC3vtZVYXADIK8QD+ICDI/vV3KiYt55OnVy/umULUsS+89AGsWNDPPZrPpZOKcI8SqLPu9Xi/Pi/EEEdM0HU3GSZLsj0dlVQNQEDbBAIprdoENAkqTfBfVx5bAwDZAZ9S1U9v5ivYcgzZsPD8s2EbHTePTjlayaRsgaqRDpWZk6NAW+8ZoBXY8Il1x1dR/a3Z669nWOyOZVVWVtf+kTp5I/ImSurWWeZ5E3R7tJh4RQvB17duIdXSVzcnYWI2siw9xK5GIWrSymP/VLC8iiATTsEydIbZJiLECIi7CrK6IyLm0mFXGuP3x5Mknn0zSzfWN43l/9fO/4Iu/8Iu/8AMf+IP77rkDABKX+VBRW7vMQQ1HMSBo4NjWxng83dhYu3Tp0g/90I+8//0f+Ef/6B/c/+Brz5w/9+EPffD8+dOnT51wrlFiWuBoyQYDZ+xkMuoalDpTTecGAABCS0CEbXjFNGmqgZKkmEyefvrZlbUhMyQuq6GWTm/ydl8ak7rX6xkDDzzwQL/f368n3vvUIQAqRr0Evnbt2t7+DhmoiioxtvJeyYaMCYJlWY1Go9Q6CJznPUdmXFVKpWVdhRDYh8bVYSwJCIgQ1nXtOZS+5qosqoL7PQ/QIHHOozALEaXu1T2/3UPdCJebthAERORDbRWWHnL4WhI6N3mskIBmriFiQJjV1ebxk/mgF7BFOG/6VzV6AMauRwCK/6xcKx6f7mSpU4XbFQdK8PP4UCNZ4k43L1qQgnOVf/H7m11dsb90fzz82Lpouo/qDkavrsEHnbB2aBMCAUDa7TFH1VAxKhEdsXl6tQdGVSIN2EBTudo+p+WvbQ0fgLJXYFGndOXLaIEdXh/qlH/oXzUo2IrquX4ThTcsUg91wp9dU1jNI0SM+Fz6pZoyaZqmaWKQQNR13Ew8+rjngni+JkGbY+kAYqw9rkOkhPXVYb/flxs7kUgAAEhQEADTJEmdVYuzqme+ZkGo6wDT6Ww2E2bEbq2RIVChND9qkdjixKWjrMRvIg2ofabAgQpu3Ov1DJEhqpnLsoxByl6vVxWzqqpCYF+HrN976rMvHT/+pBZ1cMLaB7bZcYsCgXmesh4DwHFZdFQhqB8BiCi0uxn7fupoiUyYKyrNA+u6dm2Sl28LSU2nGCk6inT5lQI12TgSlfqKo/ta5XTD4Dq97tWYllZyx9TFqCjodPR7NZSNMdIiV3Obvd8V2yEERaeSVgluIxGEjf1tiYiVQgwBNshrTc00IQW1702zlwjGzLUxJILgo4terWGFEXU2MQ5DEJcku7v77/2vH7hx48bZs2fPbN4CgPvjydNPP7t/MM6yZDya5L1Mm29yEMGgS1FzAEALgYmqqt5cW72xu/fcc8+95q67fvt3fue3f/u3f/Gd7/zv/spf/qqv/bpPfPxjn3n0ycuXL62vrYj46CwkRJMmqU+lEwVDRKB5ziaLwp4TGAUUbkkgeADc2d77+J8+vLGxMZtVIQRmwJv3U3fWGoCLFy9CUxXWrLPUda/X994/99wzk8kksa4UQY1YEyGBINZ1PRqPd/dHvV5vMplo0Ho6naI1AWRWzjQjWhAEKOpt3vtZVTbdwBIHElRhH08mx4dDZpaWRAGw245lzmMP41JG7rpo4iIe3Wd3SUzc5GFHrFj7DRJg1wjWFzVH2Bg0EDxvnTjm0mQ0m5pUYWOWbUtqAB87cF0CBKLma2Sb+k/E1q4J3OhAgJqBarv5QdTJ72XWBuzzKsx43rpyOhLWkqyFjhA9Uk4vSdwohGJdbDx13VfEVYhvdG2vVh1z/FW3r4u6WVmDH+3Sx4WTxaxsaPW4uI7dMZsWp1eNqha1J9HDVlUVmiZW2iWCKDDiE6BTGdVdT+4UoiwtZnfdoqiLCSA6HtdmvOR5rmiU+qiqLK1Bm2bOOq1GkE4UpLMOEqBriIe4t3pbXCiKfWHFuNytrKxUVaUQHzwrGoMeUAXhyqC/sbEByMUYC1TB4DVgBsxkAETpyqA2AtMpCwCCwLzuXBZxauKydMUwGqPIRCrwlOPXVWPrrKysjEajyWSiK3P+/PlLly4988wzauTVwR87tvqZz3zmtksXT546YZkIU11hQjHGIAvZVtIs1qp1vehemEJTjRNaexE6XTqIyAsbMtbY+LRoZaryFCl/NptpkTdAGhOaNJ8NEauqSltbmTqpUmr4TiaTEEK/3w8hTKfTbvmQCmwkMgDWWnU2Rukbj6G06RpR1dB3adrOkkKmU22+VMbV5Ao052Xh4Q2HbXcTCc3CIQQRQARNCmPWz2DIAPRazOfo8SYiRnDOfuITn/i5n/s313e2e/lgd/e/PPCGtzzwwANnz56uAn/i4U8cP7Z1fWf7hNkaDHrAYlzjVGDU1l6IVWUNpf18UszW19eTNL9x48b58xdM4v7aX/v2d7/nv/zo//T2B1/70M7OtY995MO33377+TPHpY1tcVlCi4AmrR/LWottDL7VhFpzaT5dVTf56o3rDz/8yD13372390pd18YlItyVF93tm0wmPsCtly8yM7JkWSahDMErl57NZru7uyjBe58Y6+tCJFibAmPFXJb1ZDKZTqfe29msVnYxm83SXu59VRSzqPwRoOfAlSoEbBJHRJWvLaIPrKyhKIoAogBP0HCnua68IIDh6Esk9gs/+sKOO2EuAgTkKIDow7+Nn0mIsUkN6t6gerkHCSG4NF3f3PAcyBhGAGCA6PECUSYM0iLbK5g9iIR5O5SOQIxvjzKOOt5fylzmS49ssnQQPCIlPggQkkWwAhhabAHDDG0K58LQoztrSUxyU17mo0s26tfcSeTh9upKVmZWhh5dUvFXOoAmO1eECJwziNJiGggAxFJgzd0NXkCI0CJZBKP1M0smJsxjh6waCrAACwro//SfBOiM1VyewWAwHA6TJMl6edbLBYFsk40850fKf41JkyTPsixNnbUgErwP3nMIhoBDLewJhQD1fxKAwCAYYZTFTnZqbxjjjHGIBoDQWJcmikeT5UnWy12aAEHlK0ExxjBCkiSGkNhbEAzeAlpACkgBJYAERgnAnqUGoBCkqrwWqXKbh2W0/QCAIUIAQnTWOmvTnhlNR2U92zq+aa0t6wrEBi8oBL7majbM6MRmby0LfZqtJGU/l7Vhsrk66GUpBjFsDWTAhjBBUJBFBhKyQglQ0jRXsC3+KLQJBIs0YwCIGUJomkPrWWeQIIDGuiwNIIDIImmWiYhayVeuXHnpykv9fp6mDtEIE6CtK3nqmRfqylubADV1fsZaQ86luTNWAoe6yUKae3Sd9cJ1kKKsy1ldzurJuKjqoDm63nMIWn+stiBpDq2EOtS1tdTrZc6ZJLGWnDNJdPi3QouMIQCoqorIAGCogzOOgKjtPN8NZOioNANZa+XViJlMJjrsLMsaQDQEdNYLm8QlecYIVfA1By8c480qy9W/Yi0hirVkLRmjLwIii2gQjUtzgcQHBHQcJNS1AXSGEouWxJKQMAQvogEgAkqQcqQcIAVxABmYDEwGlAvlYnpCuUAu2BMzEOqLZCA5SCouhyQzaTJYW03znKwDl1My+PjHP/UTP/Uzd7zmvrd8yZff98D9b/6iL/yv7/qP/8/v+fZf+1/+LdTTb/+2v3rt2o0kzZ9/+eX90SQgKXtFFCsIdSAObC2T8SBk0VJIDJ8+vooynexdveeu2/79/+/f3XnHa37tV399dXj8y7/i6/cP/Mf+9JEaia0Dl9VMFUsp4rKcXJJkuU1SEQw1UzCGLQZDKCIBgIVQUBUQEkGgBMS+/MIVZPDeCwahGkxl2ZJ3BhIQB5igSwMCGM5yc+3qK5//pnvXhgnzNKD3XJsssSYNAYioqv1nHv3swRiu70gp694cq2h1hrayOPZlTbB3MDsYVWAsGETrDiZTMBaAtrf3RSTLMpckSFSLn/lyxlUwgqlJRYJ4tk0m8biYlgD70zGVwZYB6qD2sQNh5NKyALFgYNC+ogGEkbUVkK48oijLZRXhXQAAiH5Y7H4/l2ewIIw0+NU1afQKIFpRwQgj6ysACph6skwB7YzMjAy6jAM5csW0PHvrBcmTifgpBgY0LgFCr2lsBIBCBgnEiOgyNOAdSEymCcBRAzkJwABMBCHU3lciQeUSsycCIrAnTpxQ5Xc2m2VZNplMbGJ8HVBlfIPmi4iNA0rlXFcr0c/RH9sVaarRN/xwMQd4yXbpSsEoiZdesfQh/rcrubtvOXxFKyFu59Lb4VAcWjk1tTgPWlSqfM0Ys7a2lqbpeDzW20Kn8KnrmbTGRNDK+ApqABbqOQEtvrrjDV6YoI4/FnVgx0+o8JZJkigWjzHmxvbuqVOnWMTZJEmTclZYmk+WNStTFMNWRLC7/lHGwGLUP/6JiMjY/qAHAEVRVFU1mUwIEzUIhNCRdTax1hpniQBJyiLozdPp1IdQB0TWvIOldPR2X2jhOHUT1vDm1jBRE7NRTQ6Ae73ebFpEDLWqqmazWb/f39vbc845cqurq3t7e2q2KWxWFPNgVO+ZBz6YGTqVYCEE72sR0ZrY+FsJXPs6UoW0rpG4cYhobQMRHIOmXdGu+fZZ1ti4qtHGGnHWvM1WqTVti1ydtTGm1+spZUobOlUhrfbrZDJJe7ltzx22fpS4pOp5jtOMjnTNWNErbgEz12WJaU+JvtmLlmhJw7qimfHYpposnFbpGHpHnl/dZmhwkcBoJ+bGjIeqKH73d//zyZMn3/e+9z38yU8kibv//vvvuOOO0Wj0z//5z1jr7r3vvixL6rpOkmRnZ0dE1jdWQbDf782mhQaDjTGK56zHWbt3b2xsjMeT3d3dCxfOZ1n2Td/0LT/wA3/rB3/gh++7775XXv7sxz/28K233nrs+CYzW7QsRsjY1HBdG0QyNoTgywrAkDOIhjoTVwcdIIUQDLmXX345BI1QkNIVQgM1jYgsrBEk732aJMHDF7zpTZubm2UxdWSCtqO1xgZTlmWWZV/wBV/w9r/3DzZWN48d23zNXbcP+jY1iTFgSPZ2b9zY3rMmLauq1+upl6Usa2a+fPmSHpDJdDqZTHTHIyWEAILIwr6pNTAAMBqNAggtRglFYmrv4hWYowc0Rt9ayP0uSXQZwud+LcmaoyioHSEAABhAjf2RSF3XxtmV1VVjjCUIPIcw6z4hnpGl74+4E8R0PNIL6oIIANi11eHjj48GgxXmCgCSJAES1L65QdkfIOkC6Tk/ejJ6dJfsYOg0RThS2sVxxG9CBwO5O+HuvnY/LEnrrpDojjOKje7Dl5bjsKSH1lMXrXxuQ85FUQwGg+l0qs7MLMvKsgzd4tfFUUWGFbW57uC74idqCYfHozcigvZuipwXUYiIfagDKqC0CHnvq1kpfccBqsqPYCrBW0JjHHNTT9AO0iBKAOJOPfThZYmyPxIlUYOkT4Dsg3oyk6bqkRV+3yaO0IKgICEYY01dh8ms1NpNIgoihMTMgCysQSUQIUQyiwH4eC2tD3SIO5a9QaduyvvKGNPv94uimEwm1pgsy6qqGo/H6t2UBB2mq6uru7u7w+HKpz712OsfenBzY127E2kPrq6wEVw4hMyMqg6R6Y4qiq5erxdjFlHUtbpCx38bYwqUqDyoqgo72okxBmAhGCwtIkcU25HOo/8pwndgm8wsbQCVGnHYrNtcfQFodraTVKIXL7Zp6pJ3CCFpGkuo6DXc6usSGYdunDAKgkWFt9Hv2xsWoOOPuBABDIB3zolYaNzd8Nyzzz/11FMf+siHn3rqqROnjs9ms//4H3/73JkTly9ffs1r7rx2ffvTn/702traeDxOsySxTt3yJPD888/feuutCinKIoigQrqu67ouiWxZFFmWalHfjRvX7rvvnn/6T//ZP/2n/+xd7/rPX/blX3Lq9PlHPvnwyy9fue++ewC5nFTWkATP3Exb2AsJs/clkx00k9AmVghq5hmTcF0/8sgjCFCWVVXVRMaH0HTlAYn15QawCqHfGwJcu/ee+6xJvKmBQT3xVVUCQBA2SfLmP/eWd/zj3ld9zTce31r9yMc+esedFy5eOru2tmZcsrdfjMYzJpempqqq/f392Wx26dKFtbU159z+/v6s5WaHGakICAi34hMANNOiy8dac3XOvqhFedRHEFHXCyxtbHCJz+v9N6WEm1+HZaFeBAjAHKFi1QYBqWufoKmCXz22tnn8WIni24gJwLIqsMR8Dl+RsRMY6PRHWpI7ImJvvfXChz704V4vE5FZVaRJPqtKYxDBKARn57GsxRaHlwluYoDiIcf9zRboSOF3WEx274kcpzuAeA+1YdSlARw5fuy0XJU2LoVtsFPtS9vpwgQNCBwaY1ZXV4lof39/Op1KG8SVDjaIDu7IPYviFhaUDNV6kDq1QNCa79DGXxGF2TMDmsbe8r4mIpeYqqqyLAOG3d1dlPozjz5x/szJrY113FhZX13xzD54RJSG9gBAi3F1leY1VLKoOUVeHA1BY4yi0KeZU0FFgJrm0zBVJBH0LLPae1/Vs7IMZjIrppNZECayKILAIiGwnvbWNyBNzTu12T1xAXWjwyGguyWyIUBuRVcIsLu9Y48d03TicjbTwYcQyrJOEkHEqvQrg97a2tr29nVmuH79+uXLl/I8oc7lvQfSXtwLgGjMXM/qxGVgQ2ihv00LQaU2RBx/tCeWKJA6SFIsrLFe7iRRd685wbekq7+NECiKlhxprOueif/Vd1Gb7RUpVmkeAtskMW37amojQfo59qiP3+id+jpAJLICXnHQWFowgHkDhwBikGVecKAllgDwKqK3uQggABDZhATqukZrAE2e5w8//DAiXr58+WC8DwCnTm2NRqOXX35lMBisrKxYa0ejUb/fr+oZIq6urn7q04//6v/6y3Vd/7W/9tfvueeuQX84no5EEZsRY4GsMhNrjUiysbFx7dqV2267OB6P3/rWr/y7f/dHfuiHfujeBx66euXKh//kE7dfvrS+vooEQMZaAQniq5o9aCiJBH0A05JpwwMFQmAOo9HosUcfv+OOy7Pah5pdklgiCJ51h4m1LwiiEBhEQoCzZ8+Gmi1SAAIRYHTOAGFVhOlkDCY7deasIKxtHZtNx+9670fCuz6ysYnDwTpLurM92R9Pw9gDwC0XLujRmE6nV65eLYoi5tC0vMXHDRRp2l9y0HI1mBVVWVUOxAtHSH0AIOE2zb/JOZpDQHew4USE28gRLeYGwc1F6dIlh0AYu3+akw6i6noBhAGQAYhJwBrFIeETmxvk7KwcC2GeZhH+83McTFcG6UFAoKiQHL7fPvDgfR/4wAem0xkRWKS27hCJbFMnqu0+tFtxp49NPHtdQdjVl6NCFPlOVxB2pwQ3MUAPv+XwmnbFavfOw4L88GYsLVxnC7uWq/4TnTPWzrv0JEmSJMn6+mqaJtevX9/e3o5+0a5NsDTH0IExaY2GOo4ZEQHmvLXr0F6aS+T7oNYriUHC1h0NAOyDBv/GBwc7O3u+LvM02VhfraqKQIxtgCOg6yMSQkAADxFNsdMH/mafAUB8UBxsEen3+0VZEaVVWYowB6o8l1VNRHXNRen3xuPJuCjKytehVgiCBpNStFkhAEhgBjVzF5D8uprBzTYx6ihEhDiXN8aa7e3tlZWVwWAAIorrKyIaTQheqtKLyMqgd+zYsenkuclkYq1N0xy48foqdwgy32UzByxDbusIQwcmDBHLslTgRlr01lLb+I957p5ihrKuvK80ua9JL7KEwta6IBwCE5vUOmetaPGinYOp6WBUkB8cHGh2dFQHAUATbfQ2hQmbzWb9FsEDEY1zgAgimrIOrc9fpbv+V+9sugKLRKVcpKmAJyJRCBxEEBBCCHFrCAwhIgRg9kYk9twCaDJK/yzxSw2dCGkrRqgbVWwymTz22GN33PWa0WiUZdlsNmMW59ze3t5gZZgkyfb29mAwmEwmWZ60VQNwz/333XHHnVtbW+94x48//fTTt9xyLrSI4oioLuhGX0EkZ+u6Hg4H4/GIiO65544f/8f/5D/9xu/821/8Nw899NDGxtYnP/nwzs7exYu3EKFwAG4gwwRA2IcgiGmzFEqZAMDCAiZJr7x85YN/9Ee33X7ndP8gSRIB8r42pMloonlACIBIWZbt7+wmDm69eBkRi9ksTWzpgzFiEyqKstfroUlmVX11e8cDHExnvvTHTx0H9FVV7Y1muzs7XuyxzZNnzh87ceIEs7927dr29rbCuGInGigiAqHJzQfQyglqsSIYhAj29/crX7tOJg2qkI515ND2i4zM9iZJpoelLx71/ZGXHAp0HhZ7WsjEINC2b1KUGGYOEFyWnjh7GhMLVZs+fOjtUa4dOYYuM0dsq5easu8j4p50fGv9Da974PqNvcR1geKabD0AaMEyAZDb7k9HrMhS7HZpUaLmHj8fOYHul5HhHvmnI2fe/VPXH760cIdleRxkd6i6Ggp3tbq6OhgMer2eYt1F4Pi9vb3PfvazL774ovI1aMEfonkUWgz9sJhlFpmOcnIA0vQcbAMh1AGmiGOLU4uezKZGJbBGf3W/lDNqaN8Ys7W11esN0rTpEdQs1HyROK6VLGqR0jHBpZMuFxPrmNkgGWPW19fzPA91qUabQhSxYM1hVtWTWVlWde2lrP3+wXQ0mU5nZRXmbScEoc0tYJDmydqpKXYsgJuc0sN0Im2OnqKrAwAK5Hlf66TVPRBhF421aZrqsHd2dp577oXBYGVjY200KTS4QERBvb4g6vaIC4WN5efIWi101h1R5cy1/Q1jdFbBEwCg22+ja9Tq2qoYCy2m1eGDpj3+uAUsi7Zv63tAadsiqS1bFIU2AtEMwa6aoiPRp81ms7IouK6BWaMJ44MDha3g1h0XY4GRhk0jF1oNW2P2jEHZDRARobGCBGTaxFGIe7SkXR0+nkddBEBoDIABISALQCAYQqhC4x6vy8ZiS9N0Oiv29/f7/b76n2NKh/ceUc9A+LIve+sv/uIvfvM3f/OHP/xRbNXrxkPQxJ48EYgEInAGj21u9rLs6iuv3H7nHa9cvfKGN77pn/3zf1HV4aHXvSHrDT/y0U+Mx1NAQ1mfyHoOujKCwOKFfSfHockaAparV69WNSdJIj5oo1hrLSC3eDUCLUBBv9+/cePGmz//TVub6+wrYKnrmkTEB+1LFli857LyQejB1z70/Auv1EIH09m4CNs7k+vb043jp9785i96/Rs+7/Tp07u7u4899sTOzs5sNmPmCCmvohdwIfwXqyQ0Z95amzpzY3e/9HUgEgSVGk2ZLItmWi1tH3bYNTN3EWcPn2g4JFNe5Xp1+tF1BoBu80QEQBZnrOeQ9nuYuv3JOIAYt4DhuiRfbj6CBXHTKtbLGWQAQMAEbAnkgQfvf+973xtCLRIEKNQMpCGHaB+1HEfgSA01HnvoyIwlSXPEWrS/PfzlkffIooLTffXShyNvjhYqHNppWUwN796GnVZF0NGqRGQ8Hk+nU83JirVARy5O5FnUPrljYs5LPBux3fnh4b3XxtwIdmltI2QgIoaay2KsbD1zybHNLfHK7LxxibGK0QFBQI0JEVF0uCPJV1p7PQpj37ZyasQn0LA/OL61+dmnnkNqHJ7CDIDeh8l4GkKoqwDIk8m00LZKQQAZ0DRhJPW1tLD7ul4CLIC1zAu6pKOOHHkS4tZga/bpZ0acTCabm5uIUpWlJkExs7UkQMH7ybhQC48AnnnmmbNnTo3H47JU1zGDLOB9RgpBRGZg9oKooBBqK8e8AQBQS1G7RENbCAsLxySawmAMEMFCyjcBtACTtkUVZmaQpuFxkKZ3QreWSQVwDOsSUZIkyl7j4iguSiTsJEmKolANwFpLSYJtFa8+MCZCd6mXmkIvABBjUPvew4JmGZAMwTxpHBo3YCPC25vbDRXqMJh4JDt6PwA2p9vo984lzIwhbGxsPPjg/ZpIZa2dTscEWPkaWvAyPacAkKfZ8ePHPvzhj/93//1fOnfuXAhhOpudPXv2R//e//z61z/0N/7G37hw4cLx48d3d3cBQFc+SRJ1irQq5sxa2thY29/fz/P83nvv/cEf/MH3vOc9P/ZjP/bgAw8eP378k598+MSxjePHt9I8y4mqalJVJTcwuAKBAT2gATKAiCSA8sQTjwPAwcFBXddC2HBaRABBIq6DMVrBEQb9/o0r8JVf+VZjaDYdGwuhqrVFROU18b4QSq5cvz4r6yzvi4gA7e1POISzZ07ff/+DKytr+3vjl1566bmXHgcAIqjr2hkbs3HrujYWDbXYLyoKEMigBqPbjumGSCoJ06LooQleQFvNg+YLA3SCuBR7qzMCYPOnDs/BjoH0Z4u6m19HSormFdyUlUSFHQVAoJLSg5w7d9KkySyUYJCI6rrWGu7IabtDPXKQOnzEiEbU6JrYeDeDroxIE1MjQH9sa+2+++/d3x0hSDWbmgUUi7lLmTkwL5S3LkysVYsiv8ZFO106JlRXqMTryAd27zliNY9IEJgHLLFjOHILoLj0HFkMdi6NJ97crafitjOBZqloJ5nIZLkT21COqdq08tPQmjhdVhjXpJlSZ7O7UieOFhGtm5dm6Ru1101ZltDud57nSZKsr62WZUEEWeIcGYOg+FAAgMCEiMAN9KNoWcSrORigY7voB9U5ksSur68Tga9q4JCkVg0jZh4X073d/Z29/b39yd7+qKqDViZwm2Gopqqwn092/lrqvjGuW3f7lsYZ3Q9dTUvvvHbt2sHBQWylYC0BACFmWba1tYWdFkA7OzsxXdlzUJ6OiEE4ejh0QyvvZ1U1m800CTyWA1VVVfsycO3b/vCm01NIJaIxRseLbR57pNtICKb1D3OnykgFTORW0Uusz1TC0wAEtggt0TMRCRixgUxSXGZoDVxEnM1m3KYWqh9bWnyPSAxxL7qeLYzoBIhEDq1BNIDq5DPz4C4RWWscUdvvQbWqRZ2yqxBT+z9o2TnNv9efWLO+tfnQQw9ev36118uYfRPHJZO6pCxmvTwHkcS5xLlnnnnhwx/++Ld8yzf8w3/4DweDoajL3fus3/uGb/hLf/AHf/DmN7/5ve/9w1XNhrWNWNJNrKpKJDhnADhJ7OrqkAiuXbt29913/97v/d5DDz30C//2FxDM617/Rs/46KOPv/TCy4GBbGYoSdIeM0vgwLWEIOKBgx5GP5s98cQTg37K3NRTGLOQNCqCwg27cM4gwKWL521mAIP3FRnWQhf2QmhmRfW+933gqc8+u7u7/0d/+IdJr3/9xvU77rjjq7/ma970BW8eDodPPvnkww9/4srVF7WGUz0odWhS9uq6zntpzN1zxioVGWNs4rr0ryFLBJjMylld1aGhikb68EK9SbOzrNKkbQfUYvxKm+oRWV/XP3eYI/2fu5rnY7eldhAIYMjm6bFTJ9lgDaylmzFTcvnni2K4+1cBBmzF0BzoqOuUBm0ppt9bX1f9fv7aB+7//d//+HA4rP0Bs0+zvCxLBS3RsxU5o+80so3PjRZJFN7dtx6Wst0JHFZVDg/6ZuoMdCpDlhZFWo07Lln3+66c1g+LezxXoCJGKLQuO24L6pm52ygm+vei1zE+U39SlqViJoQQTAcIsFlDY7CNoJtOg8W4CPonMg2/01dErjeZTHReFWKv18uyhIgcGSIY9LJBr58kCaCEECyxYoxIo1QBsycBJLJELPOG6vFIxIkbY9RpVntvrBWAEGoEBDD9fp5nGZGaTTFvxXrPAQNPdc0xhLm6Y9uG8FU1Q4J+v1eWpQTWxGACIIG607f4sOilQ5BhcacOU5QxpihKDmE4HK6srADw9rXrYJEZva96vZ7msWurhmef3RmPx9rKIknTmht5zAg2TUQkiEC7UxovjMwiSZIsT5QkuM0ZNh2YbmiDtXErEVEVuJj1cyRVKzVaawN7DqIMURXB0LbpVXqbzWaq+enY1Iyz1moTRmOc9yyCxjhhRWaG2awismSt1oIniYZROUmSEIJWtijojYJP6XvjUY1TA1AvIwAY0Z4CGshnQLKIGhBEIgfNqWy9drBcmHT4uEcHX2sgsp4PDj7Nsj//tV/3i//mnRfOnZ8cjICZBGpmAAkhVNVsMBjUdf3MM8990zf9xe/6ru988LX3r6ysAECSJFXprXXKIe+5/8F/8A/+0V133fNjP/ZjW1sbKysr6htoe2+LMQ2EPjOXVbG6NiyK4vr1q5cvXzLGfcd3fMe73/3uH/2f/t5r7r5zNj7x8J9+oqqqs2dO5YO1YjpF5Dp4ErZAImwNoTEgvLe/89hjnzl79uz+6IDZ63Fn9tLQj3qVBLQ2zAckuHjxFjCSpqYqq8BMloDBmaQsw2/95u8GTE6fX/3V/+1XyZjbb798/Pjxfp7Wdf3Uk59V/RKJfV0G8apeMHOofRS66ieLHovIjljbZDEHgipUBI3CuLu/d3x1RQjZBwnBGFPXtbM2tFkRqmIBgFpxXfbeFbpdsw3bMDnOBzA/FF1u0JURSwS0xPY1okRErNjaPgiAS5Kd6ejCrbdTlpQcRCRNElEsfbvQeHuJscAhGax3NngOiPqWufuQQ2iLVrQLJYVQC4eLl275/Dfd/9LL1/r93BijgYQlyafIglH36c68a2d0xWdX6OLiddMjdihKejPhfeRPoGPU3uztR65gN3bbfS91etdr8Wg0VlZXV/v9fnxO7MHQyrZ5AxlpISfVbmbmsqrqtteYNBHZmPZFh4fa3X4iIpx7MqM9qla4tVar+hwZ51zqjK9KJMgSCywCjVOxLot5HBfQGAMs2piv++potCGiQFNNX9f1aDSazWYiIj4453yoE2eGwz4g93uZtfPEHGbWcJT+zzgLhAySZClig1uSpmmWpc5YS+bUqVO9XpZaZ62tfRk6gC3yOVzQpnt0d18nEhHTiqKo67Lf7589ezZ1NlRlP0vrsshTl2UJIiZJUpYynU51sxR3BQCybD417sTCTVuAG6MVuilxETQPIMZTl44Joio/DUxptFl12dW0jWEOaU1e6Cgc0poLOtkQQp7nKysrmqusg+n1evFpatjppLR5M3daC1Pbj2s0GmHbJ7E72m4uoUQHnSJ8KWyhDxwCiCAYIAQ02n1hiSdAR/rqLh368GdepEkqZAyAfNEXf+Hf+Jt/7aMf+3iWp+pqUuVjOByKiPdVliXWwrd/+7d98Z/7cysrKyKi4jlJ06ZSmQgA1tfXv+t7v/ed73zn2trGJz7xp3qs1ItgbaKOBFUfB/2smI6sNSurg7IqdnZu3HffPf/hP/yHu++5+3//9V/P+oPP+/w3EyWffOTRa9d2iZrSCWMTEXFJgoZCXQHR7u7uh/74j5LEeu/REgCweIZARMwSQlDz1xjjnNnZ3T59eu3kqS2QAMhq8YdQG2Py3soLL72ys3Owubl1sD++fn37bW972z133Zk688ILz33mU49sb19XXIhpcVDV02pWSmBnbJ5maZpaR2SaFqUNMQvoeyNlAoC6EzlAEPbeM8DBaFRz0AwAIlKakMDMvgEeiRZtG9DU/WsweBftDVgUbHJI4i5dS4e9+6sjrwBzeUxENQdx2FtbqSRUoXbOaa5W1JVf5VFHDqM5+IvJz+p2buMpbRAntcYArq+uvOnz3khqMkIwBttWfsvMgjrZQNgmX+BNkpvi57imR8j1Rfl95D1yc+l7WKbehC/fVFc4vHbxUiE3mylccNDeq8qktPoIEV3bXFY6LpQl6ai8IDqiI6cGRDIOcSHHKq5DnKAseGysIkZFMdD1zfq69t5bS44aB/Xx41u33X754i3ne71MObjOJU1ytYcAoK7rspiFEFxioKMzxsXpcnm9X61DREwzV5ZFPSuIKM+zXpptbW1meYIN4g+IovW3h6+qZlrE7KuamdUoDCE4k4jIcDiEwI4MEa2trUAHeaM7nu5Wdj+0FHKEw0rNcR18XdevvPLKtVeubG1tnT17Ou9lIpLnaZ7nlgyhECECPP/880QUm9XbNBmNRiGEEOq4QTGgEFOKugsV5bEOvjvObm0uM2uSlBoiEB3pjWuWbKeT7pwwaH4A4xy7VDEcDtfW1qy1a2trk8lEIxR6T8zYUqqGaByEEOo6Ko5VVU2ns6IoFe5K1QiFW4lvnO8LIiKG2lOn0yIighCgAbJCyEgBMGgXkCXh+//f5eval+VwbeVv/+0f1lBIXZUgUhQFIuZ5tre3N5tMX3nxpY3VtXf8o3/07375nTvXbyASBDbG+lY5A0AQAGMB4Mu+4it+9ud//ju/8zs/8pFPhBCSJOEmfd0RWREMIRTFJE2dr8s8TQ3i5sbas888c9vlS7feevEbv/Gbvvu7v/uJJ5685eKtd73m3mefff7G9r6xibMpIrregBlAUUSEX37llb39SqH0vPeCTbkas3CAtiebCd6nSbK7e/DmN795OByABCIAQpukgK72XAcQpnvuvd/Z9MaNnc3Nzf29nU9/+pHHHn1kd+cGh1BMpzvb2wf7u76qEAKSGItJatPMpZmLZKl0lVinUHTR7SwATVZpCLHvggHY2d+rYhZLW5jOtW9CxYgAmmvV8UW/anhx6bqZCFhim68iKY54GoshQqJZKPvrq2vHt5iQmbWDuDKoI5+zJHG6z+wKEVkq5pw/rfXCh5p8XWslzOXLl974hvsO9vcVK7g7H0XxEhFoO+keFpOHBeGStFtapvjwpQ9HCvLu3I7805Ey+8i3LP01DnXpm/hBgyLq3HPObWxsnD59+syZM2o9hAbnYSE8pkaGhhBipBZaS0hakE6a9ywzEaEwTiSy7CVxuLSqUTjpf7Ms00emabqysnLq1KnTZ06dPX9ufWstgHgOCEbIkEtKH0IQPeTOOTQkMHf2dl+qGUChg4XCbRo2AGg1S5ZlzpnzZ8+urAymxRgFrIl9fvQ8EwApfoWmgAGAMaYs636/f+bUWQAoigJZNJ+8LAtr7cqg312EJd0oXksy+NDuN+FDIsqSVA0X9RO8/PLLly7e8toH7l9dGeZZWs6mgZtcp82NweOPP3pwcKBror2V0M4hMKlNyGp3qlGqpNW6WiPYdLWuJc1JFpMhoM02iIJtrrl0ph9nLdDNRp7DteoiKIyRNnxtOhY41zoDF+IL2FrSkVDVfI8+bSUS5nmcRVpfd9SQoO2JhETGWMQWWRWwVRZMR300cV/a63M0fzV9YfmS4K2lg93dD/7RH9x15+1lWeR5bgz1B/nm+npdlgd7u6PRyDnXH/Q++ME/+YVf+IXf/M3feO7pz4LBxhMugkTBe0AEEQ7Mge+48zU/+vf//r/5tz8/ns5u3Ng5fvykThY1kGRcah0JpNZUs2maORE+efL4ZDKazaYPPnj/z/7sz917772/9Vu/nfb6b/i8z+cgzz3/0mhc2KwfvBcBFhBEQPvMM89A60XTGXnvNSaCDXY/G6Sqqvr9vgg88OB9RFSMx6UPpQ+eyQsxuCzv5/3BI5/8zIf++KO/+qu/+ulPf/ozn/lUVRYh+Nm0GI32W79OAGRjsN/v53meusQZa5AMkiVjySTWxa6g2Gb5AUDlS+89BO6ewSxLdvf3yrqSGLFWodtaI0sGRowkdE9r95slUXKkaDiS4d/s53PqUbhKFoWQREQFqlw7viWprSGgIUvGIiHiUo0fHiV3l8YAi8yzM2yeUy8iSGD2IQSLiNooI0vSu+6680Mf+WQ/y0fTQmGuVR/EpkbWwKKE7848vnVpfIfF3uHvu99wJzIaZ9j91c0W9/AaSRtR6P6cFpF94m+pi3PU+VOaupjCurq6urq6ysyK5q9YQlo5pz/XEC8tQhZEY0g9kCq5lRtmWVYU5eKSGk1JCR2giS7XjmmuUe7qDXmeT6dTa0wIdWpdr9fr9Xp5LzPOTafj0Wg06OVIGAQFaFqU1lpC8kFCCKgRJqEQvJA2oiFUziQsLBwAUDl1A0ZtbSKCdR0yh3VdlqVHhNOnT549c2o2q7aLfWst4qxLGAwiLEQg7IXRGGcMeu9PnTgtEl586flemhVFked5VVWE6Cz1+pnsLWS5t6S4pOotqJ+iaPdzAlO6EgAvyD5UzjWvnkwmzz/z9P33P3jm1IkXX3z55ZeuTCaT3d3dUIfBoPfss1efe+6548e3wEjmMmau6zrP06h8wDzpgZjZGAvAKqJUirfjmSPZQluuo7IZEYi0ooZ1cxVgIXhFSmHEBpPctF2SFKJEeaIE9tJ0n9U4a2iLQwBgd3dXkwRv3LiR57mmN4cg1s7rK0yykNgclcK6rplF/a7SwZdGxCSZd0XUiUSvOzPXNSuAr4kdjdpdAkRAZdGaTsUi8rn7mufbDTwX0nNnNoYQfvmXfvEHfuDv3nnnhWG/H0IoAgtCVc3UykeCPEv3d/cuXzo7GR988k//lJn/wnC4sXXcWMshkLHGWl/X1jlq01nyvPdXv+3b77vvvp/6qZ/69//+1970ptcVkwkzE3EIAYHr5lCr35iZYTDo13X97LNPX758kYj+wl/4+re//X/8ru/6rnMXL013rz/+5JOXKMn7vSTPy3KWplkI/tEnnkSEoigr77Ms99yUTosPgQHVnYuMiFmWicDtt98+nRW+LrPEMZks75ezenRw8NGPv+93//O7/uSjn7i+vV/XtUttktrr16+BBBAiIWa2htJeL0kNAFuTtRreHBQIWlaJTYKCQYQQfFVVnj2yWGvZmIAizBCQiEbTalaVmGZxm4iIyHiNeREAg0hooL9uIi+6rD7+87Ck+G+6jvy56jQaUq5DhVly7MypUkIgICGuPTUlzssdgw4/c2nAHYDrprpkqf8TERBiaBpHBSsigCDALnF33nnn+XMnbuzsMiAain2UGgkBRoEaunI+joAOpY0cXoXuf28y+mVDvvunpTsPP6qrqoQOpGX3mZFxLA0P53H+uUlhjMmyTG24LMtUyI3HY0WqU4yFmGIAi67aJU1F+XKLaG+1dyE3aUq+u3rMqKhtcfBRP4gT0VMhoro7EkFRFNooxxg8duxYf9BDgl6vV1ZFgMFkOgXgPM0CiPhQliUD6tv7eWaMCUEAJU3zWeXjglAHZFgFiGZLImKSJF64qEpHxMCImCbJ3v44TZPTp0+maXrl2g1smxiKCGKDiQPiiUyQYAyGEBDgxIkTBwd77DldSatqFkKwxiDA+vr69evXj9SNmBdqE7sWUUtFoWNICTatc9FXDf5lVZVCxjk3noyee+6Ze++9v9cbnD17dndn/7HHHtvZvTEYDI4fLx5//PHXvvaBJElmxUzDYG3cF1Gdq82QuA0wB02GiiFD5nltld4cK3+IFvI7pFlhihNUItRE+sOKo/5Xt4M78JD62yUbWrPJmJnIxpuZWaPBAJAkSUxiIGOsiA+sDsn4fTTioTVr4rDjhxCC97V1Sed4UbtBCk1mpLEGFmA7P8drQfrOL0bEyeTAWtrczLfW165f357NZknqyuCbvlhk0iSdzWYbG2u9Xm9/fz+EcOP69YcffvhLvuyt0HaCAiDrUtUqal86Y421wvzAg6/9mZ/5F294wxt++Id/5O6770rzfDoOzjkjnJgksHCbKp8YCiFgatfWVqfTCbO8+c1v+pf/8mc+/vGP/8AP/MBb3vLnHnz95gvPPbM7Gp89ezZNeyy8vzf6k4987NLlC5NpQWSqqgoMaJp141AbmxmDLD7Lsv39XQA4efLk+tax7StX0mxA5F5++cYnPvHIe9/zX//Vz//C+tpwffOEMWZ3f89W5MOsKqcigoxZ2t/cXE+SxIsHCDZFX85PemunNr5T02BgcdT7Qwja/lajvERIQBCCMUYAyrpWkzESDLIASXygiGjVY3NQP7fNX5LKS9dhCQKvGrWNbe5IAABFQhX82taxleObu9UEEA2gr2tLBhGEFhSFVx9J+3aMLGg+UYkwf5rQpk6jAAA2c4mgKcqKLB7b2nzj573+P/zqb28eW5vOZtLABTd02ZVwR7346EU5rNEcOY0jn9z9U7Q5uo9aevvSuw7vxxLzWhpz/NK0Rb0a3yUiLZrc3t6ezWbOueFwOJvNRqORdBAPoC1O73rzou+lLEt1SnOb1NMCZbh4TxTbzA34X+hUnkjjM9QTgjpkbrrgoUI/aCKG+ldF5GBvP8tXfAivXLsKgfu9DKVxchZF6TlkWXZ8a3Njcz1PnDVYczP+OJK5GtFRU4jIJBGcXZIs98FXVTUYDDY2Nm5s76VpurayMpvNikLBvxo1QUQAhDnoINkLAu7t7W2srq2trpVlaQxZY9QFiAgKrhkRGZdUtI6C1T17S3QYITalLCtLxlhbVVVijLX2ueeee8sXPhR8vbt949SpMydPnpyenCLJY4/J+fNnv+Ebvn4yHu3u7ua9lExjGjLrjjRQ8lEgKl50fHsMTBhQ8jBRgsYUpyggAQCRYsBCSVf9DdHL59umIFGcSwc9Jv4q5s9r8QwAjMfjjY2NKK3j/sZjAqhi0cxhRlppFJ8Z/fZEFN+/9Gr94HQAElFsW6hn/Qyg6Lu6P4gInxsX/jMugbouE+c+//M//y+87eve8+73nj592hkbgqDYLMskNJpHlmVExOLzPB+N9vv9y88/99y1K1e2trYIHQAANonoAGDIAZKvS+tcOZttbm197/d+32233f6jP/qjTz752bvvvms0GkFg7WyRJUlZ19i2V2EGlxhAi2CeeOLxc+fOvfLKS29965f/xDt+/Du/8zvPnr+4u7v76OOPr62tnTt77vr29gc+8Eeve92DV65ctTaptK0nzFkBcKP79vPs2rVr999/5+233Snep3n+/PMvferTj//n33vv//Lvf31lZeM191wuptVoMi5nIc3SsizGk1Evd47McLiepf3gUVisTcAEDrUzCKZpe6XHxDMDoL5uNptphwZjjPbPDqWA98AiJMbYxBoH3lrEplWXepsNgkCrRELbXl2lOzY46hqVmPs7GUTgaOTneLrx5sHdRY38VYlFYQ+YDZECTW6dPOGFa1ZfDjWBIgRqAVxv9tj4ZecIdLVSIVIgv5YNtb9SNgIAtq5rm5gkSQSNQXfXXXcB/LaeUlFHRKO/iMYh0Mwd3PHUvcrIlsTk0s1LE+gyl6WJHbnWN3t7/L77zK5cPHxFG5TaosYmTwoEAKqqUsDxwWBgjNnZ2YkAvxF7wbctYpY0DH11nucq+fI8VyCtqqqGw+FoNOna0E2mgwB0gPUhIqYelRSgq6UHxloyxly9epUM3nfffZvrGzv7V+u6NgQbq2uJ086ptqz9dFbs7R5s71wnosuXLt57910bG2uz2ayf9cs2OzpG+AAAae5UMG1fHSIKwU+nU+MSAHYu3djYYHmCmdfXVxUcuywrzVrS3iiGUASIqCiKfj5YXV390z/90631jV6vd3BQZVmWOLezs33s2LHJZLKzsxOtrrgacU/jRhPNtTEtczpqicQ5B9xoM8wNYvMTTzzxlrd8qbqXy2I2HA5f//rXnzx5/NFHHx2PDu6//17FWrHWBgiqk7XO/2ZG1lpFjosh1a6ZyJ6jitbdQWOMMTYegShotQ93m7rFOjC9TXOhlwhMjVRp+9JoyVB8bL/f10TuLMtawazR3HZU1gIzEIEauEkCIuy9EnaM+EYyBgBjGpDkKKTjkRGRJLGmGybohA/m29GeUYhoBZ2DeOTx/DMvItrf27vvvnu/7/u+zzn37v/87n5/qOZ9XQdgqapKBJxrVkmdCvv7+8a4F1547tixY/qcKH2h5QnWpcI+zTJ1TX/113zN5cuX/9W/+lc/8zP/6vWvf9BUXjwgUVXPnHNVPbPWhRBSa2Z1pZ0ch8Ph9vaNPO+9/vWv++mf/n9/+tOPfu/3f/+DDz2wsrr6xBNPXL16/fnnnxeBsiyNcTE7BKTRyJMkKcuakAAgz/Nr1/mtb31rr9e7dvXKf3nX7737Xe9/33v/gGx+6dLttZdr118QoboSFjOZThH86urqyjBPrQOwCEZtiQC1IDvnjMQs2qZ7h6JFjMdjrfgwxqkHRcPPWZb5eqbtOIkocYlhQGQGmFVldMgBWWRwiGWjLrfQpIBCWlADACBIAgEIheVIVQzbQHL3myXuCjeXAq9yiYhBZBAgXFtbK31FzhKgQZNoIxMJgPIqT16yBKARN82fmr8iIHZNvgXkJYFgIc2ZKJSz1JkQZme3Vv/i17zlP/3O+/vDXkBb1N4YgxCCVDYxhAKQdIVrfHfEi+8OrnsPdmxWakGUutKx647rTlJax1pkxNym2/FcyZpbI5H3dX/eVdK7axdfpEzWtHaAJrs6Z7Is1/RUIlKAe0UqjyIzQlBFedxVJuIK6Ocsy7IsU6m2srJycHBQlgWiAHBde2MMAKoPM3Jz2+nniI03A7nFL20NkaYcs6x8YEiGyYmTJ4uyevr55zc3eqnLAKDXW7EuvXbt2gvPv7izs3ftxk4M6n/26WtVnb/2wfsHg/WZnwQOta8bdzrCwXjU7/eRUYWurm2eOF+DBE8m9d7P6jK1Vkj6GV44e/L5F69Yl2VZtncwMsZlmWlWjLD2lCRJXVVElKQWWbzD8WRPnfzMMC3KldUNsMnVG/s1GyLRAF70hx91DJqgrwg4l2uOiVKiOoJaFgNIElgAAIxlMi53z764//E/fezr//zXvfLKSxtrq+trfZRw1223bAzsI488stJzd955JxjrvW/6SSNECYcElqymExORSOu3TLK4g5X3FsBaK4JERlt46FZ67dlgE2bWfCWv2Jkiouts0BlLbUU1AGjb8DRNiSgI13VthH0dEJEDDYfDuq6zJPXeJ9YRkYIqKIRTbzgIIEDOZvlsNkvyXjWbQVkDQJI5Zfb1dJplGRrw3tvcQYm9vCleKoqizZ5rrHmV7vEUswRjSeqiKn02GABLqGv1b0uQMHeJN4VnaAx7r/sGAMLACDbNoVliVAUFQFrVVoPKKBJQ8dGaXQ8gIuzH4/HW1tZd97/2+/7WD545f/Hhhx9+5JFHELLEZkhgbeJ95atZkiSDPEPEUIUQxJpkPJ7t7B1sbh1jYSLT8hANVAMAACUAYKzxvrbW3n777f/4H7/j/vvv++t//TvvvP2W1dXV8Xhs0sR7n6R5XdfOpcycmAQEHBnvOU9T4HDtyivnL555/qVn/+e///a/+lf/6tve9hdec+edo9HosUc/S8bUHopZZa21lpi5yQMAI0BIhBhE6iAeCJjsr//mf/nZn/3ZD3zgD2+77dLayTN1Xd8YXauqCqYsUCOII0QDvWEPDbnUoqG6Lg0GoBIZDaO2o0UbEDUhIDCAZx5NJsruAgMLAggSIVFgnkyn/d6m6Rsoyr41Dg0R+IwSl5xLNw9u7MBFIbIWQkpmgn6KnsAxq5izQtxq840zDFhABAEMkgiD2sEdtkzzAOiC2IvXf6vozb0pLZTkhRBJdg8OLtx7B673ggkuSB9MZkyNUBEHsoyQhIW3RJa+JFY642myMSTUzB5QBAJwYAmk3BuBEAgFJCCABQDl+MyMCCsrK3fccUfyrvdnWbY3LoxmlyCkLmEFFqeF/jxxTF0pCIfEbXcC0Z24JJi7i4uH3NR46IKO/D5yG7pSVm5iPsaL5qkxGLEAiUgrN1QpjlW88fkLer2ItJCWh230uq5XVlaMMWVZ9vv9EMK1a9dUOy7LUpGJqNODdmlrD2tb0rlaNyYqawaAyWTinDt+/Hiop3Xte73elVeuPv/Cc+99z4dYYDiwvcFKVXn1hwPAH33wD4rp+E1veuOwD63ma5i5LAut+tVqnHYr570EvPdgyKGpva9rn+f5mTNn0KQ7O/tpmooPLkmjia9aWgjBOgciRVH0+/2tra26rouiadZrjPHCXlPbDDTy8qj4xZG7qY2+Y6V61N5a1RBjkZIO6dTJrT/95GeOH9/6ojd//mR0UNd1P0/zPD179mySJO993/s2NzcvXLh0MBkbi71eT3gOwykiHOZJnrogKi+jHmaMcU0eeAxJNB5sSyRtVBgIETBiPc416PaD4jodNkl1bdWovXbtWr/fD577/b5WCoUWJEtEFIvDBwEtdC4KdSyrEFVTu0GYkSbLV6dmrTXO2bqWxtynuvG1Bl1YPTWGTKslkzLW0ODHiffedAKBiELSNDCdzKbWWmcT1I4F3qO1gFjOSmO8a1pbzndQHf8M0qyd1la2XoTJZDJYW7t8+fK3fuu3vv71r//ABz7w2Sef+9SnH5mOpoNe7gzmw2HqbF1W/X7fGDy2sXkw2hsf7I8PDjY3Nwkb51Or1TWHjZlVZugYqqrKe71v+7Zve/DBB//e29/+u7/77je+8YHxeKxgOwpDhvMOVJRlSWjBRK9evTYajW+//fZf+qVf+uxnn/7mb/7mCxcvarK9LniSNJsFbUxKWzurOnVwcLC6svJbv/k7v/Irv7K2tvaa19w+mUy0E4zSs0F0LjMQjLXkjDUJQxiPGhivWmoQyVwGIKEO1oohQgTFGS0mxd7eHrZpntBCeEa+5L2fTcZrg6EYGu3uFNOynydefO0ZPKxaKOvZ5tp6OcKimJC1GbmqnPtjuM3mg8iZjzrLh5n//4VXUGZpgIgCSG/Q3zp2LEmSaT0BkQDc3IBNh7ju1RVPsCiVuwNurNtoCkOUUE31kbTeMotkjTGhqo1z7BWiIVy+fOn+++/58Mc+lfV7DGDA+FBpboghw0eZ/FEwdA2UrgnYvXlJtCyZsF2hvnQd/vJIOX14sbosW72FrWo7/94YBbcS7xlRrDWa5VuWRRwh80JuVFzu7l/NUVhgiDgcDlWqWWvH4/H+/n5ZlltbWzFeCwDRK8CLmTvdRY4SpTue6CgmoiRJNOx37Nix7e1tg4xodnf3n3zs8SeeeO748dV+v2+tDYLT6Ww6K4wxzH5vb+8DH3h/mrpbbz2l+oGqGnv7u8gyHA7TNIdWndIjhC0oBBFaa30I4itr3drqsK7D9es3EGUw7KOxo9FERADRJUkTGTVGAFTRBoCqmMXpA6gTtAXe6mzrEt0fSRtRBEbtBNuCvC7haUCWmUfjybmzJ9/9nt+/ce3a2772q4qiAPb9fj4crCZJ8ra3ve3DH/7w6ur6+tZmCCH4yraAzE12UuuMUe1HRJBE2pYPiGiJjcHWHI96J2vcWlrXDggIamLd/MjoW2yLOgnx5jaipqTi2/Y13nsOgsCRZYcWlBQRNVRpranKUpdIRWld12mWkSUlHjBAIcq8ubJrm1ytTDUJZo5olyqYjclFhGJHZEQiG0JA9siiHQViRanimTAzBxFqdk2xqIAZjEOegWnOQpR8AADIOvuuZ1KaPaXxZDJYXUXEc+cvnD17/vLl25966plnnnnqmaeefuzxz7zw7HMEYowJ7PNeNuwPDMLqYFjVszxNAAWEEWNcgKXtEk8UM2AIAJIk4cBkzL333vuv//W//uVf/uW3v/3vP/DA3SKh1+tpKDQ0/XHnaP4AAILGmIODgyeeeOLixVvf9a53jcbjb/iGb/jQhz504cKF7e3tNHVVVakaba2dTqcxASKEMJvNVldXtfPYieOn1EtczCa6uYiYJIlxhkFclgNAVdXFbGKdeuZEpBYRZ0xVjkMIzpg8zx2Y6XRaFMUtF2/NGV544cWslyNiXQVQ1K1WxdcplNPR5vmzxf7IrQy++lu+ae9gdzIZISKEUI9Ga2trla8rDoKAxpRVpW3+mm26ienyf+fFCCRgAEWg9NVwfW11a6MMAQU0GcIzc1t/JfBq8uimr+DW0FcKF1U4Wi9dixmALEJio+auVF6W1WAw+IIveNMff/RTvTzdPxgbl1hrDRnQJI42vtW9DsunyDKok70Z/xSlS/xSn7Mkb7qviDcvCfVX2cjun6ST1rt0RdYWBxZzd5lZPWbQxobjPTHb5dVHCx2hxW1F6Xg8ds4dO3ZsMBhoWR408cvGmokGVhQhkRFElhdPRdw75bPj8Xh9bWU2mz3yyCP9ft8i7e2Otm9cL4ri+PF1AHAutdZCCFVVXbp0qZoVL774okEBg08//Vkkf+zYseFwmKTJeHfv5ZeuTqfjixcvrqysEFmNtoo0TT9DCGTmjndrbc3MwSfODHq5s7S5uTmdFD5nY63CqwEh+Sbl0jpXVZX6GKLxF3wd6eSww/lzueKCx6U7fIpESAT17zu7e+fOnnziiSd+8Zeuf8s3/aXhubPXrt0QCZsba1manjhx4o/+6I/e8IY3BBANH2DbhAoAQEg6kQJuW1QphcRzCIsqQmRAKMIQQmh7plJQf3IMCZsWFaHbVFik6WyGHa9ACEE1pyzLFHMjSRKyJp5NFjDGpM7NZjMEk2cJABqkLEk1RUSYq7J0rkEOARZf1clKAkTSmkEhBOZ5JldouzW0klIfA+yZ2rYTyPPav852EIAQUa/Xo8YhSUgEIhwCobHWOusAKVRl8N5lGQhICE03QwAwijHdPNnmeaLNFhEBKHhvkuT8hQsnj5+44/ZLL7zwwue94bXPP/vco4995sXnX9jZ2Uldkjh7Y/v6Lecv+HI2m46BPbCWepjuwuKC2ifMTAhkDIcAAKfPnv2hH/qhu+666/u///vruj537hwA1XWtuCWIouea0DibVFUVUPJ+b3tnz7oXH3vssbd+xVdcvXr1qaeeGg6He3s7IqIK9GAw0EJH6fQUcc5573d399S/FfkGIiYuS9M0hACIs9nMzzCEoF6TWRGMicmDAglUsxJAOLWhCDQF7/1kUhRFoURLRFXZAG1Cx8uoqaPXt7fvufO2u++4/eyp071ePqtKz3WaphD8bH/kKn7m8Sc100IQEjLaLHLJMINFztx8AIAOz5SjPv+38gFYlBeISMaIsBUIBGVVnT22afK0qgqyZJEAkBlV8wJE4QUOHylhib3H7xEX3DzzBIi20SoRBU2/ahF5bSi9dY3b0xjjEisQLl645Y7bz734yvW8l1alBzR1qI0xwgEtLk0pjuDw/CP1dN22XYkCi2zxVdSNeP/SPXjUXsIim+vezLz88Ibvt+WM0MJaqVyJIpt5DsSvwibK1MNLETcJWyQKRcLSxnDGmOFwmOe5pjZ03GvzvNalOmBY5OBdDUY6ziJEHA6H3vurV6/2+33vPQQajUaps3XtN48dK4oChPL+cLq9XZbl5cuXP/yhD4YQkqRvDD766KN7B/sXLly49fIl9uHxxx+dzWaJM3VdhzbTuLt3zJ4oaVYM2VjkigF40MuPbW6MDsbTma+qKgm29t455zmwZ9Q6DQYiYhEW0cXsxvWpzSqHo9LdjyQP6Xibo7Yki+qaLKreIkKJTZD2Rwer6+tJkrzzne/8G//DXz935lRVzaaTGSCfOHFib+/x559/9uzZ85ODkSbvhMCtdBRjHbbmL6OkLlOhonHTcVUfJg91C0cfbxyzhIUGmsASkbb0vboyQbjLGrROXRgITc21iGRZpp18XJqIiNpkNk2IqCgKNXxdklRl4ZxDJIjIxmXZ7+cuy5DZOYuI3nubJMrr54tGWvdsotpKbfK/ALJ2UNYSKRbt8dHmdM5dZSJzrI/mHLVCXZEMQwimxRrzvtK3G5POiYEaDA3lbcPhsCzrela5LDPGQAhe2Do6febM1vradHrr+XNnz5w+9eyzT//xH/9xnqbGIAqMRwdDXP3Mpx4ZDofrJ06ICCKDlisDz9s0NRMHarQELyLGOg7BJunXvu1tt95220/+5E/+yq/8r6973f1BpCgKRc4KLC5JVUNKe3luXF3XJ0+erKqqLOuHHnro1KlTTzzxxOXLl9QhpMxB6xt9qDiApp4o8vbBwfhNb3pjURQPP/zJtbWV0HZD8d4XRWGMqYOvah8EjDGzskYAEJqWszRNtzY2xpOD8fhAhFdWB0TkfRUCaT+u0WhE1JSA6zeKW9A9SnVdG4Gv+9qvOn382PRgFELd6w8FmZkN5qtZVo2nWT/zdSk11mUFhOZQaFLJ5Ujd+mZi9lVk8JFyZOmGhXcRgg8WjIhQ6tZOHWNCAEAWtCgAAZtRalNrkPng4SgudJg7tZxfZxRIABANEQCjQFjEurCIyEEA1bqq0NgQ6pXV3hvf+LrHf+U/bh1fDyFw4Lr2iGiTVP0YS7ONMrW7yvplFCTUyc86zAeXfgWHBHPk/ksL0b0ZO5vNh+ov48O6j+2erk6kEKLsZPZdvql/jZHa6Ps9ckhdbUOjv5PJRFOgtTkrd+pZocWjhracqbtWcUbQke7xr2pB1nXdCHXgLMsmk4mI+JpIoK6LLEnX1ze8vwagvj2s6/r82XOfHgxefvnlJNkqisnFixe3dw8efvhTo9Hk2LFj48lsPDro9/Ms6xERGNKqEWxS4bz3vqql18saKYJIBhyhWBr0063NtSs3dpLElnVd1TPrUikbx7LaUmrVGWO49TFGhh5zdujPOmDd3QQA5lqTyzSIEEKjTbVm1oL6AgDMQJldHwx293ZEZGNj6zf+029+6Ze85bZbLwqCQbuxvn7bbbc99dRTGxsbsQ9090AagwpqjSjRXTxP1OpQhUHSqnpsE1yJEoPohWPuRpehcIu1wm2ontp0iqiriQhqwxRHIYQ0TYuiWF9fVwd4dPg754y1IYSyrPM8r+u6gfNtH26TxBhTVTMdKyBqbn9RFINOWxF1VCBqWlmD7BbPEREhGeg0ZQEARNEoI7ZZDtYZYOGACBi/j1YyAIAEIipmhXPOEKAl7oS6u0emqWhChMBZ1svzYjQardsErQVCiwhcAYpzbu34VuJsv59vbW0w84vPP59l2WDQCyGwhJdffvmxz3z6wTzPVjZBAFCCZ2NtlMGRCWjOFxmnCUNkTPDeGHP33fe84x3/+PM+7/O+//v/1okTx06fPr2/f6A/uXHjhlLa9es3BEAErCXv+W//7R92zt19970//uPv+JEf+X/dffdrnnvuOY2vg4izFDzoPmpMQf3bd95552g0evjhT6ZpqqWM3GaA1nVdBs57vdFo1MsyS64oitQlp06crMvi+WefRoRLt14ofVlVlTEogkROKaSq6iTBJEmKWaXdCZVsoidJ4Uvf8sWvG/ZzFFhbW6nrUoCLqkwHmQQGZxzRytrKaG+/1+uVxsymxWE2johgUKuBGZvk58On+1WE7s2O/+dyv8JhokDw1XBzLV8bFqH24lE7TSEIgpV4xJZfsfQZD6n42mmYmiwCERHtskoEzJrYzuJDpChrmr6hAIQchOsSrXPO3Xv3a245//tXrm67tEfWGONCUBlw0wAwHKUgRGkfKTh+v/SNXpG7dYXx4Sd374Gj1JAlKbj0EDxkV3Vt0K6K0BWi3UeFDkZxnODSq7mN1DJzbIcuIlpMHJ8cZU+M23GbOLO0zYdnF1eDmTU4ZK0Fgclkokc3hADGEODBwYGIrK+vv/DCC+pkruv6ypUrd9zxmt3dXSI7m1Xnzt0yWJs++uijz794ZTSaqA9mOFx1SabdAoAlJjEp/629d860yV+MwoRS11Xey1bXhnsHo2NbG8ZNKu+L2YyI+v2+TjyE4MmjgAhqZTAzizbrbNe5K42O3PfDatySt5OZAZYhWbr3z8rSOtdfGRpLk9EBg6TW/cZv/MZXfPmX3nXXnavDFZGwurKyubFx4/r1CxcvarpKdy/UceK9N8aqjzoCjka6ApaOMi0iAoG11Sgzm9bvEomhVT7mEFdKG5EC4wQJG7Eda9YBoKqqJEk0vgsAaZqmaRqgKZkTkTRNqcUVgVZeSgyseK8b5JxzLsXW8aM2lrpzYt2dtKAN1KQpgTHzWE/cINMCdQEwQdIcmcRi2WbyN60QbHsb+LomROecZgUze0SrxBd3vYEjbu3ywWAwns5QmzJhDBsbtAY828QNBivrm+V9991njKmqCoCstZPx1Fr7+ONPBoG77n3t2tqa9kkEEcAGClCnrMNmNeqRlGOLCCAK85kzZ77ru7/nrrvufsc73vGe97z/llvOrqysOOfOn7+gRbQnT54EY9dWVpn5q77qqy5evPjv/t2/A6Bv/MZvfOc73/npTz966tSJ6XQavE+SJp8rJjAi4sHBuKr8Bz/4x6dOnbpw4YI6ORR+PrqjyVBRFAYFhYOf3XLm5Hh88MqLT4cAf+dHfvCBhx545tmn3vve9z751BPT6bSXZeVM1FOtgj/PcxGcTKfdEyQiSduO8E/+5KM/8RM/9d//lW+99dKFYS8XYJc5Zg4QnHFZbzA+c+qlF14CARQgIuA6cjktwekydkSN5i/ZSP8XXEdKBEQM4g0ispR1dcuZU5LYQryIOGMQUBAEGuezMCPNveVdHrLEjrqfueWQIsI69/hX7iLLNu4627iSJHjvrUaMCMpZcfzY5lu++M2/9Cv/qd/H6axESkLgxGUssziZ7ji6E+6KohgrXbq5K3u6Pz8sRA9Ptftl1xxZenX3h9LiBiw9ZolBxAFEA7ebPhN9m9yp0I3DPqxMdOc1t/ZaZEpl5b4F0IkUj4di1bh4Hbk+0Z9Z13XimubEzrkTx49Pp9Mb164MV/qPP/7YF37hF25vb29vb/eGgwsXLr7vfe/f3NxcWVkrxhPn0jzv744K70OSJEVZTkb7RTG54/bbNLjIzMhRmEkbpmy839Y0xVFEgACpNWsrw/r06TowPvdSWVezslxZGTBDWZba303rmkJVa+kktnIIOhH3VyeApVWSNvIqHRcIAMRNPPwoY8zu7u6g39/cXN/a2prs741G4+PHT3z26WfPnz8fQsjTbHVteOzYsStXroxHo5XV9YgxGXNEdcvqto0BdsCWEVHtXcQYrxQEIyKWrOYbWGuZfQhojHFJqrSH7fFR8tAN9d4zCLTKHyJmaR7TApxzRVH0ej1m1ixolyaatywiLE1PzBDq1fVNRayOOOe6gGmaa884NIaC6ff7iDZw8MK5cXoirLVETU1E0tjNlU55Nps1+KWslcQVQGN0aI4zgBA5tAgszMEwWed8XYuIgCBpcqrUtZp0ipc7JwYRhUVUtsjzPCwEL0xg07w/mhQA2HBPACAS75kheF/54JI06/WPnzxV+fDMM8/MitJYns7Kzc3NoiieeOIJk/QvXrx48tQp1CIoEYAAYKKn11pSLVnHFFiQ7HQ6Mxb39vZCCPfef9/3fN/3fsEXvnllZUXjqa0iCFmWFWXlnJtMJte3byRJ8sILL7z97W//y3/5mzc3NwGgKAoOQauHdVvTrDebzYxx3gdr7WAwePzxx2ezmbV2f3+/1+up36sdm61DRYh5r7+xvloW02eefgYB3v53/tZXffVX3nLLLd772289uzJI//AP1x7+5Cf39vaybKgsyBiovdegW7/X087lIuKsjbE5EUmS7I8/8siHP/x3vvNv/pUv/ZI/d/z4FqIB4DRNpfIuTTa3tgaDfjGalMU0MUkpFZIQQIM62vp16BC3/L/n8sIWCQRqDhvHj4EzFESssdaiMUItBDMHZkYwQHNx22VHXU9MlHqI+H+Q9ufBtqXZXSC21jfs6Yx3fnO+l/lyqCErU1WVmkolqSQQIKAFkk2rhd2EgogmuoPoCLfbbv6wTYcbg7HpaLvpwCbARAsKJAYLEEKiEWhEqlJWlaSSqkqVVTm/8b47nXuGPX3ft5b/WHvvu++59xXl6B0ZL8/dZ59vf+Oa128RuVahEkT3AIAIFAIDnyvGALJkjYwDQrkCACCxtdYHuvvcnTQG4GCV9sQA4Cn0YbSx53PuByX1e6x6FVvX1AJuLXUdqe0+8HmlsyOmfQbfZ/lr/LvrT99sCw0b1tQLz+mrsJ0m2r1Ia414DnW5G3VfDsJeDcHuvWvD7JQM6ZLUiZNIY+qqiPR0uK5l7Mlc3DNHC3Hv2LkYi0IPRkCSqXyoh6Mkia65unr88P79B++//JEPffnLX148XKDR1trlcknOJ0ny0gsvekf37t0TXptEkRqNtrc3R6ORMWYwSEWa614NAGmaascAUNc1aRRNRc5tVfkoine3t04WK60x+HqQpUVVAgFwSGILAHXlOZzZFUUDhgvCU7d21PPldFOxtt+6f9sw1GYHiuVmbYsyszI2juPT+bws8zSO/sD3fWr/0YOvfuXLs9nJe++997GPfawq8uVyKbr7crkcjaeI2AWdydKotpKgcEG5KeZoRFStBAXQ+DW0aosiaM3cCHYhMCI24dMAZVk61+S+i0NOdFxpShCzsYHVrMU4KXw6TdPj4+M8z3d2dgJTt6tDa2aIogjIh0Dit5ZNGCdJE8WNjU0QEauqRpTcmCgAo2DTay0JvmJlaaQwAImyVlo556qqTNMMWq4AvRqMAm5AKKlEMgnoXUCjxc2IiNoqBkoH2Wq1iuO4LMs4jooiZ04ik0lAKEloS6NFKQpOW1TaGGPLokjSFBiJWSkkVGLkt1GCqIcM1iRKR1UdHj16NJ/P87IGdRrH8b0HjyqP9+/ff/nll+/cff4MbYacVOrk1uMjQmRVlovlMs9zgQo4PT09Pjmcz+dlWVZVtf/4YD6fLxaL1Wq1XOaLxaIoiuPZSVOWKoQ//Ef+yKMHD4fD7Cd+4u8BwNbWhgQkinOKCIzREjJC5LVuAjM3Njbee++9P/Nn/sxHPvKRn/mZn8mybLlc6hYlTQFOJ9O6Kt5/930m+Mv/5//qj/7gDzz/7B1APjw8VEpNh+nHXn050oqDf/vttw9PckaApu6eo8bKEhRi1O7kRmpEZkZt7O7eIPj6b/y///7Dh49/8I/+wPPPPRsnSQjBRNZTGE1H2XCwOp1nSeyqJpkKAFAxBR/CWRJgu3ZnDIWoJ1R9c9dFIiBXnx/16YlSigMUvrx5+5l0lC2DJ5BcLBRvVSBAYk1gUHMvELpPPS6SaDyvC3GbvqwYQJHwB+9C57LsSLoRQZuaadBNtiJTHNm9ne0/8oc+9dM/80sbm6Mqr6xNA0GfD3UE7htoJ6Gt0HeBEar+fbiMrfa5Y58DwQXOhBf00f5Xly7b2v2u5X4fmLkzufe5+1q3+1efWa413hFr3SKK9CO/+q/u9/PinU5uwJ4JIc/zKIrEFExtrqq1lsBbm4yHaV1WHKp3331bAT/33J39/YPVsqhDgEDGmMlkulwu33jjDReCVWo1X1zZveNcFUd6d3c7S2OtNaBAxQlOVlfXyCBi8ME5LxANjRYeRZX3xGAUTsbD6WhINEvS4cnxQkgJERurEBtUJmZu0a3PTW+nUCKeM2wSnWPV/fstvTibHACA8xjC3ZpWVRVFpigKawbehd/93S99zyc/MUizL/3eF//5v/iXd+7c2dnarF2ZZZm1drGYd/KHMaarT6d6gVRdV2VRjDGS44uI3fw0HUMAUOLkRdSN8AHQWD5bDds0ZWhNU5w4ibvawFKNtXtpFzKzubl5eHgYx3HgJnrLe58NBwDQRM/2pAdpvyN8RKAUozFU18vlUmubJEm3Rot8tRVFzMwEcRy3cdHUpRS7du+hVkkSe2+qqoriyFd1t8M79R0RQWsi9kxKKl0Gb4wxOgKlAEqlFCMwQu29MdbaCJXmZgUVaGgsmMRKaUQVvFdKeU8AipiUUsQKlRKvs/eeIWgTRZmKar+zd3VVVKTsZhRFUTQcjD788qsysUXt3n//fWb23hdlKXWl8jw/PT0Vhjqfz2ez2Wq1EhZ+3F7OBQDQGkNgqaoiNAwRBYTHeSc48Gma/quf+/nxeGytvn371nw+F8nVGMMAqJSx1hojVcNbasmSByUC9zPPPHPt2rVr166dnp7OZrPlcrlarTam4/3H+5GBv/Tf/B++/1Pf9fyzzwyz2NWlc1WaqBACU9iaTD7yoQ+yD1kaf/lr7x4dnuR5jtikoXvvEY3ULxeC15IdBQCesKi8RrW7t/G7v/eV995778d+7Ee/49u/NYnTQN7XfjqZ7l29ks/mZR3AB09n+QgAIPQMEeE8xYbzIvU3uL6ZZ+A8Ie3/hIgIVV5XH7h1w6ZJWc5BQwpnqc+yKxGbOLw1Mv60bnQ/BwANyNAv/QvM1PqfAnMgBFbIzAHYQOPDuKBsebexOX35wx/8Zz/zS0lky9rVdaklX/6CSRkucI7uq04R4ctcdGszCz3fcJ+S9leoz+rwvFq8xp6/mfXoM91Lx9U1uPZwR9+7/vTb6a/Hxfb7H9bavLTDa7PUn5BO0JOa4d0kqBaWazBKr17bI1eXFoGmCum99945ONjPhqMoNsqpuq6dq9/6+terqhqNRkkaVVXlwRvFHsLW1vZ0MopjiwoEq6Z5vVJKGUQdSOJCtfdn8WhKqdqFg4MDQJMNRtvbWwAwmg0Wi0WxKpVSFASSOuRUkKdW1WA6cwGfyVuqB+TSelDOYvrgPBu+eGB63zbJAP1NYq12zg3SbLFYTG/ePDw++s3Pfe77vve7lYJ/8wv/+nOf+9wnPvGJ0SATypgkafd2bCv1AkAITmakKw69ZlmRdelUYWY+y9NnDsymp7h3hRPwfLIvETGCsGFjDCMobBg/t5o3AOR5LlYQ7/1kYyowL1rroii0tkkSlWUZPHW8sxEIxNTTFkmMQcnonPOdhaYpQBK8TH2XCNAtOjOjanqbDodVVVVVLUMwcSRp04yKUTWItoi+7rlmsKlXCIhAxKg9gatDHKVEZJLIxgmhblzAzAwBUDzAYAVEk8DYWBKU69ojYu2rqqqCb2CKfe3yfCXZB+lo/NyLH5CJLcsyz8vZYnlyclKW5cnJyePHj4+Ojmanp48ePXrw4MGTJ4e9/SYdlFEDERijsiyT6ssdFQ1tMr0A6ctbBOmJiJBhe3tbKcjzXBR91cKeE5HUTOunWQtH1Brkz7/9t/82ANy8efP4+Hhra2s0GglW7ttfe+PP/6d/7j/7T/+TF+7eRsWrxVGeL8URwYG9FygC2Nvd+ehHXy3L0kSjN9544969e6uyMDpKIlsCKCJkHS4LAEYw3rsqhDSyeVlHUfR/+j/+pf/df/mff++nvjsbpjqOV1V57dbNd974epYlhXNVUEpdwoPPLoVAvXN62Vn+Bhz3m2HG0DNbamSCoAfJaHerDI6IrNaglWQVIANKgj5yVyviUlbSJ0p9nqiaP5uzrZRgOcuq+j5rYOYQ2FwYgAJoYrRcWe3sbH3bay995nNfHU4yTRRFUfDUNylf5GSXDn6N5z2NW3ftdNz3rFuXVYa62OYaG1trn1sLWyfZiV+q12TzVd/T2h9gx+H6RLzPRNempX+ze6zT6vrIRxd/uDaH/ceoh0CEiFpr0cYkpiayWiyiiFhXVVGsdrY2ktjeeeZWmRcHBwePHz+uq5IIlNHO18hw7fqVJIkUYCDHzIPBIE3iyKo7t2+Nx0NjtQYGRKUghNYaLIS1+Z9RSraUY0Zj48OjJ2+//XYSD67fvOEqF1t188bV4+N4tRTEKw0AtSdmJr/qT+/FHdL/jJdZXPorvrb6XYOtxtystSwaIgQi4ZraRG+++faHPvDC4eHxG298/WMf/bg15ld+8Rd3d3c//tFvEXdmX+QSdTNJEkT2nuM4lrxoaKu6qvMwosxMCEohY7fQCqW4D5+NXcICxPCYJDEzS6KaDFlb4713ztm4sXawbwzX3Y6S/FFBrBSftLWWuSmBrBSIgRM7/xEhIgZHznltsDOhAyhr4yTRiCiuCuHZRVEMh0MmZkaBxhQLecNHkeM4Pjo6mkwmSZLWtQshACitldSfVsoAgOB1EHVmD/SBFAUAIFSRUaiM1RD8fO7zyWTiibVWtQ+rYgENdHZT/M85J8MXbhdCKMv66OhESjjXvhL7sHOuWOUnJycns6OiKJbzxeHh4SovZ7PZ1772tXv37jUMFRsDhNIqBGIGrXEymVy7dkW1ZUaFmjIzMNfOdRHvq9UqnMfubz1TZ3AcWmupL1mWpZRO6fguAFRVJZK0c8F70toKjnrfXhiC07rRpw8PD6Moun///nA4tNZubGwE4vFkdO/ePaVpe3MyGqbAMblSawuxIjAAwOSYcWd7+2Mf+5btvRub00kS2a+/9WZZ1qxBI2jbhNRRAyNxxjZQ6xBClsVVVbhVzSHcuHH9L/+V/55Rfdd3fyKObRZH8TCbbGzk4aisK7GQnR1GhUgAELj5cIFin6elTyOGa99efJjP63jdA5Gxh4vZjbvPqizK69wojQDGGPTE2KiqJLWSWFxU64J+n0+tUZj2LYQAzEExKK2AiIlCaLyN3WNEEEIwUriNpSFGRGBWQB4VEvnNyfSTn/zkZz731Tixnn0datXjfH2i+bSr78Dnngp78cmuzW69+9OnzsclrQ3+Ihvr+wv7z3fNXrqE8lVHZy8+Br3lXxtIXyZ4mhywxra7wa5tlP4rLvaTWmygjtAL0cTW3ymBuFJ8SRKTlFI7O9vPXL+WZVmZF/fv33/w6PH+/r7RVoCxJpNJlqYhePJ1lmVpmi6X8zi2167sjAYZcxADqYgjItoLNVGgEVEr3QwFgSTWQJvIxnVdv/nmm9Pp9ObNm9qYUFe7O1tFURBBXXnnlrE1IUkAoKrPDCRrU/q0dezmufv34jxf+vPuGURUqBBRGN50On708PHmxvTNN98cZukrr7wyHA5+/dd+5caNa9evXlssTweDgcg93a4Wa39XjSOEEvGMpHZ8rr9hemu9rrsHJgXMTQJ6Y1WWAFpuAyagocKNP6ku6gZeP4jxU4cQkiQRdouuZsY4TqUnaZoyc1eVCwAkHAwRdRyHEFztg2Jhw9BWekDERqBra1EQkYD0ioW8Q/IxxhR1iai0NgAS3G6NiZRSRkeYmG6LCqBeoGCUrqrKBUZUJLhYAZiUC2UIYZnndV2v8gartSiKukZmZghE5GsnuTFVVZVlnuel9342my0Wi/l8nuf5YrV88uTJ48ePHzx4MJ/POZzRBIlxli1jjJlONwejoVKKg4QjNEVXvfeVq30I8+WCiKSF7uTKBuW2JBr3DGOdJY9bYB9s0hobF2AURVVVZFkmz6RpKskR3tN0Oha/cghB6cbq1G370KDEN1AbzCy5Z2Ih39nb+qt/9a/9lb/y1z7w0jN//I//0Y98+EPP3bn9/AvPxTaysQ2Ur1YrBk1M3vvd3d1V4e7cfma5WlR1+fDR47KsGYIGCxrEHEVAjZLCwMyuKpIsXa1WUWQ0mKp0C15tbY3+m//L/+PPL+bf/we/D3GURNH2ld0vv39/srF1slisycfiVe0Oq7Cc7gjgeVXtUpfwN+DN/95LARRluffMDbJaswmhlsoQjMDEKLgECKHN1Vxj5Gt9WLuPiJ21GQBQNYr0GutlZgIOxIHIaMTABKCaiP5GGNdEIYqisqyfuXXj1Y88+/tvvWfjbFVWSVu7quMcl3al36e1zxfJ5cWx9QkW966unYvN9j9wz/S99nDfd8gXFl74WZ/ZX3z+4nr027l0+H3e3MW1ivDeRV9/42npsxzoMfiOLIoSIIccOAgP1lovl8skSbyjjckkjuOtjU3c4itXd+8cHRVl/eTJkzzPt7a2NiZTQNJagwuPHj/Y3BhZw1mWDdKEqYbzs91eWmsjCKaBKATWViU2rrFelVWWZbu7uw8fPn733XdfffXVmzev13UdWX316s3Hj/YPDg4eHxwqQGEty7yQF1wcfEfcu6vTJLpJOL8cqr1/Dvr7aXOLbfxwHMf5ajHKBnmeZ0n06NF+lmV37z7PPvze73351o2bsmSmyTjSLSJHQEQBn2qc7gSqrYIgLXcm6G4zMDOiBpDD3UQFMgJ5dr5q1aammrK1NssysSFLkXBrbeBz5X6FVcuOCi2MzGKxmG5uiEAg1pFsMCAiFQJqTSEEAkBghMAEdaWt0VbUUwVKeVdVde0qPxg2bNtGUVmWou9qra3WnQeks8lLBYUoSrwnpTSw8j74UCrlEVEy5eq6DswiKwQEBp2lqVIqACql8qKYna7KsiyKoqhKwTpeLpfkw8HBQVm50/aazWbHRwcPHz7c399v2VJjkxfDLwAAkrF2OBxev3pN5FTBtmvjH4GIyrparJbz5cIYY3VTxlFbwxyE8UstKaUUABJ7ELaAgABa2y6hH3uuH0kDa+HNrRzzDiIUAKqqEOwqbuLdKq31arXa2bvy4MEDY+1oNCryCtGhBoYASIhnaGsAIK4Kib9rQK/K8vj4aGdvO03Tt969/3/7v/8NpYAJ/vSf/uHv+a5Pbm5On7/73ObmFFQgBlYIgHs7O8zsXIUMg8Hg/oOHp6endQhAyEyd06k7L1kaVVUZx1Zr7arSAC7mq/FkeOP61v/zr/+dJydHn/ruT96+enW0sRENUiodItJ5kt4Sk8YfxP1EnW+CufYf+AYPr1H47qrLarq1OdzZLIIjBA2YxEntPQAAEQdCEJkckYSIXA6u3KfD5851+0ExSBy+GJ87507DfUMQDdF0whUwsELFoEAzBgXIITDzeDx8+eWXf+tLbw8nUQBGfza8/iysccGL07TGw/gpOmLH8Nae/2aWRH7Vb6HPLPtTtsbR+5P7NF67tpaXauTdk33GgBe4F7SKLJ1PZ7p0b1282cUWCWnoOLoQDuHI3TNaRavV6nQ2q/Z2t7e346ThB6L43nn2mbIsFbBSCsQJmFf7j9has7ExGQ6HcSIJQqyUkoKd2MbvAIjr7owNWIyiKCJUEaExkXnGbm3tXLt27bnn7kTGUvBXr+yFYDcm0+tXr73z3rvv3X8wO5kj4ngwnK9yZj4nbYmS1FP7Ot1ibeGesmoSDb5egWNt42Hr8pAkV++9QlBoZrPZ8fHxcJB+8IMf/L0vffFrb3797nN3uq0luT1EJHUpZPIlLMt76tRTpRQo027DPoLEGd4LtVWnkBUid/UEoU0t894fHBxYa5MkSbKUBKyUG9dvNGzgtQXrH1tHMiJmWZamA/FSO+dG00nwXhtTtVjQIVC3c4wxyhhgDt4zMxApZbJseJwfMaEIE+LgODsCWmtthbhII4gIoNLBsKqORVQ4OnowGk02phsIioiUtYCgTJNIXRRFkVfz+byu69lifnR4slwuH+0/efTo0cHh4f7+/qNHj/b39+/fvw/MLfqjAgBtDJFnImvteDze3d3t0qCFDIb2ZAVfi9F+Npv1HFskZnlZelA4GAwAQHy02naxFDrLmmJ8TeycRQNRc3IZUKEPQXiqSD/cuh4kMbddkYbcmSbYmIkaDt3hq0RRdHI6u3v37te//tb/5r/4L+69/+Cf/ON/vHflSp6fdPQKFPXy5NkY7T0JtJm4BrIsi2JcFflitZpsbGTJgAJ47//BP/hnn/77P51E+tu//bXv/e7vev6FZ+/cvrG3t6O13tiYpGmssZFB5ZQdHZ14RSogo/jYz5w4vi4QgAIxMDJorXWSOOdKD8/evf7pf/DP7z948J/8x//xVpxON7cevv3ORYJ28eof+TVmjOcf+2Zae9orZBR1Xd964QUVm9yXwftBFEXGOgqBSQFoRGBUqAICK0Q6Z+7t892n9aQlhl5L0Bo01RfWNWAiZkStDCIjNJ6xM26DSIEAII5jD/Dyyx969jc/93D/UNuoi2qG7iffkDvShXjdi8/0mRD10O37nLWL3lob9kXKi60ZeU02ObfMF9A2Lo6i/+Raz5826ouCRX8Und++E4Ww9cP1Xfpnm+8pr+hrVF0kqjj8qClHIzUSGr1nOBxKesNqVUzGQ2YWvN8QQprG4/GQSaJtVaidM/FHP/ZqVVVFsRoPM3FTSYQReU9MwI1bqzFFthEWDR8CNsZkma6dH47GOwGuX786GAwC+WvTK97XAWIUdIXIbm5uv/XOe298/c2qrEU3opZGUi+Xt7+yHa1fm5O1z72lR4AzUKqzRUQpQIpMyhjjqtpYZW3Egaqqevz48YsvPf/gwQOjMY6jV1999fd//8ve0XgyzItKcmclU1Pqy3rvJU+3c3zIt8wcQggApgl9l1JIDXCHJ9Kd2AdKaQUARmsJEdJaG6NlWh49evTkyZO7d+/euHWzOYBSAMN7qyy1xQr7uexC+uPhsJjPBRYRlAp1rbQWdtJNaSN2tDjMWmvQGgAwBGXMeDxOkgSs8mUp+NLSt7WZ71KiDSpf1wi6qqqf//mf//Vf/8wP/y9+5FmG2Wx2cnJyMl+cnJzs7+8fHR1JLMLXv/rGW2+9VTsPqIiprUDTCCjG2slkcuXKNUmRstYSQqidTGxdl8wMzPP50vtazOPWxgJZH5oaTdCtfqd9dp2XDaxMkyI4HA65BTYXriaDEg2YyMv2aTiul/Bv2xHWnmPiDFxWtnOfiBujAFRnQAYA6Xmappub2xS+9qM/+qNvfPXrP/3TPz0ajcryFFtbCPTST7GBFjBy9DroFcLaGIOgFvPVaulCCFrZja290WiQL+ef+eznfuVXP6s1vPTC9e/91He98sorH3zuhStXrt28eTMbjofDoYlsNhhG0XsPHu8DQ2tlV93xsVYj6tp74hBFkWAaI6tA7uR0dvXGxq/82udV8P/hD/4xE9koTny17NO0iwStI3pr9PbiA5d+ftqFT1NsAk03Nz0FZTSFYLV2VWWsCa5mhQoQQZNCAhCeKdGCfX7ErRbU50e9lwIzIzGohl51Q6MuykDGi6hQmQAMyAhKkkzEN8MIqC0hcCBlo52t7e/42Lf81D/6l+PtaE7OGFt7p5X1xErCOxUAsWoyCKUzihmlaknHXfi8agjn2We3ifvjubhC/elYY8PQ8vvOldgRcdUCaKjzMP391eoYW58x99+4xiPXeH/3rjUe0G+//VMjNnZyWei19vtDxvMB4aDQBS8odEqDwPkao4FJISmNRN4jaK0ZFIOq6xBqr0aD2WLpgg9MHHxsFQIoraxWSjI7LYfg0OhskJQlMLMyBrXRyiIgEzMoHxw3VebEJcxEBDZRSqlaExGamKhJ/bRGR9boRGeDOLKxhJvZOKnqcjg0UZzGiR5kMSIbq37/K28wKqNtUVTz1VICymRCLDIze+oMjFDXXik2xrjaAwCaLoVAUj76yKAq8LlQgHaSFYIAUwEAkQ8CH1Z7p5RCwKWrf/fLX/3Ed35HAP3G174+/Ogrt27d8FxXVT4YDBExBAfAiNzhqAgbq6oqihKxEJRlDQDgJZdGEzU2A5TCK61HsKHCTK52zEzBJ0lMFFSLkzUaDa5du/LgwQMAAGKrDSrFBFmcLd1SqloggtgzJSs0MI0mU+fc44cPppNNgiodjQEtsascg4qUipxziFqryNUUpyNgBoVF7lBBliXMTEorVEnMwABBGZ0cL+c7e7tK1wDknNMG0GiSqGylfXAKwTlnFCqgxWLxT/7JT//9n/zHP/H3f/Lx/sHF8w4ACJAN0snW5mg0iW3UN9OJfVWsCVW9you5qNrqfBx7Q2sURJEBEN7mrUWCYNp6vswMAtfZGj+74y9F3lozhiLyiskqAGAKXnA+EQgBQ/Ai6QIiB+qEZg8OlFgQEYCJSZJ3uCm8RkTBKCXB4QDAOhBTZGMissYIpAYCMIvR0QPDaLhx585dJqNVhmDFEqxVjKCMafxW3JaGRMVKgY2kdjJ6b4CAOACrECpQSEh57fOjJSIONrZ2ssx7/+b92Rf/X/8Q4B8+c3X3+77v+z7ykQ/fvn07Hk1v3H7WpqlNYpvE+/v78/lclDRXByDSiAEVUQCFBgwzMwIYxUppshg4zMrndnd/41d+Bwv4tte+NdvcVYVXHpRRWHsgx4EYNaJ26Eix4EYhMirWAEjAfchY4rPPPdrbp5NegWLQBIoBAAIwAQcx5oZgQWmliDkQsUJQuLg1jG9uOleRq6MoUSaSmpnIipgrBERutH4FBGBBEqfaTcvY4EmS76IfJFBOUGYDOQDQBoU8ivXFe6kfr5mZPDEphVZS/wxc5nhDRGIKPkRxUrlqMBi98MILSfIvi3IFoHtKalNLuAPfWmMhcJ6J9lkLnGfDF2WfNeZKF4Kq+lLJ2k/gvITSl0EuXchvIFKtyQrd82tDgAscd+1mx0GVauRfUeO6ca1179KRIjYxtC27FkxmCgGNsWLzCCEQSHk4pbU2gFEUjQbD4TDTGkMI2JMwOsaPnW7d5bOeH533XinjnAuBnPOy/xAx1E4lcZqmnTdLrGrYhiYhKHlSLKVFWdR1LcCDxpitrS3nwuxk/vDhY9BCSSPdVhMKIYgPRqMy1kRJLLZiKdlmTBPW76UOT8+I0hA7PjP7nJeWzlZf2GczUqQzIk30la985fs/9T06jd59993bt27keb61Me3mTbUVkUMIeZ4DgFhBJWhZwpe01kR16yNQPa2IiCg0II5n0XPdthS/vkRLybfb29ubm5vyxjiOFXYkWBtj6rpUUmLB2s4N6b2PbCKBeHVdpyYyxrgQsixjoizLvPdKIXCLuQggvZYBamgSBmZHR+ONqbJ2OBxSkxAMopqfIVkSs2fpW+3dcDh89/37RVEoBMlYFVNNJ+N6XzvngvdlVRHR8fGhRIlCSw10W3WxObrYZH9p7KTYdWm1L8XqLnlBr2kqomJ0+yEwn5mUiAi4lYb1WZhWR506OV7aUkqpNpJOrMMImrip7MsctDYS2NUtrkxX7Vzc2hKY2VpbVX44HEqdtNFgGMJZ/Wxo2LkSQUEkti4eG0ErdaZgyLfcxrfLpwAhiiLvgyQxa63jOJ5MJmmazg/2f/Inf+rvfRom4+SVV155/oXntNZRlEynm8yotV0sFlXpENGYqF0IqeXJ3cS2xjDQ1i7z1c1ru599/Xd87V776McmsQleedfOOSJw6ErMra9gTxmTPzu61z2z9hMJEYNergoCqMbaocE1ZBYRozg+mB3vvfisMtrnVScBO+ccneEXXezV+feueyrP/jxvqcaeitj+udYgAogUA2dBNn2WprX2wUEgCu7ZZ29/13d9xy/+4mdG42SZF50zo+OOqvOoI8J6JeOzxi+9Dxcm+uIUPI3/Pa3NbiCqi6e/zPn3TV5rDz9tQzxN/sCeZ04pxYyd/fbSpi7ORvdnf0V1AxXcgPrWdS2/TdM0Gw4UGqWUorDKl8ZcvbZ3ZZBmGlWUWGwkPFQdTBM0RrPAQax16rwZn6A5coLjo7VWChotzTX1KkKL+y8c3DRhOrrjqUQ0GGbL5TJfFcwcRVEUuygyV67uLhaLynljjK4q9k6ECaUUMrcRuEYOjEqboJg2BzfoFnvZe0ZtOsxtvOC5WJOQsHcBAMpytFvr9PT0l3/5l//A933Pzs7ebDbb2BznZTEcRNDaGGV00LO7IAoCQ2P87zfeX8T+snIb96faGn/dmsoAJas1TVMxDIgIolVzAK3VQs6E6IczdMkzf7pSarFYpNlQa62MUVoXy2XzldahjUCBVgrUHM6cbwiny8V4YwpEjKCjSFRebN0B2Hp8mrA4rY2UvdX6X/78z12/fjUASIwun/OEEQAoRO45wpVWGs+KIzXrhKwUMjZiAVyoZnbx9PUnnHyjUjfSFTayZrPKIBoPISuUv7QC0ZFb9UsabNTfrn2tgm8r/lJHRDW3YGfYOMWDUiqIoigtKA2smM/BpzTCq2qyqpI08seeKIgY14RDK2DGxs5vjGqTp9vN5mS3KIEyBtZaBUVMioiQ2VU1IioADt6RD8HVdXl6epJqPZlOh8Ph7PTkV//db/7Kr/2mMfDMMze2t7cBIE4y58mHvBGCmCVZG0A4EZ8xewSlDHMgorKuru5tfP53vnzr1q2N7S1ltFLgkRCZVSOoocKWvypxEjXHAdYY3hklv4T7nv0L53gwCsqjwpYFBKLARES7V/ZYcM7jSGstN885JrqGLrwLoNFWO5Txbq9qVIy9ACZog+R7xAfa895ub8SOAUMDd9JuLxIVSndeH6XMax/7ll/4hc9orTVgCEFpJQIXEYmlBkC1MS9dm2fOgz4rujib3VcX7198oBMx+g1enLI1Ji2UqJ+o193vmrqUWF/sw7/32343utXtXESi/vZf1M3S0xrpOtZ4C5iZWasmBFqooTCDEILYtbKhydJsEEfbW5vXrl9J03QwGCRJhIK4xISSoidjb3Phuz7oHkSXlH/vMIC01hsbG4hojNHaOudC7YTuy9PCHkKLuyZOyibpGRMKTIHLskZjtje3Vsv80aP9yWTy5MkTa5p4lkirEILRWqGyVlsrgMYS9AQatfektQJ1Xn0BoHNavYLzoNDt9K6nmbXPM7dxH1prhXB0dPS5z33h+7/ve3b3Nsm7th5Jc3WksGNC1Kuo4b3USBdQaAbw7YxppZQnUj0VvOtb15T8SW1lgp2dHURswnYQBbqkrmuiQtArnXNZlq1WK7FAiEA2HW2enp4i4ubmJpNHE8mbJNuYmUGCuqMIGABRk2qgMwF88FpraAtcRpGVGV6tVt7XWZbFcWw0FmEVQtDGGm1BLLYE2pg8z6uKoig6Xa6q6kyTa4epQPKgFSMq4C75mJG5cZMBnNmQWZAlAfnfE/y4RvKU7vTYcz8MLYh3QxOhSSLwrtOkJUtbKCbLqdW9RHDhoMzouwTfNgW8l0sNSoOxtjtQWlmBC10tl5KdPBqNOnmOiF599VUASNNUKR2CYw6IrHWjrnUBXzIECbdWSjEbhcZ5h+ps7BoVaACRffmsThc3lnUG5hqInM+rGpEnG2OllHP18Wx+crqQsCytjY0T5xwRMCCFmhEVIzO3iqYiIGb23idxWnOOiJ7Aajg9PQ0bUwIQXSEwQ2fkOMfnlFRMYXXOHntxNftrfenq9/8M3mtAozUi1hTyIt+7ckVmGxR21BIRpVDYRXjqM1batY+MTaZ4Qz365fIApU5oQ4T6XZRx9Ck5AGEDON60fi6vg8iH4ACQgk9sFACfvX3nez75yq/++henk/EiX4FIW09nmULcFT5VG770h2vsp3uGenl10NlLn67F9hnw2Wx2M9Wjv0/ryVpr/Z/3e7LWz0vZJ7akFgDEK9BZm7kNwqKnBG+vTY5CrbRyrmq7pLmtCtdlXjUQHGVFPtQrtbO9sTXdmG5MjFUhBKPQGAUkmCQkiX7MjK2Dl3qBHqBQbHbOubKs33zz7TzPn3nmGTRWR7G2NtaR0Q2cJBrdmdahF0+n2yxJrXWSxsPhMI7j09PFk/1HN2/dvvvcs/lylef5PDK1p9FwwMy1ayDsjVZABEJ6tCaiyrnONAfMClg3iowCUqU/hxfdqVzqfNT62QA7G+fZKQLFWimllUqjeLlc3n/4YO/KltJ6tVqlyVApZe2Z+iszJrWnhIXAuf2poHdMWnG7eWOfB/T3ZNdPcQZEURRCY71ExLKqBMpK/L6mhctvZWUlMXda6zzPs3R4truoJgBrrYljaNyZgZnZe9QaQjBag3RPVPi61gyj0aisqwiz0Xgc6tpa29AWRGzNEthGWXoXrLWukKQsMHFUHBzaKFmzBwigaWjtQAqlwG47Jz1BuZkWpP55uHhgL06dXCGsu67ajptLf6h7mO2dGQCRiVhrrdsaGyEEsR1RQKMsACgNYvsRIxAARJHx1CQy1XU9n8/zvGJqgCojY2/dulVWeVEUaZoyB6P0fD6/du1GkiSuehLJZW1dVd02xTaQpd/bLvpSa625tWTgufFqQZkA1gYpYM9Ng0pp5z1i479UGlxVGWPysoTFIo5SiY4GAKWtMU0mAjnfxEm2uzeKorwsFICnsDnd2NvbK6pyVZfAhFqh0RgCMxOw1lrSG1piCkzCe4W9Xc5c8bwYfSbMwRnb5vYEJjby7FRbB0UZXcyXH372dpQ00XygFAETUQDm80Gd3ABxnIvB7hPkbs80fRDOCoLR689innrPwHly1PQcBQkLdf/dAAASX45IREXlUHtPPN0Yf+I7v/1Xfu2LcRKVZckAYvkUCgvELJUQzxmJSCBv+p3g1izwzXC+p/Hj7vM34MH9aTovepx7phNw+q1dJIv9n1zKZeGyReq+7f4MLU6h6knTT/sJtvpQR5vE/SSHUHRKZmzDf6LhcChn0hgTx/FwOLxxZXc8HGqNaZxExkaRia2pinxtZqjZukTAgr4rPAQb5RKcC8aY2WyGRo83ptZECMq7oLmJQvJMulUOZZ9JgJJgPgj3jeO0ripEzLLs+vWrABAZa6197u6zp6enIbiTk1MiqD2FsLJJXBSlHHilQNASlYLIKAWWmX27m/tzWJPrWF0ncvZ3Dp+XlOVju+2bFVEKBZ2GFdo4evTwcfHSi9eubMtjjdSsm2aF/IkuIpyyTcgB7+soytaWmAgIQr8KVn+n6TazFs/jXUvaWKf0aHVWByJN066yltT6FT9fWdaJVgxBaysoknEWh7oC1KF2iKisJe+t1UWxyobDqiriJAEAliq/HIoyHw/GADCMhvliIZZ/AGiqTzIDnWeTADUFhcZaWznvHIQQkiQpKye+yZbuNwxbIXr2AEA9AZdbkXTtoLbLd3Y8105l/w62/aHzJ6vbDNiGFp+Ry8YHfCY/Kd0aNFsU7wYgpa3AyMxIChGLoljNV9Kao0DUQFQCgLbADCHA1tbkYx/72ObG9vPPP/+d3/ldv/fF3/2L//VfBICPfexbDg8P49gOBgNAYcZc13VZNviU0+k0yzKpBhHH8Xw+z4tCZrKLEqCLITLE1CsdK1YZZgYGVKAQtLZKqaomYtTWMLMPgcgrUlEUMSAqE0LIy6LxDWmtNVmttBh+dLOg3teeCRGrokzjiIiGgyxK4s3trb2dXWLuDP0MsiCEqACor+3ieZ34IqO9+Cc2MrQ03+qYCAAgKDHinicilpNtMRumrFTwHuWUCRFuQ+r6U3dOecWznl6Q8yRqBAUZppnq3iha+US0m7OIaNnqSqlzrtz+VVVV2tSXVb52BMzB7+1sv/TincePn1hrKx8aTFZC1K0QIJu/19gafekmsT+V34ANrzGni7z8ovO8v+fgfEWHi+0/jTGvtfa03178inukpP9bOfAd623YHpHqAIIv4+v99e7a8d6HwFmWZFmGTSFhmyQouYBd/E4URUmSjAaDl1/+0LUre0lq4zjWSM5V0nhfHAOFopQgyn/N/mj72dzZ3N5JkmSQDVVbt7itZda4Qk0Lyl8UlcQEIWoARQRKGaWc/OT4+FhicwAgz/Odrc07t5/RRlltDo9PnHOx1aAMAESKmdloo9pzId7SEAjII7NWipUSRCcAQPQ9a+eZebnPzLr5ZD6TuM8dQsQoipSC4N3m5vZ0On706FGaxVd2tsX2K/ura7OLfDHGIIIoPZ2/Y40By2HjM9t4kMSkTtiCFq2l3Z/AzBL7miSJBHkBB+HHnf1ZXieADDKcjY0NZU1RFExo4yiKonK1itJEcBDlyTMzkvB+KYOoFCrFzFmcEFFd14PRKM/z2vvxeIzM1rboKAEcBcHzFGBqYGRCNrBarRQ2ZnmBeVo7dkJzGbmFSg4az0pu9DnK2fFEQjh33vuclVuVpXeemENjSGyeaT27RKwQdesRwDaqThndfGgd+VVVee8ePz6MDDgH0FJYY8D7M1KXpdGdZ5+9e/fu1atXJ5PJzs7OaDoZDAbZcLC1tbWxsTEajQbDsUY1HI6J6E/8iT/xh/7QH/rLf/kv/8y/+Jm9vR2lYDQa7WxvDwap1N2yxgbvsyx5++13ZMc1paUJbt26ESfJycmJ974oCmaWbYmIwgvPBJD26mIkQSEQEoVAnplRRRIzIaUgpdCkmOjEAy1YJYLzY4wpvDPGRNbGcWyVRkTQiWYGIBH+mIMydjweJ1nqKdhRFmrnnQ9MrBC0wnOyQgvHgSB1l/vU+FLae4EFNqu/Rjp97Rp8R0RSXFTVzt6uTuNaKLDREo7aD3Npt9g5rkTnNfJOgFNttLZGBUghtKlobWshePHu+xC4VwFJ6FIj4OnWBN18rc48CFITjTlYLYmGUbFa7u3tffITn/hbf+fTG5sjqisGsMbULijQAS4x9cAF/tcei8sFnP7MXqSV3dr0hdb+r87NYy/zuP+5c752/34D7gsXln9tGdaeWRtaf2mVUnVdd3FY1BrfiJoRwfld1YEqdJ1sHUVNkJF4klxdc7ONmqqxkRYkDm2Vjo0FoDSOBsPMamWtVqC8J9SNs+pMg2zLdbTaNiGeCxDTWldlffXqVQEZUMqAQhPFVZFXVZUkmRQlBcAQQlnWZVmKdYSIBBLIOVcUhRSHz/M8z/PJcLS7u2uHg8VitbU9mc2Ow/bW8fExkR8MBmVZmjRlV8o+VkppVMxc1JWA13cBKbqNRkY+K+QsfvbOOnp+sfpLw91qUltogZkDMBCmafbo0aNrV/a2t3cRNKFqVYGuQGzdmRxbZNAGeaPjhf09xqi1wj7nW5N1sLXVS5vMrHVjUaiqSsr/BW586kdHR8KGhVaKO3AwGKQhW61WVVXtbEyl0I38PIoiJAatkiTRxkjZPgohTVP2XmzXIYTBaAQARBRnGYDS1jLz9t5eWRSy8YB8CMFYiwzOOfYhSRJldHCktC7rapBMZ7MZaBBYEh8KpXS7w6Uue6MREILW2C1uqys06pAC7IKn5BjRU+wZRNRTVBr7HraJ8l0QXzfzwlGYuSiK+Xy+XEqZcxAP3zpJQPjIyy9sb29bpaPIMJFSam9vzxijlU3TdGdn56WXXvrQhz60u3sljmMbR4AIqNvIGOkqdj4POUTf+q3f+rf+1t/6kf/pT/7ET/zEw4f3f+AHfuAXf/GXB1mmFBCR8244HH7pS597+eUP/PiP//h3fMd3RlH0mc985m/+zb/5pS99RSpAXL9xI4qiPM/rui6KSmsl+QVtv6nVwFqxgxFCSyoVMnHwXmtN7AGadEdjmrzwjmdL/LMcK4Uox7lD9WpBSuOyypVWVid1XS/zMkmK0Whk04yh9HnhQ9AIqBX6y5EVoNkA5wKk17jjRcZxkXojAyhEpZBE4GBiXpbF3ZsfzsajEirJoZfBOmpqeTUcpI+80diC1wWC3t5r6wzJzUAKGXohKUKDOrNKfyG6oUntkXZ4BMxNiJdkvCmlQnAAEFytteHgX3rphQ+8cOvNt9+Pk9QzOOe0tq32oJh8R8WUUoLxQT1Qhc6a2tdI+mepo0Rrc73GYvmCV2BtkTomx2cGyR4dbImdbpEOhat16909Sb2gm4u9FbqvWpT2tX52b4GegiULQ2ce37MS9C2L1SEE55wYoEKL8SszU9clAMex7SyNXfvWWgikIw0AzteA2Xgyuvvsc2maEpGKlAzAKB34XA+b8TY5C11Ab2ePNcxVURSnp6d5VU6nU4kejHS0WCyW84VzbnfXjMfjPM9FWJa4zSiKAhMjxGkyGAzmp8vffP3zRuOLL75YlnVRFI8fPASAa9euWWu1xiovtNZFcePho8fLvBB8Te9cN89aa++91M/p7gh4vTBpiQMXpRwAmAlaS2N/+VoSf07EptbzTUSECACT4YiIrDHGmDhNhsOhHFRhVNikMUCaRmL+FZYsKyuhy6qtU2SMUSZyznXVCwDAGCPOWuyZELv9Rg2mCjKLotxYERExiZPgSVAhhVt30NxCWRDRGLNaNeYQYTmD0agRT9wZhLK495hZ9pvo2YBYF0UIwfpQ1GWapuIFFQZPrWu/LIokisej6ePHj6eqqZboAlgbAcBilXsPURTx+RMnIzXGMBEi6gYamhA14rmzb4whHyThijiEEOI4DqGWkXbtaK0jYwWpo+MHzFyWdVVVRO7RoyfMXdki8L7hsuKL1RquXNl75ZVXrlzZm0wm169f39zcHA6HaRbv7OxMp9PERsYorfV8Pl8t5/v7+3VRPnz4cGNjIzhf1tVkMtFac3CuKnydp2kMCICKg0Njgdl5stYiArHweJSeA8PO7u6P/uiP/rE/9sdOTo7quv47f+d//J7v+R5mEHK0XC4//MG7/+Qf/aPnnnsOjQHmj3zk5R/5kR/5/d///V/6pV/61V/9d7/8K7/KDNbq7e3da9e2iqJYrRZyLpgbx5Jq6mFjoCZtgRGq2kdR5H2tFQAHBQgMwIQA5AMykG+DVQFcKBvKHIi0auJOHHkn2nYJANoYRLSRNsaQC8ezE2ttOigWWbK9uVUV5XK+GkYWvPZcCcyyakUuhB7wznlKvkbe14jzUy86Y3g++KAxytLpzqZTJMfWUfBMghqrWyCaTvlsyIKYLfny1NDuRawDEbEPrWm9sb0J922CNsrSaN1BljKzZI4RUacBN2IaIShqw5nPD1uujcn44x//6Btff19pBM9aa+9rE8e+CcpvomrPjtEF6zmetzNcOrmXctZzs3OZXaL/ucfhmj/XmDr0NGm6LAG3Y+TdTy7KYtiLFu5IzNqT/ef7H9rH1oOx+bzKLg93bNhaK2VeREXWWqtG2UryPEfAwTDLsixJkslovLu9MxoN0iyJpJQ6MfdC86S/TRlaRKHz1JbA6w0qAEBZlvv7+1IlDVFHUYOA+Pjx462tLenVcrks60oKswfPtQvOuap0RV5tbTVSzuc//zv7jw9u37mFyFVVHR4dbG9tjsdjBL59+9ZqtZKiLsxYVDVzA80oxsAmcFchEsoMSHKOPNa4opXvNphSqjP2dtOLrQasmtRJ358QeYAYg+eyLDcm0+XqlABXy3w0Gk2Vdc5nmZV5kAMGvZDabmHhzPajPAEHNtiYozvjh7xRwqZUWyVaACi4l2TFLI03eVwAUNd1WVTY6srYGMwVIorZf7AxFSNznudZljGhtRYQy7KhpPKrJrgGERFVCGJX0FoXy6Vw7uVqWXsOIXQ1A4TTR5GRITx+sr+3sxvHcVnXiBjHqTXWe3/v/XsPHz4EgLKqEFFiwjtNVIwi1ijvPQfVhYN0opJMiFEa40ZzzQaJSK7WahGwREgtiuL48FgstIhNiYW+jVMp+LZv+/iLL764vb09HA4nk40sy6R+32g0StM0isxoNJJ6z1FkFVCUpgDA3qNSoECq2ZTFqiw35yezYZYeHx6VRb5cLopVzhpRQQjhZHa8XJ3efubO7du39/au6jhFbYT6WS2ePmH8AaBFsgMEABtFw+FwMhm99dZbR0cnGxsbCFDX9XQyffPNN//kD33vM8/cRKPY18ysbLy7t7u9vfWJT3ziyZMnjx7tf+G3futnf/Znf+7n/tWjR48A4M6dZ6Q2w2KxAMUGG2hrUb/FEGLjRCm1XCziLCMf4DLjZZ/+cC/0QbY2spKhNfQcib0PIVQVGqu01nXtiB7Pl4vTw+HHX/mWdDyeHc0IFDFprQ0q55xmCAjMjbwr3ehJyevK0kX6ycwIoM4xCiHXREQa0XsPRi3z5ebNK8lw4JgCMDWhCNSl6l2kABcnpLta3tRYlcX4LEQSROhvA9RlxprZI2ot4qibuSVENACADGsWdGZB+uTmeIqZHoCZszT6yMsf/tmf/TkfPDOEwEQsAQJaa3m+E2MZoC1Fftb7i3N6YWxnT67N+NqHi38+7VcycnVZsPHapF8qc3Wfu9Gdo/L9kLwe6+p3uN/sGpPu9nrXFPZgY/s/F92L2+IBYn5kxCgyABjHsUbI89zXTk0Rx5xlyWAwiG3UvUIiIduWRc46M93JFmEFGpWoI92cVFV1Op8Nhze01s5VURKLhXn3yt7GdCtOMh9C7UJZ1PP53DmXJIkQytls9sUvfhERP/CBDzDzaDR5cniwsbGxsTlBxHy5OjjYB6DpdDPLsqpyp4uV8JuqcqeLeVXk3YR7Cs43xQaoK2QLAMoorV2oVkW1XBWdBtBNNV0I6uELqCy9lRKuzVXljmcnaRJ96UtfGqRRmiXk3TDLVFN+KsgyEQFzC5MEIMUPOt+SthH2oASx5+MU9tmOgsQsgi3wmdx3zjE3Aa6iVRtjbBx1qp74VkWKN8Y0sU51PRqN5vO5tbYoCgpweno6mU5FUACBmPVeEpYay6hW0mZosajkdSEAYmOJafRjAF/X0s5wOCRgZbRzbjgceu/ffPPt3/3d383z/DO/+Vlj9XK5lBE1sC0hSLpU8D6KImttFCXNRGmtle3kGO99WZaS+RYoGASllA9EAGlqiqIRm+JYfeu3fnxnZ/fKlSvT6XRvb297e3s6nY5Gk/F4nKbp6enJ3bt3JWlKayvqQSN7toH0Ym0UR11wpcSHAwAFhyShiKyUGg0yDj6yJjJaAb/77rsc/CKf+9pYaxF4/9FDDiS+1WvXbqAFYAXtS5mb7Dc5Z6qtvAQANoqYfFEUADAaTpigKsvgvHPOGEXkgTwqQDTAcuLRWHPt+vUrV6589GMf+5Ef+ZG3337785//rd/4jd/4Bz/5aSJAhBs3rlptiqIoyzKO46qqUCsijuNYGZPneZxlIQRzVjS+I1BCIVV7mxvqDwDQOHAllVG1/ngGBODARIECa6ODY8jz/Pjo5L23qoMnR3sb0+3RNLEREcQ2LouVVZqZAwWAJrhDkLk7JRLxklJIF4kzNj7kNT8mSi2EQKSVqSns3rhmsmRZl53tRCkl6lJHYNfexudimc5diMhMQEzsJTdr7QFhwNwaX7E1/AiBNW0ImOli8fsjDACKAAEIQIMSOElqqXZZ5Ts7Wz/4R//QP/ipfzEYZ6hAqSakENYJGctGgwvsrc+Q1gSQvqbSf6aviV66Kh3bW7vf7xK26AFPmdPzPomntNP1R3rbWRWwZ9DuWriU8QOcWUS5tRH1X9pTp5o/O2bTvQhaLV/1UvIVQpIk4+EgSSIiGg6HcXRWmIGbNTlXq7HdwwxKAMhZtxICM0vtUiAu82I2m21tbgvdd66qqsIYE9lE3I1KqeVyKdV4iqJYrJaTycTV1f7+/v7+flEUg9FQKgoAQGCy1g4Gg93d3eVy+ejRo52dnRs3bj1755miqN7Qb1X1vYODo6IslEITWV+G2tXyau99WdZJkigTMerASMFXVVUURVeVVliX974Xt3UmJ52XfNeOLsvqOOdUHDOzMaYqnbUxggq9eCilUGzLRATAHVtVbfBOA7CsQmerwDYQT5hclxvd6uIk9fu63d7fcmVZytDEvtqp0eJ6l5arqhLnYllXRVEg4pYxWZYdHx9Ph1vQVM6RaiqaOYC23jkFiFoZHZksYmYElcUpee89jceDvKwk81jeaIxBxd4T1T4bjTJEZt7c3nZVdf/ho9dff/2t9967e/fuc9fvRjaRvSplCToyFMdxXVXDYVYUxXK5Es2h2459qosI165d/c5PfPvV3b2Njcnm5ubW1laaRcPhcDgcbu5sD4fDyCbj8VhCDrU2oujLEksj+WoxGA6bxSWmELQxgroPQFJ5wpgmEhIaiYqUUqgUEKHE3xPFcQzAo9EoS2IAstpI+BscsXMOPKXJYLFYPHnyuKqqKq+IYHN7N00HqlGjJbQe2iNMrR7sBc8uBJ/nOSIIqDgzL/Nco97d2zZWoCo0+Vp2AABQCEobZlaI0+n0tdde+/jHP/5jP/Zj/9v/8j9//fXX/+2//bf/33/8T8Ucefv2MyK9PXnyxBpT1pUWN4fYCrCb7a57SjTINfLYEMnuDgBIRV/Q0ACiNpH5FACQkMExGWu/9u79t96+/52vfHgUpwpBWRMFgZTps/xzds2Ool7KJi5eDVXtEWoRiK21FfnJxmRze9sBOU22DXjUWgsgEjdBMMznzbQA0OaGXKLyUQ+npbu4hZ3vm9z4PP5Exw5QIPGbTkPfWgwAkiTfpGV1UxCAoygiguefexYANHIQyJXQQsfxmWsaoC0Nu9bLy4Z06fyuMcWLv+pP1jdutr+0F193JqFc4J0XW+vR7rP73NOJ+7/qyKu6DJLp4qjXXt31R1i7c44hoAJUrDQkaRRFkXjZlVLj4UCcqXEcW2sjo5BD55hUWhE2GD+eAqNCbJGxEQBVF1KPTTcIGToHXlEUk9F4PBnFgj7vGAXDwRrnnKcQGR2Y8rKoXI1axdYURWFMtLOzNxyOT05OsmxIRLXzWqHEE+1ubW5tbiwWp1WxOjo4WC6XH/jAh69c2X3v3gMB2+qKGSNqRGLGqnJ17W0cMyIRdaFeZVmKXxZa8UWSIrHnd+xtgzPJd43QdAuapgPva8QIJWBHq8FgsLW9Cd7FcSwmX4keElsWtZAjcpy7FJc1524/vVVWrR8pbYyRgHNuTdNEJIRbYrKEpqRpakeRtO+cE94snwWUPxsMlstlFEVorSSk6dYFpbWR4DTvve1cRUQdgzTGAiIonQ1HgJiiIiIK1Or9zEzW2lVdM5NniqLoq7//tb/7d//u+++//6EPfeijH//4YDBI4uzFF1/8Z//sn4/H4+Vy2R0cpZR3Lo7jJ08OieDjH3/1yu6OxAxvb+1sbW1t7e5sbW1JpvhwOEzTNEkSg2owzJRSgAjgxX8L0CjvANxWvgIKJE47hBb0hsl5Z4zxjqy1WinnQgh1FEUKlW41EGLPzBo1aMvsCVkphcq2lkZCRO+cjWOj9HgckOHGjRtxHCujHz16tFwuKYDY/4+PD51ztXfPPff8tRu3RpMpBDE3m9CilTXitAIEBa2M6JxjhvF4jAhVWUcmqn1ttcaGqgRAAtBAnlEpbYJ32liGoLUuyzJJkvF4+MpHPvyRlz/0Y//Rf/iX/uu/+Du/81t/42/8jV/7tc/LGK9c2WDU1tr5chGZuHFj0RkiUO9DB510phi0FCkAqC5iGREZAoAOgYW1SeyjhFQjcgBOhpmb5w8e79/Y2UmMzfPSNKSyn4nUBG8/jeB/YwZ88SKUKML4ZDa/def5dDTIqeYWX/2MxVIjapi+5n3hdWtqoSSM9DuJiIAEkgTQStiSF9AnPt1BwBZu1pwxjEtUbiXaAAEDqwDEzHVZmCi+efPmH/7D3/2v/qdfHY6HRVlr3URsXuRAfd1urdP94fU501oLcJkA8rT1uJQfd6yRz9dpuPjzNT699lj/h6FXb7j7lnoQFmvf9jfx+d6eg4PG8/Gx3U3sApFQxXEcp4lEQQsDFnNiGkdKKaCQJMmtG9c2Njak2q7kBgAqDRJooES8YoXAiKj6BhwNHdtVss+YGYAmk8nu7m6SJKiAm9wnXZZl7ZywkCRJRqMRN8ZhIz5IrXVgzobDycaGKLtV6Xd3t3d3tgWDua7Lq9f2tjYmx8fHJyeny+Vid+/a7du3337n3eWyRH+GuVHXtRZMLGZmlpheAKhrn5fFfD6v66A17OxdoV5hODiL6+4v6Hl0m8s2g8RzOedGwyuuyvf3D65d2dNajwdN/UcJZuqOcSO+dMhKbaI2gZIgqUYhbuPpuqA/eV7URInqkpvyvNaNlZoIBHUuiLM2CtZa4cqIKJJK13gIYXt7ezabVauV1nqyuVmsCjFQB3cGnwAt7wdAT3SWwtT6VIP3WhvdONlYGwPMznlWLDnBURT/0i/94n/71/673d3d09PTv/7X//qf+JH/5ac+9anRYLi1tcUMq9WqcxaI9LCzvf21r7356U//j5/61KeUUrFGsUVDKzWhUp3ljEJQWjcacgiAilwdmKgmBN1mEOkAQTdoGLq1izb0VKz0o+FIrOtaW62bWeo2uUxCCxmEoJABW2+i0EYFiMwASqFWcZzmNh9PJ3meb/itsqxlXYLzvnbGmMVi8ejhg6qq8ip//vkXh9NNZAT2WqvOWHKO6CB6H1arFQCkacoMZVlaa0Nga62yFkJw3smjTKisYfYiPUj+bBeUYBSh4uEgfu7uM8+/dPfbvvXjX//61+fz+a/+6r/7H/6H/w8DKAWTjbHWpqzcarXqOrPGhlESc1EDiPMRRPtl5ra8mO5OkMBLIpzxMGyexgDKoo4Gyfv7Bze295+9dk0UzV6IUXc2mRXDujX3qZf0sz+VUmNbPp/l4lPY2t5GazyXbDW2Zudu7kG8yHj2J1xG9rF1HgFAo7sjAYOSGBrF0CI0dDW5qcWiv6h3CXGw1hpAYlY9Q4QGAIKgz/dDWDwzR5Gpg8sGgw9/+EM/9/O/miRx7ZqiAnz+athPO5A17tuu3LqGujbsb/xVn7CuPaZ6mSdrl+qlfMAFjXZNMoALLtuLfHHtV2vc92kPtPfPNdVnwNwzn8qvrLVpEomCC6qxZ8Y2iuOYmaIoGgzSyWicZvHW5tbOzs7u7nbUZjRKQAC2MVaNYAQKgAHPdknXzf5SAsDm5ua9e/eOj4/H43E6HFRVFQKFEPK8FMukUirLMq2tUub09DQwV84dHB0ZY7a3t4louVzu7e1d3b3GHIxWRjWQzlVVKcQsywAaHe75559/9Hh/Pv8ClIUL4ejoyHu/tbNDRPfv3z86mhsDo9F4MIgnG1MisqtIwAqUUienc4nvbcIsejDF3ZT2BnvRSd/AVzHzYDDg4Gaz2e07N+fz+enp6XQ6FTFIFHRmCk0xErA2blO6G3Yrwm/oqta05s3+7uqHMVOTJrDuFRLXrPdNAWBrrbYmjmLpcBd9DQBpmorIFUIQ0/RyuRwOhwbRWjufzzc2NpgZuWmTmohrxQjWWgTUSgcKzBInorS2wCR7IngpMMDOucYFqNT+/v7f/YlPv/TSS1EU3bx588UPvPQTf/fv//Iv//IP/dAP/dqv/VocWylSK55gidST3l65cmV3d1drDVQDNDVTUSEiu7qsqipKExYsBTZEXkcRILuqUEjB+STL8nzlA2SDsa9rE6fMQaCYm1XmZp+naXp4eJilQ0mZgV5YZbsNhNfrRn8WZtMEocomYdAGKKAyQAzamMwM3ThJMiJAZYHRWnt4eDifLU5PT7MsQ62s1UVVOl8z83N3XxiMRwDKGAsgITiqvwPl83y+RFkIBc4551zgMBxlgAxIQBxYgv4aQxYiiBIcyOmuKiWX4Ml7b5KEq/LWs3du3boJRN/28dd++If+g9/64u/+7L/4uV/6lc8gQmBIU+s8nRM1WgrQMza325UQoMmRQQBg6rM/bIInmo0hzIKYdZzWrk61NVg+fnJwdXtraIyrSq3E0CbkjpnOrMFnM3OBZfTPztlX53vaMlPQWldVtbG5ubGxESAQAmsF/kzqBWh4apOwdL7xM0HkvBMz9LACuY2LFPxWbnUzGQt1+Lj96h2qQbmX9ATDbcxJP1pKGCddwF2Vd4gs+cLdu5/61Lf/21/67O7eznKZdwJ+N7yOBa2xRmwkPg8XvupPwUWGd/GZtRb6n0VHoV7xduyplZ1W9DTWu9Z+/99uCJ3bj9tg1P63fT69Jl32JxNabbL7eV9H75yX0K6ZtQ1uAPa+YuYsyybjcZYlO9s72zubW9ON4TCbTCZWKebgvW/zMHtbrQ/xAiDawEUGLH+WZR5F0WQ0Fn+SjK8si6qqEVGYX56XnkgZU3s/HA5PTk6kz4eHhwLZs1qtEptGUeMTLYpiOEjqopRw3Lqup5vbxhhQ6tlnn3333fu//cXfAaW2trZEq3jy5EkUJa+++szW1tZgNBTNuyiK6XQ6nU6NMQcHBzZOuMXmzPPydD4XdthJxMzcpTh3S9CblnYVjK7r2ihwzi2Xy2duXn9yeHTr1i2BnGwxeHVn/kVkpRqFTN7eLD01JinsBcxjqzf3JTxJ5BXcg/4mlMfSNJXUZ0T0FGQJ2txrqOu6z8jjNCnLUoIADg4OrhqjlCGioigiEyulUGsrVnGlux1YlIU1MRHXdRVFkZTTkoKvIQRqg+HLshiMR865NM2+9KUvff7znx+Px599/fMvvfT8Bz/4wR/4gR94/fXX/69/5a+OxsPBYCDagLiunXORtTLkxWKhjanKMgKPiNRERUidY0VkI2PLumAG5qYoELYZHVEUkXeRsYEpOGes7bZxq8YgoKL2psh5ov5CG7tOJBmbjVlVPmilCRqlQVLVEFhqRrAirXXtq8hY0DpOk5g4hKBQp2mapmlsI/Lh8PDQe+9Lz8zj8fjk5OQrX/kyKHzppZeiJGP2wsGwdX+0qh+XZVksV0rheDwGAIlIdz4kSQLBC3MNrlZaAyr2XlCEtTHUhhxKg0r8CJHmqkDEanEanF8ul97Ve3t7n/zO79ja2vrBH/zBL//+V7/whS+88fU3+7jofQLYWi4vaEHY/COWgVZg7Sib1KflAE2+RR18pHVVVZPR+P2Dg+tPNu32jkWEXhwMtj7Q7g70uGCfm/RZ49qFYqJoObfWVgGXq/LGjTvpcLAgBw2PpM5E3FO+1681Gb1/TvvkgrnNGW8ZqGKEM7CXs7if/mdubUKIaAAtSKHwJjSltawqBMAG2osZEQwoQHCushYZw2gYfezVD/3KL39WcW0gBAVGR7V3iMYoJPbAAZl9OPOD9keoL9T9XZvWi6yRW40QW2UREdemqftVN2B1IbG4i3DpU8Bumc+v6NmvLk59f067m91IRUpq83cRm+ooWmsUYHdpKgRSqqnXLi10Oo1u7Y+9HajEf1fXTRIOUBPia5SKIpMkUTaIdna2NqeTNI3j2BqNAIY58rVryGhgBKUQCUnk1N54m/h48URqbYkqEeiMVcNxOhhlyhoERYD5vPz6195nhJs3buWlW7z/QDyjzrkoiufzZVX5sqwWizyKorIIwLPTWZ7EOJlMRqOR+PliiIyJCHXtq5Pj09FodHV3rw7hxtXtZ5/ZfeftmFjw7v3Vq1dv3X6GQJ2cnBzNj+89eN85l6XxcDDWWj+4d/+dd98TQYSZPZNYXNMkiaJoMpnUdb1arZbLJYCKIsOtjVcWXCmpHxqkxI0ylpEch8AqUvDk8GBvb2eMw6997Wv2pee2t7e9r5ljAG2tNkaFEMrSJ0lGREoJ6IpPksSYiKBvau7gsRhRMsqc9344jKSGEiMYVAE4slFeleJzJQLvSZkQihIRjTEKtUj3RVUCsxETt3PiNa9rP7Tx6elpHKdxlkky0mhjA4HiyEgRmmq1jKJIWytZsdoT+6B8KIvT4WQSqWi1XHmlstEIlEdEZL88XQwGg7qu03SQ2KRYlJzw7PD097/8tQ9+4IUbe3sHD/d/4+D42eefe+bGdQ08m82890lsK8eCU2aNeM0BEZanc2CwSgfOjY4Us/c+ENkoQRVpja72sUml0qpCRgjknLHoCmRPVV2DhiiKqmqRqSGRUyYGJiAEVOI7kxBnOZ+SQyygY13EYnvQRZvpcAS5YQYAAExEClkwWYOomEqBD8oYIEoHmdJkY4gTYyx6coy0v78fQuACELGqnKvqr/zOFw3x7du3h8OhymIfHEBtpFJhUwYqALpFMQuBk3QKDHlZjabxojiM4oxBAypitjZydW2tZaUQSCKzUIv4ogiAABWRMgZCQAZmD8EvTg7n8/lyuQwhzBbzSNd7OwOEW0lC169vvPv+yZMnT4qioLZ+V0PBCAFAm9g5h6C5rXWmoQ3uZZbUOCZJmWMU3tFYrxvNVCMTBR0nq0DpZPrbb7+XTjfHsTG+HmhFwUMg1LaWrFwTMZUSRqEQCagJ8+pguXum0y5lOCJAhlJTZUAxJB4MQ/AuGO0UD65un0Q0ZxomiS191cLtMne6PoJGYu4wsFA8dCBMNACA+GtZofM+sG+jqGT3gFHALLmIWNUrVGQ0EwEBBC+VPJAZulKh2lgbxdqYM3vXGptZu7A37CbElIhrd+eZ2x//6Iuf+8IbW1tTrl3wLcgUolZasNZ7QDDrGn3/6jPObhP0Fce+jLbGaNe4Zr/PcCEhuP/bi8O89M7FPvcZ/1rfLp3Mp8lZ0qsmgdV7RBS/addyzz3ctOy8i9pLfhXH6Xg8TuNI4lYE9244yOLYWmuZGjgqMDIbglpKfeGjbyfoCyvUIrkwc2STOE7FRGy0DaSOj2ePHz+OB4PB6SzLsul0urGxcXp6OpvNEXG1Wh0cHBCRQuMdDYfDjY2Nzc3NQWYW8+X7793bu7K7ubk5Hg6YWVSc4XB4eHA8GR+NptM4ju/evXtwdPLGG29ubm1pGz05PH777bcPjk6IaO/KzrVr19I0nR2fLBaLd999d7msphsTpZRA22ull8tlWZYhMCBGUWOj1lrXtade9UBuweuREUELwrNsmziOjcLgvQdcLBZ7O1unp6dvvvmmMUYKBOV5jsiCTtWl7ULrLBDADdWLwpBhclvxQvRC2RtywrVWpi0x2ctQApAisnVdlbVkoMnSl3nh6rqrVCiKVAgku2g+n0NraRgMBpPJxDmXDNIg6B9as3OSo4KISitN2jkX6pqAQQEgA3lQ6KpKQtahBb6QLtV1fXx8LON1zom39f79B9euXRuNRnmeO+cIWCvbGgOgm6InT55AgxbEFGpuGKW4nxs5mxsTfTDGACoVGV+WWusojquKyrpsfStBxwkQAaiGqJ47blKbqPN2P+08qrV0WBTvKjZWouawgIbmdDTeImviQYbWxNAD2zk4OPDeLxaLNKU8zyVVrK7r3d3dvdtpFJkuagyVYgpVVUnOFQAE56Uj3ntmiKMUtcEGIwlbLHgP2kKTqoIKkCAwgW4x08HXy+WydiX5IC2fnp4y8ypfHR/Pjo6OnhwcnZ6eaq3H46FzVRQZck1RyzzPXe2VNUophaBi61yIIuscK62kqp8QH+ectZFSSsqvaWMl6kKwm6BXgwSRAwRmzQjvvP/eRz/4IpAr6zpSyKiD91pbRkUXCPX6OhFfDNTiVoFWkg7F7ImMMYuy2L6yN9naZETNyD4ISlRfkYMeR7hI57mH2A8ASAyBIDQZvcznzat4Rjy5DTRZ0/rkSTndiAoADV7GvTp222leXec4UOnLNB144sl09Nprr33uC284X3sfgm+scMwUWEpbn8vXhsuY00XedpGJwvkz8zQOuvZwnztebHDtztN8xv0NsdaNPt9dO9vcyyTpjmU3k/0n+7YBPKtxdg7jWpZTvo2jVLWXba4YEbMs29jYuHJld3NzW9x7Qpsia/rz4L0UzGrkkj7QGp/3jzJzaAu/EFFgGgwGWmultScui+L4+Lisatb6+Pi4rmvn3GKxquu6KAohKFXpvPfWkrXWUyDg6zdvYKgn4yloxcRP9g+SKHZpnBhtjRpvTOcnszzPWSlAnQyy3d3dsqwPjg5P9h+vymo6nV67dmM4Hlut83yZ57lSamdnZ3t7m1G52ud5fnJycnh4yAqlt84FBqiq6t69+4NBlqapUkpwoLix8PeWDLGJ/SG2cUREjMoHtzndstbubu9Mp+NyNTs9PQ0hjMdjbnEimSU7oIm/6BrsZ+BgD5NL0gQlhEqWWymlrSGiqq6MMQFYvMv9nSydJyJUIGlXnVNWdk+7zbgois3Nzf39fahdlmWPHj1i5t3d3ePj4zzP0zRVWoHiYrXqeJgxBhGUgsAN0KlqMnC8jaLQIn4LKiEAJEkSJ8njx4+h58y21j558iRN062trSzLiqLwIYh7UoyodV0iIjPMFnNXVUqpKIqkYJFSBhqa49sQqqC0ASI0cahLrWM5AizVLTlGRHGHgau1soDnjmd3GUl7jZ4WL9Kx3pZEAvRyYQlAQnsUi8m6zeXDXj1KwaWBM4e9Pz09Lcta8BpXq9X777/PzIeHh8EmV65cSeOIiRA1oEZkDVyX+ezoUAEYo1igjAGRJStJNaVuhHrIluDQqoMaACWkUgFDCBxCUeTz+Xy5mpMPVb6az+d1Xe8fHh0eHj45PFgs8+Pj46OT09lstli64FxsjU5iSSIvywEAFEVxdHjiCBBhMhlro6NIrVarfpJ9tz/jOCYi7wkxGGO0iUIIDBI0QFo3BC0AA8CDx4/u3Ly2maVVWQJoxUxMBkmps3jUjvU+jdR3lyYIIJY7MCKctDVVlsXyuasfTMbDha+tVhQCIVOLxLnO6ftkvFc3kIn7j3W/pUawlhzURgnsIAq6BKe2cdWxg068lkNt+owWzrOotVfKnSRJXPAhBGKI0+zZZ5+9enWaF05rTSFopRkhBBJTttZnBbT73PEbTGvXUegFOl3k1l2H10Iqug73JZfu204b7r+xa7+biu7+2rv6fbiU7/ZHd05q6QHu9zmc/CT0imzLtz3Lczeos16JGXO5XBpjBoOBYEV576MoGY0m4qSU5BPEBnq46RIDIjsA1WbIMAHDuc549go60cGHFidLqLyykeDbeU/HJ7OqqjyDUsZ7Ojk5BSnao6NVXpaVU0ZrBEZQxiLq2Wy+v39gjRRkDCcnJ0WxQsQkjjY3Rtev7A3j4WAwaDEFOY7j7e3t999/fzoeRVF0MlsUlZvP5/fv3/+93/uq1hCChJDB5sbg6vUbAJCm6dWrV3d3dw+Ojx49elQUpTHWWBtFURzHdV3PZjNBsOiISOvP6oqqN+vovQfieJBqE21ON9LY5vny+rUrzz5zbTabSYNd0YU24AA6+Ml2AltPY0/YktWRZ+q6lsoZUhmNiFArE0dC5jo7EDMvl8skSSRvWFzaSRpHsV1W1WK5lEBi4fRRFDlXJUk0mUxOjo+11hsbG4LFPRwOu+INdVGUZTkej43VWuJrtE50KsRFGw3MgvmsjeS8ZszsvUPU0O6oOI6xrYrWqewSqTcYDJb5qjpdomlD/Jq+OZlea21ZlknSuL/aGZND2mD4gRw9xLr2UNfpcAjg6ro2VsfWFnWBiLoFzQYFDXxEu7TMDEgicrW4gHJzjVGvq79yBwFbZZpbUtPRBKCeB1Gk4dFoJLZuARw9Pp4tFoskScqyzLLs4cOHi8WCtcVQX7lyJUkS0AacB2MU8uz4eDGfI8BoMECCxeI0jmNEkFB/iSdEFhwVVEozE5IHQkBm1dBJ72rDvijyoii898UqXy6XRVHki+XJ/PTRo0cns/lsdjqbLw6Ojk5OZvP5PJAyxiRJg5itFWSpjaIoyzJtoqIoDg8Pv/a1dwNDHKs0TZNsIukPVem4rYYrsosIbZ5CIA8KtYoAAMlrrb1z1sTBO21U8PDmu++8/PxdbUzlvQHQCkMICBrORz+cseGnY2IohqCQEIBZB5YybqDRM8VpMt7d8pp95SMVBQC60MoZte9XQOox4EtjYhCROQiEl27KODE0dSHFvn0OghvObxVjIqUMgGKGS4A4njLS5pL0RE+BELz3165d+f7v/9SnP/1Pt7c3cqy9C4FaeRaIzwGkn3vFRZbWTMR5OaD/1cXHvsmrz8n6P1xjn5eOvc+Pu8fEfvgN3oUXlO9+C91j/ft9OaBNqu6qWfHZIAIZw93vmNk5V1VYlmVZllLvoVOOuRXVGwbQumcIUJy1a8bn/oezHipEVJJoO0lSAEDQZV3NZrMQuC5rwHyxzL33cRwXZR3HsbVxmg4AlOAZVVWVpulqtfryl7+8u70lybtHR0eo+LF+nCbxajGPjd3cmGRZGkIAQGNtpM32zubu9uayyJN6MDudv/POO2+98wARdrY3rl67kmVZJIZba5wLIQRP5GuPiDdu3Lhx48bJycl8vlzluZijoXWrt9LrGf42AEokLjbLoaw2NrGIACE411ZBCD6EkCSJMUbCoIRPIKKcui4LSHwExhhPJKyRmaU0J7UZSuLH1dYoo7k1SnNokoP7FpQQgrFmPp9nWSaafZIkURTN53NjrWjeiCgqtQRbrVaruq5CcCHw7tUrEpPlvU/TmMivVgtjjLUaAFxd2zT1VWWUUrqBsgNkYAIArVSZ50kco1GLk9MQgrVxlCR1XWej0bVr18TnLUJDAE7TdLlc5nk+Go3iKAVYykYSLqiQkyQxBowxjoK11vtKuBoRAWKbc0Vai1OGEZGqSmud51U6QEE4QQW6rcChVTBRFHxQSrcKTO8iFmiyvurWPdM7n0/jwQqABf60kdVak54cQVF6BGGmqwhZlrVSRmsrLhtBbmHmqqrKquZQl/nq+vXro40tYAKCfLF84403xHJrjGGG+WxmrWWGKErOSAcHIAbVahHMwIEZyddKW9S6zOehXi2XS1fVVV0URTGbzRaLRZ7n9+89PDo6qn04XSwPD44Oj4/q2itttUFEjKycDJDE6yRJtra2xuPx5uZmnudVVT158uSdd975wm9/eTaTXCmzs7NLwKvVigklJzCE4IJXSqmmVqaEVnhAUSACKVCgomzw+Ph4Y//gxt6OAvDeIyCHYDRwV6jjItmUab9I9ZkJkTQqz0pse0Zpo/M8371xbbg5zSkoQE1AwJLevUbf+ALqVp939g54V823y/gPotrK6RYtqGHAhEwo8h8ASJEkZkZsYIIQNBMyglnjcGucr8+Z5FulNQBYaxBxsVyk2fijr77yUz/1T/NiBa2zBxvAqdbOed7C3mdCF6ZzvfjB0xhn91vqRYRDj8n1f9s93LczX8qJv5mr32D/JnRKz/lMp9bIfIk7XP7ULUYSAEiKUTeEtVcQkVLYVaaLbEREdV1rjd6Fuq5dVVMLF6wUWGu16WoqiPxuAICgWaNAngN2YYGIyMgEJOXP+8MsimK2mKOxNkoV8snxrCgqZrRRLJUHvfdJ4hEFXwaKogBGz0SAnnixykU5KIqVcCZltPf+3Xv3Y6OZAiKm6UsCA2SjyDkX22g4HGoDVmHu6gf37wVy3/PJ74iTVCYtXy2LoqhrVblSChV776lm55xn2tzc3N7etja2UTSdTsUlWRTFalWIw1JrQRW23R5BIAWA2mKHXslhNBoZY4bZYGM6DbVbLpeS7lxVldSlYGZr4yZEpV3KztAUWmczESEq16ZNNyoLNZnWocX6DsF5r52rEfUZupzCunBxHAvvB4CztCXdFAKRagpEVFSlHPLVanXjxo08zxMbzQGSJKmqKs9zESastaiVC7Wrg0w4t5Zk51zSnpSDJ0+YeXd31xVFmRfD8UjcaBKAfevWrUDAzFLhSnYsEYluLUJGd14QcXt7q6oqZvgDf+APiNHbl41fnIiwxWBjZtQ6tJnNVemyLOMEXelEJ16tVkmSSFi4c04ZQwGMNr16kq1srRQAJFFMDWJdK4TKmVrnwd3VGaX7mHG6S8rC1jestRangxzbOI6JYG9vT+4YYx48eMDMRVHIVBw+Ofi6wuX8NF8unnv2hcFgZIaDvFh97atflSlVSjHDcpGLOGWMgTZ1lRlCCOwJiExkAICDB1BMxEzImlx5fHxYlWVZlnmeHx8fnxzNjo+P5/P58fFs/+CwyMvZ/HSRF84FYlTKxJFCxDi2WmujcJAmk8loNBptbm4Mh8MksdeuPGOMGQxeE//Ow/3ZV77ylddff/3++w8JYDxOJ5PpIEuKsgYIEEjc0o0kxKwAyQellPNeKUMaPQGY+O1HD0ej0TRNlKIQAIhYij3gOVcgq/V8qDNizo1GywDErAA0yQNACItqdffay5xYH0qtNRIDIBlWPfmp41aKoYuZ71N3xKY0et9M2I3tbK8ihEA+1IEcsOYLLFWKDCIiaqW0VdoSsHgMDJ9ntH1Wh5epocLwXVWjVmma1q7c3Nz8U3/qT/7UT/7T4cg6JMHCdc5pqwT8v9/gWsvf+LrI6jr+2v+WL9M118SINa6/Jg3geYV1bbwX+/CNe9t/XScHiFjSCRZ9y3k3hDYSp4nS5NaRTI1u1vBgPFN8K2I/HA6zLOlqhDnnIBBYUErFcSxBWE1/sAVl1LoJAuImHlgyZ7TWrJiIkM4AJajNzzs5OZ2friYbm4Ph9NGjR0Xl8qIIeVFVFYLyTMu8KKpaFD5xiUnFHmutMVEURVeuXKEYTk5Oi6KQrNCTo8NhloyHg/v379+4dmWQJS28Rg3alGV58/q1r735FkN48cUXT+crAnP/wcPZbCY5LePxqKqqVbF0zilrEBE8KqUg0Hvvvffmm29NpxtRHM9mMwm63tnZ2dqCsiwlz7IsS2ul2IMHAGQNLQYQIobgEICBOAQiTxTyYplmDVMRY4PgdZy3aYP3FEUgk8Btvawm5a+vNGMTK8CtR6Cqqtg21QwluFpSEzqVfbFYVFW1u7srkS9EVLta1OLaVQFC7WsmkBgxiZzy3mtjpqNxURTj8TgvV+kgSweZcw5YAZIx2Eq9GkB575wLUQQhkPdtzJe1VPk4jrMkrX1wdR0nCRC98MIL3/raR588eUIt1j+32Bfek0yL5Ex770ej0dtvv8sMP/uz//yTn/wkUAi+SQ0icm18DDNzIKf0WZqWTFGcDso8T5JU63q5XGrt0jjVWiOEEAIF0MzA1GSqAvCZ6ZIlFJw5YSZEc4ld7rLjfJ7UnAVOd0oP9lBmtdZEEEWJc06ENtn5RHRwcDCfz7t4xuPjw6oqqqqqKnfzxu0bN2/OZrOjo6M4TgEktDucLhcioBhjQCRvCaWkELx3ropDJOF10j2xx5Rl6eq6qqr5fH58fHx8NDs6OjrYf3I8O83z/PDgKC+rxWLhCaDFPREYc6tVHEdZlkxG4+l0urk1HQwG1uoksQheK7Vazsbj8cb05osf+PD3fs8n/vSP/amDg6PXX3/9X//Cv31w75HWMJqMBlkKCvM8946MMaiV914i2bhlez6AJ44juyrKe/sH6sruyEREzqASgDYJeW/CqC9oIJdYooWSswTgIQIgceWraDQY7W3XHHwIMWoKREAt3sE5HUzxOYoN0IZ09fEYGLjJvWYAlEwjpZRqsfQ7iicNN1S9r0sqBmyKkaDkTDOeEYWn7bw+J2vFW2DGOI5XRW6YNSqt1QdffCHLbJoleVUzOaVioThE9b9vn5+f3zY9qVVKeG1qoMfSusN5satwPpr6bB4v89rCeYGg/zD0dNn+w+dW67zLvOFw5/32dJbpexHajUWCjmMraTxrQk/3Z3NHAwIiNeXqjFLMvFqtIqPrul4sT09Pk8koy3Qq26ObHwA6M0fLztOoWYvue1aNUQFz48KgtkYYM4s8vlqtbJz4gA8fPvbeK2WKqgoMITixggqHSNNBR5uiKFouc4nvePz48fXrV2UsQhOD89XJaV3X169dXa0KSTeQN4oIrzXcffbO4/3DOEpX+XuPnxwC8872dl3Xp6en9+7dCyFMNydZlknp7CiKF4sFA0vQr5hnkyQ5Pj4OgbRWaToQ+21jpQfl6to5YA6drN1tsCRJJI5mMBjExtpIi6Gp83cKne3Cm6FnBZGrM1G2SEyNd18ScLENiRQ36mKxALKdw5I7Gq+UyCUSKJDnOQCMRiPnXFFWiGitJe7S/6msijTJxJqilDo5Pt7Y3T06eGKMSZOBGMcoQBQZVKYpQhBYKerYiTIGACrf+JuNMdZGZVkuFqvRxtTXNROhUtdu3vwLf+Ev/PCP/KmPfstH7j18IOdInLvOVTJHIgpkWXZ8dPDjP/5nfvzHf/y1116r6yqKY621wKppIEQkCIgISBp1VVUMFDwgYhwnVVUlw1hrTd4rrbMsS9IYFUJT1bEG1FKAHUAgebFz2yAiqrN6GNCZ+p5CiC69RDAQeCdoKIAQAYWolTKoFIBDbOp0DYfDJic7jmWzzWaz0FxOsGKq0peFQ63ee/f95hUA1sSrolosVqgNKIiiCJQC33IJpQQjtqoLY0yRL2XRT09PJY1isVquVqvDw8Ojw5PT09Ojo5ODo+P56WKxWJyczr33ReWiKNI2kuezOBESYYzZnG5Mp9M4sUlkI6OHg6E2KoqsMTpLE2s0AIOvR8PhxuTm3WfvfPTVl//Uj/zwO++/99u//cV//Qu/cLD/JAQYTbLJeFjXrvbOGu1rb7Qp69pYWwcCZo26Jk6y9OHR0Xg4SjdjkHg37xW0hsPWv3Y2/5cJTaIEMzMEZkbQComZQk1u89bVdHOy4hqYAYERmJgD0PmaSxoQ8Iyk93mE3JRj2D/RQExAiGxQS5I/AFBbh5fb+nL9S0hue5QlsEPehYbP89fuxXQ+vees063MLvYuQPShvn7j2vd+93f97M//0ubm5HS54hZ+mgg0XmjhvK0bW/M6NgVWz+Xvnj8AZ77Vjg1f0kNZmwsQa/1n1lruf9tn7Xi+bvEa41xbM2wDbVqHn+p0HTxXXpC6rdW6uxp8hj44Cbfxcq1uavqzBwpd8J6C0QgA1uoQwvHx4ZW9LUkXIfIaU1QsXjRZN4DG1AnI2igIuvNHMgfnnHNVrCwSM6CAMIuGJ8845+bLxXA8IS51ZEWEL11ox2sQMYq0tbF0vhYfc10rpYqylBl78803rbVpOhiNRmWZL0/n49Hw/sn95+7cPp7NVqvVaHRltVqsVisZSF2U6WA0HA7feudeXVajwWA0miilEfHWrVsh+OVyPpuf5nm+yleLxSIxkv5sQoMVqkS/T9NU0Knqus7zvPOUM7SQPNjAJ3X7p7kJIBiBzDwcDgHIey8wxeL3Um0RIWGu4uHu7Mydh9+31UCJyNrIhyDqkTB4AGjKBAXngo/jODChNpG1QrOVUsPhsLE/OYeI8/lca52mKYr/gjHNksFgEJyP41jyPkHrjY2Ng4MjV5Wj0Ui2t9IaQVlQzICMAn5nbWytRWNUYFe5EHiVl6PRyBW5MQZBq2ZKNYdgoihfrLLRiL3/g3/wD/6v/1f/0d/79E+++MJzR0dHiCjGeeecMdF4NHJ1rZXK0vjwgP/cn/tzH3/ttXy1TKJItjII9qY2iN4qBcjkGRDIB6O0iYzWFlAlwxEAa2vY+bKoUWKviESpSZJER0lrQ2aFiprgQYAgGTsAAFWZp9kwBCdqN7Y8r130M39Zcz6RRIVWyIRIFCAQQ0Bu0kMlJRcEA1JrY1Rd+zSNZTXTNN7e3oxj630dxzaO7ePHj4uilq+89wiPax9MZN9///3xdOPoeD4cDKM08UHlRRUnGRFkWcataoXEzjujNGsqq8rXDoDqupTUA8l0J8ajo+P33rt3enqa5+XR0dHpbL7MV4/3n9R1zai11jJRrY6uEXFjMhkOh0mSDNJsPBlmWTIcDoHCMM0QMY7jNI0dhSiK0mSACBBqhpCldnTr+vVrex//6Lf8iT/+x9585+0vfOG3X3/99XffewIAWaajNLVx7KUyoHPWRITgHRmlHCmF5qtvvj155SPTZFCvFoZBt4goBAyBUAAqiJqQCFEM8BwfCQjIIL4LTxQrrYFOTk5fvPVaMFAuq1gbpZSX8EZmgYNmZsXnACE6pgO9Ggx95YdFe2EM4IlIAxJLABp67xFAKKQoMXVdd0Z48U2gMq2LSiNqBMWybTrO8e+9WpZzXjZBVqwQ4dVXP/JvfvGXGUhrdK6yNiaB+X5KsFX/wjbsqPuzP/i+ZLD2q2+m208ZxSV96D53jqu+g7nj/X0p6WKzHfNWvfyi7pneujIzMDcDR0Qp0dzpXqJmdS9Vbf6oPCyl4uI4tsaKITSOY8Hc11o31QI0QA+3RCpjAIAC9j0hwxjFrJmbQCHhuBLQK7RelNfRaBTHNk2TNE21SSSoSrekrRtgM5lKdUGF3LvaucXT+fzw6ChNkixLCHixyKuqsjauKhecHw2H4sSC4PM8d4HLstzc3JydLvPSQQsoWNf1aDQaj4dxmmitozRZrVbHT06ePHlyfHIiceDcRswJP1ZKMaOYVaFNzG2PwLmNEULQGrXW0/Ho5PBgtVpFaZLn+dWrV52rJBSxe75DUdZaS8UhMRoLbkMng8kzIQTnPTMvFgsKLBksssree6U0AEvMvNgwpfHVasUtCuZ4PBaYEe99WdUyFqVUm9LMaZouFovFYkHOLZdLCXcSHcFTANQcArPEDytyjiRSXZu6qrU2g8FQKZ1lA0Tc2NwB2RBESZIhIhpTLJfOOSkW5L3/s3/2z/69T/9kWRUMFGpRl0W2KENwzMF7CiECgH/4D39qa2vz2pUrSikIjplDYBNFoEBpC0Dga2bWxojtwXsvJQuQSGmrrAUDOrJlmfvG+K9YKaUQggsEiBqUUaoBsRfthoMDZbQW/O0+7EbnYGxJTfNHEGrLDIAMxICsFIaaGIJGRVLEGCA4pxVyCHVdS8Fj1SaGRVHUpO0ppZRKkkRO+uNHB7PTE+aQpoNlvioe1NbG792/PxoNjDGb29vGxqfzWVGV0yyVZGQEqupaaxSkCO89sS/zIoTgfS2YlVK3cbVaFWU9n8/n8+XJyelyuTw6Pjk+ni2XSyIimQWlrI1MZLFR7+qNyXQwGGxvb09GwzRNB4PBME2sNmiNWG4acxFYY0xsW/MeEXmHmphYYXjm1vXtrenLH/rgD//Qf/Dmm2++/oXPf+lLX3n8+HFRgI0wy7LY2No7X3lQRmtNxNrYMi/efv/ec9euJ1oxKmYi8lpMuEIqAbCnTV2k4QEwQgQXAhBqXfoKAAajYbY5qThYaxUBEQUFRGwAPYsb+FzhB3w6k6IOaRIUUKNsIAWldYvUQeSDGKh7tL0zpikmFLAOpbRW9ty7FJ5jwOekv6df/e8VAyOjgju3n/nYt7zy65/9nY2N8bIomYMCNMZAWyvx0mb7umY32otzcbGHnTL6DZj6xXb6f/b5OrdAbp163QWGXPxt9+q1lvt962aVz/MhOK/cd+ppN/yuG33TN7ZGAlGRuVWOEVkpFcd2PB6vVqvnn3/uzp07Ozs7aRrJmVFKSYKN5BEykIImK42INAIgoDZdh51zdV1K6i8AlHlRFMVwPJDX7ezsKGWstcZGsbGz2enm5lZ/MhsJtQVWg8t89gjkvG+1T8jzEuJoc3uHGff397c3p6vVKuMsjqKDw0MiSpJEKZ1l2YPf/cpvvv7ZOBmcnC6cC1VVxbGdz0sGuHplM8lSrfXG9tbGxsZgMNhaLefz+Wq1cs6L36dT4pmbwBkxD3p/AcgFEVvLsLWxqALvvPPOt33ra0B+Pp+PRqOyLNM0Fa/tZDLJ87ytFMTGNGoxIkoUtIy7Az6UzC6BZpSI0ybFq1ezTMQFalFO5RIxS5K88zwXZxIRSPBOVVXe+3QwlJmfTjaWq3y1Ws1m83Q4WCwWRVnvXr1azUsJ72Jm1AYgVD4gYtKUNdRaG2NjAJKIJucKRDRxDARJltZ1DSHkeR48AfNytfiNz/z6Zz/72Y9//JW33npLRMZhkmZx4qt6ka9EnrPW5nl+9+4z/91/+98D0Z//8//ZM7dvu9rZOFHsXFUopbRR0LpCgvd4ljYdAAUtLgCAryoTRVEUMRMQ1XXtPSVJEsQbh6ABCMV2JQIfIiEoSJJksVhwG13RY8PQOoYAABAAu6wXeUaxMAJJbEWlUfzBiFDXEo/aoX93ZjMxRIts1OAoCWAtmKouq6qoXG1sFAK+d+/e4/3He1c/4h4+kTNLzMfHx4PhHjBog6C1qPrO1+RDUaykZEFVVYvFoq5rIprNZrPZbLlcns7zPM9ns9nh0fHp6elymc/n86JyAgwjISbGGGOEE9tI2dFoNJmONzc3I6Ol9pT02VjdPmy65D1k0kqDQkJABGTSyKywyOdGmySydnMy/dhHX3j+7vvvv//GG2989evvPnr06PDwMF+WBGCsVa1v2Ds/mozfP3iikD/+oQ8X85lzFPW0k05/a/zf563Qss8JGoexUiowAUJd11fv3BhNx6dUx9ZC6QITIRORAt2E4Z0P71XrodFnrKEJj1AIAMRM7IkImcU60lQFljgZqTRHvu0eQFscRaDKtLLiQgJJiEJE6EVBX+RYfF5ZbG9KebSGZDMzIynWUWQ+8Ynv+PXP/o7SaIwiQXA1ls4XK+7a7DZrd7ObDrjs6tjkOVr5P+Pqt9Zn59zSa6HCoVc/bu3ta9y3a+RsZi7kMWNL3Hvz0HHonqO3yUY4kwC454stioI5SBRoNhikSWSMvvvs7bt3n93e3jRSpCE4MVxpdeaNRmo2n0ZQRofQiguKFRqFbDQCUJ7nHJqKp8vV3EY6ThIAkNOYJAmgAaDagdYa/FkpJ+r1H3qA2/3pJWBtUCthHhRCCEZT8FevXh0OR6enpxuTsczP7s5O7VxdLJkwcJEkye7u7mA4uXlTB0Yi8nXNHEpXz+fz5WKZl8Vbb71PBJPxYLK5kWVZkiRlWS9Xq6qqJFNCKsx0ho2yLHtKPBMzaiVhg01qAVFRFNvb24vToy///le+/Vtfmx0fO+eyLJEBCtxxN8POOe9JgIHkT2zqJjUZw6gVE4jJLEkS733wJGRXSHZfCoRWJuuimdIkiyNTV46Zy6LSDZZWs0vJB2OMc9rVnpklT4kQRqPRKi8Xi8Xu7q4n8lLmtvFCNchbwIpCsFEkLmFJtUClpNjGRpyCAoWYWAtE08lGVVWg1Rc+9/m/8L//r7761TeuXr0yzFIiGmRDFmTjopDIIMUQahcn0fHh4Qc+yyebAAABAABJREFUcPdzn/vNr3zle3e2trNhCuRUIxUFbZPgnAQNMLMgpcgHVCqKEMCAZIsyM7P3QSPUdS1yCTKAAsEOES565vxSAADaSE0OQlF8xVGHrdIrJxDbdJQme0RIvoiwDqViEhM3TgFgDtTmd/XKaSiRn4wxxqpAygeIE7u1vWGsYsZA/vHjh6enp8A4HI6rYpUkyWQymc1mN27cYOYiz5VSIXiQqgxlGeqKlVqtVsHVy+UykFNKlXlxenpaFIV3dHhwfHI6W61WT/aPlvlquVweHR3N58uirqraiyIrtjE5yFFsxDG/OR4aYyaTyTBLQwjDURYbG0UmiiIbndWx5hbunhsrGoLixuEOqICAAijFVAMDcIituX71CjJduXrj4cOH9+7de3zw5GQ2X+QrVzsmIsIkSYu6Go9Gj54cvDN+f2syNtZAHYJEQgL3yqG2NLZHb5t/EZkRiSNr53URRcYT3nr+DmiFNaPBQARNnjEQEZxLFF/Xo86a7ZiCAmYCxgYqgBnb+BipjsltlA8Rh8AhnBlNVVObXIuuKyI9gApNWDsys6HAIvRLReSOMbQfznltoYHXUj3PYoCgAjpj02eeeebDH37uja+9HSWpFLILrn4aX+8GucZm1hjtRY7bJ/H4dA34/9+rM0WK8TBcqDYI3zTL7/NRbOGgu6/WGuls72IN697Y70DHwLTWksaTpqmYhrRBrfVwOByNRuIwtsNBliUIDbJrFxDAzIpJKYWtXImISgMRazirLGaMQVYFFJK0s1gs5L27e3t1kTMzIhOHLMuMPmexQGxgE7ppXBNQmoBqCOIxFepvtLbWPtk/KIrqxvVBkVdHR0fW2pYCgpRJcc7N5/M8zw8Oj+I4TQZZqAUHoEmgGgwGcZoMBjWTAoCjoyPBX9ze3t3Y2FgsFkopgUewNhJAn85uzMyNMsTQaUiCjDGbzbY2J8aY6XT63nvvvXD3uel4jIh17UMIwjil4A/2SguLC4Dauu5E0DbIusWra6JxnMvzPEljCcKSNeVe0AcRKdQUuCwraIskhhCm06nUH0yyATf6feyqktqqw1KfTikzGWXWxFvbwyiKxDzbFIJFSY1twru4X+DF+8Y2SzQej733EntZlmWSZEysjeEiB4B/82/+zZe//MZrr72yv7+PaKqqKos8hMAIRKSNIHQ2gF9pmhbFSsHm67/5mW959SNRbJgZ0DEHIvZ1LRG8IjqI5ywEbgOXgjEBEXUUATnvqaqqNI7aEo3Oe9LKkCEMCG2xElCKvVRRDKCEHTr5rlMMFEBHW4W2Qc80BQDMQTUuCcUUnHPkPZHnFtIVGtjIZlmNMUqD9y7UTiR4qc0lJpNbt+LRaJCm8de//vXVKpdK6refuz0aDItiNZlMBpkqy/LgYP/Os9eAINLKlUVd14C8XC59XS0Wi+VyKWljZVkul8uqqg4Oj5bL5Wq1Ol3Mxfi8XK7K2lMAEZrFIaK1ZgjGqixLRqPRdDq9feOG+KSzNJNORlqJ7m4jAwB9cFwAQK1AoYREteQ6NOwZWAMqg9575ysb6d3dXYYj2t1BptEgW6yWR7OT45PTogp5XhD5EEJJYTgaffnNt779ox9BYzpxWOhJyxc6ffcsUOOMa7ZPRNqUrh7ubG5e2V3VdaQNBCIEpRUEVlrThcCdS8nyOX1JoWw/bLE1gM9UMjGkdcGqDcVat+MiotLaam0RNTU9bmQ/09dE4Sk85ryAIOkWiE1SMxIxMQGH8Wj4nd/27V/60lvTSXJ8OtPaCA+42ODaixrJ4nxw08VnOj508ebT+vwNHljrSecj7K/QxZf216y/it0Q1niSaq9+MFcnNIHk+V3WWzFjdl4lagwdDcyvOICHw6EPdVmWOzvbg8FA/EzMwfsaOERRZIyWJLtGcBONioGZAzlu4fSgkdeAiL1jMTqVZelDLVyqqgpqACuorus0G0dR5AMwnzNvaKW6Ld4FnQo/7phlIEdECDpJEmZk8szI3JSa1wBlWed5PhoPuugkMZRnWfbKK684Hw4ODpbLpY4MAKxWK+fqJMkIVCiDUkbqE0uEc1EUb731TpxE0+l0MpmsVqvFYpHnpRgPGgGlc9bwObwdRCRgV9enp/OXP/SB2clRqIqHj/e3NzfjOC7L0vsglmcZrHBQ7z0i2bZMr7VWGaM1gzoLHkRokM5Wq5VuawN3WwUAgNG7AK3ri7BRoEV9YeZOIR4MBovFKstCHMd1WZVlIZFWAsiV57lSJoRQ1tUgiT2B995G2juJauEGNwqRiVAURmalNRMhMiASU5Hng8EoOI+I3oVgvI4icm4wHFarVVEUk0kqGcAaMYlM7aG1jZNkOasWnTGKTFWUg8HgwYMH9+/f397etgoLX6dpWpYlsU8SwXSjONaolWbUGgDIUwjBOw/WWqobwa6qKmTKsmSQZkopqxUaLT4xZgYFSitAFdCBVJklH2lTOYeIGqxzDpkFsE+JWCqagHDvBoQSsNW6EAEZnPfBOQmHDm1wUGeaUkqJbgoA1loJFIiiSMoxKQXGKK1KrdH5KpB7+ODJ/HThyN955tZ4PDo6Orp18/kQgJmcq5eLU0Coqur4+LiqSwAoy5wDhRAEaMU5J27fqqpmp/PVajWbzWaz+fHx8XKZu8Z0p0CBJzZGK6NRgwKdJNF4PN7YmO5ubw+HmVLKVTUgTaYjY0wSR9ZasT9ja32ROQ8hKBuT1K4HACADoiJDP7deMQ2SlJnZh+FooBVSqCnUTM7ViQIOoIuiysu6LipXFJWvjcUvfuX3Xrz7/NAmIQQJJMaOzHJrAeVzWBzMAr6BjOBrF6f2ZLW88+wtsprKOjVpESpQyAoNKqN04NDX2dYZ+WXG4E7PZGKGIFQUFSMjA4sM3Skboip1NJCIEDVzMBLhKMWVG2y35hVn/r8+a4HLro6CMAOLotH4y0jOvI2y559/7plbV+bLlcj+a87zbkgdUe61eaYQ93lex5nWqHm/V9+gt5e+/dLnqQcAonvoAU9j5P3OP60b/W/7D3QDvHi/G2bHudsWGnFbohaFxpVVXtf1eDicTCbT6TRNUwD23lurI2vEy2g0AqBqN66SpHIkRFRtDTCpQshaI6JqC0KIh1LUoxAcIA0Gg9PlSimVJWkURdOpVMcz/bkSabAviPRnoDelUozIYFuYkqUkA/PGxkYSRYpVHMcnJycaELS6d++e1L/Durp58+ZqtXr3vXestRln4qAqa09EkbHWRHVd18EDwGAwsNZXdX10dAQAe3t7cRyfnJx2ABciQTKHxtKDjAhiKCYiIpVl2dtvv/1d3/ltV69efXDv3fl87pyz1k4mk7LMxawtx68LpJKbjS9TwLnoDH9HQqXk1XVdN5HelWs7w8GTkjR6rcVjpNpQedXUYEEikp6InVaM6kVRlGV1dHTUE8Yb8S5NUyYQg3Acx1r7NkOxOaDYMH4OIWhjPDlrLDEhAqMCrYCV4BITkWauqoqCz7Ls2WefPT0tnrmJVqNSynsl8b0iASSCropS2cImUawAUTEiPrz3/gdeeN4MBkQNpjERgW6qiIqiDwASmA3eyeYJwRNrIBZCv6hKpWCQDQDRVZVmq4wGCURgFEReRANEDBw8I6Kv6sRGHBxyEBlRKwDUgEoUMq2MFFRqcCixcTwqQmaWtAIi1kp3UN4gBwypLR3HIiTJgUVkrTEEgv8fZ38Wq1mWnQdia+3hzP94pxgyInKsqmTNlcWhKbIptoYWGm4bbUvuhgH7RYBh2X7wAAs2DBgNw2j4zW8GGmi0LdOAWjBFtEZSIkWyyBIpsUoiWaw5h8jMiMgY7vSPZ9p7r+WHdc65J25ElmgfJCL/+w9n2MMav/UtwDiONURJbBF8EsVGRw8fPN5ut2maIofV5fnbn/sSEFNwGsAYBQyXq4s4ibpK/eCFA/zy8lLK8Lbb/b4qm7rdbDZlWV9eXlZVU9dtCEFrgYCAMpqZhZktikxk9WKxODw8WMwm8/k0yzJt0EdG5qjzQ/SY4o0BAI0mBNAdc1xvdigSQaVReRN6vAIzyz1EUTTJM6sV0FIBRQa0QWvtvnFKKWMiyrLgJs1+t19fFHk+WU5NRczsMCDxixlfxqvX3fuBgkbddYOifDJZ3j5pOFhjNGAIgRRACBoVEA+0HteE+TWNi/Cc6hkJ587lUEqJPyzO8fgmERk4oLJX2QzoiBAQ0dMVKLlbJ4MyGAQlfnpcl5lB6QFFe9WXFhQB1nV5fHz89a9//Vd/7R/Pl9Ptds/PK5vnHhKvKvPU87W2n6Y7xyM1KKqXfu3feZ4XD0navahWr1kGP0GvD88yXHqwg8azOCzrsQmiuoay13tzjn84nBkAbE9AeHBw8OrduycnJ1mWoRIMSwQd167pgFq99kVEBWK7o1WaUbR6RyIfy/ljK9LTt+2smDBz4xsAautmsVhcrDch+NbVN26evPPOO7/9L/5geXzIo4ph733omxOMJwgVo2IgEnyWsf3IkMcovn37RpqmFxcX0yxr27bWqLXe7TZlVcbGglaSZxUVwkB5kb311luXl5d1XXsX6roFZdI0dS60zgOAb6hpGimb6YAtRE+ePMmybDKZNE0zsAOKHuqnlYZMROfFajWZTb/1rW/9D//G/0ADP33yWPK7RFQUmfgiWZaJr9OBz1U1mUyulqjWga+Wh5YSIGtlEieTicxjFHfSXKEWRkNhN5Rt0jTNYHXJqBpjptNp0zTCca1AJGzkXENEk8lkv9/n+STLMjFNnKslmEHUpQAoMAA5R0qxsZaJhB0FyFVVhRnu97uiKIrJxLWtELxIUQoM9r7Wt2/fPjqYpGnaNJXg9lvv8VpRAwMyaFTOufl8vlwupUipLMu8KJRSACwB8+A8Mwt2fb/fiyGILvgg5+xgGT44E8VpmrZ1FUJom0ZIaYyJTGS7oJFSDCGEoPpq6uDZWut9Ky5+H+J2Mt2ifcl5UF0YTCmFcN04NtqwDk3TgOIe5AgSqRp2uuoLkwBAzg895CWKIiTSBgEoipJyXytldrvdrVs3VqvV9773wV/9K/+xjnC9XjME7z0iPHz4UBReXZem7/G13W5Xq9Vms6vbRrTv+fll7drtdlvvawDwRJFBImKEyHRAsCiKsiyZFNnJyfHx4WGWJXme53nqWzdZFFVVycgLGeVgxjEzIZjeGQjEqLQ2WiKz3JeKpGm62WzaxkXaiLcndDfW2kAuz9Omyat6J8S0VdNGVofA3oOOjMZ0Xtz+wud/ir0zbiOnZSIladGxmB15wINJT0RKoVF6X5ZHb92Ns5QQEhtBIPaBIx28j1ATEeuXV7EOEcrxdMMV8iYoodygjkdWAXrqWeqe9zHGbyqlhKrO2lhrTQGI6SrQJXqHNfkQUCWI0LatNZH33phIIO890Gx0T6FU2ojMYmZEDV3XzBBrxcjvfPkL/+Af/GMkRtAMqAyB4MdCEMQHIhORGIwonWlB9gAQkTFXhc/jgPCgfsZKEftc41gvYo9qGyut8Vjz6Lim8IapHU41VpMwUrQv2lA88jykRQkAgvR140ElK5Ejg/FBPbnouNJXPB657ADO6lYDKgQs6ypN0/l8fvPkBJCmRaIVuaqKhUyYIYnToSmn/F+wcyyUMExBrs6eQwAApftH4FoBxBan0+Lw8Pj09DS0bFWstQXmLI4cBURKE/XZz7zy3o8n2zYOVCttnHOtc6pvQxn6Zj4dgIEUsVZa+7YxxihtxVhUWu92m9de/TxzqHa7WPPl+VN7fBRFuqy2++32jAwQt8EvD+ZtVe92uxCcUibWej7JfJK0PjRN07TOOddYxRU0bS1y3DnXNI6uWkup7XZf161wYYYQOJCUAfcshJoRCVgx+9alaUotLYr5D773Xvkf1Z/97Nvn55c/fu/+l770RfK029ba2DRNy3I3BN/EoPG+TbJCpszGiehsmVaR+7Is8yKLYtu2rUUj9opSKoTAQIDctDUgp2lqrEYVC5e16nktBoHets4odM5ZbQBJYNXeU5alZxfn56tLYHV84ySE1jmntGZSCKiVpuC0NiGEQKQZfWBrYmAAAgxBc4g1QKhAzbS2eZF456QSZrvdKo3OOVDq9s2Tv/W3/tbf+3t/L7YRB0LAyATZxc451FaGBYCErTPLsjSKFYOQapXbHcZxU/XuvkalWQqpxVkvy9IqDQBxHPvW7/a7fDqJ08i3dRzHQp9UN941TmsLjK52DhwAFEXBaIMHReCclxizdyG3sd/vTZ4DkWXWAHVVmSRhIsUUKHCLylqggFYBIDCD1UAUmkZby56C81abIfKMiquqHDSxAuTQcQX71iFi3TRKKRW4rapmV7KOvGsA2Ebq8HhWVhtjC2uSNhhHsDy5RQzr7TkBhcBM6r0PPtrsKrmcEEaWZXl+ft40zX5fbTab3bbc7Xbb7b4sS++D5F9kNUdRhMhGoQLIE7tYzJfLeV5keZ5nWTKdTuM4LuLEKRNH8STLpUZLoQJG4E78aq0VA/ugrLLGoEEAiLVRNhJDVnrnKoY8SRV16Q9jlLWaOUTBs2ZI4yjN0mIxx6QOuq7JtS1wA9CU++2iSN+494pqL6py37ZY+YYiAqVa1yhSCWpwjISA1ismRoUILmAIBlVIja+rREdBwWVbvnnnVhwnm7Zkg4EcaIWBlNaOWQNIt4axOhjk7fhP1YHLmJk8swYDyIHaEIJWymhkZq2wrmvqqxWkBQIxMwUbRxQgBDLWKq1tFCljGDXogQhz+BfNbrfL81zwKUZbUXXqOe//Si0N1tyVHlKdunLOJXEaGG7euvFX//Iv/5N/9jvFZNo471yjlFJdcZ7qHhBHrviVwkP1spD1+OrXBu7TvNLha9e+/2nq8ycfL9XNP+E+AUB0qupZBsfGgbwY21wv3uQQ/wFQg3Mp35cIJwBJHJiI7t69Kzk2pVSSRH2z2HaAvL/0Dp+/Wx7UfPBeAHvWgoSgpaFKkidxHM9mi11VhhC0NrPp4vXXX/+Db38gSGClIEmS3W4jyu/KdiECROirYMW4BmKxD51rTg4Pj46OdrvdycEiBPbebzbb/X4v/A9AvFqtlFLWWsUQRdF+vxXyhlhhZDEBAX2Etm2rttGmjaKo3Ffr3VbkOPYdREzfy1b8acSuuuCl0y05PKN00zSo4Ic//OHJ0cGXv/zlj++/v9lsbt26Rb5l5rquxaTlvtKpbVvhFBwP76B6+1Q6iPMq8BzVp4GHJdEhk3unf7ApQepDjBEqTfkoSRLnGuagtZFYtNbWxlHTNG/cu3v67Nx7H2dZ1DjvnHCYyFUuLy/n87kg0q21wNDUtdKqqduiyECI8pVTWru27ngGKDAQB0zTODRVURRvvfXWX/pLv/yN3/ndNE2bpumhKpQkSds1YIXxepByqa7KKzKV7xofOecGpIM8VFNWEChKUhVFu9WqmM3CZlNVeyLPPrQS4QBWSqEC57spVqiF8lqsGbDWuTaKImY0xgiu8JU7d1aXl8Z01NxisYm7BujkDoui4EBVXUqaQCZa+GoGwhwi8qGVgPlgIWlUMoObzUaAV0LIqhScnp4yGKk1EFrvKIoCw7bcC6lkHMdKQdcYOITZbPbeux+cn58LKk0oPsQD9t7v99V2uy33dVVVwsfO3NlwEu1QCqT/x2w+PT4+ns+nRVHM5tMkSfI8jeM4y7LYWgF1ImJdlxJc6Zb00ACxX8yC5BoW9vi1+AxSvT1EAqIoCr5RxkaoJpOJD2xt7L13Tds2NYe22pYnx8e3bhxZxfvtpm1dcMCIjgGJiZFDIKWBQQscOQQCBKWMAgVaSoCstd4FJJodLBcHS7kT5xw7H0IgjTCwVMLzDvXLNj6M3Dxm1h3umEhIXwYV9HyCcpCgKAgMNKbveCZiZ+SbKRxFQIXTwBB5pRRwlxccq1iA57xs6OPj3ad9SF0SV55dnBRf+9pXfuO3fgeQJKanlUIQ5tvuy4iKGa+Qrp1SVMPlxgePHvXF94eNPY4DjIfyxV9hf4x91p88K8M9jJUxvhBXhysP+/q1YMyJ0WtZHnF9DBcae/DDVYY/RYElSSfRTk5Oyu0ui6MbJ0dZliVRbCNttOl0n3eo9Wg0woBqEG3bvYTA3AUGoihq27YpmxA4isxyuRQ4tIAs4jhmhcQddmmxOND4gQI2CgMxEaVJAgII6EJ8XaAGgTReGyViAO9ckiRtW2s2VdsUedp6Ojs7kwBs2dRPzy+stcLsrxiER4yInAuKiUJXVhskJdO6jvpAoygM5xxCV06m+ton6sl7EZGIERkZhQSzX4QwVMq2wRdF/t57H7zzzjuTaX7r1i0ZkNjqKIqsveJukx6FIm3bDuHVEWBBr4S6KDqzCN+yLEWoyfCK+BtW9TCA4win4MuG04bg65okCiqLxHbt+YJwdUmZNxBpg3VTFvl8t9sKVZbUFieJYeqywkTUNE6ysIi43++gDFmWRVF0evpskudKQRQZ37o4nwK5W7duXF6ea/0LURT9/jd+d70u80khzDAyzrprEM4hBK11McmMMYgsNayTaUFETe3FlPTe1/vSOTebzci1VVUmUbzbrAFAKnDaulqtLrIsQwW7zVaUorU2jROxsTqhH0Lb1M4HMW5Es2qtrbXr9Xq9XmuNgp+SGtKLpxdaa+E4Q2WVRgC4uDwX+Z4kSQjBuQb6RJWk3o0x2uB2u5XXwpQisyb1YMLJLEBZALDW7vcVgxIKyckk77Y5aCFwBQBrY2bYbrcIKEbAs2fPNpuN0hDHcZqm3BOOlmVdlmVZlk3t2tZ774dV08sQQMQ0TafT6Y3jw6Ojo8VilqRxmqaR0WmaGquKIku0FakiqHyZNSFlg1FfhLF0VX3Buuo54OR9GRzlryxFAAAslGmaus1zzcwKMMzmHOjpJ48pzaZZOp/kALxZ79qmadvGY2qMapuwWp8XcTrLi7Zqbd+1TykFREABULFiooCBFCrQalvu7735mbwoLttaxYacp+7Gnqcr/hQWcOpLyERQDpcTsTbwvIooJeqCfGHcbYgBERUq70hZZYxxnoQ4oZczVxPU/4pNYpPQujiKFCvnnImiMCJNHY6xPoCRwgC5stiDgbSxAHD79u2f/ul3/uBf/ZvFYravHLCodTWgv8bnH9QVwKeqt2vrAD5FI46/86IOxhcc6Be/9tKzXbvbazf54kCN72H4guqTKNcMmrGuHcyaa1bn+BGkwsRqE0JYzOaXl5eL2eT46Gg+n6dx1HdSIkSlgPm5U/VJC6ShW+WLzyiGvDFGesYBQFEU2+1Wa+0Da60jTKq6CYG1tjdu3Hjt7q1nz54BBYPoGYSZL0tT6o0GfD7zHUJQI7rv+Xw6m0+JSClo23a73+VpYowp63a1KYnohz/84de//nVjjAa0VjtHUj5LVCNpjxQcAIDSV+eXhKUoMyICuoo3DBJE9V0uZAAAAFnC0VezJgopio3i6Mfvvfv48eP54rMAEELY7/fRYua9T9N4wKtjxwMc9U3FUYT1EMPgvkxlmHFRukopae0QQhjozIYRE2LL4LuC4MEaGy4aet6P4YXcfBzHm82maZqucyLgrizzuCCitm2M0YhKWiTFcay0BuY0T5q6Xi6Xgdo4y3a7XZbZJImAiIPbbtez2UQh50XKvkGtlYKTk6PdbvMLv/Dzs9nkT//0T997770BL2aMYSatOhhtnNg8SQGgbduzs7P33n93Op2ayMqYiASsqqral/P5fJipNE2rfVnX9Xq9nk6nLnQcHXVdalQSPJDWj52ujWOllFC5GWMIuKoqaYjZq1L3gx9+X8J+WZbNZpP9fivEq845RoV9ibZROkmS1epCVM4Q7fChHfbpbrcDALGlhr0sU6lRCRBBagrEctqXrbW6Knd1XVurd2VVV609O3NeAYDkwpumASSxHsqyrKqKiLS5Ms4k4tU0TV21fSp2gJKAtdYYlWVZHMfz+fzendt5nqdpvFgs8iwNwaVpGsVGuPMi1Z1Ta51lmXQoGZTNSJ0/Vx4ietoOnZh79sD+hziE6GWFtz5Y4DiOUW0jo5bzKbt2s0KrVfBus9n4tvFtQ544TeoQPnzy9PRse/dwOsmnykbeMTMgk0GllfahDRw0KlasGb1zaZ5VW3d4+0aD5MnHaAFAAwa8ymN2muZTPOCxQrmmFIiDVOKpq0+ukD3chScZABgYUUuDTuyZ7KQS4Vo/eObOxTVVVSVJ4l3QGkRA9D6ZXOpTHcSru+yJ3LTWTOzbJs/Tn/+5n/1X/+rfWKuhVCLvBRYNoMR86PttXymCsS57UbG99NIwUlrwgtobPuJR+HqwhvpLPwfD/glXHL78Uq0/HKFji3wujY/PNY69fubxlA+H7trWSq72imI6jmMOnsgslrPz8/PXXnv1s5/97HQ6HaivSGC3GiNtOiMUriINIwVPiIqIoDdzuW93KF5g8B3iIE3j2WyCRgupVIe8Z5TeL+989Us//tF7Hz96WFWVtSZWqnaeB3rVweVlkBYiKJEZZmbWCk5OjosiM7bjHZPVyIEArdLqBz/83unpKXaOoO+KHJRq29YYIzXJCBrRoUMXuSi2Td9JN4SuvxMxCeWkLGnVw6y4d8tkiBCx705HUmunlApM3nttbAjwwYcfvf35nxJ3XKqAFABiBzeTVvPCysTM0hUnhEDAg5rkkUGp+xYOcifClKT6bvYiiIeVppQqm0oc36H0UESeeCHUk4b2ycJYmL3T9Hi3211cnB0dnYQQZsWkaZpImzjriB5RKWMEJ+GDZ2MVAOjI1tt95I33/vz8dB4cAMSxJaLLi7OiKJQSlJ8VHXZycrLf7//SX/pLxydHb7/99scff/zuu+8+ffrUmlRGOpCT0i9m3u+3SRIxkHj/g0AXcjFxUlerFTIsl8vVajWdTkXzicOnDJIPg7GCHDoJ5r1MZZ5PJPIh26asK7FadruNaNk0zdfrddyDDaMoimIj5kJZls53jwYAWRIbY7bbrSgz6aYgihARJVctNpbWWpIm/UoD8YwRUaEhHwTiRESAhoFcUysNURQFpuAxmy6r2isFRVEIFqeXS1zWVbdmagFgd4rZGCOQAwBgRIEyMAACxbFNkmS5XC6Xy9lstlwukiSxVseRzbKsaarprGDmNI4UDlgh0RaxrApZRWokSAfhhiOWwLHgGmSv9D+l0N1q01OgW6WtwiLN0FNo6iKLXBXtd9u2qp1zbeNC6+M4PmuqZ4+fPDnb3lzmxyc3t1Uba6OBiAEDBUAjhRwcgiJEtKCc4l1dFQezfDGr2sbEEREB9YJuJFoVQxgJ2rHMH2CD3Jcjio+LWoUQOHgAQCV8dv2vRnq6C/UhUGdVq8AURUmHLgxBoD8AIHxFw9CZJ588ef31113bYhRF1gp/kkQI4WXHWGnB4ENgh3NxTUtgtFKvvX7vS1/67J/+2Y9m85lzTthxe/JV1UGjCHsKzU9Nso6v9VK197xSefkNj1+MbJBrofWry7305z/hEtcOHB2fdqprdzU8yOCcDXIWRouDiKyxRF5rfXF2/tWvfuWtN94oiiJN4zSOtEalQQGj6lTsEPcYPXIYW6zQO2p8lWbmjt+NUakBPJlt9juGDtFW17UPGAI3TTMt8lfv3WZwT0/Pt9t9CJymcV13bYmFCRekqY3QvFBAABN3/ern06lzDoOP84yIjE69IyFJeHZ28eP3PpzMVFPuI62453OmviaHmRG0UgEUArSRE3szSGg9MgYAm6ahEMILrCbQeRIKGRG6AmBEHEqBQ9dDULk2xJP44OjgvffeK8tyOplIuLJt2/l83jaVgJ+FGEEpZeNYWLSJCFEhUB+W6KCwcv4OitwfYiwP4Pa6rplZnDYK3DS12AqigHmESbSRIQ6oEJiJgzXGGGOt0cY65/b7rZZWTllSlrvJdBocl2WZYApCH982kjnWxhjLotWYQxzHqMxkMimrHUOIjF1dnocQRK8IESYA2CR2zt28eXOz2Wx3m1deeWU+W9y+ffvk5OTb3/72kyfPZAU45wyqIs20xv1+n2VZWZaX65VaY5JEg39ZVXuNStpIeO+lxdbZ2TPv/WI201pfXl6KQSp6wuqOA3I6nYorrJSq61rYu6QQHCMFLJyaTpKjl5eXq9VqMpkMTYqIfQhhsViEEC4ut3LDAJCnGSJLej5NU2lC1W1SDXVdy7RKGfR+v7fW7rblYFKIUhc57j3JvQnLk40MUNBaE/C+qkmZvJgTQRRFXS9tAESJNwu8AIZsjvcBIDgXesveIqJQX0vyhRGEQnyxWEhp72Ixi6LIWsMcrLWxjULoynaRcACLDJp4CEhcbRYGIR7hK7nBA9Cyt92VhPpDCLWvfXBMXdBOC/mzUvPZxACdPf3k8uysLMv9ZgtIwfkQQpRmddM8Ojt/+mR1MIleuX0Hla7LqmmaaV4Ag0LPLmBgozQABiLQyhBprc/WF599+8sh0o4psUldVZ2V/+eR18/LZBypVRGLHDwRCUwVYERp0CcXhusowGHSQYlGtZ6uzja+SqeAP3j/w5Pjm2maMiGIhvxz+YJI/Xlh5LwaY0AbQDiYz/7iL/3id77zI2uMQMWGO1BKCVZ29MByN9JW+Xq0eTxAg758UVMON/Piv4P+Hqve8TvXVttLL4qfPjLjj664I/qPxioQUXKyz316LTcsK5v7SI4aYbiYkch778uyfO3VuycnJ/P5NIpMnufGCHdvd5IuyTrilGZmIo/ddZn55cYE9sBy733beAAlvsv2wz0CA2qtddO4/a5CbeIoYe+KInvt3t3ZbPbu+/c/efJUu0iZzt0XYhChF9JaKYWBOIoiQWCmWWKtZvIArE0nqb33qKOPP374gx/8SBszzQuRtsydYcFANjJBzH8ErSNlgjCCRVEEah+cHxRVA4DIPQu0V8p0GEcOiKiVJs+A1CtfAtDIABwGDIW2pmkaRL7/0cerzW5yOIM+VBhFUV3uJAgJAHGcYpdjBu99B2tnYGbTd2eS6RBVKk4w9vgJGbE0TYVwQxys3XY/CMRhPXcLBihQiFUkwFcxjORsjWtjhYgo4Lg0TVncpeC0jrXW5W6XZdmuLLXWdd1kWQY8cOQGZlYmAqWySYFASZKg1lmWbbfbk5MTItrtdrJQkyTJJkXTNCaO5tFB43wSd5HeR48effTRR9PpFEB5kqRpx5NMHIQ1AgDSOJFTOedk4mQoQgjb7V4Cxcy831dxHO/3e9k+klvNsiy4RiBXRVFInyuJPWhrJR+vNBjdBQZCCCUiM++3uySK15cr7/1kMkHFdV23deOcazwPtlG1LyWq1DRNkpSyOyRCCz2MzlOoqkprvdvtYhttNhshPhvkRl3XUloiijxJMueaupHWZ8SMTev2uypJptA3Fb5cneve3ITOFkeJ6AzJFLpqQSbBm05WaA1E1HpX1/V+v8/yJE/SOI6TJDFaAXCWxkP02BjDnnXfDVNGXvLx0IO6iQlHXi8NvYlG0lVQaUOobxA4qNBqS0QQqGanFEKg3XZ9eX62366rqmqbSiy5JEuD54ePHj+5bBaL6I17b7Cn9WZjjdlsy8v99mA2n9rIAAZHBgCUKCAG4gABE3P8yq0WiDR6GgzursSGsCPpYwVDNHrQC/J6yGqPxT4ikgAJkTq6QAgUaOwdDQ87Cq0BARu0vezti8VHbmRntThvHjx48Oabb967d4+IXBui2Hjv4QVNM+gApRRT1+omADOwtIIKIShpHUIeEBn9vXt33nj95qMnl0E6VaDwtEqoU1h4grQEH5Tf+LJjFTvop2v/jr8w/Gp48aL2HX9tuOjggrxUIf3/eozVvLweJga6Cb4CWyFeAb+pr6cS5Sf26ZBOG+Zbvj+dTARFaa2dTadN0yjgKDLaamD23hP52HQ9aPsx90QDB/h1cwyujDJR/x2qiJmlPOzGjRunp6frzU5HsdXKOVdtdoBqVmQKdZxEk0n+U5//3MHR4f2PHhCAA4cIWiOzJmKFIPUMKrFpmuZZ6r1XgG3dJFH3rKIwnPNPTx+8//5Hu30pXf+UUnVTCaOeGsDAVocAioAQNAMLgskqHadRFKmncHp20ba11qrvdiDAJQ+gr+YIe+ZBgA4SiFKu3w2IlAu3wc2mU+/hgw8+uDn/4tABsG3b2XJR78ue3BE9UVvWeZ4rpYfCpCGkOZhi4vMlSVJVlSwPCSBD35JS8G5pknnvJaUtc4GIxhgpGu5CfE0j1oAkm733VVUlWeq9d76Nomi73e732/l8GUXRxcXFdHIQxzEqqKpKIzZVhV1KPiAapXVV7iSCrU3MjHJaAJAqXjER1ut1URTUQbt1lhW7XUnE8/kyuHa3gzRNX3nlFQlytG0bRUbQaoLmCyGs12tZyWmcSE7BjTpSVFWlABHxyZMn0n+iqqr5fL5erwNTURRt08gt1XW735fe+4vVRnpAab3v95QiYPJODAIJUzNjlmXb7d57mk6nu91KaEqH0p2q9ZIwRsTgnaiHEMJm0y0JUbda66qqJIYssLv1ep0kSVmWCjUi7rc7GR/ngtZN1yojTdfbnW8dc4C+7p8YdrvdbH6AgDKVq9WKiNq2TZOoo7FDlIJPUYK9nLlqloqgxspDSFouLi6i2BwulmVZRsZGaaI1TqeFsGeLUat6AL88pkAQJDsAvSmPfU53sM773BYMJoLqkVljFKHW2hOJ+wtMVuN6tXn44f3Tp4+RIbhWIkla66Z2T548eXza3H6luHvzDjeudd4Ys6srr6FqXXN5hsuDiTbIhBw0IwtHjFJ1qA5OjtLFtFaMUZcFUBolQQXSGwag08HXMcXPqbZuRkJnZzAzQxDQDAABiBUiKVQ91sHyWikVJbFkg7XWAMpRYMIhAYyjSgf2wXtvLi5W3/3u94+Pb+R5aowJnmXPDEiZsWqBK8aoDi2GvY2PiFpp70JsbeMDsjpYzH/hF37+//H/+vuHh8uyLJnQjxzNPtoJwxkAAFENUdPxML3os44/ffFrPHJbn79tHIa7v4cO1DCcvDctr0w8eN4CGC43eK7DpcffH/YDjOqRxu7sOLwsJpWE0eSbWZbJ1wbfiIik0iNL0zSN8zyXEgJ5NGutMZqZfPDApJQOwOB9CGG4ERQIfBed7ueiBwYPljUiMhMzMHdSnpkmWapv3KDwZLPbF0Wxutyt223btrFRxhildJ7nqnXHx8cmjnbbsq4bpVRVVRx8iIJvXWQUAEQ2skohcZqmzjVZMsnzPIksB9qtNwBQltWjR4+ddGNUZjqbaKOUNAQjBmTyAXUnFKQqQGsNEIgYgNI4wVmhFMRxfHZ+uV6vd2VXFiyCXiFoq0MAiVhiX0EhlnsIQWGXYBsnaH0It2+ffPOb//ILb91LsjTVMfeFKyaOqrqOQZmu+jliZqV0Le0fNEpNSBzHorMRUUS2JAXlxmTGB8RWVVUhBKOt2CUiLgenfAhzDcaZGAoi/qqmNpFVSkmdiXNut9u1rZ/P51qpKE03qwtRn1FknIMkjrXRwMjkURmJrSmlnGuVUpPJDBGF2b+u29u3b5+dnS2Xh8vl8uLiwkbJdnsujCJMeHl5Gdk4juPpdJplWVEU4uhLkLMPxvr1ei0WjDGmtomEKySG32F2esprY8xuX0ojI0C13e4C+e12KyGNvHWr1QqZBIQcQiDA7WY7+I5KKY2w3++JKE1ziRPIye/fv//222/XdSu559PT8/l8GkLYVY0IQGYWAk4pLSOiJEnE9W/bNkkS+aHMpszsbrvvN6wWk4K7aAdJP6jtvgwhGKOAutqnIp9s9+Urd5uqqsS4kfk6Pj5k8oixGFWDaBK9CyB7Mwz2HELXP9RyR/zZtSBkrxhu3bphrU2zxNqortooNqFvR41aK2uqqppMJmVJ1AMIxHrwrZOtIfNIRKoHW6m+mk519eitfG1wowUnEWnj2bdMsbHB83s//uEPv/+DNIvbuq7LMrIJATPCxcXFg0+2t27mN27caMqdZsXeO1SkwAFsXB1q2u/3X/+pt+MohsZRAAAVmEnR5eX6a+980TMFhMQYH9rOx1Ad5JWZhdYicLdlBg0yCHDdV4tQH8G40tDEGlhrDUghdNpBNrJsvUFfDHk9o6OONkduotdKg6+sGBy51tUGUa/X2ydPnrz++utiwkAAHPWxGRQGMwMoIg+IiNT16ezaxzAyEJFG5YPz3ltljFGfefONe6/c3Gw2zIwoZMMvJJj5CiOODNeuOFZp1wyCsTq8dlxTtKP7h6429Hk/ddCv42v9O49hksazRT0O8NrZhiuKhcGjWCIAyJ6RHNXABCSFK7LVq6oaWspPp9M0TReLxXw+l+hlHGeyPZg8UTBaKWUAoA1eA/fl188Ny9V40nXzBQB6mBQMYDxE1MDHJ4cu+NXjp3mRXlxcdIwEwJEx7AMiB98mNkqWUd16DmFa5Lvdbr/d5ZOoKAqtNfkguifJUkTM08Raq5B3611VVZvNVtoTubY1NlJKZUmqUWS38x4QrVKgdNdsDhEFQ6SC8P4QUbBWzyaFVbrj9D+/3Oz23jW654VQSlndMWMgGGs1cZfq01oDCKGYAgARRmIKR0ny6NGjBw8e3L59G5RO006aF0WBoMWxE2UTQuj7TmFZVtwTBSul9Kg5UlmWw7AP4WhZG1prIY8U50yAvmIfoJTM9jR41nYNoUWHCRWUqLrW+7IssywzxlgbS0k384aZlbXWt0TUkXaJ2YcaFPUcYaQ0WBuBVk8fPZpOp4cHxx999NHqcrOYHyBiVTbz2RIIKYB3NJsubJIQURKpYfUuFovT01PVA85FvDjnBJstTnCeFeNhgR5vaK11TSuvRd5JXrxqOirv/X6/Xq+7hktKKaWqphXUG/SOe5Ikke1MisZ5Y0zbCKAsbp3/5PGTLMuqer2vSq3146fPmLlpg7VWXCZBe8mAW2ul9x8A1HVHKyZkT7IOpXxL4tWtd0opifrL1i7L0vfwmrJsNIKEKChwWTdN46qqkXkXW7xt27jIrLVN1YwFyyD0rtn9UmGutabGiRZ0TVvX9b7c1vvy/Py8rmsEnkwmWmOaRJPJxBjlfSOFuTqy+7qyxshNSvp8CDuLdyuKNvRNp3u0aeciC9J7SB5L6AUAmIiCz5O0xeobf/B73/ve9xjC6vxCdorW2lFblg0R3bo1OTk5obaKENu2ZSIP2jFt9jtSaufotc/e/p/8T//mH/7W7373239apBk5YuCKWpslk4OFjmxsu+0TvDc48n+4y7qx+tQ0oljhnavDnQdMREAtc9Baa4MAmgOFl+U3xwJWioCNiUCroejp+nX7ElwjsMMHDx7dunXLmAwUBrFukAE6B/fqQZ7TiKPTcRfVNMZ4CkophsCeb9268YUvfv7Xf/23FvPJtqwQtESTsiwRKq8RoOzlSnesva4N2U/QvvAyhT2sYzWC1H/aSV481Vh1Yd8nkl+oJO7v/8rCGq7Vb5vn8vACUpcyvr5fXgghSPm/Uqqu67ZtsyzTWtd1vVgssiw5PDxcLhfKGOfcZJKLL+Vcw+St1UpL3IyZkV8YKO5Qb/0GZmZCYNVn5bk3FLq2DQCskINvo9g45yZF9o+/9e0vf+Wr0yLzBNvtvphOQghWmzSK97g1WbLf7xUFYkKmxOjpyVGe5xpVlmWxjTrjw+iqqnwbdpttcM36cgUA3vsk0bGxIrnyLCuKLIqeaxmCiBw63l2llELFChGRY0YFgRg9Bh+MxSJN/HzKzHEcPzs7557GVjSl1abxTUBSqBGA6AoBh6C11oJzEd2/37vFcnZ8fPz973//nXfekdSpNFiV0OKQ5OOOUbkLgYiRJNpRxl9MY3GITS/yRMcMC6BpmuBJ9jH0FFqSfdSmM+GFunssCrEH24sEl7Pleb7ZbELgNE2rqsqyedPWvmmiOC73e1G3dV3m+aSpm1AG7nxEnqZT750BlaVFmuSg9Wwx11rbOFLKuECMCpSeLZb7/X6zOZ9MJjZOAP1isbi4uCiK4uDg4OnTp4JBEzJe51sffNP6pmkEtbS63EomRUaJR4ElwboPauByvYnj2LlGIGBSOBvHcSAvRhUABN9FlTwTEVVto/q4zqDsBeNWlqVQmW42GwCQ6uGqqghGWczQ+TfDNtd9sVldt8OmlsP17Qi7sjGmELpcg0zoEGJhDsyBAxmr67q+vFxJoZTchswddUXeXWEujiJ/Y/E4qOHOcgsEV8A+klXXNM1qtdpsNp988smNk+ODg4Plcl7VbZ4lURQZ42TJEZGOLWHXt2q/39d1DQjUU3N3eRYghbpvDUNKKYLgia21eZp576WvRXA+S1LnXFNWkTYK+Zu/9/t/8PvfzLPEN21kZJVC3ZQESmudTycTpXwIVDWIunUO0BBwAK6dT4o0bLb//n/wy/fefOvXfvXvJ/MJBfShBUIGnh0d5POpJw9syHkFqPpYERIPKoZUl/69Jq5fFPtjHUREqFjp7nUIHbhkWBX9l7tlwITKKmutjiziwIF4deZOa/Q63vhAddM+ePjwzt27r7/xamT0kI7uBfSVPlJKCe84ABBKTDx4AA2oRg3trdKBQuBgTfyVr3zpn/2z3wKANE1329JqZYzy3g81l1f/9uHoa8eLHup4pF70NeF5q+TacS0jO+jC8aD/hOOll+BRxHv4dByCHhT2i8/Vtu2AktXaSuGgtDaSEG5d15KYCSHcvHnTWKWwox02PSOSUmq735Nvh0Sp8wGBjTFAAeAq5DBYIYhIJCp6MNIUE0nx/QtTDwBQ7UsbmVmR/yf/yX9vvd4+evgwzYo8L4wyGrX4Ugpwv9+3+32cduAaYxZ5ntd1e3F27ltnddcGmECVZQmBGIJR2nuvACJjvPc20kWaKK10X91Lz/VRB7H2+9lkZGZkY5TWkfek0IWgjEdtwFodR6ZtrSQImVGKZySrqrVmRqFmMzpSfYPFyEaDMFVKWZtI/5mbN29+50/+bf3XmzRN27Y1JtJaCfRJwhVdJH/EJywXwh7GIs8iqkWQz9BHrmQqpRRH/hygW5PJDPqcxbCuBB8gHHPykacglUgAoIzZlaV4mWVZ5rmGQLGxSZ4bq8/Ozg4OFkRewE1N00ZRIqpduLJ3u+1sPldogcFEsScG8pPJjJmVMs45yXcK6hV6quE8zzfroJRaXCyEAkJrjQwKcfBuFaALrBBa77wLxkQD2xeMfAvVVxIP/rEoiRBC23prNTNLRll8F+8bRJTviEEmrQwNdIMWQqirRkLB1GM+Li8vpUBIZme/32trhnwnkMAputzQYL1FUTSwcxtjiIJSajCVBtAcEaV5JmeQCK1MK0mzKeI4iZrWbXZ7sd4YOIoi55vVapWmKY+KyK/JGXhBxA3f8VIzK9/hLj0pavj8/PzBgwc3b5wcHx8XRXFwsDg+Pr5cr05OTtq6mU6ncm+OglV6Op1eXJ4Lk5dvnSRB6rrWGrW+EmViUsj953kuo8QDrRiA0ahRfeMb3/j9b/zOfDZpyiqObXCehFUXUaEi6prMV3Vpibz3BIoQW6I2gNJWauu/9jM/+/HTx//8G3/43/nLv1xtS95VQLzdbF69+aqOo4ABAckHCkEpxR16DBSxYiAECfZdLwPtj/H2HHYZIlIgYUrmEFzbyhANDy4HAHQtEfpTobGijIlImiANukYsOw4dpZpxLjDT+fnFe++9d3xyuFzOZR2LF/XyicfO5R0XmIpH7H2rlBHHSWvDEG7eOP7lX/6Ff/EvvjlbTIpJti+7ggoZBgJWI8Aw8HNNEWBkjFxTtD9BH4+92/Gnvcepxud8qRd77ZH5z+Fqv6hcx6caGUrPueb8PFGl1lqplDlIf9nLy0thBRKb6+joyBhzfnH6xhtvyK9OT09v3zyJ4/j09JSZkihKUykF7h19UMyeO5d3wG5c2c1EQT0P16cXKtURUSJJiOCaNo6S1+7duX//o+9//3t3796z8ULq/Zu6JueX01lqo8P5vKrqIbFX7vZnZ2fbzb5pGoXBWmvjJIqi0DrvPYVgEGIbB99yoEBO2ziOY2VNliax1VYjcgeP4lGl1vCCiJDZKq2UqrhC7JYuEbWtl/K6PE3qum4ad9XxlyiOY3FTurWguh0oclzoi5kZUcVxfHFxcXx8XDWw3++ZIEkShaptvYCWB+YvpZQyWmGHdh7IIiRKjF223kgGcXBeRXA3TfPs2bOiKESj53kujxBCUMryiCUtBKd1NKyfYQELvibLsrpt0zQtikLSycvZ3GSZ3m4/ePfd1996I89zmyQhuKauFeJ8Pm/bNsknxkSghOfBta6NbCTc3XJvEmiRQ5w2idPkeS7OdwhhOp1uNps8z0Uf53neVLXqmUbkDINeYebY0mC4d88ysvuca0IIMlDWWuHxbtumqoJYn0mSADJxYKAQCEEZY8T9RQRjVKSM914CSESklVksFlI25pybTCYCOxfe6el0SkiDZlWsxJ3FHsIpjrJkhWT5+Y762IiZ5XuWSvnJbDYr68r3nbKY2TOU210UGUD2rfOBrI0l0AV97PfRo0dZlrm2HnbrIPHGyvhFidRLKsWMITCHLoNLhEgBsV2tNnVdn56dz6aTg4ODs7OLONG73U4p1XqXJbGMkjEmixMJ0iAiY9fw2HsvGVK8cre0zJqE2SWvLCMg6LZJHP3mb/7mv/jN35xPZ66ulFJtV9msJNDUevI+BGairlWJ9w3aZF81+8a3xEqZ3XpnFRweHn7z93738PYBJPbydF/vdpO84DQ6vHWDhDUzEPsARKCAmAOSJoXMwF0Xh4CgP2XocFR+onoR7b0HCYz1OZTQV/OPpKgkE/uKFaWVjQZlLCthjPAlImYhjyZmNkmWKaWcbz55+uT0/Hw+nw5hk061KMCep5Alig4A0Dnd3WV600/ieOJaGVQu+Ol0+uUvfeF3fuebsbEX641SGMdZ1dTjapxr2m4k918SQx6v7/E7429+moZ+6ZLtnqtXzNfuarz6X7wTeF4Bj+2Ga482OMGDoJFPrY1CX6UqwR/mILuxLMvJZCKb8+joKM/z+/fvLw/mbdumefqDH/zgs597SxJ7u/0mTzOReoGASRgZ0VMYLTgEgFFnB3lTnvoKlXDl9nLXEhWIEaFtGqXARJY4NHVZFNnd26988uCBx1UaxdNZcXJyYhRuN2tyXqAZsgnLsqqrdlvumZGJwHAIgao6OC/Kz6DSWvoWK6KQxokyurZa267cNk1TCf2xRqWBObBwziAOUQbqYIpgNTIiWx2CCXGcBfYuIGjnwqyYnPt127a26+Ie4jgmBkZC1MBd7oqIgn+OoUzitBJhvnfn+OOPP3799de11oRe966PxJNF+yIicRAuAqU7yioYmWLYH9RnRkGiqSGIvRVCYALB2aZpOqTWZI50r9hFmQ1qAFRnAZgoSpRarzfSImk5W67X68y5xXKpowakw1JZlvt9J6CDE/wtKFXXFTOnaSZLom7bPM9RKWoaNAalAVSSSNBYHDtRvfJcbevLsjYmKorpYrE4Pjy6uLiQFhFVVc1mMyJKXKq1lqGe5IVMroySvB4Elkh2gTFHUVTX9Xy5ED5no7SNzGKxICKp0BXTAQC8C6y68fFtFTr2sY5FLssyhVoptdlsZrNZx01t+jEEoL7rNvQt56DPTBdd+6ZuSbRt29aNRB2U6ehCAWCALBVF0TRN1dTDdCsTV5OtUkoi5whKKaNMIrW/MkqPHz++d+9OCEGpaCzlxiJlMLn6ncsgdfZ41Uo1EDMTgAII3ntQyhiuqsa5UFXVdrdfb7azWXp2dnZ4eHh2dnZyclRkuUTX2rRN4lgiKIi4r0opu+g6DoifSqSU6eqJ+52iepRTlmXe+z/45jd/65//ZpJY39ZlWcY2EkZYRPQUpEc1dHU0LWrTEHk0jnhV1ruq1drGcbzdbL/+zhefPTv93d//vTc++0aNVIWmBq99u7hxND1ceGRxf9ETIkjsWvouKJZqLyAGYnhRLQwS+1qwQTx+q4IaM2D1knw08j3cT5ZxFEtoCkELmfaQUrnSFzRkNNBMJhNm3u39fr9/+PDhK3dupWkMV9OJ/Hwokjl0hAwvC8NqrQFQaw1MITggAE2vvvrqV7/6he997wfWGkAtsTXJOF4/Q0+2AvByz/LTjpcqPHiZ/n4xFPzSq4wH99oGeKndcO23L73rfjM/93QSjRQbv6fmBwF3HB8fK6WEgc9a+/Tp0yRJZrMZAHzrW9/63Gc+myTJerfdb9aTaT6bTAE6QxVAAAU6BNf3WR/s6I78ZFADANzHqFVH08HCYjkssg6FL3iN4Mn5MMmL/+w//Rubzea3fudPvvOd79z/4INXX7372r07l+fnSinvGmnvUddt65y1URrFTeMAlekI0SRKjwZVgEA+RFa3bRuCJ2sV6DxPy7qp9lvhIep/8hw0fbCchiXOzFpjR/+hlNIGQXvHjngymQCjdJLA3kTz3iNa6qgVpCIZjDFaYQjB+9aYyFpL5Im9pMqOj4/v3//oZ3+2SpLERkYaKojmFhTVcGMM5L3nnq4IRmEo6A1q0TQD9Ab6CmNEZALnXFU1cdytusFyMsZIW+hhEUoomKBjwJdrVVV1cXFBREVabDYbpVQxmyVJIjXBRnXwe0R0zpk4JedEB4rvUkwLubftdjuZTLI8h15OVU0D0NkHWiMzS1/3ui6lAnwymdy+fbuua6O0MHsT0eXl5Z07d6R2VqqnnHOKu+AB97MwjjkL9GzYaNT3gKrqUoKB0i9EvHzxROXkiAhKO+c0dgFkCcbk+UQaBgBAksZKqbzIJIgqU5kkkaTPETG4jl1LVLKETLBzc5Ugsck7udtuOhDEWpJIHhHNZpP9fu+p8/7rlos08cGFnoAzBG4cPzu9QMAoigTOHfqyiLFBP/w7HhPZoUN7Ourb5BljADuZw8xKgYgXVBxp471vWw8ATbMNIfSVVJeLxSJLupDA8mBR70sZcKnGjqIIKIwFo/ftoO8FSCioCBmT7373u//tr/3qfD6v63pfVVmSir3IzB0GCBUieudDF4Z0TVAt4Gpb7lrvWAFrDsoAPHn05J/8k3+CSpHGfVuuyp1VelPt3rz5OkZGRxYCIUFAAgi1IzKKGFQvZvsGRy9JF14T+GN9TETKXIXZwojMrks29WUsagSn7byFPhpxzVfkPnYtPzcAIEVjAPzo0aP9fh9FhoH1OMMPahgs7roLIoy8Q0m7cFcjFbSV/g/BWtsyHx0d/fRP//S/+TffPb6xuLhcM7NCe5V5HNQYC6z6JePCPc77pVrtJyjpFx1r7oNdMCpD+jSPeTxwn+ajw2g5DrPY67brce9B7Q06Q+x+idaKXSkcEYvFwhjz9OnTPM+Pj4/Pzs7Ksrx3715d1z/+8Y8++9nPHhwc7Pf77XYbGx3FRtZ9VYHWKDWXffrBD5eGDht2fYhGEXLFTMBXeMvhuYS+v+vyy9C0VRTZxWLx0z/905eXl9XBYru63G22WinvW6t0E2i7X1trjdbBeW2sUVrCL0opIoZA5CloywEAua5b5xpj1GazIeDFwYG1ejKZFEUxnU4lj0V4ZbjgqNHkMIPMjICMCMBKqSSKFUaMCo0FNuW+stYmCQjGEhDbtk2zJLRBR9paXVdOHO44TgCgrusQuGmqKIoQ0Fq7220ns2nbtpK5t2BEcmmtRA0Ma0OcOWbWRg/3TD3Didy5eFFDUFf0sfTBNcYYbeM49p4kwTboJO2VqAEAIPYSiAYA733jWq11kiSNc3mec88jPTmeCL1UaNvdrpEWzoiYZdnQQkBcg912W8zms9lss9sysw9+t9tZa1Ep17ZCPElE6/V6eTDfVbvj7BARHz16dPPmTWHyCr713jd1zcxFUbz++uuLxcI5F8fx48ePX3vttTRNPYXtdlsUhXOu3u8HXTWgsZRApdrOuRTyLAk4n52dJWlsIzOYNWkaJ0lUVZVMSp4UEl7uo6+tFOP2+omsjQcrRwZWKDv6G0ClIM9zra1v3ZCPF26psakXQogig5xyn86QObJxJKqIIex2u8mkQMVN28oybpxUi8AQaAwezi42dV1LVId6OK6Mw9XOff7FsObHokvkCTMLvECcLejqdLtB5sBKEVBodzvnXJopyYlMp9MHD7YCX4+MNcacnk3SKAYAiQdsNpssy5Koa2sh8Z7Q0wyoHu4g2iRJku9973u/8iu/cpDnTdME54UZewBLMwIRueA9hRCcQLHqtvGQEOJmt2dljbXIynufJ8WTJ6cffXA/yqNiOn369Gnj2uniqC2r5cmRZ9LS8cwTMpjYaAgehjgTIHQRM8LrQv7TxD70Tq3WV8a672k1oS8cHcn55yC9zB0sGfG5LtEAIExKzrkQHACY+XJ2dnoaxxH5drNa/dm//ZNf+ou/mMSxcy11vUS8jSIiUFbyvBqkOoUBgIBBIaJGZiZg1EZrYAJm0oAhuARbaNovf/71n/7629/+0x/kxXSzKy0RgFLAChhQ2NkUK2LUml9SgDs8J49sYRi5BWOdByPOv2HJjj/lT4UuXynjkXUJ4zsZ6+/hPGNN3F8xDIpYEqgA0IGe0AxBSyJgbqJoJs9kjAohIKrJZIKIjx8/ns/nx8fH2+0WEQ8PDzebzeMnj27fvn3jxo3Wu/OLVRLFFdJkvths95NprrUhF5IkETfQe+8YAMCorhyNgGRlDncbrti/IYSAEAiIIQytrxmQmClwZFMmZuG7QQ6+ZubjV6J3fuaNH//w3Vmhq3Kfx1kbtNOqQeNszMYE5w0YTco4iDHe8d77oJVF1FZ3YpTYMwTPtWvDyc0bf+Wv/JUf/uDHf/Jn3z0+PAKtnODqhW2RSEmLWaIo6sJZgzmlFAYwzKwsaO+ZKYqgABt8HQrVLFPn08ePN+IqEaPW2ijPOvjGpdEEEY2OvKO6WgsBp3ei94kDWWPAEQGvNuvVZnvjxg3nHGq01go3staaCJxzWhlrDBHJthfNSsAu+MCEgBxoCLcqwLqsFAOhY+YojTh4F6h0exvFWus8z50LEjciIgosgT7nuniJiFrvvYznfruz1paBIqWaUhBGUDZlkmeEoNhD8HmatG0bJWlVt03rPVO73U8mk7Yn4UEGo0wIfLg4Qa1XZxd5nqdRhqQm2TSLc8/e6Lhuw3w+ny0OsmKqtH7y+LFVJOgSEceqmFobr1arxWKx31dxnB4f36jrOk8L731sE41KVKCoTFHw3vsoBF1b8ezTJBOVBgA3b7xSVVWUxEQkcePpdLbbbbTW3nccpQYNBEiTPIQQ5xNmRmhEhUMfw5c63TTJJL6dZ0YplWeFBD+applP50Nso6r2XYi+l8uC44vj2KIAXjqBoE0ku1sW56RYeO+NTgYb15ggRWXAKG5oMZ1vS7eryjt379rY7HYbIp/Ett6tgcIArR+E0pDO6KWTAhB7EpUyTNL5EwHAWp2mKQA1dQ19oTARtY2iQETsyTvC6TR9erZd71xs9OVlNZ/PkzRezheb7bM0TSk4IsrzPIpMHMeZtpPJxMRRMZkgorJWaQzMIfjYGtdUmnGZZd/94z/9R//N3zuK0jrsQwiBg0JQyhCwiSwRUaDWUwgBFEraZr3deu+PP3PvwcdPgofIxj4wa3DoPFa1gvPd5nM3P1etQ3Xp8mS2Wq0+89nXF9MJIvqmJvIsHTydB4Csz2IEBV4cdIYsIIFIZg0Anq7kOQtdHxBAYCZiB9jaiHrIRZ+TVUjMiOgpoELul5Po2izLtYkREVg63qBSAziuVVIcFFwIDUDQiojISBgHgMvSl2X55NnTjz/++M6dOwKxNMai6ksbxZJ6mcf5nOYfCXdRQNqY+Xz+uc997lv/9gfGmCLLyrLUqAhIouRwVaz8EpNkfLmxgnyp8TLWsvy8q8oveK5jlflpb7746f/fx2AlDApPKS1wx0EoiDAKIazXa2vt8fGxc+7s7Gw2m0kTUERcLJZZlomY2G22s/lEmrtNZ0XTNGkcib3GEABAwcuCB6wAwp/n6YZBE+9S2ijByLLRiK/de1UFfPdH759uz4ok11pv9zsS03aofkZAoynQEDF+7hLMwftpMQGgd776tePj48v1dveH/0oCetzn4Qaje8BYvji8amSxCQAtijDLsrpx0+k0BNjtyu2+0lpbbZumMWkswlHgS23jhzVclqXu07dxHEuyYCjJlU0RRdZYy8ELR0rbdkT2vu8NIP2bmdm7roGg7FoZFuccUNeJgZwnGpXhKiW/leBqXdeIXfcIOXmfdmVJXgoWTOIo4o6UZamNlZzFbDarquro5k13vgrODaUyQvOZFdNOD+U5M8uGFSWqTMevaZOoKcs4y1B6TzkWsJjYlxLFNcYkkXLOQaCiKACgglLEU57nRVEkSSLO07DaifxQcSfZR2aWZ9lut0Qk3BTyREqpKErW63WWJdvtloEkQq61yvO8aZxgtSZFGscxog4haKMElmz6btBSBibZ2bZt8zyXTXd6epplmUABkv6grs1tRETCjSNrI89zWYrsWmZWXcyPiFECGLLHQwht20W/uzWvsGkaBWiMCcR13RKox09OEVEwHBJHES+WwnWWoWvSbxC2V+vfdN8n8kpFcWyTOObJZKh08k7CbGL/QV21zGsAiKIosZFSUFWVsfr06bMkSWazSQgBOEg3pziOMxt/8uRZPimWy/l0MTfGoII4jhWDzFGaZPfv3/+1X/s1RGQI3hMAKmUUP++xsHKuSZJkX9WIWNZ1Xdd/+2//7T/8wY+++ft/OpsWbRu0tj44UBTHsWvrjiHE8263y9MIgI6OjmjEz4Wj3hIvSrCXSraxTGaQNDAx+aZpQnC27+F95e/Cc2puOBWiMsYaY7g/p3zSz07XR9mHrplKCEH6uBlrrfN+v98DoAAT7t+/f+PGDWszZgrBB2IA8Cz6l+2ofAheptW4w9x2HCDMVFUVmOidd975nd//g2enF86DUgqF46EfHEQE1OOhuqYRXxzNsTJ+8SfXfNNhEQ/vjNXSp2l9fpm18dLv/+Tj2mRzF+IwYrAPrUxN37q5LMsoiu7cuSPVLwcHB8JO55y7deuW6J66ruu6ttrUdb1areaTom188O0kz5gZGChgXzIGBNgng68P6TVTZrzPBeo+1sEveXwOsdXLxSzPkktUgFzXZRcxluJCQM+sELVBR2CUllwGMHKnMhkZtTWJjap6n8ZJU7Uh8OlF9VmFQ4kIPg9nuBa0GI1qR2QhORoiQqWzDJvWNy7EcbxcLgNfVlUdxV2Ji+i/xrWTeOaw678rAjdJkrraQ0+2J7pESlnk6TuYaPCSWRQqDAQ15Fa1UQPMigOB6uxlqYKFnoSWiNIozrJss98455wLIu4l0di2XmvNHARtK0oF0RKR1kaS03Kq4VdEVBSFjWJmrqrqxs2bH3/0oC3LIewcx3HjWkQ8Oj7e7kpR23GSNHUjiQbJ4hN5cHR6+nQ2m1hr1xcXs+V8u9kopSZZ3rQ1eS//aa0Xs5lWvq7LkrwxKkmi4FpjEq3RWjObTfI8zbLEWmutFqqmg4MDMVmSJNFdYVVHviGFMUmSrNfrvuCnI4ObzWZ5njvfeu/X6/VkkhPRZKJFZxdFYa0ty9oYk08y7MvDxJjrLadICtIE9SboCqVUXZUdh1FPw8LMURQL5FsWofhDkjM2kHrv0XSYMmnZKSuKu3ZbrbUaqA/dAUam6+LnXeAYC0at9aNHjz739ud96y4vL1XPGgajNn/XdO3437GY8j2LbRrHSRRrpay1WZbleS71V865umqhqxFwAOQdIWIbat+0QyR5RzsbGWH+iuO4bjqemVleOOfcg4cnt07SNI1jm+f5fDqZ5IWrymkxef/99/+b//evtG1ttC7Lcsw0DADAHUSrDd5au6/qKIoI4OlHp/+n//x/d/vOKzfPL5Zzq40Ngff7fZzFxkY+VERgbay1rvZ7pUAW8Hw+HYsCHoVCr8U4h6OTbEwAoKGjEEBEg4q4L0noE+eRMdjPo5xQAXq+Ak5qrRV2FRndsulvYLjcIF9l8HuYDqDEQvf7fZIkTJP9fu+apq7x2em5wC5CABecBIihr7mUpML4eV6U3XClfbvsSBN4uVz8zM/8zP/nV//RyfHR+fk5GoOosMdzjW4XP+3846v8hBuA53Xt2IS85vDhp3u6196//nSf4oKPvcOX/nx02x3YpKqkQh+Z0ZiIuWMrlHJM4dyReiQJBAkm4smTp1Fkm6ZxTXvr9g0AMMZcXFxMiowApFBSATAh6G4oCEExACgAYrxKBBPCtTt87sXzT3TtQETNgAoneTGZFIAUx5Y4uKYObcuoOASWfrcOjDFsABn7TD8CsJa8v1JplETWKOLN5WZ5eNS0rQdoQwd8GESz7AQ9yo3BaNnIY8ox6EtglkBuYAyBdvsqjsu2dUajh679izIaWxiysyKjBZhjNMpEiKoQFbjdrmVU+42qnXNaW22lOQwRdXaA1h3LLgzaNLTi6ok0V9YOgr6qhPI6I6IoinygAR+Q57kAXgZzJI5TRK6qZlhmovUlNCIu+/LgUCn1/vvvv/7Wm8aY8/Pz2MT7quq6dxgdx/Enjx7Nl4ddXBQ6P0b+NMYg6t16c+PGDfEFo8js1mtxDZu2Fk6M5XIZRRFzUNawc0MqFxHbuhHbX6ZA8sTyc+ec8C/KaAjjo8R1ZSjEjEiSZL/f654qPEkSaalUFIXSnTMqP0HUQ5G3MWY2m9R1WxSFDL7wpVDP6yTuvgymQCClG1IcWZGMggZo29b7VpLuqqd8EhoQ7721No463soudsUDrERYhY0xhnxXcwIAngKi1Vq3rQ822AAEykbm4cNPvvbOTyulBHgs2m4AFasRewG8IBXHJmlkrNY6MlYSt2I4zmYTRKyqrGka50Kbt+xD0zQldo0lEMC5QNRI3kqQB0aha721tqnb9YqZuSiKs7MLoelwIcSJtdYeHywvnj2b5sXhweLJw0/+6T/+h1VVRVpyvcoHZOLeL1QMFEJog29bL6j1xrn33z/9P/wf/5f37t1brVavv3bvF3/xL/zDf/i7BwcH3tvERh5ahQbRGVTMvNlsoiiqm/LVe7ens4nCK1ztYKm8VF5dczOwmyRkRA1ICthLcg4b7wE6JHzomViGH3Ig8tKBDXqcAaNWoNBTMPpavPY5lSQLT3aZMkmWpiaKIgH6+77/1yeffPLDH/1oNp9baymwMRqNxqEJGo96JwC/+HgBrjAdzBwncQgcglNgvvqlL/79X/1HPnT2l1Zdf0ViFuY/jdez5MzPBWEGzfcTlNz405ce43Neu3l+PoT+k0/y0ndenObxffZPcEWbLpJuMNKJ2JgoTWNEfPjw4cHBweXlpQiLKDZa6+VyKWFDAHj06NFsMk2TPM/zy8s1kT9Yzuu60QiIEWNn8nd3RchjHCArHjV7vhoBwudQ0AhMV0MtKIbBzGRmA7yvGw7u+Pjw+4p21S6O7W69IeeNMY4YEEGpwAQU0GjjmEExMnZAaNBoNDIEYhdibc+fPju6eauqagbYlB1HgQh07qEQwz0PVtEwawMa4gpMS4GZ4zieMNZ1M5nU0j+HmbM0DkzAyIQS5hXfBXrOo7quZ9NC0odlWWaLJEkSccJCCEojszLG2DhumoYZuYdWaaOhh/lI03txqUMIQyshiXNExkrik5lD6xrvsO+4HicpdKPk2raVNpRKKaHolozm8FsxGsRAke43RLTZbF599dWPPvqI+7hu69rJZCLsyovjo916LTHhtm13u51oEanTjaJIRimf5k+fPi1mhQJIs6xtmsvVBSLKUFDHKd1orX3TGKOSJGniWErpRMdLKlcYg+V1HMeTyUQC0aL45VmGahxhxpYQMfUlmMYYiVvKn0p34WUJIyVJ3CUpfAcBSdPUKI0MSimrTRLFglSPbSThfWRYrVY3P/MZqYUNIaRJR7uNiIK68r6rMIEe7Cr9IcqyTJIEoQNIy3qLdNR3wiVmRmCtQFnFfeMEjcq7LiBpTFY37XZfiVB+4403tNbvvfeeVI03PmSZ9qEjUBMDdNiwagRClGMA+0RRlCRRHMdJGsVxPJnk4gFz8OW+EsS4UHtOp76uvZgszF3TeEFRKaVaRBdI/Gnx2/ZVHYDD2Xkcx9vtdjmfzRfTttwr5sV8fnl2+uMffr/c7ZFDU4uQB4Ar6Q2gQiBHHAKbyCJi3bb3Pzr/z//P/9s3P/PWbreL08SH8PV3vvrs6eV7736UJtFqc3l4uNyXDRKEwHXZkG+jyLZAr7xyyxiFNFYEL88zvnA813MPGST47L3XGolC0zQAbLV2rpUmjIMAH4Wjh+noIJ8KzeDXDIJ+eK1GRB/MLNCNKI7N0dHR6elpnERZll1cqNXFRV3vHz9+en5+fnx8jChdz3ygIKCcl2OR+6vS0Fu1Jy/dbss4TuM4rup2uZj9R3/tP/hnv/nbi/l8tVoR9C0QAIbhetG4u6bq/p16cXjga98fyeiXeLEvauUX3x+0Dv9ED/ilh+rK456DuYvcFJGNPQmwRCaFzE/CdKg4io00+Iyi6MMPP8zzfLfbnZ+f37n9inz/0aNHN24cK2XKssySuG09AE3tRDRUlykBUF3TeQZEIBQdTAjEDCO2EAAQNczdPX/qRLimLfLUGMMKb948mc2Wt26+8kd/+EdPHz8LgZABFCqlGcGzN4hEoIABmVVARA1KaTaMGtCiYoTtend+drYt98qAjuKiKLqizP6i9HzrqmE6xEfRiAQoeGmtFREFT31LGU6SZD6bEcH55do5n6Zp3TgKrZxKlCX3drQxRiuQtOjx8fHjRw8ZyBiT5ykA1HWtTUd35b0PvYCGHgMoR9043/dRkAxlmqZ1XQsmdjKZkA/OOfGkjTGKgrz23mvT9VAKwTmHgxskBtyAyRR5yl3As6PYFdfn6dOn9+7dM3GUpilie35+fu/evfV6nRTFarWqdjsp7hTwqvh5oo+ZuW27ZUlE8/lcBPdsOtFGLZdLrTVq7du6rmulompfim1xeDTf7/eXl5f7/V5MJWW0UmoymVhr15vVZFowsw9OG6WNWuSL0BO2iJfMPUI76rssD08kBk2WZWK+LKeL+Xz+5MkTIhB+LkkkswUJYAxJXLGrho3cVRmFMJvNVquV6FTRmmLADbwTiFf9gngUZsiyjCFEkSEfZM1IJl5rjYQEGBgChUB+2DVKgRTptqEhBcgIAOQDKiF6g/Pz87/7d//u7/3eN+/evbvdrCJtxgIHnpeNA2ER9JJWls3gYMlDLRaLxXQSW7Ocz8QQFLj4drsVempB/ldV1TSRWPbDdBCB9w1zrfuGMZvNLspSY9T56tmsyKuqaqoqz6LEmNjoRx+dri4uybe9rvKISKELzBJRCK4NwoEFgLjZbh9+svsv/q//+1dffbVpGpRSe6A7t2995ctfePTo8YOHz/76X//r9z/68I++9W0ACK7D5DvfLubT6Wzim1YSE/3kPhfyfKkO5lEbVpZyHgDuSIoYqNtW0jnGOSctfsfC5wrJAcDcN2FUVoxjelkkVebFhzb0NJZKdQBDc+PGjbOzM+eca1rvvYki5vDhhx+++urd5XKZJImHIEE8ZtZGsaPReQHwallL9I+pR0j391q7VgdK4sQTvPPOV3/913/buVbiSyToPdQdRjfAmItyUJbjh8FRuPhFLTh8X41qLn/C2V7898Vpe+mnL9W+nz7rnQEoOYJh20jm1zlHBHFsh9uuayf+hwzR4dFyaOZzdnamlNrtdpvN5uTkRpZlaZp6R23bZllxcXkZWS3UxEqpwMN4oqQ9WEkgGgEkUYxMPU4K+FqFEo+0bq+GiXoyD/mC1qr1jpCm88mXvvLF8/PL26/c/No7X/nTb33n8vzSewpMnhiM0gxEZBig7+0FCIxBgVIMEIiAlY1CCBfnl2dnF86DiSPRvtdso04cvwwTIGMoT4vIWmttggHjXIiiKM+xqqo0jQ8Ws8v1tm0boXIU8Ivuq3LlJE3TTCe5OI5ZEgskVWuM49goHUIA7GJKItOZO1xSWZaoQCKxTVsPbJQS7SiKgrljZtZa+1bK4nm73ZqeSdRaC4BlVQ2hYPHGiEhYheWQiCv0wCL5phhkzjlQKK+ldcFkMvvkk0+kluzB/fvL5VLKQrbbPSgT+oZ9Q7rUuTaNY0bcbNaL5XK33RqjQaneQwKQUmBjOdBmsxl8fTE44jgWCpEkSZxvnW/zIju/OBPnT1pEdFsYaJIWIkm10hKm9t6nWdK0adPWxMEYo01n3Ij3/ODhx9vtVjLHQtUihfJZlq3Xa4SuRY9EjFXfbk/sXWYW6qsoigTeKMOuNCJDZGzbtuI6W2MUdJwegphDRPJBxzZL0hCCVtboCPDK5AohMIckEbKtK7NVbDWhTlNKUQBZPFmcrNdrIvj1X//1X/mVX5lO57vdJjI2KLdYzLRGIgiBhsIK6LxhCTJ2gVBR4cxdb5WORCLSy9l0mIg0jfM8RZ577zebzW63q6pqt6/btt1udV2bssSmUSJnqqrSGgG0uONijyql9lUTyE3zLITQlGUWWXb1jdde22+3q4tLDg4ZpCXMWFRKVrXtmngzA3rX1m3zf/kv/vbbb799sVohYscJ63iz36wuzi/OTk+Olj/37/3MgwcPFEIc27b1iKgxtG198827aRpLDTr3GVJRlNdkxUs9pUFWSN5XDCyNSnSktdboXmD2Xu+LEn6Ao/e9jzSiQtD9F8L46j60QgZHCBpVFEVRlDCjeuXO7bzIpIhNcjA2TgHg3XffX6/XnruqlcEWvpLLowNAyDavVlsn04nECpalZjUeHiz+4i/9zH5bRpGVrThWq3TNCRsN1nDAC6r0xW9eS5mMFTa8zDwZT9jw5/jprl1l/IzjFy+edjiEwu3ad2BEHivWsYRYRfrLfp7P51mWib0iom273TJ37OdKaQB47733kjyTUsu6bpnZu4CIbdsSozQJEueb6Srpe3WrhF0/BsKXxjj4akCQGUkKzbo3wHunjPbkloeL88uzJ8+eHB4entw4SpMkMtaiZuc1gVYKKCCNUVTCHB96gAxaaxXqpmkuLi4AII5tud01ZYV0RbgxngJ8mWveLYK+xmAAwQ7FS9PJZLFYTPI0jWPZe3H/QnDmoj+SNGrbdrPZ3L59S/xCRLTamF5JDEakfH+320m5rWgd4rBarQSxLN3RVV/SIHgfSdbuq5L7NnyiM8qylKSvhGrl0m6Ui1I9/WToyR2HKJlQuMj4iP+32+3e/MxnyrIUNN/FxYW1Vhrdi0iN49g1jVxCRO16veYQiiyTi06nUyYyxqxWK1eXcWzbtq6qymojnC4qig4OF0ka+dB672NjZ7PZdDqVm0+zZLFYKKMXi4VYIeKqDtECeXZx2eWGhabD9JwGWZZJnjhJEkEvCxOk4HIFLSHxIdk4om/kTYmvyr/Ula4p2XQS5e74QDQy0BAeF19WqY5XQUL6um8NKT6rWGZDeFzMOGEmEWfomtTiHgM8wM24Bzd89NFHiBBCuHHjhlKQpmkgx8zDHI1l1zB0g6wbw7yNMcw9esuHYT0419R1DcRZniyWs1u3b9x79c6t2zfu3b1z6+aN5WK+XMwPD5aHh8ujo4Plcr5czqWATTqOdBhypTwJfwisVitr7bs/+uFyvjCoHj96iMRATHRF3snMoDAwOefa4OVPRiTg9++f/6/+N//rtz//+aenp6hVYEJk5xqlVGKjzXbVtPxX/8O/bBDfe++9yFgg3O32RilZsSc3jq3VSj+35cdibfzn+HUAJnxOhovSIe9E/LJ3kemyV4gI6qpWk0eRNgBQSkvk2RgD2gRgz8QI8t9zt4RdRxDoUwlXYao4jj/3uc957xeLxcHBwWw2Y2ZCeHZ+9uP3P6C+pGFQDGpUit4ZsH30Y7zaZAVYa02cAIAxpq0rBJrk2Ttf+TITxNaGEJTWopnatkUG4DCEjoeTD/gFWayy3AebYDz6wxgN7u9YH48nY6xf5TvD2Yb5G4/1tTm+puDHFxriFeNPB+sYRwGl4ULDBMsDDqPHzJJmExI+yTmdPTtFBvJBzCit9bNnp0SklT07Ozs/v8zzvK7rqm2Mttyn/X2QzS9kx3JpBABQOOSr5LqEEAC5M0evXE/9HL0LAAAjoFYB2CYxAbXegwZW/L0ffDeKzOHhYZIkRimtdRLFGhV5pzuub2RmDcg+eOe8923wsj+dD9qaJ8+eSi5wUhRCysPMEAhC1xu1u1XJpsAVtdt4VIfIoTFGASKyNQqRJQg8n0+LoogiIyCdMbGA8M4rpabFhJlPT5+1db1cztM0tlotl8uiKIR3Xvf9y8qyFPyUvGOMqarKe5+kcZ5mg2gW4LrcngCFJJ1ZVZXAkeQMzLzflxcXF2JmyYIZoLldFpy7BS/VUyLTRQoPpNO678+6327n87kEurMs2+120+kUujqfzvwvyxIRJ9Ppk08+aaoKtUalmEMU22enT54+e6w0tHUpxoE89fn5ORHty21TbmUAiSjSV7ZCnueCb8rzfLlcRkmstRbTKoqMpIZFwgghsyRT8zwXD0zOkGXZYrGQTEQURdLgIUnjg4ODwZkWfPJyuZxMJrKetVHSjVgGpHM+iJxzci2RsFEUFZPc+VY+or51kmhi8a1lbGUnyp8Sc5aFlKapqASZ+i6uaEzbtjLISZIwo9bWmAhAyaTIZo/juCiKsql/53e+eePGiawE4ZySMxhjImMVoFFaS9kpMRAbpSNjNSp5f+iWbVSHVRweeb1en56e7na7/X7vmrZ1dQghTdPJZDKbzW7fvn3j5uGrr73yuc995rXX7t29+8ort2/MZ9Pjk6PpbDKbTSR/rBS0ba0UFFlijdKA5X6rAO+///HPfP3ri/ns/fd+rAGDb3nkTYkeAqCmqaR/r6dQNU3j2sdPTv9n//P/cWD+8XvvVk1du7bxrg0etAqBZdiJ4M6dm5eXl+cX59K+ekCeHx4tDw4OYmOHortBNOELjtk1twc7Ru7nGGGhr67E/sUgt+u6Dtw1BRlc4c7oUR1tqokTYwywEshrd87eAGMIRDSQhxMRaGVMhKiVMgaADg4W8+nk/Pxc6i6MMdLB9/3333/11bs3b960JgrkJSVjQI8fDAGVQnF/e6n83POrPvmstVaAWqvbr9z60pfe+s6fvZtPsrJqxI7APrQyILzHylXeH2vEQTePr4UvUJa/eLz40YszN9bEf56TvPS3z38fAV5CgYY9jBZ6+2j8WiSytXa/q7z3RVFsNpvLy8uOOj9JhEZU9MdsNnv08GMJgTaNI/Ii4j0QAFlrAwGRl6BNUAqCwAUpjHivBuOAELjLJPTYgd5YAQClDLPrhk7pxreeiZCY4K233vqv/sv/+u23furuq68++PBRua8N6rquA3Icm6Zt0caIyCGwAqUk40k+kLJIWgNB27jVamWsUgi655EZDg3oej7RsVGlADvxpK6GVwNKoTmqHvRvCLlhwCLPiyK7uFgFCuKhyvlV3+4Ggeq6zrLUKPXw4cdf/fJXis/lgmYSTgal++BSH3odkLpiNAj2VbKzkgeVHwogSyDWAvvyFKQ0paqqELpuwcYYWWTiKIuhEHr+QsFJKaXEbxtwuYNrJTsly7KHDx8e3TiZzWYSaxWltdls0jQt66ppmsvLy5OTk8Plcr1eA5G4pxdnz5aHh4jYlKVBtVgsgg+ixWfLZdy25IPJ9Ga7ElTgsLZ133QPewCa0ijRzsVioa0ZUpVa68lkQrSFPgYoFonEe2SUJDA+EDTGcexciwrSNEVEAXuLoS+eMTNPJhOx3kIIcRIxdRB0sWCGS3f5aY0arWCq79279/TpU9866FprsDjZuucg6xLJquNvH07LcOUPDEm+JEnKslbKtK3P87xuXJBm6FoFckqrEJiZojg5O72QK9K+GiwAo3VAXi6XdbUbBNRgo4voE/CabHN11RAexeqmbiqhLMvNZpOnHfJcggFWK6sVK1RFFkKIIpPliYQW6qr13jOHNuvwWdNpIcbE6elpUjf73Sax5sP3n/3yL37l5snxg4/uh+CAJQzTbUxPwjLEjWtZaVTYtq0nUsbuy/Lnf/EvBKaL1brxLoqiPE9lqJVSs3zuAi0Ws1demd2+ffuDDz5Okqgsa0RtdOS9RwV3774ipluSJHV1BckcAF8wAr1eE9Sqlw9qCJ6RSERFvh1S/uKm+L61BnCXUR00jqhSVH18ArTWDEoam8ogXNEqh76KSV4ncaatbb0HAMOBYhu99tprFxcXYsV33OJKXVxcfPjhx/P5vCgKCWMqpRRc0ZPKlXgEvHrxUKgBIYSgATl4Yj5cLr725S/92XfejSJbN25gMZWdr/WVlhpueqwbdEc78pJS9JHC+1QsHI5SAmMJPpz/pT8Zv3hxXl/88vMnuR7UfVHf9y71ONOsETtoq8hNjvHyYi1Fn2VZCsGCFGZEUfTkyZNnz86Ojo6a1u93m9lsttnv0ig2ehS5VayUFUouYlIEwsg9UF4xM7DcbYBRWoG571149WhKvgMKtTYAxMHb2B4cLX/u537m7/zK3/lbf/N/8errrz1+/JSA4zQryx37oKQXvQZmkDIs2T1KqRbAKqU06tg+Ozs9euXWyVGWWCWRXkm3iIcRQqAXqEmHqbm2FBWDABaN0gEhMlYpFVpvrZ5OJrvtlr3WSjV1LZEehUghiGdrrTFKxbF1TXtxefb666+fnT8TYIRMk6xYa+1kMpHqiCFNINAq6jGTsdYMXbt1USqCCpb08GazmRYTIWCRsK2YHW3vk8luH04OUpLfITOAemb8wQ0FgP1+j4iD15hNp21ZE9F+vwcAa2JRQsaY2WwmZc1SCDSZTEJwp6enAj9Oi8JWVV3XRVE8evRosVi4ugZiH1pEFNfz7Ozs1TfeyJnFzJfHFCACAAw5LBb0k1ZxbCU+HMexMZVMqzyySOG6rgUjLbcU+poc6PscyNMNOHBR3qKfQgjL5XK1Wg3EKcPaGIaRuqLnrrXRycmJgLaKothttlL9LOteWiQJOkk2I/UYwN73YoSuc6LcHiIiagBkDkVRNK1nQCljdc4xi/3KiEAMu135ne98x+gOp8Pdwu64nY3VxpnBouI+ATE8juT4qesPLfEzNYCBHQVscbfbaaPm01kc10SR1lWSJDpLRX9boCFnLzmItvVt206mOQW4WF1WVRUCI+Ljx48ZKIs0xvHDBw//4r//lVdu3vjk0UMFrICIrspbCZAIHAUi8iSgNmJUAbiqqp/6whems/mzs3O73rjg0zTN80wGUGu9SqosT4rp7Bd+8ecBebPflFV7eHh0dnZmjDFRVNhCcg1aYdt0EPFBIL9UMvPYxepfYG/Yd7n0oeWzueJgDu5Kuw97WfWdRplZK2VMhKABAPv+gZKPQJRef1f4OOxJ8UTDhiCzqYHY37l7+/j4WPIiEhYryzK07sP3P9iu1q5uDCpyfmhdNzxPAOY+u9nHNq/009Wi4d6GcC0CvXrv7t17x9WIBlaeaqx9eXTQp9Shf9rxYoj4mrAefzpc7toXXvrbF0/1k38yBt3By7R7vzgYsfNaxpFqItputxLTW6/Xzrk4Ti8v13GcnpzclEZ1Av/55JNPQKmqaqTxHwBsNjtWWgpm6rr13iNoyd3KSvJM48y0ZHa7+wSNoJ+/0ytUeb8GtFKGCbWywAjE5W5PPnztp79+ufK//lv/3DEtjo4n06nERn3rImtr117tFqIQAoJmbVQUB2MmBwe1awlgt14vJpN7t2/pvgJY9aQZURQZvH4z49UyHtju1rua4KA0WKt9cE3TCNe0aHellDVGd24Eaq2Pjg6zJGma6vjw6M7d27vdjlx7cnhwcLhkoCSNh2izMpoRRJxR30W4LEtxyGDkF4rnKjReYnF27FFJIgTCklMQSSTHsIMG10r0R+j5dABAztnn/zpS5SRLy7JcLBYBeL1eP7h///LycjafC8Wmc04KhABgcNnrus7zXJJQJycncRznecHez2az/X7fNM1isVitVk1VC32b6NfdblfXdWhb6OqIGumvp7UGrQiBEJIsl4uKI5Wm+YC0AqAQHHMAIOZgbffQbVtPJvnwjjHqxo3jqtpPJhPpyzmdTg8PO1JrIhL+CpFxw46WKZCR5B4QIEecRChgZmZZVNK7Qpxk6XokeOD9fj+k1QGvetLhKOVEfRkSAFgby2LIiykxAigGrY11PrROSNDZ+RCIAZQy0SefPPEBhqbIIqNDcHmRMbN4RHL/sgsAQJYKAEgQW9bSIDTG+oaZ27bdbnZnF+ebzUaSIE1VO9fliUXgJ3GUJnGapnmeTyb5bDY7ODg4PFoeLOcnR8eL2TS4drdZG6PSyPimfOfLP/XanVdOn3zi27Kq913JIhAReQreexc4eA4EgZFANc4H4jaE+eKAUF1st5tttdlWZVnvduXFxfrycrVeb3a7/Xq9/ejjh0R05+7di/XFw4cP5/OJ63tje+/FMkuSRPC71yTAT5bS177GvfuLiCG4q92KChkEoDLedMOkq6H3kVLKGgAIDEzABAPRL/Tqz3cdLVlsxDybpGnqfRfAkHI0Y4xZHsyfPXsmAn2S5+v1Wimz3W7LsgYAhdoY4bmNRFUQAisckAbDKDyvYxQBKUattQ9OK2TG0Lrj4+Ovf/3rv/r3/2kxj7333ClUZiJ+XrPC8/pyrNqh94Z5xHA2/OSaTXSlZkZR6+Gc+Hx2czxVL33zxfdfvDcABYDXPr2mp+XemZlZDyFo7qPQiLjfV0RdHx5BZMh0Hh8fC0HBdDpl5rqupRJhvV4vFrM4jtfrtYgPDCwZiDzP43hgDPYA0Guxvu2g3CSP1isrwjC6bWS+gkD3to5p2xqRkUADRsbo3P6Vv/YXfvPX/+Xl5f7G8c2WyCZxFJumKr1rJ7MU+cp3jGwCCltiAlTGPFutPvjoozhNLlf7r37lC7m1AG5sfg0GCjxfgz6Mm5he462IFBC70mtJxyqlfNsqpfM83ey93ElVVVmWNU2FiJE2vm2tteStNphG8e0bJyGEy8vLu3deQcTJZCIlrSL9nXPS+0xSBszsnZdtRX3LlNCzZMgMihkkEyoJzqqqFGDTdFUcEoxFRAnGAsDggcmFAKBpmjiJ5CO5GQFFW2vbqhQ1KbQJADCfL1erVZokSqnlQbJerxeLhRTaOuekwENZS84JFXld7ZOiQNIAcHLzlquqxfJgu948fvz4zTff3O/3y+VSbl5k4na7Xa1Ws2KCiMzoXCDuWhQwc9s2zLxcLh89eiQDiIjSFFnqYYaEujGmJ7kEAGjbVjiZJdIjrrBQZBwcHPzoRz8CgLIsd7ud9L9LkuT8/FwGf8BGiekjug17MKnYplVVEZHgtuI4Ngrrul4ul7KDkiQpy1LaCXNfDDIg9cb7fdjaoiPzbLIr94jaRqauW2MibXXgChTHcaK469z86PHTP/ved+PUtr2OJ/JK2XLfvPqZN+fTyWq1kiEa37zp+6eJ6cDM8oV+yfc7mhUhMKP3/uzszOoO8N+4VqL3svKx7+WsFQVtyFJgqqrGDSuhTtMsFk7QenXxyvFBmsSPH37c1iUCIYVAQhHRbcYAILUPzEyMgQmVbVxQJvYEDx4+KaYTWaVKKa0rjSDza61tm8skibJJsjw42O/3H358f7FYPH16DqwI+E/+5Hv/3f/4L6ZpulqtiqLwZXtN9o7/vCZye00BHXRr9B0F0IYgFcFSNR4ChRBQCaqcCfiaApYLdVEH7pYBMwdgrQxxV1XonUTC/JDbEnCl1AEppVUa2UgrDfj6vVenRXZ5fo7MYqgS0W5XfvDBB1I9JsBarTWiHtMn8Qi9/PyBzHzlSJEMB4TgsiT+0ud/6vh4QUTSR1MAsX7Uzhp7gN9YOz4vaq/arI6PYVcMG2M8Ny/V7vDpVtK193/CGZ7/+ZW5wC+zy4a7vebvDi90TwSBqBF10zilDIASDG0cx+fn54gocFbxtwTeIr7FwwefhBAuLi4IeF921ffee+9IFlPnSAHD8wM4/pOIuJ9pRLzKB4/WYmRiZKVIYWANuNtsEfHWrdtlgJbDH3/vz5bHh7PDJSg1mUwk6pjm2eHRclZMDCpjTFpMDo9PoqJ4dPrs3Y/u69gG4Jsn86986QtFEtneJ7o2L4qHu3puB9IISI/4XB5Io0LEyNg4tsYYq7RYNrKdvPdRZKIocnXTuiZN0yyJJRl5cLA4ODiYToo4slVVDVhcAJDuv5JFhr4ZGXReL0r2XfVwMAkID/FnZhbCZEE2xXEsDX3FtRWqBNE98jU5uepRr0IHwQjD/cuy0X1PdZmgpmkODw+rqrJRJGtgu91Ksmn4/qC/gVmqWS7PL5KiAO9907RVtb28bNsWmI+OjqRc+PDgmAldG7yjcl8DK4VGK7tYLrnPARsTDdkvImHviiXR6D1JVxwZFtPXSeMIFXF+fi4wLtE6Dx8+rOtaMGiSWZeG2ev1OssyURXiVZv+GMIn41iCUgoVMLOE+tI0PT4+bprm6dOnMhRZlklMXsZQMvdaa1QsoYJhNY5NQ+79JAG+BSbvKU7Sum7PLlaPHj8tyzpKUmD1yaMnP37vgx+/98Hjp6f373/04YePJI8+AHyAQwhwfHwo3GGimXAEJhW3WIwGa+3h4aFEZQFAWwOq26qD38bMu+1+vV5vt/umaVwbmqYR6nLXeoXamshoO6AINapJns0m00lexHEss7BYzibT/DNvvFGk8eXps7rcIXhkr1WvegAYgVABK2YMjJ6AAD0pF9gH9ARn56umdU8en16sther7WZXlfumrNq2CeW+WV1unYf1dlfXbVrkp2dniOjImyhKi/zi4mI+z2/dumWMyfNJ6Fs8vShgh7l+Uaoz86iE48pJC32XUnlD9iCOGr3wdXXeQWsRNKLuKB1Ft/cjIj/0Pfek937o7a2UaluHiIa7UJKfz+dvvPHGZrPb7/dSoSi39dFHH73xxhvHx4dSwuhc8Ewc3HBPw7K+pqWGsUBAEC/TB+4dlMPDw3fe+eqv/+Zv58WE2SvotNYQYR/+HXbmNaU4/tr4oi8K6/GUfNp9jifjmkJ98Rg/3fj9/iTqz3OeF+9HZlS2zSBGh8Rhd04AgXcCwMHBgXNuu93t91vnXFXViLjblZvN5vT09OBwUZZlpNXl5eWkyJlZSpucA/IOAIRHArokCA0rZrifLls2zCMidrRlV0dw3hrjmzq2tm3b2EbOuVdfe+0XfuFrH9z/OCkmZ6vLL/3U2xdxtFtdTorcWbvfbBEZlYrjWJlo37YX+/3j09PT9Xo6LRrXQAi/9Eu/uJhO27qM0gheZniFEHCUaLimcccjT0SskDuAFRmrkiRpGiciuI8ikjEKACZZftlcVlU1n89nk2KzXZXbndaago/6WlURiyLioQdZVFWVxgldlQwGgUwYYwclJD+Re67rWrrSivImIgF7dw60923b+j7RKz7c+PFF8mqtCYmARSGJSiaipmkCk/c+sl2u94tf/CKaCBG3m41c4uz8bD6fZ1kh95Pm+Xa9dk3TtjUzt65+8vBh0zRFPpUkSFmWn/nMZxBxu91uNhtjzOnp6WQykfyroHVkoQCAtTYAG6UlzC6uvIgUIVHKsiwEJzR8kmGRSRzYReR5B9C4+Kky72VZ3rp165NPPrlx44aMQwhBjIyiKJ49ezabzQYnVWFX1S3DK1kMIdOWLSb7Qu7ZGNPUVVEUZVlKfF68lu7R+tJP6lvDit2APQJLroiIwKpt26Ojoz/61rf/9b/+1mxx8MYbb83m2NTtbr//5MnjcrdfrVY/+tG7Hz34GACoQ4op6oECSsFisQAkyY4P7ChyLbFaZLrltQQGyrLsGuAoVNKJltAzadIAtNvtjDFZluR5Hlndd2BURVGYni50kJNN4zrpCjjJC/LBKO1b9+jBR/fff9capaSgUCid95UxJjBQYEIVCHrdD40PxkTOt57Z7cs4zVab0lobyqbk2hgTGaO1jkzXPzGKoap3X/36VwDg+9///nq7revgnFPKNK37uZ/92tHREYBsKNW2tdYvl7FqxAMxVhwd1mYUP5PtDyNop9ipDEG4EQZ3BUZ9f6HjobSICICAKK1/uzAhAPQFC4KzkTmVsLOsQ+8DABgf3ID7v3v37mazu3//PgDUdS1mclVV77///mSSx1HknVPKQLi6oUEuX9OOzBJX7l7IYvWhRWJrrSPK8/ydd975x7/x24KzECyJVkB0VUAybBJ8PqgIz+vgF2UuvwwgPZbUw4vhh/hC1Hp8vGhPXbulQT0wMwDDp1hh4+8P2oJHOZvB5go9vcOgj0NXId4VTUrc8vT0dACGyCbcbDbetyGEcl/nBW42mydPnsSv3kVEof1zjsg7pRTgOHDUO46Mw3KUdwKyen4Rj0dHaw1ErDUFZ4wBol3V2iT+6Z/9me/98MdtQ+9+8P6jhx/fWC535+cnx0cUxfvdLo5MW9Xr9br1dL7db7zL8mK6mG82qyKL/8O//NfeeOONui4To/3zhpSIe6VUVVUarheYIUoXsKthl0dQ0hmqr7oeAsJ5msbGrp3XgJMsZ+LpYtq6ZrPZXF6ec/DLg3mRJgKzkvzTYrEQRkkhpBQ+W9lpUu8oSpQQASCKIgGwDPMrtpTkJq216/Xa9+2VhCJDdJLWOo5jVErKz1arVRRFQ/aRR7V53e7rneZBMaBWTdMgqFc/89ajjz76+OOPj45vSM5vt9uJBVxVleq7DAXnxOdOkmi1Wkn0Vf6VFTibzaIo2m630+lUQFJCjn1+fj6bzeq6XiwWcRw/e/JEaodOT0/jTHrldh6tjWMOQboCFEVhTMockiTZbDYC8wYAwRseHh4OtUyDMyqIceo5MrXWkuSWCi6l1H6/l/Tw0LjaGMMEAzhcBlBrrRjbtpXyYtFDUoHdNA0FEfdKbkDISURCXhNxcn7xZriHj4mG1oqyYvLN3/+X//X/8++89dm3f+r2nSwvmLlp3NnZmTFR3a6sjYtpUv34RzT060VRBgwcFrNiOp3utuvOJdVdd1HodYBkKCSiAABZls3ncyLaVzV13Eyd6ybmgjGqqhu93ZblzDnnHUlqA5HFpx+FQyTljDL7EpuZTCZpmt6/f/+D997Ns4Sc994L+KquS62RiIS43RMGAk+Ku2QWbne7KIq9awUTrpRC1K0P5EMI7FxADho7wLlz+8XRfLPZ/tG3//U3v/mdycwAR3Gcek8AcPfuXaVUZHXb1CIeQ0/Vee3A52G8g5LqgqZAvXoKzEzcg8+NQkRJEnWjN8I/D/5eL4girTWI0hUO5i58HbB3eQdrMoQgXb+YWaku+MTMRmvtfGusJiKtk6Ojo48//jhNchun5+fn6/WaW3//owevvvG6stHT8wuBpEsRhfdeGS3JMCbu2bkYERUDsKBkiRkImAKDBJqIkAMQ37u9/Ku/9PXf/t1vz+cTF5CC0TYKVDKSNjqKjAIwBq2OAKiuW++JEAgUSDlczzSKiKHXUkqp0BsynW4GoaRoBDEI/JzDNBbT4w027LFr0nysQXlUbzrYR/IhACDC6PQSs1UDFaVcQsyL8boZbmOYNjFOBxhIHKVxlGZpYXQErIBVWW4nk4lARUBpRnWx2p6ent545S7U/qNnz+q6vkXaMW92++kMdUDn2shaAxgZFQAUk9LCJNxqrZGR2BMHYkKFzBCAQYrlUCEHEAeFSDFrpVkDswGN4B0QRRpCvbm9TP/m/+i//89/63e+8/0HJydHD1e7VRk+/uisDdUQv43jCAwQ8tKa1pXr02evvXr8F37+5165dULcRHlEDFbrwYPsHCOFgCpKkxCCD61VVthIiD0CMiMRKIUAKJFypRRzUEyefRyZummNxiSKfaC6bpeL6XZzuds1JoqICJDv3Lnz8OMHsU0QcXW+evPN1zlAZOM4SrJk61qPoChwVXYt3IU7aVpMkEFMHI0qoHYueE8E3HqnrRnSJQK3aZomjZMospfnl7du3XKtMzrSYCezuKqq1epSa9U07Xw+j6zVWofet/beR7EV4ghA9o3P8xw1ogLR1lrrNE1D66QUlZt6fXmRZ0WkEIFbdtoqAIgiE0UT71sABlDOubqutdZFMZUAWBSnl6vNfrueTqe7sp7Mpp7C7HDOSEpDWsT7Z6ssSdJYGwWtJ6WM7FC5rlJKMTVNY7VRgaUZW2RtbKO6agJxlmebzSaxRuqtkzipqmpQdaJxxfXsIUgmTXPR/YKH2O12AFAUhTRBms/ndV0fHh6enZ0N8GBAFgexbVsfnNZa+MtUTy0OAJJdXq/XzJzGkcTGxeJBxVmeEAVjFZHxPQ95CCFJohCcQeXbJooixeIWIysbFfGDJ2f/t//yv3rlzt2DW3fS+UKnKdqo3O1L587Wa1IKIovaXK53DOA8AQAQW60U8m5Tf+HtNzV7amvyNbLj4IwCYdsSmZblSZraLI5m06TcV0qpkEXIEx9a13ijFLJiQqstMnrHHChJjHfh4mJVFEUcGaWBObCriiSKzDyJLGpjIqva1jknDR+thggQQz2ZJH/0h3/wZ3/4jXlmwAOwUoActIKIAZkheO9cg4jOO9AKjQpMddNAyBTG231j40hbZMXONaCRfcNAzqMxkdKWAKs2hNAyh+0n5b/+v/9xCDwpJrvtbpojcFPudm+8fnz71pKpdQ0qpXzTEiL1SJbrx8u6ISmliFlpBM8hBGQCJPKtc41CQSmzxJ+ZCBg1GmZHwVFwXTAXkFghotKxSVJQxnuPUmnCpFCR90ZrAPQtBecpgAYLoJgxsZlV1nsSEJWojyuSVWMMM8zn05OTk8efPGWE4+Nja+2zZ0+I6MGDBwKPFOada97btedkZoDnFNiLOsZ7r5R+8803f/f3vo0Kql2lbcQhKK0UdplR1dMYIV5VFkq1jGg3pZQecV90GxUR+pQM9jlz1VcP08vysi860AAv8XqvHWPlPX60l41GtwDgBVd7fOlrpxrsgMGylgfxXtpVBkSUkkdxTSSWQESPHj2SlJjgHjebDQBst9v9fl9MMu98XZeQptCnRV1wyo9CuABSTjuu9Hn+Ka4WN125+zDcLXOoqurO3dv/6X/2N17913/yD/7JbxPAwWKZTdKyDCdHh0R0dv5sPp+G4Nfknj07txp+8Re+/qUvfH6+KPI04eDJtfp5Cl/oMxr8fNzihTGn5xhfRzZN0zQAPY4R0NqYLrcHBwdt2zZ1k2SpMWZaTD73uc9997vf+fKXvxxbW5ZlPJu3bVsURZZls9nMGCNG5yDlBYcs8C7ucchyXRtZARmFEKTPgXxHnCdrrfAx1XWtdUtEeZFI4dBms8nzQlLOSikIoQfZWgDwPfMwWJTXQgomzfsE3d00zZMnT4Qsoq7r7XYL0p/c+8ViUe5rZi7Lej6fr1aryWQi9eVlWR6fnDR1HUJYLucW1fn5eZJnZVnO53PvyRijDbZ1fXl5mZycVFU1my32+0oS3oBJFifCZjWZ5GdnZydHx01by8OK4b7flWdnZx27qnfaGgDQ1ljqaKq22+18Pld99yGlVFEUy2VHk9I0zXq9Pj4+rqpquVwKMRwz13WdZZn0DRwgV0opQQ9hDzUSxw4AJKRERGVZDlKiF01KKdUza1byc0k9jBLVqLVxvo2SuK0bpZSyUZREzkNVVb/xG7+htT48PJRRdc61upVypv1uBz0E9/Hjx+J1yfoMgW2sjYGTkxO5eVlsRBRGnoN8lGVZbI0Q9bSNs9ZGxobAGlBAzmK5ympUPZtmWZaXl5c20nNgxgQV7na7NC9MHCmltO6cPNe0kzzjQBrZNfUf//G/+cY3vrGYz325ZxDpKs14gqSqGMharKoKtW6dY6V2ZX10cmO/qeI04TIkaVrWVeucsbEwmDrnEXXwHChoha1z5b7WhqyNQuDEGtdUn3njTeea1fqSCO7duRPHMbNHfYV1/8nHS+KUAETMfdgZ+iIF4DCW5xLG5L5UgYgUdnXk1BPFc1+/M9BJDX72EO4aPIehrSpRp93kOwb6lAai8j5MJpPbt28/+PgRKzTGLBaL7Xbtvf/w/sfz2fLzX3jbWi3LkUb4+5+gdYYP8Hmwj1JaGfPGG2988Yuf+bPv/riYzpwHCoA9uTQQg0YFoBQopSUYgojovQsMHACQhOCwH8fxgNJQsccKQWt9rajm5ccgqcdS+9O+OQz3WGvC8+p8eEcpM14Ww1y+9Pv9T9QwVUMGCLWSNBgAOOfW6zUgTadTCU+KjfLee++9/fbb0q3Bt43Qze/LGhFdGzarSwCIbeIgMDdWG0QgwK5tGPRkZAqRtJCojZ+REKQIuF9qwKgQCQGpB8VrrZNUr9eXJsp+/i/8zGd/6u0f/fjd73znu+/d/xABzs7OZD08efxMXvz8v/flL37h84fLhY1QAVutbBTXdVDYtWIaNhIrVHxFNEEv2Lm9TUMAelhsIA0BEdq2BVQhsFKKgY0xBwcHkn9tmsa3DoiVUlmWvPXWW48fP37t3p2iKNI0btu2bqoo6mDPAqyw1gJ2yNiBlMd7z6FrABDH8a7ci1uMPWRBQrtZlq0uLqUJj9a66z7ZlB9+uJZ2thL3Pj8/Fz0hudWhGlV8uBBC8CQnB4YQgoBxJKgo0CQZooODA0R88uTJjTu3hRJLvhACJ0lS162olvV6vVzOQandbpfnqbXWIgj302q9XSyXnzx4eHJ4oJSKYjufL87PLpIkefLkyXK5lGfpo7IQRYaIFovFan05m82ISLJaRIS6kxhpmjI5MQ6Ggl1Zfrbv0SQ5csm51HVNBBIRlfpp4UuXsPZ+v5feUNLweEicy2RJYFkC3YKjFiSwxPzFrwghxFHXAENSA4JVLorO6xDDS1aL1Exba5um0pEFgKZpojhN0/jDH/34n/7Tf3p08/ZsMpd5z5K0ruuy2onXLnlxBZ0B3VcPo/eeGb2HLgqqukkXHcA9CMD0jY2F59laW+kqtAEZPLHwp3pP2GeLlFIS3/YeqrK+uFjpnjeNgEzUVFXFqJIkiUyslErjJDivUTH6xNg//va3fvM3/lmRp841AJYloAeMipkDqxDIu+BCCI4DUqSUubjcfOlr7+T55Pzyyb5uojyqW4ceU5s2rTc6CZ4QbJrkdV03da2U2VdNmqaXF+cA+8+//WYcJQJAuzg/OzttEOHOnTvMzExoOqdRv0j8NBIEg7Adv6004v+Xsv8Ktm3NzsOwMf4w04o775PPuaFv9+2AbqCbzSASIMCCGC1aJMyyGGxSpF0upwe/qCRLJbv0JOnBpQeXA+WybMElkaJFUmAACAIgiNDoRgPd6EbnG849ae+zw8oz/GEMP4w55157n9O0verUqR3WnmvOf/5zxG98H3HsJj5ijDKApLtmVozXiIl6g6aVMcYCgNKmAz+LlioiasRrTHzUEZSKTdBKSfQmv++9LzO3g+oxRoVtSLi7uzvdGV/MFvLHxiR1XQ0Gg5OTk0ePHk2mg9BJh8pjL9BN+bq/2k59dsvlbNlHeSo0qtFo9IUv/NjXvv69JEmaesMoiZfSqLQITGi5PqWNknRNKYXe+whEMqvVfqAMyCBK5txWd40MDygFum2mokZmVnzlrfl1Sfz2av6wX93IzGCrjd8vsdx0xGtvVh24TFa4/6Bt9w/XEdrbziYy1XXDzKBwXW4o+t3d3TzPV6tVmqZnZ2fL5Uqg0XVdu7paLpfybMfgZrNZVZeKIUmSPM0ALEBIjAUgQgghWHXF+C27BV5hsSZgYa6+WkOFGDUigUKlFAGz99Yorahu1vu7w4N/7Q/8gS/86LMXz10dmqa5uLzURgl/8sHBwcP791CxBlYaNQIFFxkTa4kCxat4BQBknKhfYaWu4d0Q8aqZDddunPxIKeV8qEov58/Mk8lkuVzu7u4y83q9DsEhsnS8fFPNZrPJZHT7+AiQgVi67DYx2iji6EM7u7ndfE3TNPrQ81K1hIKdOCt2DJFFlm/sWh5UmYASwzoYFDJlIaRFArgjIt1RUfb7Rw5OkbXWxNGgkchMnG6SJED8/vvvv/nmm1VV7e8dJElydHQkMzZSShU3IAkftxguZYwJTQNAMcbNZjMdDvZuHS1nc2MMKHXv3r2njz/a3981WgOAsGAOBpqIlFUIuF4tdyfTy8tLcWwMJDNFkv1L+IIKhN1iMBhokzFjVTVJ0tLRa23TNHcuCOGadGFb6cYkOT+/HI/H/XTQYrGQkrXoMYgPXiwWWZZhN0axXC6LohDfDADi1EU9AqAl1ZIdMpvN9namPcZNuERCCBTlKUYJIxBRkFlStFfKYDcdJKv6S7/0K86527dv7+/vj0ajLEmdc7PZzNWNwNpl2TWqz33uc++9/4HEbVJMkih4drm4fXTonfjdthvFzIL66a2NTPFKlr9ZrbMsQ90iEpbLNSLaRMWgULHQcAkPVDs3UXvvomcfF0ttk1GIUqUAYhe81YojpUnyld/60j/5uf9uZzqOMWrAAIqBCSVVYgYIkTx55qg1Fkle1X69Xv7kT/7EYDh1keyAiWi5KkPEsvbzxappYl3XChQRzedzeTg3m02e5xeXF3/mT/7RH/mRzz19+vT733tPwI8A4Gp37/bO/v4+cDuLJTYffjgB1GtfzL1Ovbjy7YEOWdK2ZtD+vh8NJQR1lXTJXVAtJTtAl4XGGAXw5L33zvUHkUhCa+1jVOrKoKGgoLuJ+LaBXBTFm2++uf7G74t1m0wmZ2euqprz88unT58PR2/0/qN1J4wAvTzTttV7zer0uyfEiJqSxNy9e/djH3vwwfsfpfmIGbVuhxqtFYAcalRaa0BSSi7bKwU6aBdC33nFLZ42onain7uWe4/u8963mrhXjBNbBvoVKDWAYv5X1Tp+uHtWr17+9vF563UVtWz54+13bjtvABDYiDgDZgbEqq611s778Xj83nvvPXhwXwj5mqZZLVY7OzsAcHp6mhfper1yzqWZhTnovT1tDUVo2AFQu3RoALAHRbdrxYqJYAt9RQhKKlH9qWppo2jGCNxqu/rg8iKt63WCaZbaN9+8Q06YkKNE8YvFIkmM1qi0UoDeN8RRZ4nWGH2gGAFN/4kAoK/mj9tib796/Z7sfhj7mj8AWGtr79I0JYYQKq3Re58kWQhuMhnF6Ou6FN75GKPSkCfp/fv3naurTel8s7+/X65X4/Gw8UGO1qdWsvcEgwNbp6e2wPliK/vSkbX27OxMMm+ttbWJtDyVUuv1SlyvuGS5oizLQge/cs6JKqI88IlNUQEH7gFWAt8V7Yf79+9fXFwMiqHEAdPp9PHTJ2pnt1xXWmuVJNYkTdNQ8Aqyy/MzoRR+/uzJ3t5emiQxhBC9rqrFYpEXxWa5HIyn0+nuarVZLzebssysybKsrusYXbX2QhO23KyFu0NpLIrCN63fBQAh1Kyauu/1uhC0NcVw0CKiqyDM3rIC3ntjEgkpmqYRpyjrEGOcTCZC0SAWczgcLhaL4XC4u7srKyBDBMJtqZSScUrokki5iVLglUWeTCZEoLUWGFdfNpeHLqEEABlI8mCllGTS1lrJ/r2LWtunz57/o3/0jx48eLOp6m984xvCyeW9967O89ymyc7Ozs7OzmQ0Dq0WOCBioBhj1KiUUqghHxRorPceUYhZLPjIHcmDnFiixU7qJEmM0tEH59xkMhITH2MsyxoRlb56KBARFIZItfNl3eRNvTMeOeeqqsmyomm8bELf1KlNbKq/9jtf/X//vb+7tzMBAI4hxsigIjIzR9EwIAqBQmynkIKrzs/Kn/5TP/nojYerdZkQUZMwIytDYEashqOdqnSz2eLpR0/Kat1tnpCkNs2MAviTP/1TaZr/7m9/JfoGiKy1HD0RfOITn5iMhtqgUhC8k9w+Av//5YMRsUcQM7Nw+XWFxnaVbjhgwWf1ET9DG/t2FU2FyEDc0hQxijxgcF64ccQCmCSJzNDV7baturlu6DlGRtR37tx5cXr24YcfTqfT6XQqhLF1XS8Wi2pdFUXRY3g7b/N6oK9cNLT+5tpCiLm3Cvd2pp/77Ge+973HO4NMYJnG6NQaa63psl5tUKmWiJUhctSkyCiIzDFE0ADMGtEqrZSKDAyMgAaBgYwRVe3w2ip073e3zq9vybympNz/Fb6u+4iI8pC86piv/Nn1v2IE6AQ0GJiZenYTUP3MDwvRiiDOyrIUxKAU9JLECqx0Z2eHQT1+8tHh4WHjXVlX2pp1VT5885FSaj6fo5o0TU0hliXAjhq5oJSPJmqtEcgYiMRBUVtWae+ekK4wM0sQ2PdOhC9adYGouJ0+uNtsNmLgKLg81QTBNbW1FiFxjbPWxlA1TXN4MF0sFkxkbIqKkRUCGGMUMGhtjKk9CZtSv+B9DLcdrGy9CLrR8+5GKADSWlMDSqFwF6zXZeN8lhWuaXu37QwPB22QfNibTo72987OXw6LAQBcXp7v7+6JKWSAPkmSRqO0EqU43DSNAkw6FUXJXUIIshrGGO99YqzAiGTMpigGMlWCiBKDyz4R1yIo6yRNoROek2cbpB/MxFHGCp0UtyXDE4aWs7Oz6e7OcrEKIUwmk9FolOcDkRxM0zTPBhITiMylgOOIg2jxVlWVpjYxuizLg4O9k9Oz4XBcV5X3fjrdjd6F6PZ3987OTgWVaa1umkpquUphMcjlTLxCcXISGaR5llRJX/IlItAIjJLtKaUY2QVPdS1cmNIFz7JsPp/L3RTNYACYz+cSiQpZtCQZ8/lcay3U3JKhSp9YTgYABHMu7WTuBHR7pPT8cjYej72PSlFVNcNhIZtNGskAoLWRoWelIhH5QBQ9gqbY2oTf+I3fuLyYh/j+V7763xJDmtqm8QBgDYQA8gw9fHj31tHx3t7eel0SQU9Fjq32DhweHgKAMSYE1ydb2KpcC3k+28RQB3MBIMmqMVCWpJPJaLUaOeeIrhkiIopRAcSqrGWWLDFWadhUpUksIobgBlk+nYw18u9+9bf/Xz/7/9zf2Y3BOddYbaJ3yrQGS4BKgTCSiYQKCQBenp//m3/hz96+c+dyPssGhWFWxUFdN2lh6so7zxXSixePP/jg8aDIINLlxXxvd6hssrOz8+3vPv4rf/W//+Yb93/lV36VySskCo2yJkssEdy7e0drbYyK3jnnZProh+c/N7u/ANfyTgDiSAykuK0IwxY7AnRlZCKKdKW+oLUG1FpbpYwyRhj+ZVNRIADQSgFGZmaIDFFuDIKW4LLLr/ozZ0RlUJBNW2JJzFQUxd27tx8/ftyjD2Kk1Wr10UdPbh/v37t3j3zUiRUO6xsO7CqfQ+ipK0HyEb7mh0Q9YzAYPHx4/+ho6urKKtRaJdKdUGhFklpxoltCVMUQdVQ6WFBaGSIVDIYQiKJWGhUwECrQSrepWaRikChlXFWjQWMMU+R+SIlec/+2zxC2fG1/XTdcae8PoC0hXOsc3/hD3Grjb2+I7fdsp7x9CsVd7bofpWiH1ZiZWczN3t7ecrn0LsYYe2IgYRiuvVNKiWhPlmWL2Xw4HK3Lqna+yFKpFiSJURrAsVJKdZygmju0XddsYbq2sxkiAxGwBlTKKBURNQBkWSZZV11XiEBERZaFEBRGjREZNPJonK/Wi7xIiQg5GjSYWu9cWZZJYqw2IQRWGl4Bovfrpq6PgIOMmeNNdQ0p4kntFxGLori8nIvEV1nWodN4v5ydxxgzmxwc7FlrB8NC4aHMGibGNq5K0pHRaYwxyVIAkJIjdUy8sk4a2/GPKExkiAJL7oPO4DxHgg5O5b0HYFFPkqRKeBBXqxUiWtvikhBR2FQYSEPrhntkjTHGBS9eRBJoGe+R52t2ORciSTnscDgU39PqIw0GElsPBgPhlVwsFkqpNLWnp6eT0dB7v7mcTae7xiQEMB5NbGo9YJYWQusxnU6NMUarxWKxu7vDTKtNLWqGqqNOlBhFvCAzE0cxO0meRSI0WobKEkoBgIEq76X124/6COxodjGHAbSTF8xZlsmyiMKj1nqxWMj6j0Yj4YcS/kUAKIoCWgBzJjVkqf/L8K6YSIE3yoeGEJwLWtt+GFequ2ISiagJXljZNXNVVcPx5NmzZ1/96u8WRfH1r3/9Yx97O8vz2Gp7iKCQ8jHUdX1xcfH4g6cAoDXkeSqb2RijlWxRkETfGENUx8iBSOJIeWdfbpFk12pjBoMkSazV5+eXznOWpLvTSXB+tVl7H3GrXhpjVMrW3i1Wa9RGaxyNRkxYFB4AFIM12ij4wfe+95//7b99tL8XfCOskqyiUoohKFYBgBl9BCIgBkBT1vXJyeVf/Wt/8f6DBxfzC5sXngEAi3xnZ7c4OXl5cnry0UdPv/Pt78ZIWuFsVh8f7n7hY2+kWZKm6WK9GE3yT33qE7PLi/nlxWa91AiE0DRVCO7Rg8PpdErRR0Dnm95UKqVucP1u2/EbIXtvE3oQssxcAgB0kx2xYxPjbtIvhKDQSMONiNQWM64cWClJc1utoH5aQXXCQiK8G9sKFm7bduZour5LW1i31ngfmePOzs7+/u75+eVwOJQxD631ixcvzs/vHR8fczvsqLHTq3mty9kmzAIAZtXVLAEArDaMCED37t375Lsf/9V/+aWjo0MJ+a1WLZlNp2MjzREiMAhkdQs8AaAI6/W6qoICRm7pS6xNQEPwjhmEBGCx4EQbgyo2NQMI17loPW771OtnKwv2+vuLXVWt96Pd19emmG68offBsOWktz/01R/eOFTjnTIaFIowJ3fqLuJgXr58maZpDKyVGo1Gq9VK4uXZbLYqq6Ni73xzvtls0jTdVKXw/jOzatCHZjIcDAYD753WWpGUZYBVF88BsuoK99xTvcQ+SpCiNCqDQADR+6iUCcGnaUYUU5sE55VSDDHLE++9UkjB5YmlGDQKWUsUhlxjDIDykQDV9nJtB3k3FqrTkHjNr7gFYbEMziGiuENZtLIs15vl4eGh0gMfmqbcrNdLREyzxCg9Gg3mc58YOxi2fExNaKSA2avXiR0XxBAiiq6RbOMsy5r1Stiv2rFLbhn4pPgsWJ6ObbHFum82m/V6PRgMkiTxPlRVNR6P+2dYGy3QIW6J+7Gu6zRNszRdrleilyftW2bebDYcWJrKgoVuscfOFUWBiskTxdiSQocmy3tK6pYAJwSntdlsNkfHd7XWTGyt5AE6y7Lzs1OJ8HxwVqeIbT9oNBolxgDAYrFI05QpZFmxXK5NYo1CuWTnBQOVCTI8xtiUtQCjhsPRcDhEhh7CvVyum6Y5PDx0tUeG1WKZ5q0aWAhhOBwKM6uIJgkeYjabiWcVDmrJMtM0FdkMZpYAUcyXDB3190WWSCpn1toYua5bJhBxxkJSprUWUGTtGkSMMZ6evHz33XefvThdrsrBYLBar2Pky8tLrZQxyqACq40xezu7O5OpAMcAFCBCBFDIHAF5Z2eEiForIlLKRK7bR6xV41AAUKRt61d+LvWbLMt2dnYkXtnDPYnRQ1h3tUh5gpAVAmPT+KqqqiprmmYyGk93xuv1Wg8HTdN8/Qff/9n/8v9x6/CAog+NQyUT7Z4jURR0MIQQQwACBEZGWJer/+n/7H98eOt4U5bFYBwYfAzEfHa+vrh4/NWvfvUH7z0eDnPnKTHw9ttvfOrdjw0HRZraxXJGzGmxn+f50fHB7Pzs4vKcKPgQgY0xWJWbhw8fjocDxBbqmCRXOMTXW+cfngHL3DAyMERmVsiISnXNq96adQ6StWrHuxERlTEmSdPUJKm0KvqEqm85SUAsHydbSHVg/qsuQGeUiKhF0wEAtl3otg1ZFMWtW7cuLmabzWYwGAyHQwHX/eAH7+/u7j969AAAYozGtMIm/anDdX92Y40QNQBFYGmcFMNBVW2GxfiLX/zCr/zKlzSC1soolKqg1T36l3uMVZIkhowEF4hI2lxNhmidWsvMWsFgMIi+qV0wWk2n04vzc2u1czHLk7quESBGKRpc6aV0vcNWNxfauab2g27Yd74uyNP/8EahG69XqrcDsdavbIlZ9ner8xlx+8R0p6EmwbtSSqgKVKfpm6apOFd5UCnCelUS0XA4jKElVzo/uzw8PMzSwjVhtS4V4sGBdS6G4Oe8Bm0MMKMCikmCioECowi+SJ7L16ITAEXsumttGx6olSIj90wpwwxKafkfABAhBH/lIpHQXMNzAQADiN4RvpLy3lhbABANzr4HIrDp3jn1R5bkcjAY1I0Lng4PD8/OL7TGTbnabDZJkkwmk1uHB/O5DSFU5WYyHtV1OR6PdyZT4SCUeoPQcQTnffCi/S6oH4kIJUOCniQWwGgrfjo4L7uXWUTLvZRMe7EdqaxGptVmPZ6Mm6aZFNNmvkzS1IcQvAfmxFpjNBBzJLOluSRhNHd1MymXiXRuURTCEBJj1NpW1VxOVWZnlVLO1z40aWYR8fT09M0335Rjys4hitbq3d1dOXObJOVyJewcgtOu69JY7Tx2KooWsYkx6g51pbWOQIJEk/lvof3RWooFwMzWJnW9FMSZ1rosSwYqslzwxnIySZK9ePFCyAVGo9FwOKyqarq7471/+fLl4eEhdQgpY8xgMPjoo4/29/elPH55eSmOE7r2geAn+rp9nwpLl1reIOwrsj2Y215An7GIEJk8ic65xNjlcvn06VMi+oVf+OUv/IHPP31xcnE5994boxRiCC41ViWptXYyboFp3vu6dkprREYAVKrclPdu3RqPBvOLc2bJfVsLQB0xgJwJAHjvB3kBSMaqPMmA2DlnrQ5BFYP8+PhYyDtd8N57IjE7rYyj9977uF6vk8T4xiVW3z469In58PnTX/nlfz4qcooeIimNHMmTBwDURkXtfCRgIGQmpdGH+P6H5//ev/e/vnX7zmq12ju4VdYNAz59/vIb3/jmN772zdPzS2MQANbr6qf++B/5xLtvH+zt1tUqBOe9n0xGIbLW+u6DhzHg+fm5jHjEGCXZJArGqDSzTVNFCn3mo1sShZtGWF6vVhmhz2sjyc5H6htqLNtSorEewNz7L2OsUirEmCSotYyiteW0NlFhkvkiDex9E0KblIqMtOrobtQWO4qc8NVsDGCfkZOoJL399tvPnj1bLtfU0e8BwNnZ2WKxqKomTW1mk0hR0ArtEQCAX5N/XCVJQuYPbfjJzBSjc/Xd27f+6B/+3Je/+rtHh8cCP8mSbpLSWufqG4mjrKzWmhk1qmC1AqO1RgYiVsDj4cDVVdPMjQKjQGs1Gg6qSi3L0igNXd+aiJhCL+u4dc78qowgvJIrv+6HcVs4aPs9/ZnDdY8OW/57+/9tb/3DToBbAQsQltGXL1/2aTF3QhzcUfr1BcY0TZ0LzoUsy/JNlaTm5fn5/v5eWZZFYvtPaXuxMjnH/TxSO+TenslWkaO78wqUBgakDuvG0AO4mOM2boK29HsJFUOPXsZu2Pv1bXjsas6v6k/D9UexX7G+kFjXGwA4Pj5u+ZyVWq1WVuF0Or1169blxfl6vZb2CjIYY5LUWGsF9ZpngxaZz1Jyb++12aLm76kkZGooS1MKUQZmiqKo63o4LLz325OIfUQsFcvpdCqMsMZq77qRJ4AQvDSr+odZSLWEOwIZeo6tvb09aXxuNhtkmEwmSpk0TafT6YsXL8QJCWQ6hCDCA9IdXy6XWusksZKgr5cLBLXZVGVZEgFqc/r8xd17dxTgcrng6HsZKJumiFhVFaJ6+fLl8MF9RJRyOgAQYD4oFouFMWY0GnnvBaZnklS0jzjEiiruNCrWm41I88oQV2wFiJS1reiylN+rTTkYDC4vL5l5d3eXiGTCuCzLo6MjSUeop+iJUdZNugNiZOXgACDXy5E6aEXSlwZDCKJ0Kzhz7khMvfeCkDZKO+cI8MGDB7/wi/+3e/duP3v27PTsXJtkMBgIu6e11sfIde29r8q11O2HwyHiZrOpjLVVVU2mo3IDDx7cGwwGl2cvjb4ixbuxpdsOZYyo2BjDsW1J7EymQLwyq7JuiGg6nYYQFouVcy3Qkpl701eWJbIb5MXuzuTi5VluzWY5++qXf8vXFTAjsYj69nkeEUWHxKqsK7DamMRT/PDJ+X/wH/5vHrzxaDFf5uOxd7wpm1/9tS/95pd+a7kqJ0WKAAr4z/yZn/zMZz41HY+8r6xRm7UbFDlRGonLjdtUtVbZetWcvTwvNxWiTmwWY2SO3vt3P/lxRFYaMaI0SyX6v1kGu24f+tPeNuwUhPoqEJHItAAS8E1bzR3/sboiEkcZRZLJyxtGBoV7KpJzTjEopsAt1g8Aul7htYJra2OZAK5kaAFaDBEliQGAR48efeUrX5GqFCIWRbG42Hzrm7+/v79/eLjPzLGrfQO+xjMBAAN1Lllxm04CMGitbWIisbXau9rY9LOf+5Evf/l3E6NcXSZJgqnlljPTSQVve+fxFXMyIGJitBZWemZRVxoUmTk6WC7nTVVOH94/3N+NMRZZErmt0ccYfWz7Z9hOR1xNjjKzkHZsb328Xkm+Yd+3XvH6t9cc+Y1sGF7xFn3Itu19u1PCPrJTIHsHiICoJSY7Ozu7deuWVBr7OEu0YqxWRFBVlfdxMtmpqkp6bHmee29ms1lR5FprqzRx7IPEtvUkSISuMAOAQLG7in4KnAGA2pvAzExAwLrdF53/Bo3MhIgEijtYWS/zAF3bAhEQlOo896urjYjA6sauYwSNugsErjDJcnDd6qoqIorRF8MBM08mo5cvT/amE2YmjkWe4d4eUajrejQYSjQDjE3tg6cYWNywVAUECie8KAcHB5vNpi4r+SxjjNamKWtlTc08GBT7+/svX76ULG13dyqiwiE4ebhaUb8YJZCSKrQUq5fL5cHBAfXMoLGVLZE0t699SWTknJdnZL1eyzulW/nRd77DjEdHR9bazWYj4ID1ej0cDtfrtQztiA8uikI8d5pamTM2hXnjjTfOL2aj0eRyPh+OBtZaBTwY5qfPL40xi+Vca31+eSnCSmIrqsYZbRtX90RUUugGAGk2yygR+WCMcTFIs1aYIrTWRqtNvTk6OpIBJJkvEopmCU1ms9l6vZYO9GAwkHkkyTkkngCAvb09UYLqAXHUzX1J4iuBab+eEu5JM1hgaPI2CTL60qK4agkUGlcpzEySeu8Tm6Rp+nM/93N377/xg/feL0ZjbRJpPwNiCF5rTYwxRmAWwLZsoSQxIfgiT43SyLC/twMxABMAyaiqpHr9Zoa+xkMtiIxbtmGlDRaDTCIPTpK9/V3V0cs33kmspjtSbiQ2SjdVfclxfzp5/uTJy9MX1WoZfNOOI7YDv8AMPsQYIwd0PqKxEQAYvvnd0//0P/n3f+RHP3dyehZJfe+77339a7/3C//8NxRCIFAIB/vjv/DH/tjxraPd/R1EDr5WSHVV7u6MyBNo4wKPx8Xpy8ff/c77xLiaXSqd1k0ZAqXWVFV1997t4bBgIABCbPMNAUD9/+KAO9fWxhzEgbs5XcXU5WzkvetXcvsIXVEHiSGxqTySwriw/VkKiOFa/Vkz2SRJWunf7h5tSfbK35rONnYetM1iZReG/YPddqJAFIaJANTTp08ff/DhaDQqigyBqeMiaM8GbriT3m72C6GwU0P2rjE20RpjcLduHX3yU2+vlm39oXNCLV1c7xclq1OAgAqIkVkBW2ut0VKUSES3xJg0Te7dveOcd3WVJbqsQ5IkjBKrcgiB6hqNlkgWABRyBOpCkNbbXbPvW752OyN/nQ8GuHIbXXADLGOs/fuZWaPGroCKAO3X3H3dFQzEFSMgiWDW1WS1PHsBEdfrtdggoQiQ3ybaGKVWm00+HSNiCFSWy9lsJnCMshQ9OCw3dVlWaZqGkLYblFViGRUTAEdWCgJfdYEFaQXQovS3VoClcMPUzjXJTFNX1cfIxKCuj88rgKsFQUQmlF4VXV/b7ToBgga8+pNeyVjAEX28gpJhI0GHdCWGLMu8i8vlcjAY7O/vLxaL+Xx+7/5dYb3Z39/lSL5xaqS2uwzSOe6ewBhCIE3CJSuszoJ/7rYNpmkKsdWbahonh0rT1FotbERCCqE1TiYTCbfLsizLUhCwAtNN0zTLU2ttXdfGCPwV5TQkPJfJYwBSCpVKkyTJityYxIhAggunp6fHx8fHx7eHg6FR2lotok91XU4mo+Vy7lw7DSxPQZ7nQuUYAhljd3d3m6Z1ikmSHB4enr548fjxB2+8/aZbOSLSRtVNzLPicr5IkjRJMmvteDxFxOne3uLyMnTCLXLCAuGWHupqtWICqb3LMhpjgElWWHihEVHqAZKy70ymXZdaD4fDljI6tnNEfXF1PB5XVdWX5WXPSK1OrrQXWfLeS1AiE5j9gy+ps9xoYxQzCysyIsrayt4rsjzG6HwtDT/nXFW3A9bQMchKzAdSbwNDFNMkqeuSmXcn08FgILFXjNEYnaagtfauUcAaryCuzG1zMMZosB+GUUREIUJHER8E+JOaJEmYG0gz3pl4751z3jcILZpXEg9mbuoyTVPyrt5svKtDXRmNsYnMqp9FZOYYObRQkEiatdYuhG98//n/5f/6n73x5tsfffTRD95/7+d//ue//OWvEwMCRIbPfPqtH/+Jn3h0Z6/FXmjwPhgNhJxkKTNHjUoZbWxejD5KXv7LX/31j7/7yXK1joSARisCpZfr1R/44ueLovC+kYQYW2UfRFAKFfGNbAe65bpZZeQtgQBmRoqw9fN+pPCGAe8ro20Wqm2fHXXvou6pDyF4lmY+oun0yuQ4JDZd1nOLosDAa1/IWiut0+kU33jz4a//2m8OhxQjl+UGAPJ88MEHH9y5d3c6fcDMEaL3vsfN8hbO6LVL0546sgQZTVNnWW6MmYzxs5/59D/9+V/c3993zmHn1/M8l8pVv4IoOZh0RLRCpVihUlY4NiAxWmMxSNI0d3V5fnmJwGmWNE1jtTLDrCyBmYM2FKIQR6xWKydMoZGVQYrILUTr9RNWN3LTHxaIve5X/Q5oDwM3de+vPgK2Ng1ejSJcvfoFl+ExmfGX90vM3jRNojBNskt/SQTGtOMxy+VadWORBwcHaWrn8/nR8YHQriFqWVsCZk8oOCzqTltqwm0NX2HLyI0R+obK1aW2O0HAbgwAIDxWwtnCzAqVpLgdRSgwAwMBKARAgPDKRtreY5KJ8hVGGxBFOUKcM8q6CW7EtxUnNRwWzHx2fhljNhwOHzx48OTxh2VZHh0cCmAqMVYUC7q5uJYEQ4DK2BWmutQzikUmImGTkBQqOl/XNWg1GAzEjssoi/e+qipBOwvFxGjUUjIlSfLi9PnJyYn0OOUEhsMhKqjWZV/2lGdBHIOkbT19TwhBeyM0I/J+EVEQGgrn3KDI14ulBvSRUmNNroINRVGcnp7iaOyqer1YjooBMzPxzs4uxAiw1soOh1lVVdraJDFHR/fPT07yPD2+dSRsl9bawWCQprl3UaRqARSHEGMMPmqjZHhdtnTajVR57xWCQlBaxeCNMQrR2NZNyvpI/C0IZKEGk+oOdzWwvb299Xq9WC03mw0iStm/v1ntViTCjgxEng6pEPS7yHTiwY1vFQ+ZRZjIM5O4f+qQ7dK8VxqIgmIQVFSa2TzPl6sFAsjskI+RGVErqdqBQmABqWmJrsgHpRGBB4Miy1Kt9WJ2kSbm7q3j9WqJiqvNCgC0QWYOwWvdspD2+RwiamWZucdFokKlVJIkMlwgzendvR3hQ/Xes49GIZCiEIPzaDC6JjKtLs+1AoyhKTdZkkZqlWEjU4zsIxMjoPYcSCsX3NMXF/+n//P/4eDw9n/5s3/nn/zCzz998txqEO/7p/70H/uxH/vcrVtHSqlYL+t6ba3VSjNEbTQRYjtBp7wnYm2tPTo+eO+DD27due0dOReAEFFtyuqNN964c++uYOalfqok/AYpuirm0FvC3urCVsmw96DUKQy2llf2BpLQcUhAA0KZd4VxaZErAO3gOLSCLrYzRK3ICzMIYhERGQgRkySR97de4BVEmHzxGgfMHQKoaZrEprdu3do/2N2sqyTJ9vf3Y+PKsry8vDw5Odnb2xkMBpEjXPes25/VW97+yCCLh9g2YKrKeyfUufcf3BWRcESUCBRbbLaVH8qf966IiEArZtYoinNtNpwkCUfa25l63zDHLEtWq2i0Go2HISqWkk4CzJEZldEhyGwsAjEapbSMmcuG/qFAu9e+bkQeryZw/de4JeXU/2Tbs8J1HcpuQ1yrrPZfyIONqInAmMQo62rvm3B0+3AwGCyXy/39fd1KTPLJycm9u/eZmvlsQUR5ns/nS2DlvS/retD2TkKMkUJUGhCRGKX3qwhk2DwCSxlcLlNJE1d2JBIgAYicFyDxFaD6leXajiTgKvIQ960QXpMEI/RsOO0I8tbWkqOB9Fa69UFQHIFDCNoYY9KiKAaDZr1e2rQYDwef/OQnnz17lt5NsyxJbZIkien0dDuPa5TSROA7vSMRNjbGrNdrRA/dEy7bVdyztVYn1ph2iE4ybGGTmM1mcnzpTG82q7JEpcytW7eIKM8HMcbFYiFvFi4z1en+dgvFAEkPzZPjMHP0QWVKHhnJ+c7Ozm7duvO9733PGJMPW0VSKUHv7u6en58PBoMsy0JwAHB5ebm/v98KCiEuFisiGk7yl2fnOzs7yqr9/X1UEKN3DkaDQZ7nlxez3V29u7svYz/WZgiCQVPr9bqXju8pmkMI6/VaUmGZhxb/Kj5PKVWWJSIKsbNS6uXLl5LDpWlal5VSSrBRQid5eno6HA6tNmVdiRChjFRh25Bu4dxifCXX7Pu+ki4LYhwRy7KU7UStTGEFACJ+JZQRbeXZKq21AgMdUpI5IippbL/zzoPVRiBm2vvoZQAUWCkMMWigGCkGZ60OTajr+vT08s/9uT+plPoH/+AfGwN/62/9rcOD/eXsAiIVebp0NXTiekQBEUNoC4RiIQWTJVvCao2mNYxpmnoXy7JEhNFgOJ2MmXk+n8slKIUx+roOidLeO41cpAlSdK42SjPIdBEwQ4zsAgWKQkbdkGaGF2cXP/2n//T33//g3/n3//enLy/zzDKAj/C3/sb/8NEb94+PDrRG55uq2mD0CjmGoBATa61JjTGqawqsNpXzVFfre/du/czP/Nm/83d/7tbxUZYlWZrkebpabf7gH/qi1jpSZI5iUrpQA5gZIt3Ij3o7sOVBr8YCmVlJF68j2IOW+ipuJ8e95+5GrttSk9Y6MvTGavuzZGYthoAAMURltLXWIEQiYECtsEu02vgA29TObNu+7ogy12jSNA0+Tqfjz3zmM1/+rd8uioyITF6s12vv45PHH+3uTu/evQsajDEMV67i+nJwZ0O5/xREFiyaMUrYDARBsLe39/nPf/7Xf/3X8zzvIZQdX8zVg6Q6Pn1ZBQUEUquhiFonqRkV+Wg8YIjj0QAAZBi/KGpmHuQFR6pdI96orGuttHAphxbl34bPgAxAQgByw03CVpzV/9/FH9fZifn/C5Krv983fMyrR2Zm6kSstk+pfxsRaVQcSQEaY+bzed/bOz09/cQnPoGIREBEgkEV8+e9F8xeCCF0xPRGqdC9LBttWtFC6Iso0H1PBlCoOEhw/EQkHHUA1L4FWbV/xQCma950ECTuMlaGNjMW2Bag7NE+1LhaH+6kNaQPfHMBNQDFrmnaAsuBkiSRPEy6d8Nh4ZzbbNYHe3tJkty5c6euy+l03AvHhhAEZBUCKdVilIjaaVHZnzZNeqciZyvPuXM+0SZJEkKQiR256slkUlWb9XotIWZVVZPJRMaQAMBaa6OR8rIMiYlnGg6HFFqwhZyeUkrrNrqXeRjotA6dc6ZpEHG1Wp2cnEhBWwZnjTGr5bKqqtFoJO5Zpo0FbUREIqslTe6iKJaXl8IZXG4qcZl37t8h72YXc5lYe/Lkyf7+vsK2FoqgnXN1VW02m+FwiFobkxDRfL4YDAtZmfV6XRRZjL6qNkme+KaVHRSnKDIJzDydTsWDqm4WCACkwSwpoLV2PB4XRXF5eSlZKTPPZrOdnZ0QQlVV0i2Wa1Ft+78lzZWFgm6wRwrFUinVSltrV6tVkrTzEfKkyLNgjNEG+za8Usomyns/KgYAal2Wd+7c+Zmf+Zn/3X/0n967d/tisWx8S8BCTBpVCFEnbQ0gBGdtC5V/6623zs7O/tSf+smf+smfKNLk9ORF4yql2r0UY1QaVMcmJLUr7krlMUbgdgjFGoOGRZYqSZLhCETnA0BlWba7g9L8dM4xgFTUd3d3QuNicE1dYgxW6UieYwdEIiaSP+JAHJlcNAB4dPvhv/i13/iv/t4/jgxpCvnA/s//F3/zi1/4vMIYvStX6xAJQixsGiFoQBeJImitQxOQEI1BrWOIe3t7T58/U9oQN5//wqc/8cm3/87f+YUffO97g0G+Mx3tHuzv7+8zM+BVVtr6FFTMSipf/Loa5LbR4A450X8NnbYgEfeLLH/Yt0tk5AygjZKNSbaPDABCkoiKgSDGGKKTCAkABPOPiJ3YK/eJ6Q0v+WoG3PEcUUBUMicwnU4PDw9PT0+ttS6CMN6dnp7KCHyWZa8txPev/oP7aipAK/dLFBBbmWvxqg8fPvzKV76yndDIiJExSQjysAQFKKS1iKiR278EZqWMVUWaDQaDzCYy0rdarYxJd6fjixlba/NiIlmLMjpJksistc2KvK5rF0KMZNOEmX2nO/baVx8BbbtSefVVr/ZXyL23uOFZtw/AW4kgdDH49sdhh+jro13eam6BmBJ3RctnrT0/Pz88PJzNZswso2KirC6HEsBLXdflpgK4sFm6rspiNKzrOkkSMkbqBDFGozT8EL43RlAAzKrrVSF3mi0MEbDDFyCQTAtey1YVcpR89l+91Nvr2dUI2la6eqXZwVv4tRuBjtYmSRLXTcvkeb6/b8LL8+VyOZ1OR6MRUByNRq5uWk+52bSOLbTADcRWekjW2TkXmYgoy7I0TYG4S2oTGf+IMRajYQfEaDNXGRXDrocnvkHKrZvNhhGyLKuqlshpOp2K2o9RWrgYdafPiFtgYLHyACCUyFLjFZN9dnYmNXBr7bNnzz72mU+E6LVRqUqCj977yWTS7y7pOneOPDSNn4yHMUZU6vDw8L333jOp0cA20cwk6XWMUWtdVdVkd2+13GhtQ2jDuNViMRqNmqba2dkBbHdvCCHLMpEOTPIsekfBByaNygcnrdk+GwYAoZTpe67y1MtT8OzZs/F4vL+/f3Z2lqbp4eFhkiRnZ2fC7y2NZOzqQ/3DQkQy6CK+HDqx4a4+FIno7Ox0Op3KYva+XNjKANu2sbzT1dFaO5s5YwwrTQ188YtfONgfP3/+fLp/AMoJQN173zQ+z7Pg2+EWIjLaxBj39yff+MY3/uSf/Ol33313vVo8ffxhCMGgqlvhrNiiq3TbY4IODiYmvmma1CZKKWw5OgwACGFPkiRCy9M0fjQaSRIvebx464P9fYOwbkrfuFQrF2MIPksTwZ8TERETcWQKRD5SDKSz6WKxeP7hhyIn9Mf++Bd/6qf++Gc+9cnEIkdvtd0sHAIr1MCEoJW1McbUWGZUoEEjMxhlmCjLsrpc7+/veorz1fLBw/t/9s/9uR/84PL3v/Xto+HwydNnDx78wSRJlAHXBOywygwRQXeKBuo1ooNdC6q3GL2pRESKBB3CtLeitCU53xtlbvtcVxrkzIw9M4HCrcpujLEFrmJXsm0HaIkRFW1hXLbDAhQu6CtrCiAtSQSwqJxzEDlEt7s7vXP36Nnzx4NhGryKDajE1iH+3je/c7B/S2ubppY5RgpJmroYlEKl1GZdpmnK1BacAVipK1iWkJnJ8GjslIuUwfEkf+fjb3z9618fDEbIqtqUWZYBiZBcKzjoyQMicaBIrGKWZaiQGRONibYcKTqXaDyYjGezWW61VmCSdDQYKGO0Joplkau6rnJtNhjzNB1mqR8Nzy9neTHcVOVwOCpMslqtHMcGyJjEew+gEZGYrdUhBNWFkCEEZkzTtGk8IqKMr6BsAGlCXvPW2HdzQZQnr+okvZXvvXX/5v7Pow+olVjhPgqWNwSKSZY23g2LQYzx2bNnt27dMlbXTeW931Q1Ac4WS2MSZdLlpsyyzGbpR8+evvHGG5nNUpMrNrWrq6ZJoqCWWuSI9zFJEiBUqoVECileJIrgmBlJPKlsWYUsmkURwDCzgh5KBmJ+iBmQ0CgWQUMEifw6/9265Qh0IxBRSkn9WZ4w6DZ0v0S9SoQ2PTUHKNSKFQdWhJow+pCnWVR4Pr+4dbh7enpqNKfWhADOOWF5DYEYtUmy5XKeZZnW7Qi/WGH5rKbxWmNwsShSCq16eYyxKAxiJv7Pe5emCYAWam4AsDYtimFVNXXtqqqZTrUQ8AKonZ095xxHCMGbTAfnow9G6cY7tDYfFM45oxVT1EYrrUFpIgZQ3sc0TbMsaZrKGBN9MMZkSVoMcpsY7/1qtciK1CQamHYOD777ne/cv3+fG4eJMXk6n8/TNFVyklUteJ8mlDrREZt0kDrnZpdnh7sjt1ocHh6WZTlfLr33t+7emc1mLf4oNMpyuV7funUkZJ8HBwdKKVgtnK8ROUksEI1Goxi5KIYIajKcnFcngpNLErPZxGpTxhiZqNpUSmGWZb5xvnHj0Wi2uEzTdDabjcfjNE+YeWfv9gcffPBwOBhNxhKbS1l7tVxXZQ0AWpl0YCXgdq4hClprwdykacocm8alaUrEWZaE4NI0Dc5rjUdHR+J3xXAbqxh0iG5TksxAS9S1XC4pQpqnq9UqYTAGqrqaTsb/4X/w7/4v/1f/Tr1aWGMDEVIcZHnVlM45rSwAhRiNTQmJUSmjf/mX/wUiI9B0NI4+aK0j6wimcrWKrBgUAxAhamY0xjTB195prSVcixDIBW0QHCm0xhjFZK2unc8G6dTszudLrBtQOBoNNAdD1Xx29vDBvRBWy7MSmQ0H7wISoUbvvZgsT+SJQ0TWifN+1XibJh++9x4R/I/+6l9cb1Z/9I/84c9+5lMAZI1ZzuYhBIKQqyTaxDmnDDpXR+10qryL2liZ+k4S7bi0RtfkTJYwJhmm1fPyc+/+RNyMfuNLv8lARCFGeOvR7TxB750FFVgBM7CKCIBC0U9aaxMVMzMxIffhrHizXnFHI6BWgYkoIkVBFyGicHGIkWCGlhmVaLuwHxQaqyExESAyKESFioEVMqGwzwZuQ3NixtKFPM9tMgokY2+WiKC1m4CAgJ2FV4jYaRy+GkFIVaqHUN+/f3+xWDx9+nQw2MnznIiWy+V8Pn/y5Mlo/HHvwRglCBHq0OH91EHv+fvI4nVRS/ueQZF98t13v/2tb2VJWlUNIlaN64HKfeDQH4eZBWJnUUm1pK8ODYb5bDG31mpjQ4zCJCDXLl0+ijDMiwhgrCqKIt2USimCfDAosKx8lsUYU6UBFKHywQu4NLT8JphmNkaPqBDBOSfD2gKH6SMdWd7IhIg9nmt7BW5keDd+jluveF0Cc9s3S4Cc5/mTJ0/yPJ/cur3ZbDblRtCeWuvp7q5rA+oWTHR2dnZ8fGxtKnq0qkPrOefqynBCzrm9nWmMEYi1QSJSgC3sqe1HIm61sZmZkTsG6WulY2pFSNrrfO3d78lPbqyD2uI67fatQkTZZn3IKb+iDuS/vbA3Ahoi4i6XEqDT3t5eWZZZWrT9HlR6S8VIkk75IFlM2XJ5nitlBG8lbYvYUYRKYsrcEkwKukqGU+X9y+Uyz/OqqqTaLOcpCW6vNg/dwH6e55JnQ9c5U1sEnMa275RMMca4Xq93d/fb9oG16/U6S3ORAXjy5Ek+myulRoOhEJMtl0upn0s6ldpkfjnb399rmqau6+Ccc36xWAiSq1ytRYhX0GRS0m+zf4ByvWHm3b2p1vru3btSAFgul87VSWq8b6IHKarLWpWbtSTf8u1gMMjzXODWy+VyOBwKh2I3rxWsTb33wvQUhFUZYDweS5tZYMyS6DPQer3e39+fzWbGptL3lVsjyZ94azltmUSSDl+fDMnXPVeBMKX0QFmpeAtuC0Gfn5/LXDW00oH0qU996j/5j/+jf/d/+x8MhyMfKAKv16s8zwJFYVuSQCHNrGS3u7vTf/bPfvXD9z/4a3/l38rzVACAANAXtHirKykrJjwq8kpNapQOIdgkres6SdMkSWrvBBDTNM1oUCxjKNerncmkKZej0Wg8yhFhs1oJvS93aQADERNE8i4oY4N3AXSIvnYeUc/nS0/wd/+b//yNB/fXm6USZU7X1DXZQlMTys1Ga12F0qa6LCtWMRI2VW1MotAQIyJGGaDXCTObpNiUze/+ztc3pb/74P6/+Bf/8gc/+N5bbz56efJsMFDHx8cA7XPQ18kEgdv7ixvls956yAPfPlx80+QyM0Ps1ZDkT2krR+rfbIzR2iqlcEs3AbuBXaKglBIYslgGC5ilxXZeRERK6R+G1r5WHd2+Bt0xOsnGzfP86OhIOgre+93dXUFLnZyc9NtUdckHEQUfJQPoV6o/+I2XnIBGQCaOoWmaw8N9Wfo8z01imZkIQiDnggxgGVSKQYsMI0H0oschr8hA3jfaYJqmwtndd4CkGmy1LrJsOp1OJpO9vT2DKBMI4+FgOBzmWaINpmkyHgzGg4HR2miUsp5SQBSyLBNRZLl5SrdmRameS+v6JeOV8+iXmrZyX8Rri9Pvku3lusII4DWnorqXTLAopURDZrlcTsYTsfjr9XoymVxeXkojUE5bLF3vAIQbYT6fbzab1WrVUiSGAACoVQzbW1MpZRA1XvHC46vnDwBbshZI1x0hwM3u+Gu9L27BoOT2CbqnL952s7Cm+3cTKN4eQbfGS0pDEs0YY8bjsRAeCYPjcDgUSZm+iithX/+UiuGOMVZVJbo64lzFrG8XaaRmJYGjiOGI3RdXJ/kTdCAggebKJ4pXFsLIPM/X67XAtWLHLB06JcG+BCK46MFgoDri5RCc/Lkk6yGEJ0+eyBTy048+KrLMKAUA5XojHvdw/8A3bn45k8pqnueptRzjzs7OZlMlSSZJpE7s+fk5EWXjcYzx6Ojo4uVZWZaypHmejwbDoihm8wu5rqapvG/kbMWWee/lkRQqShlAEqSVnPx6ve7763KxMsUu7DHCG8WMo1E7uCWXL4HLZrMRmBsA+OA25VobtVgsxJ+FEOSw8kHiUyVI6kk5ZHLJd6JV0mKTjrJEQi1yWynq0BKxmxKWCofgA5bzBRH92I/92Hw+z7IEAJLEuk6fToB1o2GRp1kIYbNZN01zfLzzg/ee/OzP/uyzZ8+sSUxilTKyMfpnQcRm+g0pJkhssgQlRJTlgxijCH+Nx+OiyJIksUblWbK/O/VNfbi3X+SpQlzO5jFGoACRiAIzE3bWO5ILsfER0CKYzbpp6uA8XczcT/7rf2g4nax9oxIblbZ5Bkbp1AZkD5CORhHVaGeqktTkqUpTgoQh0Tr3gevGodKAhlh7wiQfPnt++g/+4T/+z/6P/8Uf+aM/bhL7j//pP7HWVlW12bif/umfHg6HssidGbmCXm4vyw0bAtfcJDBfUxhs7Zhqr7T7+dVvb5ggYxKtdWesrsyLfCMEz3ILuGsR9jgGvN6HvnFk5ghA11Tit9/Rd02yLGuCB4CdnZ3j4+PLi6XoDVhrsyx//vz5k4+eJW89ShIjZDHCjBijqA+prc+72atTV5PULUM0EWmlAeDdd9/9tX/5G0mS9V0cQUgpogylHB+ZeyHC3sNda5dKdBkoWrFKPmhttGZrW7EUbdRkMhFzyUpF8sFT01QU/M50UrsmSQ2vy82myrNEKVVualSYZ4n3XhdZjNEY7Zz3oTE6kYKt0KNf7QOFyG0EwAoFMdTfDL5ySCQl7mt/261J/5Pt3dZvMnktl0vJRXp0lTBWLv1mOB4bY4QhSGhyEVFwWMJGVBRFUeS1c3VdWyvThIyIi8VyOh55HzmGNKbKtuC93ooBQN8JISJgxUg/hJHl2ohSf99/2PbYXoHW9eI1F97faEmdsasEbNcJrr+z/VZr3THpQJZl+/tWHHPwJOvGzCKzKtxVYoulDyS/HY/H4kTrupbYS6BPYt878tR2HkYsuFRHBccroYA0ibMskwybmdM0FYsvwj4iYi9uwHsv0AQJaqWTKgGQNP6FUjHP06ra9BGblNGm02m5qV6+fJkPivv37z97+sQ3bnd39/nz53lWNHUzGY5kgjxJkvViebi3rwAkRGDmhw8fXlxcnJ+fj8fjpmmE3jKUpTiqnZ0diQwkKZTudYwxku/vCEPMssxV5Wq1SlOLiFW1ljl1MVsXFxfHx8fC/iEbSSiOY4wXFxd379598eJFmmebzUaGjJ1zQrUhpFqr1Wq5XEoqPxgM5B7JYkoHV7JbIRqULwTbJfGorKf4s6qqhB5TeuqCh3C+ZmYZA+Ut9aQu6cH+a2qx083jDz/6pV/6xfe+9/2jo6PVep0aDS1/IfbmWM4HEVNrxdgeH+28ePHia1/72qfe/aRzrnYNgJL6fGsxkABU7MAZs9lsOCxQschhybXU3iEq8l6wWs43o2FeA2imi3IzLNLVctnU5eXZS+IAHQRSAUdmiTMjcSTWNnWOXCQCDoSbym/qZlikv/DPfnO9/o9v374Vox8Ni8EgHxa5UtooLc+RVVruYFWXw+FQI65K76IaFgNlzLp01tpiOFBK1w6//OXfOz2b/8hnP1E37ktf+fJ//d/818LSCgDvvPWm3BcOIjbfd5Su4MTMLM83MysGuqKaAKSWSY9ksWIkIoYIzKgYAPuubas6uO2e29vURf/bk6LdwCMRAQsWvR2glwNp07Lj9cZHKdWfWPdD7gCt/EPmgAEkVO9ngRBxPB4/evToyUe/URRDIkqSNM/z995777333rt3/440UZQ1wAyMSmGMUWvbpvvXYWnIxMywVUnGDvqfGNP48OjBw2/9/nfOzi4AEJQJ3ksSrBR5ra3Aawk6B8eIul0qrZUCVByj564dq7VmREMSSQWZfLdWUmhMUlOVzd7eHnnfhODDwDm3uzudz+d5mhSjqfC7AqgiS2SXKyatFVGUjKquGyKwRik0Pl6NS4kh7F3FdgjU34wt/yr0xVcE3zf8zY0bdGO79K5Xqm0hhKZpFotFmimZ/b0CbigVYtTGrDcbIprNZoPBYDQaJklycnJSZGY6nZZlmVh7fn6+O52EEIoiY+YYGC2zkvJvNxDFvSBa25AliAJHEu/4Ci/Y1k7Y2gCvvqe9TLrypjcCFEQNwIgE1731aw/Yv7TWaDS0sCyd54n40egajiQgIOZYlmvvG2u1gJLko2U7yUpaa50Lkr3RdUwHAAjATWhg5VbKfZEsULLM9XottluyMWut+Ly6rvsgSaRERqNRWVf9Lup3lPc+T9twWzI86pSJldKIKJQag2J4dHQkT7So9R0eHkYfGq6L4cB7X603QOQaNx6Py7L0PpnNZg8fPpxdXM5ms/V6eXBwsHd4ePHyJfkgrJxKqXQ4HAM8e/bs0RsPy7LEdmDBXF6uhVtbarNJatbrpdVChwtSEN7fP1ytVj44gUmOx2OOpJQRwJp47t6/yhUZY6qqypJUyJum0+nF2flgMHB1Y7Upsvzy8vLlyelkMkmsTYxdrVZgLTJQiI4bClFrHX2oNqXUnxtXK0CjtEZFIcYYkSHSFehJggy5+977xWIht6NVv8iyEII2arVaSxIsVaUQ3Gw2WywWSgMzZWkaiVwM3vsksc5509loo1BdDckwcZzs7vzar311NBrtTKZKKZNY2ED3hsgd6IGZyYfFYnF4uG80QpLWdSux3ESa7oxVVN77ED3EYJRSSBpJcyyr8sXzj1xVE5FWKgTPMkjI7UcIVolBOUeECEotF+uXF0uTZUmSMurJcPKbv/41Y74RogMZzAUZBVTIQF2YPR1PrbWHh/vjkZW4anc6KYoCkMejyXR3J0ky1Pbb3/+wqd0X/uAX/+Vvfulv/9//C23MZDw8Pb34sc+9WxTFYjmbTqflehFCkGf2VRsIrxjGG3aGe7AqEpOYC+yWNPS573aeo5TCjurEmlRr8RQaOnYBbgErLFEOUQtIVFprayKTUgpbGiJW2rLzEthhm3NeAb7Mq2e8/bWEe2iE9hoODg4ePnz4+PETQSIAwHA4fHby4gfff/9Hf+yzoA0zM3FvjLb/V1sk0b2BfDUtFotmjPrYW2+/fHlubBpcIALU4j67sAKuhKGgs85ad3AfJbMfSZYneZ5aa13ljLHOOcAoD0CMEbEllDfGMESb6DRNNcCq3GjFWvFoNIqcNJvNs2fPkzw72N/13jdNEyMORsOyXHvvh6NhkWXz2SIw1U1prJWT6aOq7SulK8rOdt/GTlVCXIhS0Dcyu/rqTQq6Gz6mu/Zuup9osVjInlgul2PMjTHCpibLJT4AANbr9c50ulg0q9Uqy7LRaKSU2myqvb2DGAMmyWKxjgwiqYSJCJmliC0XsXwibLnGdq9HCdX77aS36EeuzwuBlnfy9b5++x4Z+INrV7r1tb4Rmrwao2y/lEYZh1NKGdvSjCulbJJkSRpCsCqRKoJgYiW0ksqeXEg7dmJtH8rked7i8kOQunGPUe/upuo9t/yJHFP6OxI2yRt6gQ3xRr2PF8oIIgLiJE+hGzKWWyBZoEzEKgVyGkopgU8zo6jTF/ng8PDww48eX15eHu4feO9d3SwWi92dPUmApBPx5MmTg4OD+XwuSW1ZlvPlYrprJFw4ff48s0mM8fHjx5IOfv/bv//2u++G6N977z3RbiKi0WS6uzt1LpTVWhusqs2Lk/kwz/IiC8Gt10uhBHn+/KmUmmWdvfdWGykMmE5pijqtX0QkYGPM7u7ucr6QXq9oa45GI4EoywmIpxQ6676xLT+UtZJ9K9/2YHIpDkuE1H90GyqR55aRo31tmfUgzSPpHcROzoEjPXv+tFxvZMgCgLXWhTFGlHe6UjxR1B2xQ5IkGkFCqOPjnW9+85s/+qM/6l3ANt8N1IF4EUiBEkb9EEK53ihkq42sJACAwhgYFRDHRCtQmoIbZmkD/MFi9tEHH27WS2BWHXkLbVE9BxLOWWRENLqpmrwY372/7+DZYr0OBMogU/Pxd97a352mqc2y5Pzs5Wq1evny5WK+BoAEVWBSAMvlHADml2eRwRrwr8yUiEXY2dltvH968nNEQVsDQHmerRarj7/ztrE6SYZltWmfF+5Jaq+Moer6wdglwdLv0x0DgBDVgdScuwGN7npjb6L7HtN2nK2U0tYkSQZd2n3FIwmsACMAd40ARCQCmbO4cZJEgSj0lFid/WpFIAyLjtx1Gye2SXohSinoHOp4PL5///77778PkEm3Q8YnXrw8vZzPR+NBe3rtfLpmGdLtLOtrTeS2wWJmjWCUDt7dun20t7d3cTlr6zCxzf7bNZL/ARGUVt3VIhFBCE5pwxxBoUiLt+sOEQC0Aq1gWAz6VebokCm4RmttjLZej1XB0Q+LbDws1hXlWTLI8zTPpqNRVVUaoBhMhuPxpswuLy+tUeL2XOO98VHGh7fkCpiZOtT8FkbpqrKE1+dcmVsys35z9D3sbde7vW6SRuzu7kp5TWplAGCMqap6sVhKtO69x05RWDqX/bCs975pHDOs1+uW9yfj2WzmvW98kGoeBa+1RrQh+h6gd+OssFW9BdWJKMglwhZPVn+x3XpcRX5XO4Sv+sfbW6VzaZpfV0WArR/eeGmtgbGv3ELLaKM1KjHTRqM0yOVb1VH2iy3u/6QdBtWaiIxp59SFMRgA+uZl7+D74RY5N1l5uaei+dqPADBzjF5rXZZlT08hHX0pqybGNr5V7uu3ltA/yYlJ5bavhJdlLf74B+99P8+Ksq6qqhrm+eXlpaShbe+Q4mKx2N/fjzG+//77R0dHQtS8WCxms9l0d08ptVwuxUlPp9Nnz54Vg3wyHp2fNfOzM9FJm81maZoWRSGjt3t7eyLikue5Bh6Px42ry3KNiMfHx7PZ7OTkZDAYlWWZJe2sc57nClTfDy7LMssykRGU+rOcUtNIH1fLJSyXS4FGy7pJAi1Ttk1TaY1ya/oevCyaYLWkni/tA6lzwJbukOyi0I0jyi2T4yBi01RVtclsomwiaUOaWkQuy9K72DTNbHaR5kVZ1kmSAkDjXZsnMShUrDTatlsh+QYQtyhRo+raffOb33z77bclu+p3dW8k5YEFgKZpDo/2RZILEXVudZKaxFoDCFaRNwiJtUDxm7/3/nd///cQkb2LMXrnjNXIDAwRKHaZArW6AMjMkeDO/Xs2yb/2rW9VVZjsTgD1cn55tPfgL//lP5dlCZP0GbmRvkPkxXwVQnj58mXjKlHImM1DWa0Xi9mmXIpcZAgACEbBaLxbu8Cs6k0VyKep1YmOy/LgYHzv3h3naqtaAyhhKyBu9zTF+25bHhCIFiMjq57jiBiQOi6K3gRR73QBiSEyRInpW8eiEJTI4EL7oS2fFcunCD2w940cR6YnBLMph6B+OCWEHlDFbR/hylgZABDqrG0Vo94lSGDedzhijAcHB/fu3ZvNFqPR0BhzcXERYzw/P3/58mWeP9CmFVeMMaapAVAcw7bN3fYc+EomBy0TOqRpOkb11ltvXX7lt41VUqOLMTJgjJGUFB4UYLRKb+1LIOYQyCa68eKKjAKMHBKjahcTa5PUxhhRo9TrtVbeY88xFrzzTS0pSJINlVIKYl1u7t29XbsGgUbDYrNeHh7eTZJkMsqHebapK0QNxPOwNDp1JE0HjgAycUURWRqTvO01SRB8fQbfo41kfyjVSkTIjewxRzf8CkoVnkSdW/WdPwGYWGsbV5+fn7/11ltN09RNyz0EHYrHex8JmLmuaxmd1NqWZZnnedP405fn63VJBOvVJs9zH2JC0bARTNaVL2RpaVxlw22HmOn6yepuNGtrC4IGvBJ7afcDvyYi3PqJlrZK76G3Pe62ndp+A2I7s9+7RtWBuXqnKAxQ4hFNpz0n7UB5p9hfKS8z83ispWUrFlDavfL+Pl0WAyrGvXfnPaS/LMvpdJqmqQjmhBAmkx3p+wpNlex8wRtrrWMZ2LTUV7LI4r28b3Qnk7e3t9c0zXq9LorhbDabTCbj8Vgr44IvyzJPkocPH6426+nuDjA23onYaD4c5MOB2PFVuVbGpHl+fPu2jP3IZGo2HhSDfLGcK8AQwt7eHhAnxjLzZDJCxKLIAvFsdnnn7t2Tk5MsK/amOzQeEceqLpMkidGfnr4oiuHezu7FxcxaO8h3ZTWKohDyegGfS7N8s9nIBcqqeu/H4zEiLpfL8Xg8n8/Ozs4ODg4Qcb1eS/08hLCzM9lsgvSDh8Ph5eWlbGmJOfqlkzsiiXiPVpNgSO4acSDqlFo6sBuKpmxEIto4nyQREVNrhY/FGLVer4dFbozxjUvTlAldDBrVcDiM0RtliCjLEiJqQyWtfeN6w+29z7NssVg9e/Zif393yzh00XxXG0CGvmDQb3hpbUamPDWRIE2MQv793/vmz/+jfzSdTuezhVx4DyaIPjAgMRMjgQJEZgF5qeM7t533AeDP//n/3tls/o//6S9lmeYIn3jnPtDGQFQGlA6jwVBN8xACooa7e0qZGN8OIUj2eXpJztXaKOfKsizrul4uS9fE1cZ99zvvzRcbZY0ymGR2NrtYr5fz2eYP/6EvTEZDYB+8x44SR7UTHK/vLt1wJb3FkLXijvmHO4ra/iUCbF0i1FkP4Y8HrZWVjQDcpcVtpochRKVbrm9jTF27LEuGw2HsKAqkoIKI0QeTtRPn0JHW9ybLXJWLpVnL13IRyRj6SI2ZR+PBo0ePTk+/JLZJsP5lWX3zm9+6ffu2Nm3u1TPXKLjiEFdb2rd0HTDMHfSamJij8w0zPnx4/8mzp4tV6Zrgl0vXNEmSrNfOjIfGJiFcMarLfqLAWaKVbstBQkN/997tb3/nB4nNE6MQAIk1oELFtp00EDVNRKwqxxCHo8JYpU1irWFmq3E8LCY7k/V6PRqNzs/P93amk9Ewz/P1ZnXn9q2L2eVmXea7U46xLMska9t+67JEVFVVaQUk089dVtdb5L5HztdZNeRy+gJ7X4Dq91Z/j2KMgjUQcR7oaDt7X96TiBljxAz1+ZaMmsh4jPd+MBhMJpP55QURbDaVMSZN04vzWTHIWOuqcQq4aXxqEwBgwi41JyR5AIQ8JF75P6UVXLMa3aPSPgxdBPpqBvz6SknvXElS7O5P1Bajp8Qo4iklgO2XV7DNtEUjzJ2os+SUtCVOR1ukY9JYDVvcLPJOiU2FvMJ0ZML9TZQagxhWOY4IDcnTZK3t1ACdMUprK9PAUksUCaPeVYhIgFQ4jTHIIGoisv8BSJhJ0jQVmgUJv4xRSSfUvVwux9PJcDhkiqBwPB674IExSZIkz1arlQ2peHrn3HA4bJpmOp3+1m/91p3j24k2Njcffvjhyakej8fIEGIQzPzx8XHTVNxZrhCCtuloNPro8WMkRora6npVLlcLuZaqqoaDwXg4KtcbYWEz5lAmmsqyRFZSVxN3KyM08r8My0nxxjkn1BxyRwRv6JybTqcChdtsNsJZIbhlRBRabHm/rLC4LmlP5nkui7+9bSQ+k/JGO3Ek3jFJtyVVYksdHOUIJk3SNB0Oh8UgXy3XzIoYrNXOOQUMqBBYKSUzG6bjt9/eNvJZAHB6elqW5WQy2v4tbpEMy/mEEMbTVt7RWhtbVkDerNZ5ql0dv/vtb/13//DvH+7tV5uSpcQMSimFADFGiiwMjUQQGRgxIjJAVhSBYuCAEWxqHjy882/8+T8xHo9vTbOjo6NyufJVWRTZYDAoV5skSZiQOQAorQkEA0UASmWp2CUyOhmPM9eE+/fS4KGq+OJ8tlyu7966nQ2yYpgnySf+/j/8bxHgjTceed8YjQwUg+sDWdzCfhpU3CGZt+Pvzn+xdBNCCJIYSH1dAwYiafwRtSz3sePA6iyMkDS07b8oRmYLriL/IWII7SCMjyFJksFggKhJZq06IQPuZEkRRbtuKz0gZt4q9LUv9UOLePIKIRwc7u3v70sPRuCa0+l0vV5/8MEHRCTlcnGBEgT9K143LGxvqZk5NbrI07u37+xOxnfu3tIG5SFE5hBCXddZVmyLFbXPA7BwONd1fXJycn5+bozRCEYrrTGSD52Om0El40wCHKdu0FPoGwURY4wpy83OznQyGkxGg+ib0SDfP9hVCNboYZGnqT3Y2x8UuUY43N8bFvm9O7fv3DpOjD7c3RkNiiJLjWmnvrfmvqFzJDd7I1tr0tE6XidU6/+XH4q+lQRDYnRiN/LYuwoAWC7XNslkTkMeezHlMuICqC8vW5JYaaEhovcxRp4vF1Uts2exrpqqqmrnJXuOoSuGKySE2AanV11PRESlsWvV49brmkTjdr4LGl+nTnE9VrtSDdsuG2A7KIkCRO8/cfsIsFUYR6lFd6NN7UdAFCJruVnMHMKVflk/DAodkFVCYFk3uRFaX8Ho5KNVi9WnvpDTD+kWRWY6NUzJ/ABA4iFJAeWY/WCopGh5nhdZrkAoFb1YKDkNAd8xc9LJ9BKRRFcSmqRpWtaVSaxkjSZN5LHKirwYDr793e8Q8MGtW8ropmmaphkMi9n8UoDfm9XaCpuYc0RUFJmw8cUYd3Z2pLm7nM8VQPTuwYMHq9Xqg/feE3R0XZdZlo2GQ6XUycmJOMXZbJYk2XA43myqsqwByFqtNXrfbDabzWYj3rTvBcjmnM/niOhcc3h4mGWZQJqFoB4AlsulUkbaBKFj1LKtmnKb4MrGkEep3cwxyiMj9FjMrDSIneGu3ouIEKlpWpGl7T0gTWXnnKvqJDH37t/Z391DRKO0MUYKYNRShRMAqH7m4eqJ6HZpNxoqJyzBhDzy2xayqVqKzYuLC6lQxhibponBVZs1x5BabTR+4+tf+7t/57/aGU/Wy1VLp88tEydFpsjEmgl9oECAaCMjMRibglZR2szl+uLypW/Knelof39nZ3roHYWICpPNplmv60DKO/aemTWCpagia0YbGV0TtI51tWzqleKGXKUwlptlDPV4lO5OR++//72Xp8+eP/1ovVp4V3/m05++c3c0yFPJO+TpphaA1nlA3n6iCV8Zurjhv/pFY46oWnq1/vZR97p6tBUi6CRJimJobaqUUqj11rAlIiAycYt5jDESARqN2nYkU1uFcb55bv3XhEAIV7HVlelHfvXd/StGn2XZm2++KfHFer0GgCRNTWI//PDD1WpV17Vs0HZnMxCgcFj/K3zw9rfMKMmEMeb27ePJeLS3M/6RT32y2qxSq5UC55y2Zl1ulNG8ZVJluoSIIkHTeJGZY45vvPmQyBkNiVW7051WPbtLyDRgL2Nutij45YFXyKNhoRUeHOxba5LETobDLDEhOGNVltrpeLQzGQt7eFFkuTW3jg6OD/d3p+Pjo73d6cRqHBaFoLMRCIEUolbKCGL7ldfWkxb6cAQ6JGTs2Fq2/0RidpmZa8cNsZ3iB1CIerFciqmS5iJ3wXuPVTm/uGRGra1CPZ8t6qqReuZisaqqqm58Xde1d96FGGOgKL7k1S0FXYn4ygWCEqf8qhvu/5YJt13vtV/dDFlkNa6BJq6ix46poGcL6X9F13EWN/5WbT1g/SdG8tSRuki6JpmsZNL9cWJHL6w6xnbZPGLu+1smX/RVjSRJAKhpGhl2ktMT9xk6tkvvvTxfEiBKTL1t/TW23Rn5OMEZyXQZM1dVxVtw+hjjYDAwiZWfhxD2Dg/kbahbgcUHDx7M53MKfm9nV4q6QFEQEkBxb2+HOSoFiIzYti0EjLbZbGaz2Ww2K8tyb28vhABJUte1MFFLtdMonWXZs2fPdnZ2AEDIpaVK3IYmTD3TQJ6nWZbleU7AgkCW007TZDAorDUS4ud5LkAz4V6Vju9ms8myQpCr/VB73xSQTPfGVuStTChJEqXbIoesz2azKcvS14242/7p6wPi9qEDalxNPoxGox/90c+en10oBeV6ZYwBIo2oTTuFIh+67YNvPEqqE96QaKzfuu1GJQapLyrVVC3pqRS0OHgDYBGA+Cu/9eVf/uVfvn37toQIRC3cJ3Yd0AhMBBHa9JcYGFDZRNuUSWSqEBHLzWq1WoTgNuv5pt64GMqmrppaae2jK+uNpxghEgAhsWIAYiRGYKRUk+YQ6o3VSiNoZIhOMTH5nelwWKTL+fl7P/jON7/+tcePHwPx5z73I+PxUCspskXdvaDzvtteo/NU14xhf0Ov7BIF5qswX7Y6X2dMkrqCSRL5LCHfqFwDXUpxw2chcXQNUpsGyBAKM4uGLLKSL7atOrCScF++kH+qDwGuuUC4ntfDtQMRhTt3b+3v78rmq5tGItMXpyez2Uz4KMSf2U6PCQAIUDxx5Nd44quzVJpR6A89cxwNi9E41wj37t75/Od/dDavJRx2LiRJJhPJ1ErBAzNShEAQY8s1AwDVpjzY293dmbimUhgFagjEVrf6YogtNkcKHT14Ukxhkpg8z7VGo9Eak+d5lifMzNELRZwPTTHI8jx1TT0aDsajIk/M0f5ultjbR4cP7t2ZTkbRuzy1qW2tczcwfa2neyNq6+5I7JxxmxBfu6Pq6iAyOCh2VopsumOEwI5tX8wubuXTvVIeIvRgH/HQddV4F6qqipGlp9g03pOUaqEde70u8QFtlR2lgd07XYVaUuHtH/b258aTc+O1/Su4FqhdA5n3v+2/kMeyP4LYStVNLOIrTaOtE8M+cRQfzMy+aThGuX09NFcgP77jvepvUG8yiEhAbWVZSswnPU7xwtsdGbH+kgQLDFsSOxHNFSctHyH3t8+kJfaStrRgiwS9JW8W8gpmrptK6h/S7zw/Pxe0lDCEK0DpTSBDlqSubpxzt27d2tnZQcT9/f3Hjx9fXl7GGIPzTVUnxkowJxGD7qZsV6vVZDIS8mpwTkoyOknSNL1z6+5ms7k4nw2KESI2jd/d3d3d3TXG7O/vSz2fmUWZeLlcGmPquhR9X631ZrNZr9dFPhBt8r7MIy7q5cuXh4eHsnrT6XQ+n0svf7sTL1msrLnpqLwlnOpvPQAQB5u0/f4eAeCc87VUBCpJPEJHyXIV3gERUV3XZVki8YMHD376p3/q6dPnRVEE10jIAvGaXb3+OHQ/p5ZvC7dkicUFtO/vJkHkjovtveoVeg/BI9Nvf+W3fukXfzG1SVNW6/VaKQPSJFJaKQOgPHEIgRCUMgQKGAkUo9XKRgZQWh5z+YiqXLu63KxWl/NLRo4c1tWaFHny6/WyrFeoKXDjqSb0rAKxA3TGAiLneYrMGjHLMmTI0tQarMvlm2/c+9f+yBfOL16Ox4O6Kj/64MN6U77z9ptpZsU+9Y/zVSgPAAACAgd6DbdUG8p0iSVyz7YRO0PFMbbqv0xb6NGu5gzcMvaAMsAKWt68/kXIwpB7pRKbZVma5H1adMOpvXp6W6+t5tm/8n1bf6HbYOETn/iEMXo8mciwo8BYnjx7GjoZTmNfz78FAL0bpq3G540zCdEbhdbqw/09a1TjNvfu3npwb3e58kqpxvvZYuWCrCz1/FAi4suE3kUiUIBlWV5cXDx6cG+Q29DUrmN1FyYE2f19GZC3hn/kogaDgbXaWk1EWZYkVndSEMoYxRx9XSmGxBir8WB3b2cyAgrDIptOxqkxh/t7bz58MBjmqU20RqtVb5pf9R/b67C1MtSnwt1NuzLcttOHlxczSw3NGBOZtNY2SaiTWusHMJTRQigtoNP5fD4cDlfr9XyxcDHYLCUE0KoJfr3alGXpfdyUdVVVdV27xm8XY5mwH9Xtr+WGZ+0uDGW0vbc7r/W4N3+uZHD+RhVaUsB2QmPbPdNVp7l9G26lFzeO37eUuCtob6Od20PJI9u1oLAbwJUvhAaOOrl1cY3yAMvBBZ+V57npRIUlIevhvtILEF9O3dST/FBamLDV2O46jq1hEqkf7IrPsSMhkd2iulExGctBRHFLSimh5i9Xa8FYFUXx8uSUQmya5uLiIhsOL8/PX56cnL548dHjD5aL2fNnT7LU1tVGCC6kCNwScyIwc5Jko9FkMJqs12WapsvlUgQPmLnebGR59/b2Hj165L1//PixiDEMB6O+n9LveWm7zmYzieDlb2/dujUattNZfT12d3cXESX5lhU4OztDxKZpTk5OxHv1ioTc0ZiEjslEHBh0fdx+Y/T8U0KApToONex6DTJrIBjybbIquQXEUWscjQef/exnP/9jn5PxMIm6+k342le72bZ6K3DD9hN1tE4k8YE449VqJY9/CKFIE6Pxa7/9ld/57S8f7O2FENbrUmsbA/kYInfdeu7ruoqYvQ87e/sPHr2xu7uf5gUxoNIKdXtzQIdAvgnRB+d8WVYU2/K4lLWlaOE7QjEJf9vnhTlLkizLmtorVhBJAyoN053RcGDfeeeR95BanWXJ7PJys9kMBkX0viUJESx2aDngrqwKX5mCV53Lq4Zi27Iqda3oG6/on69gJdamyiQAILq/8l75J74/Rt9K/zLD1Xjhq+fyiglsXyj/AK4PIF3bDXgzP5CXMUZpZI537tw5PDwUFM9oNHr06NH+/v7Lly/Pz89lF1JL2Xr12dsngdhmw70zlt8SIOEVDxcyTcejYZ4BRQT64he/ePfOTtM0IRAodD50Jb6AqBkRsatkKi0UOT64cr1ipnfe+dhgmMUYpfDbNI3GdoJItrukMgLDCd20SZpZVDIoyXmeJolB5CJPtVLWaIWQJImEzuPxeDgqLEKWWGTanY6txiLP9nf37hwf2URLez0xQhtLnRd5Pa7v+g3jPhWGrXQQOqshtUdEDCHIVGL/w74Ttlqt5BoDRcmGWyHk7iW2qaoaIoix7SCwwtq51WoFADHGunYyGiEgoL44xnTVu2Il5/ZDt9a2/7tWrN6awOve0pHPIfUk5v3+gTaOidtryB3ACgCkQ6k6MpYriwZtZ11ttQBuOOy4NeLc4wa4S036uQDv/Wg0ih3AcNvzcdc57uO5/ucSz7WCZV0vQL4YDoe6o8wUxyz5JXa4RdUNz/QQ7v7IoRtKlkoGEQlzqhR7JSbQqDQq4XA+Pz8nH6zSGjA6HxqnGJqyqpfL5XL5zd/7RmqT4+NjcboSNFxcnk2mo52dHWGuELIRMT2ReWdnZ7VazefzyWQCAEVRvP/++6enp/Wm/vDDD09OTtbr9cnJye7u7nK5vLy8PD8/n81mTdMISEo2pxiZ9rkG7ldG0PsyLyS2XmhGpNhjOjpuOZpzbrlceu+lhyqZHHQ2VyDl206u/78vLcg7Jb9ULTD4Kp3ol7ofKcYOOIKIkjHnefr5z//Ym2++mWVZcF7qUjc8rt6q8WxvbPmJghZ+f839XMEdenhwy1aNiBz97/3OV3/rS18C4s1m4zrUt7AFMqEL5AIxodLaJonW+vnz5x//xCc+9ZnP5Hk+GA19iNamRECACi2CQlahifWm8U3wNW1WpasdkSIHvooU0DdUl54CcwQKDIRWJ4lJFWitrEIzHu16H5smKtUyBlL0iHz33q2/9Jf+9WfPzwDJB3777XesUcQBiJFa4pEbl4+vTw6vyl3bNrO/rf2vYqtLeDVb0dsc4a7Zenhv2i6llNLtQfrQjfkKb6Ve6WRt37Xu59iXnAHwKhy48fphwYVSINbHGPPGG29Iz0asvzC7vnz5UrY7bWnnbdu4G4FJG9wBEiCjQL01K5mgciE4rXG6M0mMBoDJZPTOO++sK44xxkCr1apq6k7UNvSNeiJWSgVP8/l8NV8AwLNnTybj4cMH95RSVVUhgGCsuJsY2a5E9WfYP1qCl5NrlIkFxPbOZWmSpWmWpKNBkdqkKLJhkSVGaYQsS4xRCmEyGu9Nd/I8FxXFRF+xFsMPCeX6B3Kr7Hxd5kFfWXzokqS+jyUv1QrytAgRtSWcEFsYtha70GbG3fCrAOtjjEVRAOB8Pvfe+0De+6bF/rWgku2T77fa9sj8ttXov9j2rz8sFe5/e/VXinviju1jMkfm2NfoWqjw9ZRX6yvijhuv/qb3z5VqtTIJImVZ0r9BVlvw4XIXuknBG4NSV1cq1lxKyhLiCEiCOuyrZGOy/tKnlyYIM8tAMCJKiN3HENTCeUB8qnigvtAqXkfeLOsglCy9U5FSc1PVt2/fnk6nzPz8+XP59OjDw/sPfvC97x/s7X/60592deNc3TQVcyvYIJXnzWZzcXGx2Wx6dxW7jTqdTnd3d0VgO03T27dvA8ByuTw7Ozs/P1+v15/85Ce/+93v5nk+HIzkQkajUS+xUBTFcDiczWayzjIWpTquMa11CE6gN6I5KPwnPRuRBNDD4XBnZzdJ0uFwlGWZ3EopDscOzNyvKnfE3dvrI9V1ub+LxaKVppCSz5ab5K590G8bazUA9Dyjx8fHD+7f//jHPzadTqMPsquvIRC3TSuA0OG1G5VbuH7/QdtPijEmuEZaG8xc16VUYr7/7W998+u/l2gFFJsug3eNB1AKTYQusEZgRufCk6dPf/wn//hbb73lnIuM1iQHB0figKUGFFxsGkfUNvh87eUfNUGBZk/1pmzKKlRNqJpYO2o8+KiIDaBFSIzkt7lRab1xWglNm8qyxFiYTofvvvvOT/3UH0REhXCwt99FRVeVUWutZKI3HrFtb7dtZ7ZdTO8FdfeGvrLVrioIhWJLzQSsjEmkg9alBzefa6IWfiWf0rMCICIASl9S8bV7vGXqe6vOkgdsSdlcf8ErPrjfc609gnh0dHRwcCCTDzJgx8wnJyd1U8n1bG/ZV48P130PXo/vxLsAMTLsTMZJkuR5Gpw/Pj7+8R//A4tVxcyESkCJ3nsf+2y4bSFLIPzy5cvNZrVaLp8+fXp4ePjmm28Kdkx8khi+HvbCAJHIWCsgUjkZQWEILREiMkR5znsrn6bpYJi34yhaMcWdnR1A4kgcY57n+/v7R0cHk+koT7O+OLkVB9003NChMGgLOtQvF3WDNLiVcvVVUMl+oCU9pj7HFSckiALqJF98bIvbQifkvZ9MJgL8KYoiy4rNZiMNudVqI4Wmvsq0fRNfa1AED7/thl/ng3H7DTd+dWNNtt92fVu3JyP4Z4kOZQG3A51tj4tbfJ+qo3vty/jS5ZVvZcQIOk4G2SpC+ydoLCkP9FDV/oPEKfYTX1JfESspe2+5XMoYvQQHksTIx3WJshVP379H7nLP0iXGV+5gf2k94le+XSwW0+lUyiGSBwNAVVVlWbq6Wczmq8VyOp4kxp6/PLPWLhaLy/ML37iDvf2yLEPjNOAwLzTwerHc29s7Ozs7Oz+VZU/TNMaWkE9Ct8lkcnFxwczC9syMO5Pp2dmZ3AsBasms+TvvvCNqVHLykvVK6NAy2zgnTPrSVWmaRghhlFLOOQASRSkAcM6JGJRwmXnfYsW3w53tkqmsP3Q9C1nbHjItorkCiRCybtcpN8hZ9TTOsNUP2v6VHFDoKqfT6f37999999033njDN1f16ldf17wsXz3soRPe6O81d8Ie/VaRM/zggw9+53d+xxjV9zhkuWSILgIDKACF2sgtu7i4+Df/wp9/5513ZLuOx2NrbYyMWiNoJnlwFEUwqCFSvanrarNZLaty7aoquBqZrFHAMfimKtdVuXZNFXzj6iq4RiEASB+ErUm8jwBoTSqF3DzPy2o9mY5++qf/xK1bR9Pp6Pbt2yG4Vuh+ywj0T9YNE6HU6xPIV30NbgVMiCjEkNsWtR+1tdYStHSERG0TsP1cbjF3IjECSKqDX0FHw7Bto9Qr5qvbckzMV0K0AhBoYQJbpwXIApXu/xIAkDMEE2PUVukkvv3O/dqtZvPz9WrjHQyLPdfgt3///eCZXETibQu49VJMmqKiqICN1laqfJECUFQgOsYIoLRNCFAZWxQFEnP0mcaHxwc/8vbdzWxpm9V8A3W0LiaRNIOOrBiBsC1GVY2rA53P1w2p+dqfzcp7h4Mf/8OfmRQQ6pniGtkBh9QYqcUN0iJFy02EhprVxjJOB/bhvcP7tw+zFClWITZKoXPNYDBwrlYKtEaOLtE6MUpzaGKweeYppsYO8jTVMMmNxSZV4e7R5PhgHJpllts0Ta21xqYWIdWKKRgNkZw2rWAkR0A2CqwCC4REFMgHarr9p7HD1Ck08rQAK2jj67ZrRcDBxTwtsiSfzRZEZJQOQkxKzJGM0pL4Gq1d07im8XVlFQprIADFGMuyDMQuhJcX55GIGUFpY4y2hog8uQiBFbGifsodAEArmU2KbX26c5bY/hOMJaNiVII07ELO/sGjLenDq84FIBEHpoBACllCNKO0URa5TWShUyWK0QvcafsIBlVidGK01QoVM0RUrLagAAJoSNO0GI6rxgt1SE8gIumUiAQDUJKYGL00jgHIGMXMLW9GjHmei78cDosQnHN1CE4wR2LcpY/bND5JMmE1EQ/de33dcYD0dRqx9fLt5XyxXK6JpEFQt6osIVitY4zzy5nojE3Hk8XlpUJIspQRJjvTQHG2XgTkZbXZPTrYPTq4WM51lizXq9F0+uLly01ZHd+6/eLFWVX5yWQvMCzWq9PTU601U8s9fn5+vpjNgTjUTay9JqydL4aj2vnZ/HIyHXtXNa7Mi+Tu3duf+cxn3njjjc1mE4K7uDhDBUfHhxcXZ7PZRbleBdeU6w0yxMhV1eztHeSDYVU1TGBskqRZVuTK6MFo7ELUNml8SPPscj4rikLCIHGiVVU1Ta21Wq2W6/VKIIS640in4Ci4xIiwmUOOgzw1CppqQ8EpoOiiBq0YpCZfrTcGlcwO1LUTR9UnQACAyCIeQJGZAFgDi3iaNQryVD96cPvurf3jg/GbD299+t03j45300xpQ8gBORjFBmKiGKMDaMkrQCtMDGktc+UGMTE6hIDIARiMrkMkQFAaABKF2JQFuWff+d1n3/pqYL8q14EjI0YGH8mFWPvACkN0ja9rVykFlWsCwd/4m/+TT/3oZyPGwC7NjFV+VOidSTJIKctI66ZuVhEa1OCZSCnPXFNomMsQykgbHx2oTU2elIvkiQOTp9gEHwEJVe2i46YhF1UY7OT5UK/Wc1RsTIKk2YHlRIUwyfVf+jf+xL/91/7UZLC0kABpIhVBR9ABtGNmhawQOoRxRIrAATEgKmUIVRCiSq3AICmOFFp9cYhIUTFoVMhIIRLFPnMmDsThqomDSiEqpRLTqvRqrSlahAQAW7AR+0gNQ0REijAeT/Mk9y62uTJ6VhwhBg7U+e0uUDNSNWRmAFYICgEVXHFBM7Ow2782oLhyzBAku+XYVpzu3bv33e98fzqxWVZYa5u6vLi4WK/XO+OR1ipuKbYCckd6xkRtwfP09HQwzKfTcV3XqK45++00azKZuOZcdnxRFJ/+9KeVUt/67kfpGABgtVplB3vOOa0SbRImTxEIUGM7n+OasF6V6/VaPbh1586dL37xi4+fPHn6/LlipRRQ9MxY183FxYVw1kyn03duvb23tzecJHmer5ab5yenq+Vmtlwsl0vhSeAOVKwAYoxG0FsGQwjcJpatio6AuUyaRFLL9aZ2cTQoytpHAux6tEQkwbtE6HLm1wMovVUPIYCWmRMAEEErJGIAJBLV+3YCWEyGUAtJxi9GPG4xIPLWmBN0YB/5VjgQ+vr2arXx+75pmiJr+W+VsgIduRFjbQee12PA14SEcqtvpLxdeMt9qLsdz/JVkaY/4DWqy+2wDzvMmupeVx+N7Wf1CDVB+ggUWeEVuatUKaVH22fD2LHF9R8ti9bnmkIlQUQxhr4NCQAyTVuWpaS8dd3mWFmWScW4qqrDw0NpB8hmk2xvGzAodWMEbJqmr16Kbw4hiMazc248Hi8WK0mmpWwrUGEdwsXFxcOHD2ez2d27dyU0sdbevXv3q1/9qqyG1no4HFbVJjWWBoPLy0sR3SrLUqopeZ4vl0tmRqOapsHEGGOGebFYLJg5T7OPPvposVjcunVLLvyzn/3se++9V9f1l770pSzLBMyCuoVlrNdra1Pn3Hw+19ZYaxObLhaLNM/G4/H5+bngoiX1l9u6Wq2KohC9QmZer9eIKLRuQk82m11I58h7X2TtmK/cL0ku+9yFiKpq0z87MV7Bf1arlfeNMJ/0xeq+MdHvLu7my0PHViaFdBmUstaO96lcby4vL2VkK4aW4VJrTSAj/qiYA7ST+uBcjISKpUKQppn33lhljIoxuroMTW4zM5/Pnz59ulqtyqqSAyZJSq1QfGBudy8qk2XZbLmwJv3rf/2vHx8fXy7nshV93TKYpsDT6TTEGRER+T4ilPVpmiDFv0Y1q9XK10ma2DS1UhkiagufoeNflFVqmhbu6n0TY9b/KkmSsnJVVe3v7+dFcX7xMrHJDYux9aTf/CEIu/5W1ayrEEQiput48rb7SwydbHxrZ9BIfGaMMV15srdLWhu4ElnqOjgtwiZR7TRHW4ICvLK6r6adN9Jx+V+s/LVhkit3S4BXajT931+DCQyHw7fffvu9H3ygtZbYXyl1evryg/cfjz/9iTRLpOqCqrOTKGoNaBLNhGdnZz/4wQ/2D3bH4yERZWkKgXnLkvZJvaBRrNVK6Rjjzu7krbfeOjk5KQGrquJIl5eXeZomSUIIwBiYXCCrGT1WZaOUNIn5B35T1/W9hw8++clPolbvf/h4uVyPJzuTyeStNx/t7Ozcvn1bazufz40xHKmuNyGEyHDv3r08Gzx5/uz73/9+PxYyGAw4xrqurUm1dBGU4hCZ2zFcpRQzxRgHRW69jZEPDg5ens98oG14pGIKwVtMEDHLsrpynXCHbpmjWnGt1+CN+29Vx2rJXQdFnn+xC9LolWyAO+BAv1F6/h2x78aYi4uL6XQqnH99p1PgPCFIsNHOugD1Owh4C72HiKLE0O4r1QsXXXVrWs+KLHw121uruyyN6oqTZNvTd9t1+4G8ItaWC+xXhrvWybYDbp9hIjGOYjj6epe1VgY3qdPlVB3kTYIY2QbQ0Wb1pnwbrtx/nHyE/DzPc2lbqm7cM3YDLfP5fG9vTyk1mUx8JwC8s7OjlJLWgOto9xHRe1+kiYixJ4mVT1mv1xrbmEh6sXLCaZoyglJqOBwuFgtrbQZgbdIHH7u7u7Jo4vvH4/F8Ph8V6cuXJ8651Wp1fHx8gbP9/X1pVI+H03xQ5HnKzE3TaKOyLKsbNzu/ODo6MsaIJJH0a6pNOUfFzM+fPy+K4uLi4v79+/P5XOoBEnYAgASLABBjnM/nUmQm4tls5py7uLiYjEeC3mgZCJJE4P0A4L3f399/9uxZnuej0Wg+n8vKS29Y9r8UoqU63Ud1fV1Bhm773cIdfbRkn/Lq73jo5uB7q9ofUG56CK2llvsi0AHPfm9vL0kSETCuqir4KK1cuVNSsIkU5dMNQJoVQohNRBQcEI2KSV2VRWqtUUmSeFfPlpdCXcKoQohZlvc80jGyUhhCcD5OJsPT87PJeOdv/M1/e29vb7FYIKKEKS5QnuchEjgFoEaDISIyVwK0jJ0KBcXofTTGS5jPSUQFSWIaH63elqBXYnzEPYpTE9tSlmvEkcQoTWjk8Vyv1+vNJrEZAMhw7Y3oGa6/+gBacVujvXo/tQpHKIG1QkAC2uZX6KfzQUgLtNYxUpa1BKgEiNB/OjNIceMKw4WIRCyhs1IKu0YGsOJXEg9EFMnUGw5YCC/Nle28/urefE25iJkRW/4mxPYsj4+P33zzze9//z1EzNJUkH5Pnz59482HMkVAREy0BecDRHbOeRc3m408QjL13zS1RdODVPsPbdtpRoVNsFYjcoxxPBm++8mP//KXfi/PE6M0M66WG3EViVXW2kgspYPIdWKsUqapHIzT89llWuR37979+Mc/dv/+fULY290/PDwcTabee+/iycnJYnEhnf8005FEQ43TfPDGG2/s7Ox85StfEehZ0zRK6B5bCjSUUb+ON7QNPDnEfDRC5fJIt4/TxKbPT84pA6u0jEmkSWqMFvxdaw5a73hj56kO79f3Dq4CK2aEG+9WSlslnTBZf+54QNuIuNu4fZwoEGbpt4nGuwTUeZ4ZncQYvPfGjLCTNOg2hwJAuK4MCFc+uBvp0zJSdPXb3qJB561vHIGZUbCi6gpPoLaQKYAEW+RZ/eOqO33Wljv6FXlH7Pbidq1CslVmFr5DrbV31zjFwpacgyAQpUMpbcsOkXHFfiWpABEh8jY1tBxHSil9mzN26kbyHhmKret6NptNp1MAEK1vY4xsGwmbRJFQ4FdZltV1PR4OpTslGgaSNe7v759fXigF6/VaSjKw2ZDF/qKkM9c2oYVFtdNPFNzyarVyVd00zWAwmM/nxOHi7NxqE6Pf39+XYRgp5CiNHKmJTZKYR48e/dIv/vOdyfTWrVtZUbx49my+XJycnBwfHx8dHb3//kqq/RJqyI0TIhG5wM1mUxRFVuSqm+gVrQhZhLqufdPSWT958uTevXtZlokwyXQ6lSdUgNOC1ZIuai9YIpCcHkFNV4BH6G86Ikqa3peLpC/DzOKcVCdSKV9LBCZdZGtTeQzlitI05fkCETnmGiG1SZMXzEzA69VmtVqtVqvaNURkTdIWMLXxMciEjNxfoLhczHcmYwWkASj6qtqcn58vZrNBnkduWyRJkihlyrIUoxsJ9vb23n/84cffefcv/MxfFJULybllqxSRvffOhxCCV7EYZDIm0xMrUScw07bPo1VKpUYzAREQeSIdmGI0vQMmIp20VN7e+zRNB4PBbDbLssx7FKelO4Vm35H0AYDqtI/6h5puUDBjddAAAQAASURBVE725oVZ99JCghNrtQIjMCOyZMiRYh850RaEZft/bRKttXg9MSMMIANRzIwcIgVRx5Jd2nPV9Xa1zxC2vxacQN/Fb6P/buTJ9H6u/x8AgAWCJ01fgCuVDJnNkhgtaKV8iEmSfPzjH//Od763WCzyoyNmttbO5/MXL15kWZZlCXGkuGVYsb0Atvzy5cv54vLOnTvSvGmXHW90jkkoM4uiaGpR222nch89enS2rL/97e9hmsxmc2tN7oK13iSFI1QomRNYRuTIXPvGMa0PDw/ni0UxGEwmk4ODPaGfLAapa8rZbHZ+cTmbLXxoBGbcuBjKOsuKfDBARGYYjca7u7vf+c53bt062qxWkj/5RqafUem2DakUWm0AORKPRiOtdZrYpmnyPDdJen5+rnXujPPBNU3DEaT5L+GLtbaJ9XW05DXkpCyO2poVQ0SALk0Ehn6aELVE/arrcfYbug/oiAg61LdSqBO7Wq2Gw/FisRK1K9kbVmtWILZMWgl4/QWgRXgErteBiUCpHkOgRO6sfwb6F3f1FeZrVZb2nFkjwI2IpD/C1b6/Wo0WFgHXMZP9O9vcFJS010EpxaABkRiYo/NIDJqQOUkSIojel2U5nk6xK+BLHC3BjbjPjnv5CpsjTMXM7FzTe2WpPIeOY4uZrW3H4WSHCGxK0keB+0pIJAl0URQywzoYDGSXeu9j9LJzpN2AiM45cdjQEVMnSeK9U4pFeFgplSeZjCH5ujk+PhbaSFmZuqnGk9F6fnF8fCwZMzMPh8PNcjUcDmOM6/V6MBiEEIzSwTUi0zuYjJBhMZuHEC4uLgaDPEtSRMyyTAZ2lVJ3bt0u15vT01MprsiJ9QUYAJIUf1gMtNZ37tw5OTlhZmOT0WhEMTjnpL5trQ3OqzS9uLiQAsPp6enh4WGapk+fPrXW7u7uWtvydYi5TK313s/n8z43oG72Wu4mbFGHSltGVkMKD9SBsfu17QsSsp+lyMFdTycEJwhcyey11lOCEILVbYMpSYz3EREHeWETk6bp2cV50zRaIwdSSjFq55ysj9ZaARPTIE1cuXGJ2r1/u6nLJx8+Zgry0Qo1RTImAVCXl5fD4ZAiuOAHg8G3vvv+j37uM3/xf/Azo8m4rmvUqi9vZlnGqBeLhfB+MLMxRgI7uZAY2ip0ZHZNS8ypG12bYJ3TRiXGAkRpJoFWOgb0zjCl7RB/ysyJNX3DQhQ/qSs1JUkSuqJR74MBgNVr0t/tx18uQDGIOHGPbKIOtYaAxCHKiPZ1vinoHS1DB9tUgaNChYgi/UAkI4IchQOwI0Qq8sJaC6BCF22o6yCszl223/agAUZA1RphJjB9xsB8RbN5w8BJdAyAsauGK6VC5NYHRNrf33/77bcff/ChxAKDwWCxWDz+8MntW3ezLOkjAkmdmYEgIigievOtR2V5JOedpqkPLgRChP5UVDsQHJ0Lw+FQKbWYL13TGGOyNM/T7JOf/OTFxcV8vhwOB875zaZUSpkkQdTWmAgRmCOjlgY48sV8I82V4XCY5QlDZAqoOGlMVVWbzarcrENw2pgQnPd+sd6EEPZ2D6rGHxzo8XgCAI8evTGfzwWK1TSNb5wxCTNbY4UlBQDSxGLHsVUUReMqlSTaKABKrVEIWoMCk9qkq1RzXhTC119XoqbAUpntDPq1ebh2G3U90L781QaqCACKGVFhjDFQ7LVRxUxLqQ26wjUDSPhZuTAcDquq0lomtWxVlQcHB9AVtHVHtcivjEbIjobODfY/V0oxY0dtAwAInZD21dOlEAmYFTPhVtEJ8SotRmyLLlvBmbypTYIRr/SDu482vUe/dp7Q4sEEbSqroXqqd1mKqkrTtMPDtwPHXfGKVMfALGmiLH5sx8CU6vCZUt3tJ/fKsuwWhGlrUL5vJ8sYtyj6iXqMVGgljZA/6SfKYozWtBgCocfpvQURFcOh/CTPcxHsE8WOnsxZvKxSajwei7buZrMRJ6c0imuZz+fvvPOOMF0Yo2IMRPHi5enh3gErkRTD5WItSkd5nvrGiS27uLhAJquN6EkDwN7h4dnJSQjhxYsXg8HAGDMaDE9OTuq6Ho1GMsQoIQtzKzWxWC1ha9rq5fnZerna2dmR0V5hDhmPx4LAOjg4ODk5EUEk6FQN0tT2zXjvfWJUX2/o73i/K2KMAqPTWjeN630zAAgxGXZzoj3GuK8DiS/fzpKpmwKXDFtrRDRZYqLGLDGC+dLalnXtvUfU4+FIGtUXs8sYY4xBKRMVJFnOMYiqoGvqLDHROwXx7bfeCL756IP3KQrggKXcB6AUQ13Xk8mkqT0oTNP0+cnLL3z+c//WX/nLNk0uLy9NkimFaHSms7quCUAebW2UJetiIAJtMKUkZpLoOxIGS9FhiRxCqJouyldKFUqj5iBzJBQCIToiEkUQ7xtua4QtOl1aNp5iTycn/bgb3lGJBXzdq41yWtqHq+xWSBHF5yhWxKFzfq195F5ceasXa9MEEQNTS7aBgNAaE0RGJk/Bh1bmBDsl757Vsd8GvbPrsohrxeeOKR9b2mQAA4wdy8drLnL7FAHAAEZBR0vGTZJLcWL1xz/29sXZuXNNlmUCVJnNFs+fPy8GD7VpWRGI+rF3zUxa48HBgVBOAkCIHuJVCYiI+vY6ESnVzXV0X0TyAHDn1tEf+uIX/t7f/6fD4bCqGx8CMSzXmyTZSZRGxEgBIwUOTEprrY2dLdaBgZm1waODQ7LBN/Ui+Kpx6/W6dlVVlbVzq021Wq02m2q13IzHz4fDsVJ6MBwOB4NHjx4B8K/+6q9G7aWWm6Z59MEY45pKIdokkdqdGEqFrdhnniaoTVn7wSBnRq1M7QJz1NY0Ph4dHKDWs9ksBmc6pRTZKgCglFAY9tFM31Bteyx9wtdLGXJXE1Ndn08cRl9x5a1xpsRapZSIPgHAer0+OjqSSloIIU0TBkgSKyq2PbNP72K7TaIACa+XkTt/AwAM0HfOWmfde6NO3VP1eXB/gCsfzFpQ4q/sVJIiwVU02T4M7dVJ9t+/5EHrI+J+6FPspowP6Y5ysj9anqf94quO1FB1lAjQdYl6Rc4Yo1UttssYS0TCnIWIPdOkFGBWq43q5HqSJJH+a57nwhwpiITxeCw3UcB0ACDMFamVedYougXWWjZG9IK4444Wy24SK/XJyWRHittnZ2dqX8GyBev54BSiTdPpdCpXaq2VfH2xmBVFJhiCpmm8b5h5Ot0lZqVhPp9zK31qN6v1YDCwWt29e19mFKuqOjo6unj5UrjilVLf//73pVw8n88PDw+TJCmGg/V6PZ/P0zSV2ul8Po8xboiSJDk7O8uyDIhTm2xWa6nV++CZWdpYdV1Pp9PDw8PZbAYAEr40TUMUet0qhrheryUbRkStMUbqKUL7JEYeIkE+I7bFQ9upUnKr4Guoo1LZftD6WSaxUfLEwRUikkejgUwrtbwoGncmI+9j470xqizr8WS02WzW5UY2YU1KAlpjTLWpE40UfFOufuKP/VED/OHjD6tyLS7NKtM0DZMGrRsfmXC13BDwaDR6/8OP/tAf+cM/8zM/44Kn2ueDERH5GGyasHfQicAaIV9TontRypZIjM6SlJk9+OBbraUYI3pkZuTaJrq93oS1RiDtr/rrKGhERARoGReyLCnLWsbfpd8xm81cE7KsqKrq1ZZo3+XtXdKWZRAc5VVULXNrwNxqOQBRuAbgajMHAO4ySa2NMlraz62xwit4ilGAHMMWYRYiJjYzxgQmJXq+3Dop6Pti/axKRzPO3KF4EIGRO6nWK+WNq+vprvO1L8BWQqTfrPLze/fuHR8f1nW9Xq8lpI0xvvfeB865GAi30nAxgNDSJnCe/38Y+89nS5JkPxBz9xCZeeSVpavFdPdMjyTeGzwAtrsPWKhd7pI0gkszkruk0Wj8G/ll+Yk0EgCNeMAbvNE906KqS159j0oREe784BlxT1XPgHtsrOfWFedkRka4/PnvVx0cHJAAj4PqdxGEaAUh/22Mg5LWTqeTGIPOX0qKBwcHP/rBx2fn17PZjBk2m13X9qvNth1CZElRWDAwh5hS5BSxD7Hrh29fvf7DF1++fvtmvd7qhfV9f3u7Xt1ublarN2cXb9++ffHy9Zu35wySBFbrzfnFxZs3Z2/fvn358uV2uz05PCIijklTKOfcbrdF4NJK1JkQVHI7lhijM6apagMyn00qZw8P5g/unRiLHBPHoWmavm27XTufz701lpBAGWGU0UkxBZoa300EotLDsqCAzsFSnv/TI6SKSYi4P4pa/CJksFsGVI+wET0hde214FmPIDg3nU5FsKoqa+60K3DvDCAYyBPA722kdzwmIggi3HlxuYMzjsNU+8dw/63ef5/sg9/pMANowAnv+GP9eyp3XXyw2uhCuaDmVZ+jJjGc9bLU6erzLZ0/2Euk9ItS3q+db/zI32Sz9JaiclQqQBdQy8LMrORNJvNZrtfr5XKpuK3b21sAsHu8hpBrIXGUILSaLheX4L3Xwq+ChFUPcbfb6JDx06dPh2EY+o5TdJW/ODu/vr7+5ptvrLVnZ28mk3qxWGy32+m0WSwWKlhprf3hD3/46NGjGONms0pDGNrOEliC68vLEPqu2/V9q03r7Xarf6XKKJeXl7e3t9vt9uTkRH2zNmjX6/V+SSalUFXV1dVV13UpxLZtnXM6kj6fzxV+AQCbzcZaq4xXu93uD3/4g3NOEdEhBE2yb25ulPVaB/80oAkhqAAzAMQ46BBtCEFx5jpzXOa8KYtnlASXaNR5LNPYOgZd/rBYxVKx1NJuqXJba4+PDw8Pl97bqqqspdrbyWRS1/7k6Pjw6MAZO8bHOtNnTN/3TV0RyNvXN//sv/wni9nkqy//kOIwrRttl/QxgCGd9xvJkQzNZotf/vr5f/3f/M//1b/6V93Qg1DghIZCGqEJxhhXVdZa5hhCCP3QD10IwephJMXfGGesJaMAkRi5RIEh8dDHvu+7MMQwcjCkJEMIIcagg3ddZ7Kagj4F1WcEAGVHARkb51pt2k+CZa8c/Z6rggzCUvDm6FYAhKMy1NLYDFanPBYk9t8fEYmMtdYab4xh7UpZ8+7vaCQdcjFSjDGuroSMclFnQXS6KzLrkGXmuh8dsNYHgQqj9XhrZDBxZEmJozZfC3vGu7bsboxyRAmlsf4AWrpB/vzzz7tuJ5JCCK9fvx6G8Pbt2Zs3ZypjIoJa+Skxpr7SEHbrTSkHZfbsu54xj01+FkEd6VGrN51OUorrzYpAPv30ewTQte1kUm+7dtu16/V6vdlwEiDTh8QJQpLIqQ9RwCI4Fnr99uLy4na76/oQ19vd1eVN2/bDEPoueF8vlofz+dJam5JcX1/f3t4+e/bt8+fPf/ub33/xxRcvXrzUnpyaTvWyPA50J21pKzCnODOUUW0NhCtr7p8enx4ffvj0SeNdiP3h8uD68vLi7Oz48EBJsOvaN42mN7by1lunrSNrrbN2LEnvxUy6RDpjrrO3wigIJQgtu4GsIWuKc1InOpvNrLaRiLTRq3aHiIxR+sOgtMYiSQibpslh3J2vLY7hfa/8nZ5u3n9EeMcAR+/qHxPdCfrevT+Y8v6Q607MvC8sqH9CGatFuf9dnG6xhmp8NQOWXENWZ6C/o8O1ZVQsZHJ8LaMVoiXIsK9yg5qtao9TRGrvYyZ/sNZqGjSbzZxzmhdCFlaaTCZKpKx9MpUb0mdxcHBQiBX1FCiSVm2cJuKXl5fqpfQKNRrWiFkBw5qohX6YTaYpxN1me319LSKb21tlzEAUAN5mDmdE1K2uU0DT6fTrr7/ebDbMvFgsQugLCRcRhL5fzGYa0CggWT/u9vZ2vV7re2oSrJ91cnLyi1/8QkNVJdFbr9fMfHx8qEoheqb0Ljabjea12gZWHg+tqN+7d282mz1//lzZMUvlRvWRNKzRg1ASVq0BIKKeU/1aC/haSFAVjZRnspULUx2Plha0F6AN2s1mM2R5SvUlYU8lkLKyZOJoCDnFyrvppDk8OLCW6tpPp9PKmclkUlXu4OCgbioCJEBjCTg5gygsKVycXf93/+t/dricf/3VHyUGyiMAemzVuvZ9b33VDaGezH7922f/l//r/+6f/JN/EpMAWUYAGgtCgVPgxADa+JhOp9Pp1DlX+8pXzlqLPA4Uhaxjoc5MvU5KqWv7GGNIcb3abrfttmv7GLTUzAwhk2YPWYpKr1P1krVoocs+ZP1ybQEgiiJMATi3ftJ7X5cvyI0kVvrUZAypk0GRsYLImBXH9UfaaEJE57yIhMje+8BCRBoKwF1vWPT3mbkMAUZmnUZDRGbQ6FxnvdQT75u4lKnO9+P+kiUzMy0WC/2W1t8E2HlbKmzwnddoDQUBwAAWvkDn3MNH97/3yUdaWKgnjbGWRb755pu+D2GIaomMubP7AgwpT5jsTc5Azk5SSvoLAABAMUblMa6qSvkNmFnZKO6fnvwv/tt/YQwhoiO0SLvd7uZmdb263XWtMYass9YLGuPqbTus1i2hJ1Nd3dyeXVyvV20SA8YCkq+axeFRM5kBEFrXtv3Lly836+3t7frq6urLL7/86quvvvzyy5ubm8LDrldonG2aJuX52pE+EIlgfPYqBrJZ3RiU+/dOF/PpbrueTKvlYh77rqkcx6CnySAcHiwOlvPKW2tkPp3k2jNqYUofqC67IdKgCzM6VxJDdqspE/QXbEiSDDIn3IOm39E77EHt45hXZQqIQrysp8W691RN714CVNihcS8vVFKO7+wqLP+/77b/p7zGN4e7geb82uOwzIVEABC+89n62u12yqp4FwVmLT81PQpvURbGzWajhni/75sy6ZvJklMlhlBLXciVOE8cad+rnNJ9TXi9YPWgOtVa0nSFGpVWcfH3agL0ftW7l8hPRSqn06lGhJPJBFhUzmi9XquTVlfXtu2TJ0+Wy/lms1E6yaOjo+12++LFC2t9VVVv3ry5vLxU/JfiwtRz60EoPpgI4tClENrtVnNEteyffPKJyhIzc1VVi8ViNpv97Gc/s5nuUS9bo4SU0np9yxyJIPSDWvOjoyPvvZK1rVYr3agxxpubG2U1UctYmuUKop7P57e3t2ru0yiKBdpf14Z6zKrvkueOZG/cqGR7OqwhImXDFLSzyfTdmMlHd7tdwXkVozc+XDNiKbz3ROidnc1m6oYrZ6bT6cnR4cP7DwQYCYATcAx9V3nz9TcX//V/9Y8Pl/Pf/PqXu/VKRLQeCQBCOA7VWJcEnHPGuWfPnv2f/s//25/+9KcxSeA7fNl+OJvdkhBRVbmmqbz3zlgVDaus81ZHGcffB3gnQ00pxcgaf+x2Xd9p6qtaJmq0ebfrNpudYs2K4dJJNsiAUA1x9hOz916mgED2DjXu1Zk0zx1ZaceOLzMnJS0v7zxCsfLXKttqjPPeG3KQeez3rdwwDCH2GldF5qaZApAw3vFKgggC5zGUfRc7/hOBcjm6JMqaFdBiNtVYQ3OdsXhlUDkx/oQpTKPmo3pfA6j/2+02zPF73/uo63fM0Vo7nU6NcV9/9ezN6zPlThYZG5DMo3ak5rvybsGheGhIXCKIsnZoRvJbGKG5iJIIYT6d/IO//5dD300nTVV7Iuja7Thpx9L2oetD2w+7tjfkAvP1zWq12fYDb9vu629fnp1fCZiqnpDzTT09Pj59/MGHn//gh3//7//9n/z4p23brlar169fX1xcrddra3xxbKMYInMIoQ9DZthnvUIcJUFAW8LaAmyaxqBIjFVVGYInjx7OZ9Oha7vd5mCxbGq/nE+fPnp4dDCfNh5RCFPlLBEYAkfGIhlAR8YbMiAlYCREQ6BgS2aWTFFZSqb7/qnkiPpSG1Fi9n3nIcLGmKpy0+nUmhHSWWpxRPZd6tTxgOXj8j4Ds346f9fDyn+qXl1edw6+VJX3hITvgk007/1+ubD3Ikvcg2Rj5pGGHAjucz2ObCp5ZEWTY81ElTo4ZbICzrNGkrHlxQQgokHUPaBmSFVvKU8y0B4QzFo7mUyGLEqvA0UlG9PJFnW36sV1YoeZlWBLF6QQIN/e3p6fnztjdb7o+vpSm9CHh4fz6QxY5tOZM0SAp6enl5eXj588HEKntQFFdSgcrK7r+Xzetq0Cu0II8/lUc5r5fK51dUT03h4cHMxmsxcvXmjgcn19vVwuP//88wcPHmiaq6HMYrFQheCjoyP9LxG9evVKC0uLxaLv2xQGjmG9vr29vdUau96+ukxFfWpuPZ1O60njKn+zug0p3r9/fzKZLBaL65tL/X2NMnXxS6O3sI6UOEa3t251TXO1c6w5ve4QbVuoiy2RsW4YJWChjNsa4yE3cuCEFIcYNEa31lpDk2mjJeja22ZS3b9/Om1qYDESvcFp7b7645v//X/3z++fnnzxxRdt21prrRujPd28KSUB2Ox2VdOElN6cvf3v/4//w49/+pMhJNU+iiOWedyNqKK9GaStN2utNQaNMVoDt5a0VaHtGOecOouic6ARTEgxhlHTvg+x7xXxFmKmCi9Veo2B9PFpXBuG9N55+ZMvEfnufHA5ueN3MgA2mzeRNBJ5lhBWa2X6pJKwMu2gNYQ2v/M7JWLJrJ+Ye3O68ZhZEEDp6dMdY3+5nnJ5DKOMMXxH5IqZ7cOHD5Uqve9bIjTGalH7u2vxHZu436Jji8TMjx49+t73vvfi5ev5fFlXDZE9P3v91VdfPX7y0NqxyKAlHRyHdFW2eK/xLCACCKhsmfuhxJ3ZNRS6OIQBCJkjIm43q/lsMZ1+EEL4D//hPzx8/Hi1TpvN0Pc9snjrAMBbZ4xFBDGUWISFEvQDd30KcXd2fj2dTocYr69v276zvprP57PZ7JPvffrRhx//+Mc//bu/+7urq5uUUt8HAOi6zqprIUEap8dK/RkAnCNmFhhTebKGCLTkqKmMJohdjE1lJnU1DP20mXhvN5vuwQdPDg+WIBH4wDm33ewEsesjAOPEIIKydyABM5uM49+23TAMmc5MENEajHHM1cb9TSh7e3E/sS5VMvVDxmhpK6KInrfJpEZEja4AAAwKjDg5IvNdWWwAQBkHh+4OSXauQrDfsRUZSalG/OH72+/PhMbvJtkyDg1j2VHF3Y5hwagl+o5qoXMGYERIYc6fJCey2jhU/2ettWRTZssSEZ0mKiVrychnLSTIHrxLyzOa+liiISNQtEZXVY2O7aasjOSc03rv1dXV4eHhZrPRbFgTOx0PM8YwCIOWo1PTNLe3twq/Kl3qggGezWYhRcUoaYOTCHabLQEOiHVdf/vtMwV/LWZzxqSZsd7+er0+P788PDzUyqEu+L1790RE58VVNOLt27fL5TLG+OjRo2EYZrOJxoIXFxff//735/P59fX1119/vVgs5vO5iNzc3PzqN7/WEOTq6orzePrR0dHl5SUAbLdbddXqAi0ZTUb7vl8ul0R0cHCgbeY3b97ovFbkpAzM6gUJhJkfPny43a2JKKS02+2m00ajFnWBWvkUAZ3/KaZT67rK0IKIOndkjEE0OjbWdUPTVPtJAu8R/412wNvCAQJ7IJ0YB1vXQKIfhWTI4HQ6NaYDAHtkHzx48OWXX8a+mx0sfv/71//qf/nXJ4fLL//w+3a3cYTMLGlMpxIgx5gYELFq6l3Xtm37f/gf/vuPP/64GwbnKoMYOWGMkKW3TFbrGqK6Uh7NFJEWVyB3gpih9mMnKCWXeHT5+jt6FpgRBYbB9L0DAKy0lesAgHlkYWzbnkMcJSwFteSz67v1eqNMIKLUj/9JVT/k97RPFUqizSbilACYRqooRhAlm+QRLMyav2GhTFHst6/UMTFoAfnO0YiIIeKUhFHZar2vrfUpjnAbvKtU64JIsV2Y0zOR0dPthwvldyxLtI6cNwroSqKldv2798xgRmxJ4QnZG8QEFoCU+Ec/+vzZt8/btq2rpqqqxWL55s3Zi29fffLpx87vkT/sXfe+ay8PoFjV8gu6aiBojQNBLWszBxFommo+bfqQTo6WTx49ZEknhwfIY5Nvvdlaa8WDc+TN2OYki4nh7eXlru+tNSLSvXy13W436+2m3TnnHjx49ODBg916c+/evcPD488//9GvfvWrl9++0FbTyekRWGuMQYDIiaNoBWy3WxHdDXsAABlDBPqAtU4VY9QZu74P1gAIHyxmN6vN6cnJEEJTHT198tgSEiZOYTKZvMWLzbpNMThfWTdONVCO4wCA7IgS0kk1Q0g0iuWZPDX03lamQvfDd5PjzGzHWHj8TowR8ujLZFKrHWmaJsaAOCEikpJl3mkswp4DHs/NXtXr7vDsnyLdvXp49ioigoqOvrtyARABRCMw+n/9JiABIu1VfkriC3eR6RgPlRKxOl0YRU7YGDceVER1XZPJRCuNatCb6TiRqd5XiS9CJvg0owaR1yNNexqXLLEcQs40n/fv349ZCkmdeoxD27K1tq49cxRJCmTx3mrltm05hB5xZKZ0VV0ctrrbzWYDuXstIsfHx9PptO/DYrGY14uLi7P5fN73/Xw+3+12Osh7fHw8DJ1iiB48eLBrNwR4c3PDzOvddj6f9zEc3ztdzuZ/93e/+Pzzz3e73fX19cOHD3e7nSbHCvOs63q5nOtqbDab+cHy4uLiJz/5icbci8VCH4duoYuLi9N7x4uDH/37f//vNWJYrVYnJyeIqMBma+2DBw+++eYbALh3755z7uDg4OrqRvvB+w3XxWJBRJvN5vj05Pb2VivAWmbo213btmdnZxpOWWN0Mrhsb115yjQsyrN/t/kzAAoARLDve+/ru+29V1h+z1Lp8SczVoM0nOr73lZ+1kz0g8asyBoUHcE3th5pR13kp48frje3q/PzL37/+r/9l3/18QdPvvrjFzfXl4ho8c7wRoGUIqCx1gBQn+IQw7/4r/7l0w8/vLq5WS4PrXeAmIZUWlclHBeRNFJmjobXZBWQupaUUoh6UqxlLcnECTUFewgoANq4NUFC3xljOkRxNMIRhoGcBS0SAABJ5b0YQ9ZSQWbpuFTuvLwfx9+d+mJYBADu2lhEBHskEzKWgRn3oCR66vf+CZqKGCQ1yCAkwgKY55fy7+xBt1IU72ptMo7c9bmqvHeFd4O8glm9jgGzwK7mn7DHUWjPzs4U06vscTe3az3M2f2WN3xPQkvzaBQBRVRrLXIXu8PDww8//PAPX3xtjUtJrPEhxK+++uaDD5943xBZkZSGYIwR4f1GnYjsW/BiQPUeFDHLnIR0f9QF9NS27XJ5sF7fxsgnx0cnx4fb3e7k9Liq/Xq9ztMIzAw0hDCYqqqm06YPKTJ0YVjvWmZ1KlF0itw4ZthsNq9fvzYg3377crfbOVchYt/3z58//+lPf1zXdaFfZObEQsz9MBhnnbHOeYXPqb+xvsIUUgrqpLuuC0H1XC306d7JEQB+8+wlh+CsefTo0WI2RRJj5dWrF4vFwaMHD1+kN5HJ+6qpvPcecCyKKnRWLfhiMZlM6uvbddu2QISEBGyML4tJRLpB3m39jsZIDxUSGYMi6oaJOQGKMcZaqrwnFGauKl9wtjimueOwL8CdjO7daZG96WAYe8law9Ek+C4C0wgyZ7CICH+KiG4fFJ33zzt0qsUOFn+vgaOUuG8vFE17zAnMQc9qSf54b2RLkyH9Qmu8MaubaapUUNOSB1d0q1trhxBLqQ0RUwjT6VT5MYioaZqqql6+fKmOVn1h4Vm8vLxUNkr1/ZqRj5SNzMrxtN1uq6rabDYHBwdd22o3lJkV9gxAwzD4ulLpAr08S6ap6hcvXqxWY5U1hEAGUkrz+fzFq5fl1m5ubp48ebLebj/65NPASckUDw4Ozs7OmBnROIdEdHJyogk6AIcQDg4O3r59eyAHs9lsOp/drlcPHz+aT2d/8zd/89Of/vTN21cpJWMNM19fXzdNc3x6IiwKbUt5gnY2m11dXSHi1dWVunDFQl9dXVVVdXl5qf5e2a0PDw+7rru9vT0+Plag1nw6kmr5ylpr+13b92MVQeukup4aTnlfF0AQ5PKjjDMOVUqDoqlLdaQ01EpHrPwhMwuwtZUyfu+Dv8AQ5xjOWptSSCmhIVI6dxTvfQjbyWTyweMn/7f/7+//m3/+l5//4JPf/PKXr1+9qOva0agTICIpCXMQIGsMM/Shp9r/s3/xL05OTr755psPP/4oCcswjPiePD04dklYiEjGUs2I7y05aJm5YGMQjQoJwCgTJDpTpOdbxrouaihTOy8iOigMLOJMDGytnUxrvQx1vcw8mUy6UMJfRkP85+iuilfLpmCfKitXnkYXCzKWVEszCJAV+VHehEEMkrXWeGeM4QTGWcpKvYhokAQ4iYQsrQuIVVWNhDnG5DiB3vNZoiOUWKrM4/WXXnWxS4gGAG1VOeZ4cXHmnDs9PXWWhpDuUuq9l+x9V/K8Zl4g9N6LpKpywxA//fTT589eKX0jp+Scu7q6evvm/MOPHpNBGcO9O6r9vMR3GvXFjOo97OdVGkEoDmu9XhuS+WQaQuCYlsuDruseP350fX09Xyzqul4vNtfX12/fnAmZwIkEOez6vicanVAckkCy3q02W8rS1iys0ybM3HdtSlsAuL6+vbq6evv6/PPPP7t3754xBvOMAQB473UywTlLWS9lGIIiJDXT8s6Uk6DGWkSI2PvaGh+G9PrNRYUOQAU/pPbu9PjIOH/SLIY+GLOKQaraWWu0elFVVVV5Edbyvq+rGDillDjEwGTIGJMiF3Yb7X/AXnCjq1rqUURkHaEhI0bf3BiDko6OjnS8W2Qk0S2hn3o4wtHVMaNOBUgePIfcuSGwgqXNo9CxMWDM/lsAQHfwfna8f/D0pI3N3zuT9840XclO9oNZRAR5R94R91ijOU9wai2rGN+SZhXIVRgGfdyl7IxZFdjm0W2iUddMK7249yoBdV3XZMybN2/0MrQZPJlMVFoHMwhLRLTAqwyLNk9D6T8BQJCCjGZoGAbNaHXSSa9B0WTeuxDCZrNR6mZjzG63Ozk6ZuaDgwPtyRHR1dXV69evtasKLH3f37/3sGmam9ur8/NzxVQfHR2stptvnj87PDzUbax44JOTk5RS1+2UMEdHXVWnyFX+d7/73cOHD2Mca+C6tnVdW9ecnp6+fv36Jz/5yTAMTVUbY/SaAUBBXvqYnHPX19eqSaxjSypmHEJQJqwCjVauJQWZd12raxtTGLuauThfcOOY5RN2u6vyta5STlnuZnw1G+Ys6IlomFmnDEpirZG6sTo7kBRf5rLIqZbQnTMSk3MmJY3JmMAhjog/a20I7Xw+/9/8r/6zp0+fPv/6q/OzN9Pp1IAojkSra4EFwRiDIaSQkrX2H/6jfzRbzK9vb5qmGWfknCe0YChwgpDxwHEkk8kbMjMj5hnFPAhnATFGJopanQ4hFTHsGGM5pmMhwcBglQTBAhMajFltXRhTkhBaXS7FymhAk7KKOTPTe4nenRl43zGTjHlw9pp3faVx+CiFGO9ia8gBPWbUi82SsmjwDqqsYQWOobky0YpIAQEgGAAl9ivmvwzsCCAUydf9umNxvThCZUdMuJ3NZqrG3HW7kTF4bCm/sxKyJ/ohuahdLGT2i2OId3h4+NFHH33z9bOqqnvuKt+E2D179uz+g+NmUqvByivyzkeICCLtZyf4rv0twAeVZFmtVojIEoFxOmtC37Vtu5xPq8ol4eVyPp3PjDEX55ciwgnQKigm6MzfMAwadtmQlOQTM0DGWtuHYRiG2nlEub1dv379um+Hn/3sp59++r26rrt+5xWAnjilVFVj74SIASCkSIDa3EqF28GOsWeOJVVAgw3CZDJ58OBBN4Tjo9PEyomanPeffvrp2dtz69xsNgsJwsBIUUQFiV3lrKQoiHWtmpSIHo+PD6tJs16vb1ebtm0RvI7BEFFKgbOWhs0jvLDHZaomSb9f1/VsNtXNeXx8GELw3jrXXF9fq4EuRWzIneC8EUf09Z84OWIAU37chMh7frYkwSR7qgySf5p3Bee47U5r4b2Nuu+JSyjAPEbB78WRKSWXBXS10asTnzFT3mgIpR63bdtmOkdEHQ9Ve8rMOm6kJmkYBiKrkJyUksG7sFqP5VhpQCyqZzHGppmq+2zbbcoodEVI6cVcX19rFtU0zWazUZbKEELkmHCEJWovTW9NG8wiopClvl97713lV6vVbDZTH3B7e6vBeByGpqoyV2W4ubl5/PgxIsY4qJzf69evf/jDH+q6KRz6+Pj4enX7+tWrx48fbzY7a+3z588BwFrSOWbvvV7n4YFfLBaqpqDY481m8+zZs5///OevX7/21bTvQ9cN6o/rqtZlTCmFvjfOKZrpzZs39+7dG4Zht+tOT081MNLMWBdK46HNZqNFJq0eazqrxQBv/MuXL72xw9DpJIWOx8AebXgp5uv7a4NfR030g/bB59qtKKAteDdziDEmBh071nLdGH5ldQfnzJCihqE2C17pdte/GoZhOrWPDj7UsYumqYa2BedgZOwCEWROCCgCbT8sl8tPPvnM19VmszFZNdl4N3QdZF6w0PVazlFaAsygBGPumDhRRGlonFNkRkgpZ4G5dqpRQjFlmLlXNdowRjtKtS6mkur3fZ9CgEyToHMBl5eXi/nBGASPydj7jc/3bcj+YX9n2QUAtAGMgDxOJ4R9SBMR5dEPa95VDR+G+E53LBO5p5QILSNrT4RFiIzkFFRxSu/bn3JV2TdrxlXsgLroMeI5evRDbO7Njj64vr58++ZVu9s6Y5mjMyPCG43VQjQDCajKJADwXRtYr5iMoEEgAnbI3//BR9+++JJhe3B0hAZWq/jlV88ePHj0+effTxwAExIYgzGGGGJlK2McI4nkFdwnyEQgg3GsWgshWGd10HUxnw1t0AKsZUwiKJzC0FSOyIaU5s30hm6aqo4s5Kht+16GqqrW/WCtZRaOISVBHJtAja+IjIBB8ijQ9R2ntFqt1jc3xpgf//gHn33/E2/M0G0hBV/PQhgaX5nahBAqb1NKRC5lfnwi6vs2xrhYLETG4qEOI1qryytAtp5U7XbnKB0vPISbWdPE3c1kOjUiglB517arxdT2u3C5vaVUN01DQEozTQRNXRMRS0TEiXNmWs0bqiGYsGuBLtYDpyCMXeys9QIYY3S1S4LIKaVQeR9ib5DqZhpjhJCG0FpnmsovZpPKmdvba2NxsTy03s2mM83s79+fkwDd0WiIek1rDTAVJJGoUUHMvFMMrDoSCQCYQYvTROOzZmZAQbhjCEEwkuWrRQDREpW0+Z19r868MrbvBk0BDaldA2NszJyCmLUotJ6sh1AnTOyoPQh1XavAe2nQAsBsNkPEodsBQO19SknRoYhm1/UGiUePb9p2O5021hKiIBAgb7YrRc9674ehC4G9t9v1rbWj3FLoW2ewrmuOLoWgSVgUWa1WsIfqUttd7CmSSIjoHKKwxM12NZ9M+747ODlq27bdsvd11++msybsdnUzcRaALQpwYgJs234+n89mNZG9vl1r1OW979qha4e+71EodLer6zZ27XzSxMg3bbe6XsU+kqd20zbNdDqdM68vLy/v37+/2Ww2m918vjTGVRXv1pvdevPg9N627SVxXbm+A5C0OJyDka+++Xq1uvn0e585CyDBGuQUAH1iZmHlSK+kmkxrjTl0TMsYozm01tuVLAwAVqvVbDbZbrdD1xpjQh+9tdv1SiesEFFVRBWuvN1uC2USIRLakAKn5MgyR4ipcb6p6/Vq65wTeV+ysChnxBit3eNzFfHOpZT6vNmIKEAAABSMQzTGeAHuAqQUIaBQJ1LXk+12KwCVpdB3lXPkTN+1Mw+1c7/+zS9VgxnReF/HGBEcJyaiISawVRTeDf3y5Pj+0yc4qzdtN5lMqqZBNF03eAbnnMQESCSAeUwOxiYlY9IifLDW+sr2fc/ALFw3HmDouuissdM6ht5Z6tphoMRxUCRmSikmtmgSc0ySUmyoBvIhIfUB0bBITBxCVAy1OFNVFRhY77YHBweqWnt6716MAQBSGpm0/4SjfbfyuheOA8KAwIaYQ0QRJMMxkTExRGFDY8g7zjullKyKpxqxzjuqhE0SBARrRqEUg2p8WBWj1Wij8VU1RVMJJzI2CaMjLSnmUWwAFhRiABylYgn3OPv2y2AiSW/IGLREdHp6Op/PDw4W3pnn33ytdHSRk2bTIiLCSo5JaP48NydgRm0h4mKx+Oijj7766qthGDQwJ6I3b96cnBwdHC6sNSkFEcBcvtM7kZz7f/fNc4UzF/pBJ6ldt+01VlU+Gw1++76vqrHQpOcWeGyBgAAztG1vbVIWBWMkm1epR1Y/Gbq+bdvdbte3/dC2zrkPPnzy8ccfV1XV73aV94gOQBUURDiRNdpPUjio1oi0GDidTodhcG6kjygdJjX9IXHXdUXcZjqZAIA2d9u2Z5Da+Rij89W9e/eIbBfA2DEI1XSQJRJaQ0bL4LpQs3kA5L5vwMZd3+12Xdqmvu+Ntc65oevquha4q9soaEv2xhYpixg2TQNCi8VCrfNsNjNGqxSQJ3ag1C2YWVvCpbFatp3eOGfyjlLwgXdT1f3zVr7GdxUa3t94auwAGUHto2RKDRmlFO4I90v8Xig1NDuZTqfWjphYten6BK21+g4hBC1vUla/UVoJnZE1eR7fe9/3ra5M13UWra6NAhE0NGmaZoTsjpRbVaGp4twnBoC2bR88eKBYKkUVqfPQXFlEYmANI1JKgKC/ICIpiXOVDtFgZkBTHNnhwTGMbFNJFSdViEy5JPWONCNc3W6ms2axWADA8fFxSqnvByLabrcffvihjt62bfu73/1Oz4WIaKFVD0JZk4uLCyCrM0XKEAKEr169stYeHx+en5+r0O/V1ZWIXF1dLZdLDTgKTGEIUY+Vni9jjO5DrdJr1T3l6equ6/Rc65SRJqDMXFVVTEPbtt5YRNFZUF1tGSGxkEQQQFlHXF0JJGsbANi2OzUsalvK4dUzoug5rU/2wyCZ2r20NkpOT0S1U2wwxxhZQEQGosRRCwaTutJzVFWVxeq3v/3txcVFCqPYJeuoOhpm7mMSBE4pJG6a6cnJiSpkVFWlD3paN6WQrntg/zSVYFR3oO6HlAVaKI8k1XWtY75jbQxMt1llaAU752Ias7oYI+UMOCWyVOuRgbH9mdTfhBAokXXm6urq7du39++PQgAiqGMjf9a53FmAO/jbe7VSxCxrynfTR2lvCJiZGQ0ik4H89BMiAIrNiquQXbWuTAo60jK2GBIngJGrMr/u/oqIAO+mHHGvfLv/q/t2zLKIIWeMqevJ0eHJ+fnbzdnaIqnDGH07AKIYoAQJ360Jv28oVQkjpaaqP/n4e29evdaV0c7N2dnZdvvhbD4R0TmjkV5RkigF/3cvt3xzP+qRrE+paZaunSCOB6/vEE1Iabtt356fXV/fGOMsIDNYSzFELWKD0NBHLT8qxLxpGmbo+55jCiGs1qurqysHVNf1hx89/d5HHzdNo2qDfd9qZC2ZS9lkOdiUOXQAYDKZ6NZ3mQNv37eV9iHHpMlH2/q6aWIIVV2LiDGIQFVlojAgKdyMAgCASi+LQFU755zWfLy3VaVKsZUxWFWubVuGZDfr9c2tsTivJuvtZhiGuvFpVB7N3PEwIvQksvobAGCGuq500EvnB2gk4WNJEYwho0/nbuwHdDD6T/FplJxAcrqKWWVMCDH3YPZ31r7f3T9y++9cfoqIOhhmLMVwd/b00egeDcMQQ1APrQGHde7q6koVZPt+BI1rL0YykEqroACgkCibmSCzq6ZyHFJKzo88GCPuxiRnx0q1tTbGYTzYKemqhhCIsHwiAOhUKxHN5/PVaqVBlYr4AkBVVdo2G/VkMuOEdxWS6KeErOG63+/UqWVOl4rt0oqu/rJK5+52u4cPH65WN23bbrfb5XLpvd/cXg7D0A/Dq1eviMbWY0rp9PT0+vr69PQ0Zv5FRQnEOGjPdbVaaWG8rush8na7vb0dgc06J6MldILRgr948WIYBtVH0kvFjCTXkEXRavqeWplQXPFsNgOAGKNy7ekVaiCl/x039l54R4WgBpHHH+WHmLsqBlALSyzRmtGBaT+izP5aa1VgJsZYLkxEMFsnfQom551ElDIpG2sCLiIpOjISU1P5lJIAWyLv7W9/9evXr1/vNq3ut5RSAhHBJCmwMEhiQWN95ZrplNDoVIiGazoyJxnHUCKzfaM6giJZdK/GGNUM7vsJ51xKIw4RAKraTHgyDEPfBSJb1yQC/TCUt2Xmvu9jROvIWqsjL0QkzMXuaaqtjC4HBwdtHljf71v9yVe2BrLfHtWLTSnl56WTbCN1F2fgm947aa6gJK8qz/ru0ISMrpo5Rj3FAOCcU0hmyk2KYlJwlCmCO2uHd3Ti8G7u/l2nCQC2richBGt9SmlxsHz8+OlmtRZgFABgta1IoOJFEhnd3ZzyexY2t0bGAZiDg4OHDx9+/bWKEtZD6Fc3t8+ePZvNJwcHi8ScUtShb+GxQC8qpLd3rXf+uPAY5IaNZGSvtXbXdfp4tu0upSTCm9vb9Xp7fnahd6cLxMwIxhCCJT1IGp8SUd9dHyxSaqqu67rdVt98OpktpvWjBw8/+uijpqli7h6FYfxoJdMv16m5uGYA0+kUMpahBM5lNn90eykZMioABwBar8bcYrTWdkMASETUDT2hOTw8tNt+u92CJBAhQ95bnZIvb55SstYg+hAG5uSM1JV5+uQxIF1eXve9i5ziEMgaADTGJAZgIJRBK/kgxpghxW4YGhFGYCRmtsYDjsJbxjiNM3jEcYwVntJEYWaV3FIEloiM1eh8Sr9ztAyToNwNI/354/fOgSk/Kv5+HHrmqMurEylExClh5ltQc6kOAInqulaOlKpq9CFOJhPlH9bpkfJEipvUjEqxAt5XaEYWQMw4L520gXcrxsYYRLKZykOVjjRrCWHQI+1spen49fV11TTqazEzX2q+rq5FRLqum81mxT4OfSTptOOosGprrebKiIhgDDll9tAQBBFD6IdhODw8TCntdrvXr19/9NEHm83mzZs3zHz//v047G6++ebw8FByeppSevny5fHxcdM02+324OBA4WOXl5eTyaTrdjoKrGGcc+7s7Gy2ONCDcHFx8erVq8lkojPB3377+tGDx2dnZ0oRrHwmOu6s1n+EENtKCUYAYBh6AFAiqlLkcM6VZurY+8wvvS8i6oeWs+Bj2T97Rj/pQ4lDqydXXamO3ChhTgi8b3N0IxljqsoWVIdu8iEEW8K+XL2DjOwr3Zmy0Z1zfbuz1hIwx+Sn/qs//PEPX3zhnCkABWEktCmlqIqjZAUYkVxdW+t2u52QWSwW7a5rmiYMcZO21u0Rwoex7AzF9aoDoDFN53F8kcqaFNcF2ZnpzkTEoRrZP4wxztp413IC5gSAMXDvgjrFqnJJRIt8Ik5EzIAxRsU3IGJKUoKt9yz//qv4AlVLz26C87yJAWR1JSmP+hT7oH+YD6CzrnKuIrIMAECqMEF4p6WW0ji3zczKXJY0ZVLMEO+hPvfiFSJied/XluzxvXvR79uQNALyjhlAZvPldL5Y3VwnYJNRYwDAkkTeeXL7RrB8oTteV9OR+ejpB8+/fcuSEHGxWMQhfPPNN/cfnM7nU2ONSBJB5nFORUQUhV8W+rtPoqQ7JfusJ5Oid9b3PRAimoury6urm27o1dQKYhpSGZ3ScU3ltmQWIqX0xJubm5sbrpzX6q6ztqqqTz96cnp66pxLoTfGMKehH4rLVGicPu+C41BjbfJ4g2SuPv01DZyxlGSZq6pmZuaoWJV9cXJFhAHZruuGNBCR84Y3UZJoQdh756yZNI1WhARBxI6gXEeATBgJJHpZbXab9a2khEAIyDGhICMp+xqOo7FovU2AwzB0Xc88Mq1rxqatYo2v1Z7mPY2Id2dVCkLyLj67QytQCbAKhiDv1ztElqCI4B4K8LvJ9J87qJTZHFliTEEE1P7GPKxJWXRILX7KU0MKVYNcX9HF17vQMqz6y1LQ02fXdV3mgIUxxUlpX+0u5vxAzZwxI9nWkHmh8/hvqOuJtZaTdO1gjKmryc3t6tGjB/q32+22BA3l+kumqLGCMcagxBhvb2/THq8TM4chKd9WTENMgyE3ZDi3c265XD579uzjjz/+wx/+sFptDg6OAK6stVokV9rXk5MT72tFUaleVlVVFxcXqpqlo5yatRPZGKOCtBGxmjQppfV6fXl5qRmqiFyeX+y61jm3WCyYebVaqcS95JKSVoz0pBu6E3XWbaYVb13J4i30oeiycKYDU4en/kM/OnRtqVfxHigvckxJBCFwYmGRO6/DeUZWq9D6KWPhLWfMqmZSYsuUybrLFtW3CjqzxBx5pGbkmJwhg9hu17WvppP6+dff/ObXv2aOzIigesaMiGiIASMnNJY5IZkEEobkPHjjhLHd9ZPp2C4h1bjV8TwWtR5oRphkOUGl/oyIwmOcVyYdSh5fUFfI4shMp1NmXq+3GgtqfSU3s1AEQwimN9YRZsqXYtP0v7PZTHtzktXPShz53TP+3jEXkczSNM77MLMgiQAza06vP9VktCQ8IiIogCN9Qho7yvk9xzdPmEcTCYXNOLDLxcXuDb+QjArEuqpq18qHftc6lX9yobsXAeMqEbHOOecnk9n9B49cVafIMRtNtR0CbJ3ZW4JsbVlIAFkMoIoaGcDKOiI6Pj5+9OjRZrPRw7lYLIxx3z5/uV5vEcgY954lfc+qlkXbz5lkb3BTRJw3SKKSWNY7ADi7uFDIZRaOVor8O25CzgPR+8uRQkDEynnvfeXtbDo9PT398MMPHz24N5vUKAmUAYKZM5uaZhLq+xXtTBlOrIhZLdiWwkBpa5UbCSGoS9MIVPOAMhtakuzdboOI1lCIQ+jaSeUnVV17N5k2KqRKBIvFYrFYHCyWy/lCFe6Uge/e6eHDB6fzWYMpQkoInEJvLBoaH2scQkopcgpprImllESwbdu+H1RJJgrc3t5u1jul4HdkYhhlDBSAqn+phcGYxTz2nuYImNQzzCAMkvYAhCJjWYlxdMOIKAzCo35I+R8IEhrCd2Z73tsq+k0tUQJKCKHvOsnZjNr0IrGgZWTNFPWf2kUDFfvLJPLqJvWb+idjUBKCPrvQD3EYOfo16wohaLqgXeSqqjRMgRyj5A46VVW1XC7r2ouIpnqqmue91zHjzWanabrOIymNlLpA1V0BAJ0FGiIrYYXeXReGGKPS7OnWGtrOALbb9fr2VqVztZQ7nU4Xi8XDhw/7vidrZovlvQcP+zA8efJEWQP/8Ic/VFV1fHysFbm//du/ffnyJeVxo/OrS7RmupinlLTRq+uz37RWwJSGEfP5/MG9+8Dy9u3bxWLx4MGD4qLKymtCbK1VNHJ5WNoI0N9XbGqRatbb1K2oa65PR3vbJXzZ7XaqYKF7uJzolIJzPsaESKUjoL5n17Z6hPMjFiLLQEOK7dBrV6uUu4ksZPR7cQNqHrHIF46IGUZJWvK0ZKzB8zdvf/WrX6UULBKHmIYRqcCAMXJkFqTEEgEEDaBhQNUABqCUJCUJITnn5vO5ZgKYRzdFlHH/jouGs7gI5Bx3yCzi5VnQOOCuoJMRhWOzNLi1RhccRl7o8eyPCxJFH5nq6ABgQZ7PZ0sRIbSSODt7I/J+nP2e93rvVSy5ARRIufgU1LaXgoTsFd6132qMk33FtvHdizjpkFJCYMgdHzUpuf5n3ru20QThaAP3nW4xUPu/v+89rSCIwBCSJRCgqpkcH59eXp7HOHBMUdiOaqwMAASU4B2XaeCdNeKsiaiP0zn3wZPHL54/s2QkMRqazKYXFxdnZ2fTaaM6wbo14c8EC3emfH/Cfe9HzCMrwmbbisjt7frVq1cA5OuKQhSRmPv/MQrkhrGuyxiDEOAYTZNBcpaWy+Xh4cHhYjmdThE5xoCgnGTBGKqqqZotZiaaltRfn42CKXQCUrMQ5UnQyeP9Vr+MhUot+Iwzedq8UerUuq7RYNsGAnDOtG0f+sE5N1/MdJ1r52vnjcEoI95BrZtBFBHleQi7YVu5tm0FYhi6+eLAN00/xCg8DEMag7Ux3iSixBxiBMTtrrtZ3UpiAOm67tXbs4P5KD7ThYGIwhBBkFEQ0Y3aeXdVOHiX+DT3uzLfJCQZ8dF3nH/vbYD39/cefoRIpcZAsuLY/n81auGMARFgpXcAAA0ROLdgy7tpbRmR1BmrHlHma6TtdouIWuzNGoWdEymVDDW+lFv7zKmkgDHGQnwBYDS6QkTNy7WMURbBWqOZ7vHx8YsXLwKPbFZlwriI4ungSowxJQEA771I1Cvpg2smNbQ7IZQo2007nZKIKBkvwah2PAydzj5pLKKN4clkstltV6vVZDIBgLbtp9OpOrzT01MtTU+n09Vq9fTpU5UUBIBhGK6urgpH7rfffqvRJABsNhtXV9pi1JUsU6RKJ7nZ7M7Pz1VDcLFYFEyZ3mlJFJSks6yDvmDk2Q4aNhW4k96p5scGEZjj0HnvlUE9ZjNSjOO+TYwpxSwYHDKIKY4AaR4jY+PUxuuYkwJ/onAlriTNxvgYB8qK0SQAlpjZmDvUNAEYo5s5WTIsYXV984tf/CIMnTGGQ2RmYRAyACjCIQkQAiKDEDlBIOOMc0mwGyLZZIwdiUQYQ0gAylfl7QjHExFQL3PnewTiyJ2io3rjNHOKkm0CIFo9CCEEBWukFNWn1nWd0lj544zhYmYRo6ePwAPE3A4YEKSuvZqpGFEJHWWPcwm/U619zw68d95TSpJCAVVJGkMKyvR/xbIZlZKrauM9GlWH23elwiyIAswaQ+sbVtYaY0Lu+KbAOhSu2F3JMzvlslMGA+7fhXynd1b+aQmtQKqqWll/q3riqt3BwVHXde1uE4YYCZzmbZra78mek0Apmpc4y1orzMXinpwePXjw4PXr11XVsBJXgXzz7NuHDx/WtSeDzFoFyG1geCfZvQt25B1Id/kpESkecrVabTabbdsTUWQJw9hMjWNYIzEOOFb5WXvP+py8HSGLlrCqqqPDg9Oj49l8onGfhZiLycndsauDCCopndYkeVTnNlqy0x6bZKkc732Mo2KM5LC69AJVucFau9lsSpGzlGv0nYfdLoR+uZx7X6vDICKb2QebpsFcRFG7Q1lW+rI/4xguz197a/5nP/vRdHbQ9aEL4fziYg2saLQc1ujyEnPUmEYV0b21q9vNzc1N7T4MIXjnhmFYTGdaw5wfLFJKfQ4VBTgNQRNNPXVE+2MDhHRXEbrb+9n86YszQ5bk+t7+ISxeU0Rgj2RVUQsl/dU/z3wLNGRZBe3QF7OYMgdk0zQpiZZqREQ7uJwRrSNrRHYAI/7WOe+9cz6EoH507Bca55xbr9eKr9aAQCTpw9XwPGV5pfl8rt/Uj0AkRUVVVSVh0D7uzc2NMpBPp9NSgoYRnGliFl/Sjarhgr5hiqMAsO4ZRLx/ekxECkL+4IOP1uv1YrHY7XbKRL1td5vN5qOPPnr16hUAXF1dAXyirvfo6OiPf/xKl2W73TZNo1LBi8WimjQffvjh2dnZt99+e3ywVIPunGvbto8h7FJdTSaTyXa7ffjw4cuXL5XAMsa4WCycq7SMfHV1pcQauakxlnn16Wy3W8rQ3BL3KG9J2w6admy3W91vpWE/mhRJBRiv/ULtodCeinNJ+NRqhyxwlM/UnU6tcVUfdqvVqq4nxhgUJjSI0odgjGl8BcMI0WIGMjAmTIWrAZFFxjAcGdEqp8OkaVbX7d/+7d92beuc04FdIkpoYwiCIGiAAJDIGgSKwgAjR5UIIBLACPL3rmbm3W7XNJW1Vu02ERUR+DxxO+rE6POSzHaSRv6+MTE1xuhR1mpHDOytSymlxAYlIiKONlBEYkoj3w9ASlYjgFqDmBiZYzPRwROj0FRd5yEGrVMaY1T7/Ls++E99k0VY0rja+QGN/WzYU3fQ9UFDImLIKeny6MUIBSQT9gmAjOVeHom7jXfGO5X+VSL9EmfrfijeVHRckln3Z/G17xm3fReGqBIQYhgYiEAsp2CcXR4ebzabq8tLZeQPITrnAse6cint0U/LXYp9F1HuU0iKTCaTH3z+2c3NzWazsb7y3oeQ3r59++LVy8+//9kQemNMIbDWYdYS+cK72U/I4ueyV0URCd77pmn6vl2tVn1IACCAxcwpGRgBqr5HHwZfub2HqiB1OTk+9t4fHSyn0+lsUqeULKEhNojOGe8nKSWFb4TQa8FZ5080Xk4jR2CsKqffNBmr2TRN27beWz35BUKp7A0pBcmU/QCgox02yyeEFIlgGAaOcdo00+lUW9fKg7HdbpkZR2cPtavqutEUDRWogGjuMSJ+/vnnMXJIGKJ03XB9e9NOJyEOzCkkQGCikekpF1e7uq67dlAa567rzs7OjpYHfd8b5WWMoxIc2rH+2TS1XrOxqLZePYRejIgoe3mCVOqHwJKxMgggKY2dNkgsuS0kWbJJvRQjoDEjV7UeAeCUkqQICOqNptNpVVUj0QoiCiSJqv2pj6k49cDJu0rdpzFmGHrlMlQkncZSWshZLpe4B4AqKC3vvYJvtaGVUtKOgE6tvH79uqmq/T5lSmk2m3Xdzhj03gKAem5FyG82G+8mzKxKt7ebtabL6/X65ORoGJJW9nR7AEDbtk0zlbGUUsVxCKpXWSRjDKekIGFdSWut/kibr+v1+vr6+ujk5OXLV23b/vjHP1ZcVdd1v/vd737yk588fvx4vdtqCTfGeHBwAACbzUb5n1Xfd7fbvb04Pz09ffz48b17926vLolsF4ZNu1sul4HT+fl5DHx4eDidNU3TnJycKJWV9uBvbm7UeetWKdwmmOlRQwjgaTab7Xa73W5X15NO1eZRCm+z3hcRbTab09NTrS1r7m4taUsSEfWflDXfODe2SpO4bdtqMgUy5NwQeompdEBDGMWmIkNVVdfX185VrvImm1fkUTZHEJwZRaBZ4C4YzUaYmdmaEU7DEjk1db1br/7mb/5mu9kQUd+H2tcppRAGQUZDLCgIXdcfnpwAmsDJMKIhIiu5+xMDG3IiMnQdSrVYzBQkVVc+hFDXPoRxFJN5JJ9JKVkaw/27c0o5w9trXeuJqKoqxpSSNFCvwjqEUDnXA1hrRGhQLTUeNUVDCERVShJSMiGE0M9mk8yCYEPsE49ACjUIlLHKd94RAO7yPdRJGRzZ1EcWkTRATnbHhKc4iD0/N7JTjc/aGiDDIohAiJKU7dr2feutW23XMUbnbBiGzHOeVG9NHWqpvsCe6nlxSSZD38tdlGUsYYTsJcQ2Xy4wB0BAa+pqkhbp4Ojk8vKy3W2stWIMwEiEC+ihwK/xrixwl2LDO6lr226Xy/mTp4/+7j/+ylV1HgsOr16+eXj/wXw+7fq2duN7vhcvlPfcex7w3Z9qQrBcLl+/fmtdNQyRLA19UKstkgDQWgNgAaCq7diSMcZaY9ApnPXBg3uWTFU7EkAUQ4onF6FxcTnr+qmEqNLVhj1JV2MMAGv5qwBkdNEmk4nO7KYRCnuH4qFM8Lvb7dR6qtIcIm63W06JhWOM3lvvPUhCIItkcQQFiAiwIOJkMvF146wzZE1xUYgOZ0R2sTiIQa5v15eX1yGI9/b4cN622xB6LSoZpCEFEUkxEoGGd23baktyvd2GEF69OQOO8/l8Nm22zg1t17at8RUR3NzcHB0diYgxZnu1NSjqJwDg9PgkxGCt7Ya+rmuVh1K9bQFgjlrUgsyIKXEEl5awukSL5KzJnRh9HCklFqmcZ0PajUYzhrcEWPuq4JW22w2RyVtCcp3QaMlOk1qdDdWsSxMgDeOqqtLUWR+6mmOdQ1MHzMw6QqMI5JR4Op3WdV2PHUqxljQwEhHNLUpuJ5K0OaK3XK5HXTIzM0dVhStZWik1mawJ4ZxTfrQx7Iv91DTMHOK4G5umefv2raaYOnalB+3q5oazD6vr+u3bt9fX1x999NFsNtPf0TAlpXR9fd334fT0VJfie9/7no4AIGJNWNf11dXVdrtNKTTNdOqnVVXd3Nwsl8vLy8sPPvjg4uJitb5R70tEqlYUwjin65w7PDwsosVl6EuNmspOKPOdc9UwdNaSLo76OXUhi8Vis9nc3t7qsqi/HLpdsZsjv7ExzIwEZfRRG5Mpw9YUYslK00GkAai2U1TJUYAnkwlzdIaGLpZMGtIoqCVG2qF3ZIicZlWgNgiJcQT3QQbrNbXvuu4//sf/eHt766xVL96DUanErg9oTV1XL169/Ht/8ZenD+5fXF7fbtZDSDo6hYQ297ZCCGRIfDbRmfFfjaTJwGzFnagNVGepz7SkUhplYu6MGAPej1m14vaTSVXvc8d3dDbO24IwDxyttUMMta9i5GCSYtqPjg9d5YsDQ5L35Y3+1Kukv7ppme/ip5QULwYiIOkubUtZbQKRyN5JoqGxmmyU04R5HhoRtXWFiDGO1n786L0y3L77/O51fneA4096sfJ9C++4S7FkjK8a5tP7929ubp5/sx5icNboI2EAhVyBaFzxJ94XMqJM/+crlyKfnp6W86z74Ozs7OLq8uBgAZnmm4gIMH2HLLBEEOUZlOcn+YQQ0dHRUdM0nUokgdBefUlEAMWMeoisgAIls9Su7aSpnCVrjUUQEASxzjoyKr1V7iv33irjbB8GRLTZ+xYoh/6mtujUVeRseKRWUFGzmAl7tfeW50FphG1nfYWUkqpXqlXSrqQIAQBkBIpzzlnvXWXKy7pSpksER9NZ1w3r1UbQTKfTXddfXFx89fU3zcQBTohotdkF6b2tODFzNGYcGdSmICe4vb01ZFarlUG8vLxst03btpoYBeH5fH51daNSNgcHy5ubG5Sx+FN5651pmqbtemABcSCJOfHdo4Fc8gJvLBKGu7TY7AdkiGjt2AIAAE0oSJSQdQQh7zabIfLBYumM5dwxVYumXT399ZiZ9J1zHIIueNd1iEZ1eBCx6zpNImOMqrhXEoXLy0sVF6qqarfbzedLrd+qRwwheK+lvxGA03Wjwrw+66pymkxgRsLrDIzuFnRIRMZi3fimqdStKnkkZrZhTUf0SMZ+8MZaSzGyLhpLlC41TXN2diZ5bGYYhkldO2OUnLlpmmGIaPq6rpfLZQhJRQx/9KMfxb/7O2PMz372szdv3vR9G0P12WefvXnzZjabpbRWQOXh4eGbN28ODg6qqvryyy//83/81zrd9Ovf/ma5WLx+/XY+n6/X68lkopQjk8lkOp2u1jdadey6TvWLrLWbze7rr7/WypBqTpRyoq5n3/dDPwpgVFVFBEoeov0gEdGst+RtWsmnDJ2T3PHR3GvMrYG1Rq2fIswIYI0BY7oYDAikaADFICEA4sBJQLEmvXOGIk+barvdxtQAi+CY8WCepdHrj8Kk389IBSYcQlJOeAEIw6AckM+++vrNmzNLbrvZee+berrdbgUpJHaTmpm//Prbv/7H/9n3Pvt0u9sdHMh623pLSYCZCY2SSepHVG48+1ppQ6g10NTwEXJGyyMmf1T13k8wirlTC6bR5zB0MQZrCRIgEhjwlQ3Jp5SsqO9PSnqqxjlm6UMZB6DBuiqFoNAwjnfzvkiCop3HP0MD/a7HKsafZaTaKGY2ZQ7X8tL9j5nEyZArnri4Ehox4YmINNTT9anqxnlfPA3lN1HXtP8+5fLwXRqD/Zf8mR+MiCQyIEDMzFpWtkbZia8uzm5vriwZIGUt/xNkJcV57y+TXg0RxZSGMJycHH322We//f0XxpihD13fpRRev3r74N597x2nCAAoIHtViP012r8B3Sv6/pDH9fQwP3jw4Le//8N8vuyGkdUWEX3lUkrAApKMta5ys9lsNpspj2DZcAbEgACAIdWjRqVVMaYQkkgfBjSkipJd1zVNY5xV7KvNJO82z7yXKYUx4t5DX5uMiC7/NHuzSS6L8Eymddd1fd9Pmso6JyJV5bRZEkJApGlTCRpjjMtjnZQlxO++ppqIrKlm06Xqol9d37bt9snjB0fHh199800IYTGbbHYdp8R3uQKlzCPjnGt3PZKklLx3220bY0zCta/Wqy2g0bGT8/NrBawCc9d3IoLAnJxBIkB9H8k4Bchk1OPjTmNnRS9bgJFAY6YixUGav+Tn5ZwPoTfGAEvfdykFjrHrut//4cvT09N6ZDIx2kPVcCdlCgV9h1IvKkW2qmqUK1R/YbPZSIYla8ObMhGuLoJzzlWVtngRsSSveqeG6Pj4+ObmSivDym7WdTsA0Cq3Lq/+1V6NmjV0MMZMp1NldCnIXn24sjcIUDeeDNTeJ+eYOXEo6ePh4eG33357cHBgLBow0ZimaYx3j54+ubq8QcTTxcIYE+P4iefn59PpdLlcXp5fEMHVxTkRHSynm81GQw0iuri4ePTokUE6ODp8/vy59/7o6Gi9Xp+dnd2sbh8+fHh9eaHn5fr6WrvXWqhYLBZ/+OPvVWVBfbCIOGeK1ISiGe7du6f6dPpxugm146PJZfEiipnQBdHDqOkpZFoMIlqv19piNcZYSylZ7dqwZngCnFhQayGqaT1mMSklZw0BKoNs5UwKkcB4iwZS4GQIhAMPvagktSQkAuCUmEiH8k1KKXAYPx2MMCYWIhpCAkkWyRiDKF99+c0fv/iCmQdm731IHFJP1sXARLTd7W5vb//6H/9nP/zJj7UA4FxYLBa3t7cGkHJlVUSAmPLgmcnYi+wz7vT4ssVW/FpSEHJxnGaPaELtgBmFBQciqutaosQYMQRrrXemY1Y8pDFI1ikj4b5fiJmBLoTQeK+9swjDfzrtzdb+nakkolExDxGRRLV2iyMojmPfH+17YkLrnANBEETKvlNRbgQAoEB2zLI0Kv0bRGGAf2Is6j1fvu+23r2LP+t9AcDSCBGw+U1BpV8G5uXh4f2Hj7tux8De2jQk+I7Pf++avntl1hCzRaCTkxP53e9TZK2vbrbrly9fnhwffvbZJzEAmbHSu+/Lv7us+1/oy5FJoPABevLkyYtXb6y1jaEYIxk0lowxljTJNtbR8cFSy4NERHQnYTtSE4AQGZSU0nibZCjGiGYs40jWSCl2MAkryFA9bhkLpndn2L13moep67V5kF8j0/V6LZkLZkyjkZ2rtRaqybriSHe7ndoLRPLeAlkRRILixckWPIIIAqEhY8AAkSVryJqqqZcH0/Pzy+fffnu4nDPzarWtvU8CMTIQ6Qepudf+KDMDwwBDCGFVb5pQpSQyl81uS9YBwDAM6/X64uKqrmuDAECSgqtsHII0sl7fzifTNPQSKzEAKESEBCxJmcXIOWNIhGPOJJgZBYy1jGOjBczd8DSOJGhOYoppBDQNXUcE52/erq5vqtPTbrsrwRki7na7sjnJGgIlqk3F+iiRk9IFaH6p9G3K6KRuWPu+2i9QbR8VlxxriU2jfU1m7ttWW8UiSeHQ+mtEVKgwxkEpAM3/tJRtjDKKj3hs/Vpb0cwMyIm52+50V7Rt2zQz9UYGUS9eeW9ijPfu3dORm6Zpri8unavW6/Xteq397Nls1vf9arWqqmY+nz979uzg4OD3v//98fGhohA0iFGPu9lsKuuGIc7n881m88nH3/v+D3/0/Pnz6+vrk/v3lElba8taS7h37958PlfDfXp6+u/+3b978OBB3/dt2242m2EYjo6ONpvN2dmbqmrUlSqIWiFjWrQosaC2ZiATUekZVBSVjnit1+uDg4MC+9AolsY5e5UHMFq1NkTCY5KqMRAzS0yISChExlVWRATYqwwfR+eodnXXdQDsvEmSaiXwnlYEqQuRqCIi1OQhJs6ozPEMkjBzEkZGEVEoUBwSeDBor6+vfvGLX1RuhDgRWU3UgKiPu6qqrm5v/vqv//oHP/h8t9tZ53a7rqqqxWzStq12nEUEM3cCZs5LGFMXReeRcy4ETpk7IaVEZBFNCMmNucCd3NNdlR6xFF2UTrht28L1iAjOOQ3ZwcS+C8zROZPSCKfKiJmx8NB13f37pzbLwSEivJ/18l7H9/2XiECeuEFEyLTHJq82pyCQYKypcalJaPeX0GqrMTAiotbM9lwMiIiaiCSsZxn3+l/vXRXm0fD33K2IEL5/C6Ml/lNVa0S0d45zbN8CESJZ5yr2w717926uLi4vziwZtA7SHaN9eQv9gJQ5rADG2WTRsnwICs87OT36wQ9+8NWXX+vzYEmbzerVq1ePHz+srLvzGRnNC7m6W67+TwYUKoUUhLXDd3x8/ObNma8rrV8hInByztWNJ6LGV0dHB3uxYUp5dpDHD4JRz1ISMztjk3BIkYQoYwI1rCv0SWW/ag9STbCSHkgePSyXrW5e100xO8biELq27RaLhXpfr+LtUTSvUvDtXscrOeuc9wiGyDKCYhudH1Nw0UE0QgOGxAgaXzVj4ijSNFVKaberlstFwX+tVuvauyEwEsY9KU0t6OnciDGGBYFT3w86JZVSipHfnJ0dLpd93+523cuXL4+ODubTibVWELx3YJ1ReSNmQxRDyKVWRSCP3aZStQMAg8TCIcYkUUSMdagjs9kBa6iRUvK+6Xct94yIKYSu65wzn332WQHyKLu47qJCo6EQUCIUvhMZhKKnlpvE9G4jVmue6l2Ojo7u349qniaTCdGw3W4VJ6wJRAhh2jTqHu5OmrWFrkQncPSzivnTXrgWBlyWj9VqR934oe+ms2YYBg0CNLPPAlyUUgKiEHvdLbrrStaSUlLglfeerL+5uVHxwa7rmmY6mUw0zlPZ2hjjixcvPv/880ePHn377bfrze3YzjejfEUK8euvv9ZbUOTOarU6Ojl2lf/FL35xcnRYEGo6+KuRjbZRb29vJ5PJwcFB46sWttO66ULUpM17f3t7e3BwoNIL+lx056s/LlmdVhS0Xq3Xtp+96f0W++jsKLwzmdQaygxDVoKzNvbDkO6YOlKKFgQBHKEh8BatbSrniGio3DAMxtkYk7U2pFRXbrPZODLIkoRRGA0ZO8bQegHWWpWGjzGCBUQc+mBQrHeKFxmGGGOsvU+JlRchRVnvds5766qLy+uf/9Xf//Cjj29XK00uJWMS59Np27Y7HrKnBN3zxlkex5qRSCFgoLuidPpSZsosIMqy7Ytp1X8WH1zssPeeLScOnq2IhEgAIaWEJCnptSknyegXAmjvWQzi4eFh8eiomn8go7av3BEsf9dRFTdZwhq9RxEhAu0B7v+oFE2JxjaWMSOJKeNdfoJjMVkQKY3SGlZEwJCrKzCUQIQI+Z1Us+Tc77nY9zzrd79TTNz+n9v3/lj27EWwfr5cnpyc7LbrlAIByKhb8/4bMUJRcJW9WS4tFQiRMNd19eTJk1cvXw/DMJ/PjaWUwtXV1atXrz54/AQFTKY+2ne0nHGw+J7fLcyUZAQxP3I+PT29uVkZY7RQjIgEMl9M67q2CE3T2NxZZOYMjhu5YYwxWCASYgjEGCO5AKibMomEECJzYy3GWBYh5dFvbTvFTISku2H/CwAoG9o557zZ7XbWka/sdtMys7GYhlG+ymUScIV0dV1XVVbVtERAOAEaY1EVLEIcQiJtbRpn9c5c3SRAFKwqZ41yryfv6Pr25nvf+7hpmqaZPnr49Nm3r589eyEigKM6W3kEeuy1/VxXTkSYRRDX63VKab3dEZGM3BQUQvKuct4CJ2vQOQcpOueEk6s8IhgkEJCYUh7zxwwsJCJJHNKghQFdn9l8UXaw2XtpGcB7n7gmQEkzhZ19//vfHyWN3t2lY8fBmmLFGO4GTqpcSYYsnV2wS4WvQ8uk1loVwVTXslqtdOhIfd5ut+v7HoCnTaOF0LquNbKmDL4tXyOiBmr6iVVVpdS1batNaETph5YlrtY3gAvVGNArV5pJEamqCngs3hgzmlHNRPUj1KudnJxc7VoYYRakNEbb7db7erFYrFYrXdLFYqEc459++qnWdY3F4+Pj7Xb7+PHjy8tLZNSeGTN/++23ZM3jx49X2835+fnN6lazXucckf3qq6/u3bv38uXL5XJ5fX3dNM3BwcF01jx79oyZF9NZmoZhT1k5Zm7nPZjbSG0hItZ4fSK73e74+FgR1JSbuAqfLvAZbbSncURCiFQkYwAArTzHGJjZIhHSwDyGWUTjzBhGA2i9QURvbVVVzqAxxltKlWPmYMkYU7Hz1qTQ+abmBJhiCEHG8VBBuDNlIhJFSMZ6GOfma0rRIh4eHv7oRz/68g9/0Gij70IfQ9M0V9e3fRh+/pd/9eH3Ptp2rYhI1+l7Kk5NMUbMPMTS9QQ0Y3NXo2edYdE43jmzl8xpyjwiJ4qjFVFOj6Q1Fc5D2PqGo6ELkawxxjiHYEgzSUYKIWhy7L1n7pihsJ4NMXgw09lMZ9i+O0+Ed61T/k5a/P6rhMspJeUf1YSX914CSVt1+c2lRO1I40QZSnGKUCw2AIBQ5X3lm5FEDAEMCiCk8d1UeKb0wiS/xjXcy633c+j38unyIkQoWYVGgoAEACzivZ9MJkcn946Oj9W+lKh8P9aQd1/ls9W2WjuWeXU+5MGDB4XLpmmm2+325cvXpfG2n++/94b7q7//Be/1pBFxNpkcHR3p+bTWTpv65OTk3r17B/NZoY3UldIr19NLGbElMkqFcwbplMYbAECuf9b1BICcrcq8kJpFlSLXwF93rfalSn0YcvlCC2iawaiZ1igS8I6MpjgntVDW2vl8buyoIBtCiGnQsTkA6GMfQhiGvpTgdGJSU2rjXUppiEEjDAA4PT45OFw8evTw5z//i+PjYyX9d8YKJOdHjkm9WvWFmgsCGmWo8L7SsRBEVKojZva+Vj0fdV1N0xiD0+lUmNUp6lWVaoFWF9WZMTPH1Lbt9fX15eXl7e2tzhHtP+5saEbItJrO+Xw+mdQnJydPnjxZLpeHBwd1Vc3nc8W4hRBIQJM/n/W3y8JqmVcyLEufWqE0UWe2Wq1sZr2oqkobKHo9um8LVafSNOo9asiCmR87ZSVBfZUdq2GWCujiCOEBaxVpP6gWISIqp4qSNSofCGemC93PzKyjULmanawla2kymWghXZfij3/8ozFGq7W67dUZK1pKx7dCCPP5/Pb21rqRL/3Jkyc6U3vv3r3Hjx8T0cXFBQAcHx9/8cUXetfGGI1Lrq+vOSu6p8ynEUL48ssvtZJ//+R0uVxqTVJlg5W5+sMPP5xOp6XYI3sS6Lr46o+1WaMdYt2l2+1WZ8DUJeue0Q91Wdxef1l3lA4avBPP5W6Rc25Se+dN7avae2cMAacwcAwo7AylMMS+G9odS6y8nc8mVVVNZ81yPtVykdpxxZCXatm+1RqGQbL9Ubv78ccf63yX3iaR2e52y+Xyr/+Lf/LRRx/xnrBPMU3driUCLb9r+RoyZZUGXnolxYSqJy5JWLHexRwBgDFutP9AOhCvn6i1bt3VJXjVzMFaa41SYqH33ldWAyA9ZVqkgay0rcTpWgT6rh8CGHnj/9yr/NW+9S6xe3FMpfZQAhHI+aT5joiA2UvGCgZ2f8PIu3nmvhXSGBf20l/8Dv9G+dv9/+5/HwBIlWsEBfLSiAigFbYInrCez46Wi5NHDz8g41VrSfsHiAaAooBSlIvge5FL9p8TgxNrrcBQ1/HjT++THYACIhryk/r4xfPLFy+vvZ33Q2IBTgKCnCTFUZ2RABXFA9lH6urp7DmQiyIalYAka+T4YOIoLifuZDk5XEzunxw4BENUV1UMoVSx9AvnnAGwiJW1k6pyKKp8aQiIqG1bnWYJ/VA5TwDOGAIwKHHofGWL58YMOyRAjmnaTCrnheOkqRDFOaMZpHYB1XRqCVotsvqnEILWBjUCBeC+b7tul1IgAkRJKVisiRyKCX3kRN54EYlDgMQpJUJUrcDSB1KzzhyjMJBNaIIgVQ2bqpkdNvNlH8NiOf35X/7o008eWLtbNPPYhlk9RSGDlsCkJNZ6TZ8QMTEI0K5rmWi123V9iokSmMi423Vt2wonA2lWmdPltMLkKE0bX9d1M5kCEqYh9TtMA8Seh7bfbmLXpr5Lfbdd37bb9WZ1k0Kv+jC189ZA4iFxRInICVldlLXW1vUErTHO+8mMfIWu9pM5k+yGNkp0dRU4CWEfY98PKXEIsW97ZxwK1r4mQAQxxum8tAZy6r2YI3NUUaAMVq+Pjk6s9QzEQIKo5TxtCqQUqsqlFHS6l5nX220znfYhqBPVyM9ab63X8RIFFgGQph11PRmG2DTTBAKG2qG/Wa8q3wx9RDDW+Olk7l1tyCEYTfiGrNYCAETQbXeOjCMzqbwjE7o+dH272Q5t50iLt8b7+ubqYn17nUK/nE+9BW9hOW8I4sFiMqntZnVTOdNUzltaTGeQeGiHL377xcXbszSEN29exTgcnRw+fPwgSXz+/Pnt7e2zr76eNbOpn+xut7WpLNpJVX/y0ceL6UxiSkOI/cASj08OX716JSLXq9tq0nz4vY+/99mnk/liu1v1fSuSjg+Wj+7fq6yxSLXz3lgOA4dhaHft7qbtVyHtyCaBENNABlhiP7QCSRkrR0MfAoqgCHGSMEAMLEH1rRHEOcucGl81zgoPBMO0kolPmFYON7M6NGbjoPc4kLQVxdqJN1JZlNiHbju0G4m9DF3qdrxbx/XKDH3VX7ndZc3rR0v7YOkbmyi0BxO/mNQT71MYUKIx2KW+jR07IJuSdLthGzkOnAaRy/Xmpg03bdhGMtOFaRbrLn346edHDx8NWnFMmq+jNaauHKFUtbPWKhm8egL1JQQoiGQtECVBEWy7IbEwY4wsgpoXVFXFLMBAQCkJM8Q4lu547AQrMec4KKUhtTrRADFwAAMhJUQBEiSonCUCg0AoiUNd14gCwNNpYwkJZLNdPX782BgTBUb+f3RKnymMimMjAGJBAEIZxxTzMAWOQGYAScLMKaAwgRAgkVMELYIhtAQILJIYgSsd/EvgbFM1cwYLVOt5scYQUYwDSkBJ3W4DPKAklDSbzWaLOQMCGTHOUUViFainVmK/HrDvUIvVLd9BHP8K0aAQChEYjSO0+Kr/w3f/4O6l39TQ2Ho3n89zRM/a3oc9ukEALgNh8E6cNXbLjDFKWXD//n3NmbSmCgBv3769vLxENNtty1mkr/g22COJ3X9vDXx0o5TAR8EpmgBVo176mK/oNlWMaLkkDnG/QAF0J+kDmadXgyOtUhZCJREpaZzGuWoF9lPz4uY14paM1qYMHinRvWZRLiufaFlSVLprL3Ur8VrJUHOEqxh1raLrY7+jmI5xKNWLHPqNjdXZbHb//v2PP/74k08++eijjz744IOmqabTZhh2i+UspoEl6jCMSh7pmqeUhj5qlKBBvcYQ2uRTbKrepk7vUMbRiEjps2rBVuNrALi6ulJGfm0BbLYrTd9VnDWlMAzDEHp+l4h0vB07Bge6SdSUKNQo7QnDmYye04zWOU+ZPbSErkrUoKzRksHtJUbWfaIPyGTdkRJc6/ZQIiq9C80my8prZVXPlGal+hHOOe0iF+xuXddHR0daWy75q4ZrkCeG9QI0R5GRLCK0basLq3tJxYtSSpo3L5dLDQV0biqEsNlsnj17Vte10qdPJhM9UF988YXu8OfPnx8eHmqreDab/eY3v7m+vjbGKOGzyjAA8NnZ2XK51Oo3AGy3Wx0ijzFqEBNjPDk5+fjjjyeTyZdffvnixYsQwsHBwf17D7Rn/Ktf/Wqz2aj4vGKVFQhWZgpKRUoyvr3k0JvNZoRuMTMzokRODBI5aRKfMkGgAVS2fGuMksk0tZ/Pp42vlBpDN5KOpgCAQdW/Gw+pfqLyd+puLC1qBZBbQykOm81mMZs0lZvUjbdOYpLEiDh0vSHrrE+RY0giEkK6vLp58eJFCKntu9v16vb21tXV/+P/9f/84osv1MKMmXRKClHUJ1usmfd+lOHItdayW2CP4XnEeOcyzB6hJ2s4W5J1yXh7ybQ8nFldjTGaIagFU1NQ6m1jKIAjYVkpqaaUHjx4oHLFxV6VUwzvvhBHf5y7g3d+br/yOib0d9bgrjSb38eMn4Ij1IP3Zmf0pvb7X5DLVMXdyF6tuyTZ+8WM8oL/Ca+sQ/V+KmzzPxCQtRzNzAA6DSIi5Otquphvd6vpbLZe3yZO+T6TCBSeCtrD0exfH4gAapxOzKGqqo8++uibb75VWgktwZ2fn58cLat6JBM2mSkpqyK+09MWEX173is+7607eu+V/acY1mKpy/pSVqaEdLf/9Duq22UznZg2w/R3ME+CxjytK1lQQU0nM0MW+kbUMYcRW8h7ROeQR4olE++VQrfaC/XN+05lLLghIZKqWzvn+iGmlKIwoSVrNNGRXIehxEnEEAMhjG2bEeyGmbMeAOq6bnwznU51NOv//W//Q0zu4aN7t+vtZFJVVZ2EAUBJdlLWHVMv610dgt4iDn27mE1TSsqx0Pd9U7nKaYcvAEDiuF73oVtrPJH3zBhCrdfr+XyujEuKUe/6XeIQJTbTCQAorY/GKzCy6Y6wOIuUxm08GpTtdnt4uHz79i1k1InN7FHFxJRWmfbXtbHattuykfYQHAYxM0uL7Ha7wtVQTAwRaSrGWfNO/RwzQpYjLJGlwvSGYYhxpc/FWqtDYnVTX19fi0hd10MfS5SmUY6WAVkIALTfjIzFEwNA13Vani2lb+0drNfrvu8V6KceS5HYr169UuGH29vb2WxWGDdDCGdnZ1oC1QK4MaSqySGE29vbJ0+eIOJsNjs5OVmtVsMQr6+vDw4O2nZ7eXn57bffPn36NGU139VqpQ1s/XN988PDQyJijvfu3ZvNZi+ff3txcYFoZrOF+n4dOCEiQoNm7NFy4KHtIHE1abRupG5eU7SqdgycmLftzhuLiMY7QiMyyi0AR0tYeUJJkpIFdmQqa8hbg4114/RwjFEgSeIEBgBQADiFvhv6PoRx2NQ5Z72TJIhoyVTOC6XGVwjkDc0nU45JEnd9aIeeBFCAQTjpjJDKdRKAWOvJOl9XKaUkGFOMfZzMpv/m3/67fyTyg08/HIZQVRXAWCYFACSbxlMA1loFwezb9+JXELFkWZxZNiVjDBERQIqd2XcqxfHoeR+ysJslCNl1IaK3TpC6rpM4/j4RKdFviby3u/WDBw/q2jOzNzalO1BqMeB4B8p6z5+pjg4XBBZAtm/5jnjvJftVYmNSYpWLyOkiKn2FDr4SIeS3RSTmSM6avblTyOAeeVf377212r9cfDcz3n+pchPgO79m9/4AiTA7J8RR3NigyGQ6r5ppSqFupt1qheMQyAhX2Y9TynXvX5neYeKRhEU7SW9eX1Su0iorSzy7vDg+OTw4WAxDd/d4cNQH3q+t548YP4Xone2l3ym9Xsgj4fvrgnky3RhDZKw1JRcxFtUB60a3Wdu8hN6U53Q14h5vE6GwZ1gySZiTTrWPs78arasJ0Msrj3O/t7F3ZtBay0yY6VuFBQGQiFnuXHJiEUEWITHGKCSBmWWcXUObOY8NjuolkOMPyK0R51ztag2lq6paHJ1cXFxMp9Pf/Pp3X37zdQjBkhNtUwAo9b+IhJC0cqvVqhh6rZkfHh7ev3/fEId2S0QgPJ/Odl0fQl/76rZfaRyTspaqPtYYk4jo9IvWRQqMXN2z7km9O849Wl38/U6MiJABRcZqnV97kFrG0PfnXGJRgLeO3ucFEXV4OriidDPqsUqANQyD9iwxVy/0HTTFL3RXWhJwzmnurj/CjIUZhdhyc26z2WiIEEJoZtPJZFKQX7oOqq3U9/3p6almYM6529tbAPDGM8cQxqguxpiSIEoIwblKB5PUGlaV2+12IklFkHRaSZHhZ2dn1lr1xKvVSjmzrq6uPvroo+VyOZ/Pm6a5vDx/+/atdmr/+Mc/atv4zZs3WlxZLg8BoGmat29fHx4ePnz4ULNhpXXb3K50qdfrNREtFgvlyzw8PLy6ujk7O/vggw9E5Pj4eLPZ6WEcKaWkU/z2kMYCjPF2xDDGcbK8H9ohdA3VtjJCLvRDVbm+J18rlg3r6YRj4JgkBUkxojiEoe+8Nc6jRSFmZ0xVGeeckNG8ExLLyIM3phA4lhlDjKPdTyl5X1ljLJIhMiE4BFvXzpCROG/qoe+HYTCASZLEZIgEDDIiKAtbNMbMZrPT09Pr2/UYWxP6ugoxnd4/+o+//Lvlsjk4OOhjQBYADEFjGsgehYwxSURxNiJJZBzLSRxSGkUUzAirFLV7Gq8wj7OUpbRTCm9Eo90rmydlcQJXewPIcZRYreuaGRRmaAATZco2YGACAjJgrT04ODB7o03yp+BIACNFtY4bKRmtOpD33Fvx9CIcs+Mvfgf22rGajxljIt+VDPdcKXHi/cqlVlwIDCKCoEEK8o77wPziPfDTu+7vu7e1f4MjVrlc7R5tNJC2gZkZEQQJIpA1YRiaplkeHiDJ4dBfhiHGqINGjGAEUbvIeU5L81MQANVHRExJBUjGGqB37rNPvvfm5Vs1rIiIgBcXF+tHD6bTJoGAVlMtEZkUYtrTDXx3FQQA9yEt+toveEKe2S+rTxmFP2YJ6Y4MAXXcOst0axai6S8Rhdw/LuZejab3XmXYRxyZIYijZo5iL0v12GbJEchBCRFxFgkutU1vnba9FUK+f+9a5NTijIK29NgwkCROmCwa4613jmgMP7FUJtJYL9JX2TckAESa90yn00cfPF2tVm3bXl9fffXsq8mkRjT9MIQQnPM4qkSMbxJCQJCm9iklAGma5qc//fFiseDU8zAq+k0mk6aB7bYl65uqBs44gz1EKKJolVIy7yPvEavGITCzc8xcJY46iHEHdYZSdxqxfkiiKL+HD+//8Y9fHR4eVlWNuXqhf7V/YouV4TK74pxGWkojPEaQKYhgu92GvpeUOEYUAWZJqWma3W5nEG2GN1cK4kKMAAo/0V6y+iFdvZRS3/fOVbrN9FH2u7Z2fhiG9c0toqmqSlLqdru6qjhGgygpiSSyzqKmuZz50UTPQq5vj2NvOkGumxkRz8/P67rWpLaoBmmVm5mbprm6ulLpwOfPn798+XKxWLx+/Vo7R69evdJEs+/78/PzqnIi8vTp0/Pz881mpWIequZUxqY19FRnv9vtvvrqK33oSv1mjDk9Pb2+vl6tVgaw60Z9T92oVVUZg5rgStc2TRNTGHZBvxNjHFW5QtCdRiNNbNc0S185QOn6zlrrrelDH/oWhR0Cp8DAq5tL70ztXe2dVJawFoecYLfZ6JYgQzpJycyQGCVZAmdMAJAUQCixcIiO7KDdIoS6ct4QIHhLmJJDnFrbG+o5YWKhlJiVMydk3kcA8K5+/PTDm9WvXeVlGLzzSlWWQHxT/+qXv/lH/+gfxcAxxslkEuOgw9AafIwxQXa6PIpAcAnlTZ6Lc9kmUCYbKDlSOQsmj2MVa1N+Ry1YPpLYdV0cBiCy1ouIt47QWGt9jGCshqSATEgicnR0NJ9PAQCFYxTELBu/51OhZFZC7/wzuytERGDIRNDALHvjJ8Ums+hcpo5lg7Yq1K0bM472IY0SHbxXq1c3oYSDWUhIHdndRM94PQgCIKzwaQDAMqAMACWuyBf//iSxlB9pz2v/bksqNn6t+sOCRFhPpn3fT2eLuNzd3NyMSwwAROb9Hu2de9fHUJ6fMQqlDtp3/N3vvphOZ1VVdf1uGPqvnz2bLRazeY0szBxDIsPjLWKh7nwPof6OfwK4CwxLjUX2aKpgzN4CAHjvDWAUJYAaQa0UyTpCwLHexVy6HSJikBik4OXU+6YQowp4pVRqvFplbdut1q6LQjjmSXltfnvvDRGBMUgGCQUIUfKbIyq07Z2iR4kSQiZbBgCBxIwEhggqm3WWYoiBkkTa4yVIeTpLXb6IhBj0G2qXr1fXdXWsLKE/+8mPL69vum4AoK4PwxAQBxA9wIICBCjAMbL3brfb/eAHP/iLv/gLh3h1+bbrujipAUCpFRBxt9s0zZTviGY8Z+ziZrMhoqapNpsdIqp1Hov2yADgUemOdS48dsyaGkJmsStLpFjl7Xa7Xq9/8pOfvH37Vmn6Y9aqGyP9KM5WhLauR1UM3WP6tWJPtO5KWURWg6oCQtZdxJl/VGM4bcHO53MNleq6vrm5KeWilNJ8Pi20WYvFAgC6blATqW+rjVgRads2Rl4sFiIynU61Uq2e0jmLiMpPmSMYxNxj1uN2dXUFRaJKRFHuIqIJpU7lAoDi1ZVz1Fq7Xq+1nXl9fa2iC9bay8tL55wxeHJyst1ut9vtbDb79ttvq6pq2/78/HwYBh3J1RN3e3urNM7K7azMkZC4RAk3Nzc+y1cYgw8fPu77vnZ+u32r6A2NepumYY76bjfrlVbIzV0HfJSQUn+via+WKiVFDpGB+90OnDdVhZJAgkUA5m6zbneb1fUVp+i9PVjM5vNpGvrQeSJqQ0QALaKCCr5p3SUFYCBQuCqkFDiN4yiTyYQIUwwCUntjjfPeeRJmmdaeeRr6ARGtd203pL7z3oMhg0BkWASQHz58eH5+fnVzXVfNZredTCZDiiLSNM3q9vbZty+ePn7ifR1jBLIhJO9HGnB9iIyg9LQxRsq1LpfR0bj3Kg6vpH2lgKSPz2YaS8g0W/slRhFp2xHzj4jCrP0OY0aOdnUJOrGjRriu65OTI+ecsp1Ihi4jIjCpP/tzr/d8cDlE+S40ybsrW8vYlxx9ESI6XxtjCpmPIIiw5gCII+a5eKuqqqzx+s7MrBzJ+xfwXr773qXuX+f/39uB7In3hJn0buTu93T5jTExJuecqyvjKxUvU9wHZEoUgTH9LfFC+aRRLTPHU4jILNbYp0+f/u53XyBi3TiWKMIXFxfX19d1c3pX3xZQ+prCV4XISkH+3nK8t0yYUTB7HzpumrLijgzvdWQhB1POm5jZdjQvsZk3HxENYOQxcbfWGqR2nMAZu7Z3YWmeDC4bnXPvRAuw6g/IOaIR979/L7Kn+1TyM1GsTRp5VjVZFE09LCvwSiVihPKZAWOMkawebwvDuLWkPfKxGIAiSYR0ROTm5uazzz779NPv/+t//W+sr72vv/n6+Wq1qpwPIXVdR4qZB6OFmKOjox99/v1/+A//6ujoaOi2VVV1Q9+27WI21RjTORMCAXDhEyhPBBE1YVWTLSLK+V70hcQKgWrj9CoMl7hPHMlgmT7Xs68RutI4X99cfmI++fnPf/5v/s3/Z7fbVdUIgEwpcRoBlgziwDnn6trrAJU+Rz3n6qU0WNGczFrrXFVEAkwWVpIs2Vv2Hma9DTMKsTEzEwFz3O12JycnMcbMS3Drfa3+NYSgsRoRTadTnbTWjEctJjOPshwAiFjYoPQ6daZWL3W5XCrL483NzcHBgWLBFN6lkaIiv5bLZYxxvV4XPG15QBrinJ2d3b9/X/PX169fisjBwcHz588Xi0WMcTabnJ+fz2az29vb4t1PT0/Pz8+NMcp8vlqtdCkq64aq0qz36urKWqvmW/ksJabZbPb27duUkqou7nY7AL65uSmHAhGBqB165dLSxvlkMvHGXrUXYsiINNZzDEa4rmsjHONAQpVFcKbvdsN2e3tzeX150W43lXPOzMqhGztKICySEmgagCTOWEQjIixqFsZckPku7PbO9O1WRAyAgYQciKMAVAa59sO8qWMSY4ElslgD00mDZLbbrTAwR2/d06dP35y9nTROT7pz42D6bDp//uzb2Wx27949SaDaaB58qdZk/zc6yxTFOWfdmIHo0dPglbmI9UqxSO95l31fkpJYS8WsMTOKKFxUW1d933OI4MZRTBi1QVlEnDIsstS1Pzk8skhp1C8aZzSI7iph330xjJ5o79qSMIfQhxDseOhKEfiOaxNyhxEAyBrvPaJBICRULItOsRNBcQr6FsYYLRGpC9esh/dgRu+50js/utcbfe87772++5sAYAHonSI7gWKZmSOi0VPNHMlUzWRq12s7aaqmdl0LPPoYISAp5btxZfY/lYSFlZJNjHGIHGNcLGcfffTB2dmFiCIRrIi8fv16Np/MZjNv1F0hWaMay3QH8torOGRqbHm3EE+FfXtPflUtJrIo8VbOYu/YgMtWSymRNb6uNpvNfDrLkd2dnWVhS4ZjCjwCmtSbKlIaRyku0l8OISgCRVMf/QWFxmBOsjPIEEsqU8pBzGCQR/S5CNIYP+rJH4YBoPSBIIU4DINzwVprrWeM5Ekk9X2UTowxVVPX1UTz8nKziEiIAkAoQhZRnj798PEj6Ibh8PAIyDLDNx8+32w2q9X6m2++efXqFRENQ7y9vb1/evTZZ5/de3jvH//n/8VkUnvvU+g0u725uWmaajKtw5DG6jeAqjKru9WPVrx6iYR0clqBVKqtW/xZjLFpsKoqltH/OTIFtVEOoWZ41tpnz5794Ac/+OEPf/DLX/56MpkMQ9AxWQS03nVd58inFHSIaD+H1rRG2642k3tr6dWYccS84AO0bKUKjDp0q4QSWvkokLGu67wfsaaKqNKGaMrM2Hpt2oUCgNPTU2MMZ/G7p0+f6sqkFEsgpaWCjGYgReeCUnFNp7vdbrlcXl1d6e28fPmyruvJZDKfzy8uLuq61mHrxWLxxz/+cbFY6CD79fX1fD7XZ7FYLJT56+rqqm1bpepU76v9aRGZTGrFlKWUNpvNYrHQKndd1xcXF1oVmEwm6/V6uVw6Moenh8Mw3N7eMvNkMlG4Rtu2q+sbDbnOz8+Pj4+991dXV4iy2WyWy6VGA7rymkPrCbLW1s73fVt5LyHEfjAEKQik6AFCEkMgoRdJod2tr69SHLw18+ns8f17s9lEJzvGaQVrQaTSohpySkkGRlGslAACCyCAUiVwTCkJWZPi0HbbEC0RaDcq9B2K73FnrWcWIzBrGhdjYOFqjOZn08o5x2kg49rBtt1wfHz42Sefvnj5atpMVGWBY6qsU3qo58++ravm+OhQN2Rktu+OxZf9T2QEUggJEcnBfs8FALRxWxxwsY2Skcm6FMVwxQhEjKjUEFw6ZfoUOAEReWOVKoTIjO6aQEUmQgjW1c2k9pXre60V5YSH33H27ziqMbndfzGIMMcQQoyD9Z4ItRO/D+eW3E5yzqU0EjkkENTmXVSvL8wJIHP97xl269UBjwh4ys3K4lbeK69+15uCViNglDP/c693HDCONFA6/vteS2zcjK6qCSSlNJ3OLq4v54sDZri8PM/ML2Mnb+8T7qITVXrRUqE2VFjGKfvPPvvs4uJCxza0HXV+frk8mC8WC/XsKQpARBlZF0pquOd6sahM7/80ZeI0tY8lNRERZwtVWxCRlEBDfmWcR8QUJUWppqNkjWIKNLEwWaNbPd9+hcdaqwB9yHUSZQaWjJrjLLFp8viK+l1nrcqDQy4EZUm7UUhkWjeArAAiItpst/Wk0UKlflNRjkag63eEFlEJRiGEnghCO9bhjbN1XTtjCcVYFEjDwNZaawynFO+Qus77atLMmXkueO/0AQAlkMePnorIMAy//vWvf/nLX/Z9f3V19Q/+wc8//vDp06dP7927d3R05Jxpd5u6rq9Blsvl6uY6pcQpVL6RGJSyLmYWT53SWS6X6qXUEBfEOI9t1+RKTYwQEZUoalKN1HqRx8eq83nW2hjuivPr9Xq9Xv/0pz91rvrVr341ny8QcQhhOq3VrQKANSbG2HcdiCBAl91Mu9stFgtCnM1mXTtIYuNIE3FdefWaIyw59/XLfzXn00BEn3hKScRo2HR7e6vHuPQvY4yKjdL6sz79w8PDm5uVtXaxWISsX6nNcsgYulIAz72uUStpvV4/ePAAcWymqLYKAOjEjjr1ctIfP358fn6uWsj6zb7vj46OptPpzc3N48eP5/P5q1evnDOLxUI3p7KCaD0sxqi0lGdnZ7jXSi/MHpPJBAAuLi70a0fm6Oio67rz83PvvZJtichqtdKjutmsdBKpFCRcXel0Q0g8xHBwdKhcmP2uHYaOEEPXOWtj35Elg+SYJQxOJPKw2267XUsolSExfj6dmdMTjZA0GAKygiiM1vvGqzWElFKsYkpJEpdqlve2DB/mEZ3YNJUxuF6vm9rrejqmGFpOgYwDRm8NkMGY6sMFkvSddZgWs/m9eydDSJdXq5v1egjp4cP7APDti5feeo3hdrsdC2tL5fLy8mC50HIgIjKPJk4bTHqFfpQGv+tZxhhFxr6YNkT1p7lSAilxSUa1LFfSCW27pCGllKp6pHwvXDrW+OnU6MCe4gxSBr1PJ5P1ZiMiu93u4+99pFs6xqH4b9grPL+XLzIIpzusVjbniUb0CfgxOIgpk5hCLo9nU8ApcRL2ru7C4H1NRCGx9pX0AGrzIoQwpAgIQ4qVaWLWTCuV0XINkNusfzJx38/U1UypppGImH3+6neTYH0fLUG/mwTvl6CRiECYAQGJrKsUINdMJrN+sd2uY4jWWuPHEn95k3LdsJe26nsSjzrCp/eOHz58+PXXXyuhPCJuNpvrq1vFGBdP6YwdhrCXhpaixDsPrzhg/WfJLfSV8litUl/st81KGlqWGxE5AaIZhgEnWFCCin2F3LErBefy2Jxzm93WWksISdgAqPnQUpuabP2IksSYLNKZGYzHMceyhqWSqfaarI6Qj3ovIkI4kreRACEnkRjH+ZlBegadl6gq57XNzMwpjGFNisOQKdpHprCQhFgMGuMsIplRwKu5VwmaEILmIl/+4fcnRwd/9Vd/9ejRg8XiwDmnxVUy1PfBWtvMpkPXjhdPIxmQTiCUSoC2NtfrtQbmiEb9q7IjYa7fgoLUnDV7mlFpGIe18lyjKKlF8UkAsNvtXrx48emnn/7sZz9h5t/+9rfWec3VtOJERGHoRjBt3+vf9n0HIMo8VXgNva9ijLPZrO9bPTt58F3PDleVFxHnjPfWe6tbru/HufZS4I15NBxzJ0LjAFVW0FXSYVONQnS1Dw8PVa4gjGhz0ArBdDqdTCYjiXyO2Mrm15RdK70i0jSNUm6pv9xut1qun81mWqMuwFftCGw2mydPnmhW2jTNvXv3UgohhPv37zPz27dvdV5OO9MxxpI367FSCYoy7qwZ//HxsQo0IQuyPPngqfLiKZh8uVxOp835+blzy+12q0m5ttWj8DAM0+nU+mo6nR4eHsYhOOe8IRAJXQcikmLjfOy7LvRxCN12YwAH3qQYHYmS6sznc2OMARTGdtdHYaUR9nVlrYkxgjWAQNr8BwwggdO+xczGlJKwJDAA2+02pIiIXbdTad6h65um8b62QCzIwohUOdtMJ4aYZzWhncwnk+mMgXQAoY+xqqrF4qCqqlevXhPUIjLxNVntyMLbszfTSfP48UNmCH1vzB0Zk16bus8ybod7leSQSTaModJM6fsWss78vuUvEbAxJg1jLBuG5L0HiF076I7ljOSgTC8xmiMymldwSov5fLGYxTgAjCQHKQsSs7yjcSfvljDLapf8UJkn1DwSYUmgSw25pDoAIAjeeWMMI4EQ57HVlJJVkJrEtttpu0cNeFNPx+omiwggqlPHIhpd3vw974bvZsD7LglxHMBFREWpw3dedv+3FfktIAhIRJqMAyChARRrfdNM6+lk0+6M87P5PMa4CStmts5EieVSmFmAWa9bWBPrdxYaIcZofPXg4b1Xr16lFA4PD0OKu7Z7/fr16enp6empmdTFp+7VnyEPhN2B9/bv/D0HXL75XmC4H8WETFtf/lydohLjaWriMrdliZKI3mlFh0xJqPArzRLAoEUD74Y/JZICkRQjZBpbbeAZg2U+Z6xOc0JEb5xIGoZBEELoNZgYC0HMwANSJltHlBSSARBiZusrAFA+mpgCEtTWEmAcQqQYY0RR3y9928UwOH+YktjEQERoDZLqtwAAEVpyMp8+vH/65R9+f3l5Xtf++PhYo1S0xtUVcBxiHEKoqybMpkmSBRziaNk1bwCAXDwH5QWczRbqcdU9TKfTMsxD1qq/lMRBEmLQ8nKZ7YtZ/gUygFm/iWDQp7ZtLy4uROTv/b2/1w39H//wZdM0VeW323axWHjvnR1NkublOmOdMly8hALqINu2jZyytPBd20n/RJ+FThxpoMB54ouItJ1Woiv9fi4dd87NMWswAIDWh09PTwFA6xwq0ue9VWYSNXwFk6JbriyLAo9TSldXV8y8XC77vr+8vFRqGgBQn6rNbMUt611oYUNE5vN527a73W6xWCjo8uLioqpGEpurqyvtTKvTJaIYB2NwPp8rmKvrOp3qFhEFT6lE0nK53Gw25+fnOpfy9tXrw5NjM4rfxZRC30cN2larlWoD6wSgVqF2ux1Zp4iww+XBMHTWWgSorG1n09cvX3a77W9/+avlfOYtWWtrX4npmBUeAWht1/Ua+W27TnPZIQ4iUvd101SI6MDecQ/ASGeokjqjXUFLyq3BoGe87YfIoiA+Iqi8t9bGyN4H5wOgQWuMdcaTt8Y6S0QMUNd+Npsa5w8Oj49P27YPV9er0113oHWaIVxeXg6DCAARTSdNjPHy8vLgYDFtGuVL2PdSdDfX+52iaOZZ1PqWlt+8t8MwUgNx4dvfY3YEABKI+UdapCG0QsnuSZiUmp+1RU8PnbPT6QQRDg4O9OmnTErKzPQd2NU7pjvjp7KJHs/X+CCKPc9sB7JXMBtvXMXFXY3W4F4Pl1mlB0fKprJuIqLzeOrE73DLjLKXN+JemvsnXemffN2FQQXevXfLsO+A4R0s9J1/IrIiQUCMcVVVHR2f3q42Q9e7uqnqlpm7bpciy74yJUACARBCU3Sj9mMcQHHOcYoffvjh1dXVL/7274DM0GuaS+fnl4pPESHKcF9NnuRdkFeGfv0JEEG5/rK9yk8LNN9kiaE8GPeOzLBORGy2Ix/vvvPQnp+OfxhjdH9Pp9PId1q/RGSyxmLJ29Qixxhd8Z25V40jyt8rvTNnPYAxdjMyDLEPyfoRGlbseMqi3+q5NadHHrWVCYRADAIicoiRZRDoEABgbAMD9ENXEjWkQREKToQtC1gSArxDeVSV+/DDp7vd33vz5s2TJ0/UjndhsGK7rrs4e9O3rQi6yjtXrW9vaj9ChHRV95+OMSYlSUmGYafxjeJmFbwjjNbYclhSkhQHjTwwA6Mkg5644NWjeGeE+5SnC0ZZ39n0n/7Tf3pwcPBv/vW/nU6nztnb29vpdAqStIZGRGV+OlcgeLfbaa+x63fKy6FpH+RhRDPKQtzRzOprv7ahzbDCgqsbQFfDmLv4TPNvziKsVVVdXV3dv3/fe79arY6OjjabVdM0fd9XVaWTygWQz8xFT6LAHTabTdM0McbNZuOz5oFqX5a5ZBWJ0ke/2WxWq5X6VGvt2dnZj3/846Ojo7/9279VkPP9+6chBF23i4sL59xqtWqa5vr6uu/7Fy9eHBwcKI662PHpdKptaa2jdl334MGDr776yjn39OnTr7766vnz5/P5XCSpkMNmswGA9WZ1cnq83qxiUoA6Xt3eOOeqqmKQm5ur6+vr48Ojjz/4EABub64P5gtm/tWvfnVzdflXP/+Lw/nydnUtMW02m27bWmvb0Gk9pe2iMebi8rZtW51ZstbOFzMCQeG68e12bCiMIAxJIOicCSOdFqhoDydhQAYkxhgYJAlJjsCScy4GhWs7Y209nThfGVXpmE+9r8gaZRazvmqms3tg+5Bubldt2x8fH67WN2dnZ8CBiNbb9ubmRj3cbrd5+/r1o0cPirejPU3xMqyxX8zTnyKwIozKZuPcEq6q5j0fg7l2GlKkPeioTudDpuozGYZtvOMQdJMXqKC+23w+NwatQSIAScLJEBKa+J3Z0T3PlOeAR3suIgKizSnVkRRgBcqlmMahjLtwBEdbTc5qMiIICISYxSSyWcC9akGZyMCxyKwtXtFk9M9c5/tw6D/plfd/jTU8yOGdftO+9wf5B3ePanwLISJxrloslkdHx2/fvgFB5yp/4NNlGLreWOIxblDvCwAg44feJX9lFBkJhm6op/bp06dff/WsbdvK11VVCaerq6urq6vZZGItpRSTMPEIfi6XCaDldlDM2H5Uol8UW1+OU/m1fcAqj+L2d2lx2cQm81Kpt9MQyXsviYUYBSwZznSPmo+mcDeOVc4AGqJMHK8me6djnZkgovwojZxnY4cY9kbxxvqJtc5ZzUv4boh2pFoUjomzakIm1dNitJ6NlJJxI37Sex/TmPdrktc0FXIKcQCdb2VvxAGwtR5JSd9II9nlcvmzn/3sL//yLw8ODvQaUpeGYfj666/Pz99KiqeHB7Np1TRN3+40CimDVdk6gzGOyG42K59VU/RgV74REU6ACCJCe76NhRUnrB46nxbEPbyicbaUr8d9zxxCePHixcOHj3/2s58dHh7+/ndfXFxcHBwsEM3hwcLkgZamqbVaCzmZHoagSGNmnkwmMUgYOpjUCILACEgoiEAogGK99d4LR0MAkhAwxcGSQWO98zENCGCN8c6BSNM06/WaEIe+N8ZwTJZM6Ac0oP3s2WymOrvL5RJRvLfb7bjTyqMHYMrMMLrhc/+bvK9vbq4mk4kxowBUSkkxqJD7x1rw17mpMhdnrf36669V0eTy8nK5XE4mk8lk8uLFC++tQsO0QsDM5+fnmqFqMHR8fKz1cPXNh4eH2ukvo6vKKDKfz9++favDS/OD5evXL5l5WjcAYJ3pVx0ZVGe8Wq222+2nn346n8+vrq40UDBIlsxuvbm6vkwhTiaT129e/t//x//x008+/pf/8p+vVzcW4eHsUQzhMAwvv01t2/Z9EuSUhiHEEMLNzY0AE4iv7L3jo9mkqZwBiBxgFyJldW1ElAQxhpRS1w1J2JCLMYUYhxj0tIYgzrlep3oAhyH9/0j7015NluQ8EDQzd4/l3c6W682bd6viVmSJEgUBRAsQhGnoe//RxvyARgsYskeaJkcSRVEki7Xdm3fJ5azvFosvZvPBwv3EycwqUpoXhVsn3zXCw8OWxx57bBhjXfGx9yTTOi8366qqBGB5PIb4+PTULKtF5RbOVWAsGYfGAfHZ+ekm8nLZhjC+evVqv98L8zffvYvRp5Tauj4cDgo7PXr0qGSuiJhUP6CqUnqAlus+QUSESWMghKkND/LcxrnlL2ZHM8Fy+5R8QP8ugjNjRrbKZzGTJSGrAnMmPJc79J+YPhYHrD+dUgIQmklQAeqBSTHmmFtnDbk5J2nK1hiKrdCqh766WCwIp7qVet/yEf3Cj/qXD4+2LON7T/J7dC0iASizmCYWtMp9FawYp//l3wYCSKhsW7Kn548Oh8PxeGCERV03zaLve5NnKb93fA8yd4bc/iQiUjfVMAybzebHP/7xf/ovf9XULQCFEMdx+Pbb7zer1fn5qWaiqhx2/z0FI3oIJs9/WkqTXIF8dfYWTOOAdLlLNbeghWrjtFakyZOhB2M0Yi62VVU1+ElxsBCsypVjZuaoqCDllSz0GcoqxKP3gMhT3+eDKk4pe2PmBdR1HTnkGILLMatvnlIuFjIoIsCChCmFlCBGzwxA1CCiq9CQWsbsvCcEKaXkIDJLSkwElCQRIoIBC4QsbMyUuK9WK+UyIEld12bov//++7/8y78korZ2Lz/9ZLFoOUVXV8LRAJXAc70+UcgBEfu+f/func6NYWYE0x0H9QGKCY/j6NwkN01EgqAVAQ35dfgPAHASQmMNgqAhSbkhu+yEQ3f0MdT1lff+xYsXX37x1TiO6/Xae694RUopBH88Hi8vL1+9evWrX/1KB9qsVqvD4ViIG/3QzyNlfcgMktHdqEjJnANvLMZ0Lw+uF06hlOnLOVSuQUQRdo5CEGutal9obLff79WVqrttmmYce02C67oOYSoBElFVNX0/3tzcPH782FpSKNtaawx679frE/2UQj46CEunWm23W2ttVVXaufs7v/M7f/d3f/cnf/Inbduen59/9tlnd3d3P/zwg3ZnXVxcqMIXZRWX/X6vk4b1Qi+XS4XlS1szAGjjk/7K3d2d9365WarS1nG3v7m5qWqnReWQZxH+7Gc/CyH80R//MwDo+973w+l6s14uvPd3d3enm5Pr6+v/9Jf/909+8pP/5X/506Z2t1fXr998H1mudrf77TYmvNt1MXGMcX/s+m4cx1EgNU2zaOtnT59+8uxRWxlhD5xYos7w0T5g3RjKMBiGkQWJJCYJIY4hRQYRlBhFo1wkBggJU2JEUb6tiJgkpvfMTMaISDeEDRg0VUhp8NGBjZFRIhpbUSVOrDP/4k/++Scvnl9fXl1eXgI6FE0ufYy+73tFIObJKOdRXYR2GA88TQ6Y5uvqttSdE2PQuE3HBZaSB8wEegEAWZKIErYpC9JpwctUThIyAiMUB6+vFjOoi6ajnROP7+UkLIFyvew3PeS+vsOc50Po3cHMnBJLRERLxmc/WhywMcZUzhgjAkj2HgwAZhA7HbWqAhszmw6g0rZ6g6c4WWD5wLN8eKi/5fny31KtVzoUT549s6DnnywlEB0xxDo3V4nXQspF2pyexhiBJUW/WCwOh52wMNyrqxQ0A+G+U2hCtgUAQZs1DQsRvXjx4tffvOqOfV23oWlE5HA4XF1drVYLoumKltBs+raHihzFzb9nCucv6RU1mTmlZTO1IHPQRj2Z6hYpNG3JFKNZuj5KxEdZ6S2lxCCQoV1rbQhlSBarvIDeMyV7S3neiNrWqq5lkg2BEhZInmgkmaFj82xt9ZqUJ79O2kYcDN+TxjX/0DquxSrGOAydMa4beiKqKovocrjAtasAEmh4KT5GYQSWSNGi0Z40jHHCSGMIVVUJoq2ruq6//fbbf/jFz5ft4g9+73cuLi4c4fGwjTEGP6wXS72NdQK82lb1KwUX4gRNM52XVuXVTA/jWFJ2slNUG0K4vr5OKSGQQu5TKgwwjkOhcUoGugkNIh4Oh6ZZHA6HkxOjQGvTNClPwlCBHm2AaZrm22+/Vd5TLtN6a+3JyYlOJ5xHSBqeS8aa5mUFmnFkaMafNMaoQIearQJKExHnElSM8fLyUg8Ac2uyZo2an3HWmRmGgVkKKU+da9boULF+p2okxhjt/1GGbVVVl5eXJycnWhLWftyU0vn5+Q8//PAv/+W/1ARXa8l6nLqxEfHu7k5rvc+fP9/v96qRqZdJk2BrraZKBWnX5jpdSZ14qIJZWs1ZNi2gFHp/VU18i88+++zVq1ftavnVV19tNptut+u643q9fnzxaBzHd+/e/fznP/uDP/zDZ08e3dzdbtbL08cXVVv9+3//7199+83F6dnheut9Cine3e72XV9VlW1bS2azWT0+23zy/MnJquY4IBtnDCFau5jIOBJjpo+llAY/cgJBEsbej+M4xshJmADTmJCIkUUkCSNSSAIpIQunQFkGpzLOObdo165eVFXDYGMSEhhDcGRC3ycQ5xxDaprqk0+enGwWj5+cnZ49Oj3dfPfdd9fX1+v12pLhxHc3t/SIlA+v1iYGtkaMmUa9AbAxxs6SOZoJE8WswsHMKcn9PZiryJyp0WVLFytXOkJTHnOiF70gjpNxiFGnoQAwABa2l3yA3MIslQIAFc/SYpC+yhKnPF7dl/YIqDJE+dRM0FcXvHzzfZasB5B1D/V1rTMq5wk+yCFlclcfeZSzKG+efus3++MPk2P4EIImmCrPGk7cfzsYRAGAqm5TSqvVZuz7ytrb68umadq2Pe4PAvdlsOlnpsOaHUQ+KxWjZxBJcnp6+tOf/vTP/+z/cq5WQDLGeHV19eTJk/V66b0XTjMXi7P/fuRCQubczx1wRnc55aKsyfM7V6uVrl2W570fJ8LMyCjGKFxTVdXYD+oY9LPAUth9SVi7QdRHmqzAAACWJrl85ZQ2da3NV4gomfKjkU3f9ynHlepoS2SqVl4zHkVZq2oSVeCsDj9xJcgLYykoQi5DhpAwU3VijEAYI6kAljMWgQVSSt6AgaTRJEpSpgZjMkmk67q6ahHRj6Oei60MC2uy+Md//Mcc0+//5Ccnm7PucFdXzcnJye5uaq9SKX+dGjsPvRHRmkpoShzVb3Vdt91uz8/PSy2g4BN6z6tHscZtNhuVfdaXtDk15Xm3inAYZ0Wk0EBSnnjhvedJaFoQpw6/x48fv3jx4nd+53d2u93hcLi+vtntdkprgqwWq1c2m7CUcr9gvuGn4Tld14lAjBFGjnnoJGf6qJ4FlGIeSYxxsWq7rgOg7XarXcVlCv1qtdIWNU0Qq8oVt22tKaM+9JC0X4g5+jyWmIiGYdhsVoj45s0bY4xiAG3bvn37FhHVg6aUVFhDZ0Lo5Am9Ww+HQ9vWxpizs7PtdtsPHSJ+9913xpgffvhBm4wBSPuGU0pPnz5VRQ7v/ZMnT47H49OnT9+9e7derwt9eowj5D7pEL3Kdsbor6+vnzx50vfjH//xHz9+/PjV998dDoff/Z3f+/zly9vb29vbW50ecX19/a/+1b9aLBaJAyQ+dt2x6/7bX//V3/ztf//kk+e77giAArTdH33iullUVaW//uTx2fnpqqnsOA4WuLJkDRqDaie0vuhj7Lpuv9+HEJJAisKAwqjMwZA4RamcExnJGEYMmYQREy/aVmIaJ4pc1bZtu1ysVpuqWRBaJEtoRTD45GPfCAROIYTFogGAkXtrrXF0erpxbq1zsdq6uarqt+ltiOMwdt4vtcCv0Zgfx0IBKYkpmEmLI3gik0TEOZtSUoxdphx3LHcWFNQtTb1z0z3CrF9LRIGT5g8pC9GkPKClZEra7LRctjpCTe0c831UGvz9/TK30vNn5r6qxBAE9+GCTAqGRIhpJuNIuT6dWCxN38AIquwRY4yjR0MlhyEiQxpSq4vRL5kw/JLozXO8D93Ne294L8h475/lU4hoCUszMrxXcRZIgEJGXeY0yyWMY10tVysZjt1V37fLdeJwenYxjsH7AYmQhYURUTXHAVgZC1O/LikIPc391UKUtbBa1k+ene33e0SzXq8Ph8P27rC925+enPsh6OTElKIUrF9Y1T6UtlpO6b309/5U8v9iCgCAJGqSlBeqtKZCEF0ul0gy9r1Aaqq1iMTIMSZjEhByYh+DIITkyWpndwQQHdnNMXCMxtkwDilMIwKVS6V+paoqHwKoknX2LpoRskRABpy2O9/zelSTkkSQE1nTZN4Nls/qkWugoHExMwOKgCQOMbCqJRz2u8dPn4z9sa7bMYSqbfV2Ekvoas/goBJGThhFOMWqIkZGY8Y0TslK3TX1YhzH3e52tVq1ovUt/OlP/vDTZ08vLy9fPn9urbW2qttFE8P13XZ/OKwXyz54ZgYi61zQ0T1dl0Qis6q+aH+ZRSBDzXJBZPZdZ63RPElEJDGwqGBnShx9GIdeVktDiIYQrYjEIDHGpl3psiB5AVXt0GgmphS6bicSYrIikqIPeT6MZv4+eB+obu0nm6fMT38kX717d/W3f/u33vtjfySYxtRT6cHI95gyhyGDz9N1txLCCDh1Oqm+lfKojTGlEcI5N6RhtVpaWy2XRqHa29tbnfGne14zTm3EBABm0OnCGmfkbNgrtKO3wzD4sm7r9clx3wFL3dSnm5NDNw1A1O7bUvw+7PbOWBQI/ZBGf3t7vd/vtVTvLDlru67bIiKiM265XGoRQfOzlBJa55xrlosQQuDkU7TMKSXlYJ+crA+H3Tj2682iac+HYWhSdXd3l0A2m03fg2bkFxePu25ghpPzszeXb376J//sy9/96tWrV79+9Usg/PLLL59//tnbt5d///d/uz47Oz09j8Px8cnpYXvz3//mv/+X//SX29u7L168cEM0QzgSdv4Q07Be1WcnG2uwtnB+tjhZW4KeGAgFEaOIRAwRPHHcH8cxBZ9CiOMYvDcpgU+eiFjEpzQmStSEGAOnbozWWgLgEJy1RBVHttYS2v3QA0KzWImtzGJ9+vhJvVxW66VbtmIocnCsA+oNxBFCMMzxmMjZgBhDAMYQoo3bBvpPTqsFnH1y0vztcNhumZHG292Ipl2tFam1TZUMDpAgMVmXQhROyhdrnLEGgUhiUJsZI0OCunHGWlVCxZkG0WQ5UwSAwGkKR4TV15I1Poa6rjkwh6h63eohmKVxFbIMw3B2dqYODMkUl2TyzETrppqUyL34hL6JU7TGsIAwI0JKkWNCFGAxiCKQEicRJMeSQggmRSF0xgmCCFlyxrUhJOtqouIRmYSIMKXYxZERUCSE1LRNu1gxA8ukKqqRgogAiTALJIQHSMDcv96j6IYAQOdWysSfz643RwwiksdSGRFWfgACvp8Bf/Qx92eaIDZNs1qtbu+uj+NoHS2Xy8VyqcC6yVDblOHJ/ZdMrhAEBBMnxRA0JtpsNhovL+rNRHtJ8fXrN+fn503tVDhQZpJVzDofSAOH+7CinG355xzfKM8gTt296hpNFqUq4dWU4OZFDyHoODCeFYPn05QhK6QUcrXM6IhEpDJGNIlbcWEk3c+ByJUzZpbE5c2SxapERAn9iKiOVmnYANC2rWaWBXcNs3G2nCVbNTXvus57zwzL9VrzRZhY/hMbkIhk0oOZjmqSlXC11HUIwZq43++vrq4eP378yYtaf265aC7fxbZtT09PUxj1BJXYPI59CEFFx0Ie2KdRajUNbEbmVFxL6fdHRGuNZmY2z7SIs2+YrqWZBCNjjEpKE5m0QpmZp+qRFEqdtaQLlVKKYSy5Y5xpw67WJyEEEWya5quvvmqa5he/+MXbt2/bui1yB5JrGZLrXu/tNJXroywnrvun4GPKJgMArTcr8A44OOdUAUOTeBV40V44veL6bZq8QkZQJM9+KdMsIFMRdcry4XAIIeikXn2n5OrGMAyPHj3Sfi3KQ59sVamSxpMnT7755htd6ZSSHlvf9y9evNBUe7laKUp/eXm53Jzo+Wrr0Wa5gsz5SimN43hxcVEqiyml5WJ1enp6fXOl4V0B3n/0ox/99V//9U//+R/XtfvVr371+eef/6t/9a/2+70fkw5revTo/OXLl49OTzkG17avvv36//V//p/fff31yXqpAzG9RDAkzE3T1NYtV4vNagmSDIgWa1AHv5Mid1NPiwcax7Hvwjh6icIJAEBIRCCmEEIafBxDjAlSxBhZaOKj+WHgqiqFEiJqFq21tF6vV5v1ZrNZbtbL5dItFnpZoYDA4T7ULlXYAqKI913X3dzcxJispRefPq/r+t31TW2ciKTg0VWo/ashihiTU6uyRSVNNdTGVSZPQ7Jtjbl1uFjLchgwQ5gpE611U/kYVPBL98NUwkMEgLquE3NMHkmWy3axWHjvAR/Ueh/mRQ9dw8zXcNZyKcbc5upy8YLFmMPsjtMDVj2i8ouISDT1F5U7fbFYrDcnkIOA8kNlBfIH72UQ4YNc9r1T+8deZYD3ByH/4w54/qXl/jTGLNar05Nz730KAQDX63XfdcPQTSobQAkSiJgHTV36LQgwbbU0FVZHa6tHjx4VY1HXdc98dXX17t27zz7/FFnN7j1nj6eOaSH8bVc0W8npSSLCXA/XCpN2dKjvlDxtEGfSHAVprGtXiHOSuzmLi+LMtbZ54N20vtbqz4WsF1hY05i1XdTZiEiMXus6OIu29DH37mUr+BCWy2XMVcwiDc15ejxkYFZElNO0XC7HMJGENfnW1imkaYiK955oKuTU2CZEmqq/lfejQVM1raZxWuEjlOAHIvr6229/9rOf/d7v/a7kiUZ1XXs/LJfLw+EwdMeJdcmsVXCDmEJoqgoAJIpVXyXgnENASIxGauuEJqZJoSmWs1Nr0g39YrWkrHMSQyr3jLFkxTBPU+QkjwFOyRRgX5UiYgYbmXmz2azX63EcnXPMcHV1NQz+5OTkyy+/HIbhuD9qOEIPCepQtMSd01BAuWalDAH5mmoiq1vl9PRUZUk0QEGceAlacFUBLIWp1V9SZq0r4aWAxiYrljDfL5H27VxfX/JqrS2/uoB6iyXhwiHQbF55eVqhUNjZ1XXTNCpKZa1Vec66rk9OTohIZyowcz8Mel7L5XJRN+M4QmJI3HV9W9XH43G9Xt/e3lZVtdvd6SAmLQG0bXt5efnys0+//PLLm5ub7777LoRwdXVVVdXv/d7v/fSnP/3hh+9evHjx1RdfXl5fhRBOTk5WS4d4fnd3d3NzzSk2TVVR/cO3r/6f//v/vmrqk9N1fzg2VV1uLrU86/W6XTTH45FQTtermLhyNqYgKU4ZXpyIOX3gEELwMcZJlJeIyBgyEKP0Y+hHH6IIYxRi4eDHyMkZK4REhERAAICL1XJlN1Vll8vlcrM+OTlpl4tm0VIu1evtViLy+6QqD4fXgMwBiODhcOj7ngTbtn385AIAhhAFgVM0Bo04YI4pSgSyNWglUUTSpFkLwI2rYoyEoFBfcata1Jg74PJHyfxkknoGAKjqSjdeXdeVc5oSRGZESQnQ0GazUQ7NFCib98ulH/XB5Q2IlFIqMh2TAc9HpVxofYVZ/wYAHYmGRGiMM8aokjMAiYBSf9WSRx8gz5RrmoXW7IhseYO8l87NuEEfHjbOIGi8T3PvG4hULWT+qupCijBmaNviDIV/74+P/xjqHQ7O1aenpz4M29tbH8eqahbLpVpwk1NDEZn3Ms8CDEbQ7nsGox3i4WS9+fLLL3/xs6/NNNY0cUqXl5fnF6fGoGb5RASEOclP71WCP4yk3vNhACBJM7z7UkGJieZOV+eoz6MeZaPAjM+FOOvxyg7Y5VEzuk01DVKFv5QZ+TCrSatbLamnZlFN2/phhBy7xMhqHL337UyqsPy6DpQtJUYNbJXPqT2g+k69bZSXq26AiKqmFm2+0y3InhGrqrLOEIj3gzEGgNiYlFLTTBzRZ0+e1M6tT040pQshiPAnnzz/5JNPUNLhMMToNchwzp2s1ncxWGsr6wKMmvSnlBQCTfGeFYKImo8uFgsFoAAmDovOl9RyrxK4NHja7/fr9bo0B8cU4T7wstkZM5HLWUUPkhBAo4QYY9/3h8PhcDjo+kguOI3j2PcjIt7d3V1fX0+/2I8xT4Yuf8x5AyWG00tWKvcmd5+XLKeQqxExBI9YiYi19TAMqnWsV2q73eqXaFjAua6v26YMb8huOOUvnAQCNRLS7afWVt8sqMNcJxvd971GwOVC3N3dbTabm5sbndq03W5BZLVa3d3dqZAkZMGQzckJZ1376+trdbFae67rWruJNIZrmkoZDO8u36kQtHXm66+//vTTTzebzb/5N//m+++/v7u7+7u/+7umaX784x+/fPny7u4uxvjpp59qSt22SEiPHp/fXt9YZD8e+3H4//yHP9+crEI36JZ2dcUwiQKKj8um7Yfu7vZmuWzPTjfkLBGFmHwIwzBEH9UBKxOwT4GjFiy1cgjGoBGBxD5E71OIEhlUUJdZsvlCYw1aA4aqtlosFquzk7Zt69rVbbNer5vFwtU1zqZ3TNEbyNzOMDPHadSKWpsYp3BzGAZkMMbUzj5+dH7ojmNIPgbhhAkMkNPyvx+JyICwsOgkO1ZMaNrVzjmJSctVi8WC4X464dwRwkN9x3KEuluKIkJVVYkDMCplOsWo0u6S29yL3vI/8XHvdDOXQuJkdVNKmoOVNIansQrTdCPrnLXWkNPcdX4KzBz8MIx9jGzMBBQVa+y9n6t4lltgjk1+9Gg/9MH3Lz2kb5VoZrrQwAYQFIL+R33ww3+icQ5SNGDqRVtXLZqdg3r0/XK51mvDIJWZusJVs+q9xRUQIEECAuLsGq2lL7/8/Ltv36SYNNbuU3rz5u3JyckXX37GHBEF6AHrrOiEzWOrstXgnox9f3WJCIREWN3VMAySEQ9NSkQEkEuC+N6VKBdDcwJtxCyvzn9UH3pv5wHvU0+UOn590EyWoapdzBOcIGc2eK/pKoVtqIAeGac4pFrVQpctX6L2SLJ4NTOXUQdd19mqappmikJCBANEZIAIiWS6fzgmgxTS2PdHaytVZvbeV1Xz6NEjANWdEUQ4Ozs7PT3d7e98PxhjlovGGGOQNHPSjixJ3B0OhUemf6CdRE7mIdE9xYOnKwWzZm7N7ZT4pjHf5H1DCjGUG6muaxUVQdGiAHMKQ/R916nWLgCoVoFkpVx1wMMw+JAWi8XZ2ZkOHnj16jv1IkWKudQXmFlTihy6TTSxElW4PAtSRDSxVt+fMw+x1sY4dW2ykLVWSzwqnqyu13uvCtKr1UovK2V9IpgBhirMp3KbmDuL1L5on1vXdSqOIbnPhGe359u3b5XZVD7lnHv06FFKqeu6y3fvTk5OlOesxQslKJXVu7u7I7qnt+jPac69Wq2229tp8rElANhvd68Ph6fPn2mAojPWzs/PT09Pnz9//vbt22+//fbpJ0+/+OKLruvC6BfLhV7ZpqkksSN88viisvT9m5u7uxsDOHJUzJyZBz91RdfNcrff7na7xaI5WW+Wy6VIisI6M2MYfIpq2UGRkm6IGu+mKMCoEWRV28QcQggh+hSTgDCKpCRoKwBDpnK1dVVdt8vFZrNar9ebk5PFYuEaV9f1arWqmlrzY93VxZPlMpoUEA5mdBb1KzGmxWLZtt2ibqwzvveLRcMciUaU5GOCyMZWxlAC6UPSuh4gxhmkrEZKdx0AVNYoUTT4WCAcmSVwxf9RfuhtUvBCtWmLphIR6ywCGmelgCh5vMp7X/uhm3/vMZ04GIAp6xBmmhSN7kWsJs8qgIRaR7euqpvGuRrQIEKWcQTIchExxhBGjYybZqFt03qmpTF17vKKy/yoi51HJLnhSyD37n6IRL/vnhWPLhnwPPItf8wjgvlXTAft6haxWS7qfR1jHIbBVK5pFkd7KHf1lFQhIBqRe/xWpSiJCA3o2Ao1Ioum/fLLL//mb/5GMTEN2G+2dxf7s5OTNQCzpFkwgu+d1Tx+KYBbiTz0mhFMrSwlaymEQKWkMzMSFXQuBYUNJ+11mAkYAQCi0VI/zAAcdRgySU8nxQnxXl9p8uhp1jWvX9u0057Qvkx5qOFljFksFn2ekQcZSyknmzL1V1Gm+a9XrtGESZd9GIaUpjEVYfR6KyILERlBsiTAyUcC8d6nYPfHbhzHs4tzRdRTMuPYq8o5WgQAi8QS765vvv7668ePH3/22adNXWujqrU2ELVtiwKd7xSh1fTOOYdgdMqbzfoSRKRpbsrM55Tp3HrPlCDmeDy6qq5cPQ7eGudsNYyDUq5U+R1RnLEpJQFBEiQBwdyfMymreD9oTFOEVmwOMpi5aRgATk5OXrx48e2333777beVrWLWGSixEeZhG8Ul00xCqNxWJvcOmSySJXLffV6MS9/3WtxV9pkx5u7uTt28UqB1DbWiX2K1/EMSs074OI6qwau1Vc5F1onxEKJS8bWBTbfHpJLx+o3yzx8/fvzdD9/qaOHtduucu729VZ96dnamtWSlTOrcJO/92elp13XB27apCHDsh7ZtU4hDf7y9vfXe73Y756Y5UcvlEghPT09/9atfPXv2bLPZlHaDzz77bBz7qm289zqzSETImMghhcgST0/Wh92dAUh+5JTapmqqcz8E732MvNvphOn27vbm7u5utVq8eP5J0+r+hxBC34+j9+MYUoQkEINm8BjRJUwJSIi5wLCMIcQQoo8xBp4a9cAgQkqpbVvtFmva9vR0c3Z21iwXm9NTHcdiK1O3ja3c/GZHREFgUMXeiaAw+aeHI1Zd3TaL1dNntl0uFk3bHfZX8YpjwgkKFJSQEhokQoMgJACJRWV8EAkRRECkqethGBTEUgPVj8F7b3VibkbjijGRh3EA5BzUUqZDhxCjF3G5bjXxMIzG3QZEuNzCHz4+6n3nz8/T3+KMOHNilFdIRMyJiGRqf5pEqnMvbe4ABInMqqWoR27vB4Yaa9FaVwoW5UjeCxfgAx8MH40tpi7e9xnNH4YjIsIIFoRUMro43fd+uzwDSvEiSswKj1PVbDanwzAcdnd120QfmqZZrja7u62PAeW+PUsIULAYI4FJ9ggAeALsJxzvyZMnm83Gj6HObmy327+7ullulgYmZbD5Qnx4IecBC0+krdn5E5JAyUHVKZYIaAIV89wummYACqJTvowaVjVwGU1CmIz+pEejJ1JwwmJwS3o3NRrmfVzAzHnVyhiDxtzPfMwUf6XwKLZpALXbUpupigPQZVffXL5NEyOlYSfJcHcOCzQmMICiglrMIYT+2N3e3tpqyrOdsZU1MUbhsW1bUjQixsVicTz2q3YBp3x2dvL55y+bpgERPTXCqeZ02G2nZ2jqVlSQHHLApMZXPYHC5lpmhsSJU6b+Tgs7juMwjJsTo36Fck2rqo2OLSuBPzMLJB3PlbJis3NusVggyvEo6tXUb6kbDiEIqKyjaM+JmuLlcukHr4ehGKzNI0PUHZZoScFhyE4XHk5T0bAvpajDEvQCqYokGdE3aBdQXdc61lcvro6vUI1J/Tma0fq0xbbEKDHGtm2Ln9YATnNWXfkw+sVqWQrVjx49+vWvf73f76umruv6u+++u7i4WCwW33777VdffbXOmffp6amO7tZNpRVi3ZOnp6dEpH0+RFTVoodxe3t77PZXV1eIqElw3/dKeP7hzetPP/30Jz/5yXa7VXOptAbdCQDQLBdlV6SU0EAIoXaGgJ0xd1eXX//615vlKoy+63rtD/LeD35smubQHffX15++eHF2cVpVVVM5ROzGIcZ47LpxDKNPMfIYxPsYEwMAk4rY3NN/TNA+LgzMiYEREAgQiIwxar6t5rXW2sV6dXJ+pkMyqqauqooItH5GRAwgyAKkFrGYrLJD1EThNG+YEZEF15tTWMvFk8eSwu21CyHsdjstXtQVG6TICUBIGHlSWUdlqBIRWk4chfvBi+io4EoEvB8BoK5rI6JEVHWiupfmqRfPK6MIKSWDFEU5vxMbRqMHZraWqmoifmJmQf6mNOk32O1pHRInSAwAZPQwZsL+KR8SMggwCAEQWZyS/ik4BgBhIATBpGpiiOJ9tLZyzunYRFWd9Dx+1F/OkecSBOguLeclIjDzwTM3KjARv97vX5r7VqtOCQB0kPJ7Pvj+rfeHRYiCRCnGlGLdNOfnjzSs3t3dGbM8ERm6vuvvK8HTyRDOfbCmXzFGR8anmFIwZJl5tVo8f/78F7/4BSIG7/UOv7y8fPHiubFIBIIwwYogmQn94KzmIUlOxCcHM+GEIFpmxtw7qxZK9z0gA0yUlrquIa+1doDMU5kHW1Mw8yegZEhqR+btp+UaqNUrWRfmGXDzKK+qKgaGNFGi1MFQZgPqlywWC5XzNVkMRPFYyb2wpZmY7xXdAFiAQCUt27Y1SCUWQZauOw5jN47j4L1SnU9PTzenZ9puYA0liaXYpglWXTvmarl8fHKyttZS1kw2SCklS+3xeNwdjtEHZ6YSuKbmzPexC2T/qpm9xtKgfa4iJNMQKl2ud+8uE7Niejq/HQAWiwXgNDmuAAyQ80v9Uc3bAKCqrDHm7Ozs9vbWWntzc6NCiZq4sOBmswkhpZT6fry6urrnoVRV2VqK4hYhi1JNVC/OzIvFQouvKv0PWb67aWpF0dVnqxE3xixXJ4onKVDBme+t0YnS6JQXPd+QunvVs6aUtBJMBOM4haFarNVhCSGE1WqlIULtqhCCohFlwUMIZA0aCimq7LNKbXzzzTeT0jjiixcvrq+vh2FQMOPu7u7i4mK5XMYQVHJSg4bE4bDvlNb++PHjR48eNU3z61//6vd///f7vr+9vWWQv/iLv7i9vf3n//yf64lrpzUREEHf96pYovepMWYYOgO4S8EhjEP/3//6r7c3t7fXN1dXN977FCfFVmOMNe5wOHz1xWfn5+dVZRnBGhNT6rrueOxj5JC49yH45IOEwJGBiFIWM1DDKZICgFoufZ7IgCaXhNaSAUQWA9hUddu22tZY17WtpvVEM1knIrJEWZP/Xlu3FFymez8loZkpB1u3duyHum767rBYLR+b57aqbq+vBYGsQUZt8WdmMlKRC1ndDyGDNJz0SgFQ36sCT1WywCI4XyL4cidKpsjofrCEkthYBXKM9/7ArDiN5iOleQE+Nh+iOJTf5IOnnSwikiCxql+p+9a7jwABkEm0RM+MzjkQIjJkjDFGeJpxwoI6RVgkMacQAkcPIkQ2q/hpAjZZG4YpAynY7Xs+5aOZ3nuxxT/6+NANTzG7iDIO7mcUcylf61aYOTZmZE5IZMhyROvc6enpD98eXF37YWiaZr1eD2NHeI+yqul3ZACA5Z7KpHe7JmQCbJ1x5J48efTq1avgg3UuxWiMOR6716/fvvzs+dQHxumeFJo91nzV5os4P+H5gjJI8L4yVu1m8aksUeFoxVhCSMYYH4PmCpirgGqpC5Y4obgT5xDmIs9ElAf3Ykr3mZym0Yq0qLvt+tHMuo805xYRlSrVEHvIxFdrrbVuSvsytqzphebHWuNUk80J9DZT3hMApMRK0tHESw33MAyHu1vVuFCk8fHFRVvXVVX5oY8xrpnJuhDSydlpSgl9YJ4G6mVKoRJ8UN3/xMPMIQVZk+IYwiQeklKKMEls6nVRbQHOzG1N1Mpsvma50Jl92kvz+s0bRJz8JbP6QlfZ3W632+1evnyhlWYAEEZmHsdR2XDaHXRzeUVEq5ON4uS73e6Xv/zlarV68eLFarXph+Hy8vLk5Gy1WnnfAcDXX3/9q1/++ssvvnj69Kl6cWOM5g0Fai4Bsl59yaiGWiI9u+KeNTLTOYCqd8HMfX9smgaAvR8uLs6urm5U2qVEabqXAEqYr00mIpnobq1ljogQwlQHdcuVRgY+DNaZw7FzlTHGuMqwRB+G1bJVGrAxCMDff/9tXbsY/d3djY7g7Pt+t91qTKkiG5eXl4fDgXJPRFXXSjlMo18+faKhxjAMh8PhZHMWY3TVxKU/Pz+/vb1Vq13X9en52f/2v/1vf//3f/9Xf/VXT548efbsWdu2zOycWa/XyrM7Ho8/vPkupbRer8nZ4XjAFB3hd6++eff63auvv7m5uem7AQBc3bi6SSm1VaPjGp8+fmSMsZWr6+o4DLe3t8M4qJizH0OKEhKPMTFTYhjGMWZfiyjGGIMCAIZQZgUFvRPJIIA4snpp6tq1ldtsNicnJ+qA1f4QWiJCysQUKeT5qD54/oA83UtomvBhrPGRrasjJ2OrekmCuElJZUwO273eEcPgFVJy1q1pdeiOamGAqK7rMXi9u2OMrqkBKbAgiIQIMg19UVuhVf/5pkVDCpVPtzBMt7b3XFWVRhO6DarK6ohPETFIcaZtWczv/Ez1TpE5JMssia0llUPXTQ44pTopTMSrxKmQHoTRGFosFsZaZk17EjMDmpSSjkn0Y4Q0YUKrzUlVVcIoMOGCMUZTOUwydxzvudu57yhp8X2m94FzLfl3OVN+WJDCTMV9MDxSREAIcioMADJNlLj/TH6zmhtAxKpqQKRZLvbbMcbojKGpxSiVNBRRrLUxJZhpM8G98AowgDBwEk7h0ePzH/3oy//8n/9qsz5BMHXVhji+e/dus1ktVy0RVlVT0DZ6mKnPz/83PTAXUJ1zkNnnlHuTrJsOr641fewR74V2dTtq/prymG71vjIxKSDGqAyjcuVsnmNYekYh16cVrNPdVmjM+igHPPpxukwpsfZozoZ/lY9gboPTlVHfw1rnpqndebFYaBwQQ5qIiyk1i0UIYbc73N3dGRQVf6jrOoQxpSBS7be3tq7aZrnbKROenHOwgsS2IichUZwghAnbnwqWrI4ZAKz1GiWwyHLZhjCNwuUEygtzOr+TH9yuuixd12nOFwbVjMRx9Ij45MkTrUoiouoX7rs++n6/3282m6pqvI8aPBpjQpigC/3+EMIR0SIc+k4PWyWL/9t/+28x8hdffNH1vfdxGLwxLsZ4d3e3vdt98803P/7RjzR0KLcQ4gRCao1No4GShWgqr1lyuToAE8KhbCmf5cl2u127WKpO9d3d3TiOVWW1RVX9XBHhSpk4phdROVwFP9BjWywWGilqdVYVdXTraspewsdJSiwrsj179kyLIzp2sOs6QvTee+91pq9elHEcz87O9MtVwS2E8PTi0f5uqz4bACrXqCi01uzLibTtYhg9CxyPx9PT0z/8wz9k5levXr179y6ltFotdP6SMs91Wtzbt2+///77tm3PTjfG0N3V5evvf/jFP/w8xhhDQjSApu9GXJimaUMIZ2dnpycbJHCVRcK+77e73fF4HELs+pGFfOKQOCRJUZIkTsAsCQURRFggiQjTPR+nYG9kkCaxaGhr65xraqe5r+4ENSyUKVdqWxBIBZmKoQcARClumDMQLSLIAMCAGDGJSEI9DCJydbsAoNVmc3dzE0IMIQx4z2gB2wKAJSMIxiCQIaIkHKYpHZPZSSl5DymliqCgGhqllfMFAIaJy1uO0JhpziYApCSAoridtVakMGMQEY0gsDxEdj/eklT+KyK5FYtVRUudUUqRADmrvKmGBE3qs0hkBAjR6JUjnXYALMwMmFKIo0956jmhRbg/TtFhfSUuQKDZmHn5WNY7/3sKu2dv0JFEepYyK32Wu3Ju35jZFtc7WxqCLEWoW6O4ekTUnYNotKUJ0FgLItXJyUkcfXc4KqzXd4fdbsccjXEx+lL2A2BDRmaZ6PTlCZSRTyAi+NmnL7/+1TfM4uqqruthNNvt7vZ2u1qtlPlcEg75ILWFf8IjewvLzFHY0dQe4JyrG6fZkjFNyiPnyk9wZt/ZPPCVM9trCtPSfS8TzGKfwszSA9BGmmI09Z0TKyonT6U623ejujGFXbQNNIRAhrLXn6IHTWfnv6L3FeEkBFFCsJSSNi9578cQqqo6HDrd90pTUt3NyjpNzpbWucocD4ckEyTunLG0nKKQzDIzpflYASijwBeMRAoq6KFq289yuXS2rqpKZzyUi4OzB2T4brIvWXPj0aNHSCQiqvjofSRnT05a5ujq5vT8whqnPj7GKAiuruZBqC5jQDTG1HXlvV8u13/0R//s5OTs5z//uff+s8+/XK9b5+q+79+8eXN1ee29/8lPfkLTXFVUzFaPsOhsUO5Bmu+WIiGSI7Z7MqeZRuGyNm9QFhvXTEJXXrHcOaWucKzUQ+Ms+S5IDGf5wPtqS2U0CizTL1JKmspTHqmEiF3XqYrvZrO53W0v3NnFxcXxcFAmlEpYqOt9/Pix8qWVUj6Mox6Aum1FLPzYpZQWi8Xbt29VaFpvpO++//78/HyxWGx3dwAwDIPq0eZgC2bLxcYYhQ2dc99/+9312zePH51vb2+v3r1DRE5ibcWSDv1QVdUYk43RWVivlqeblSMGRO/Dvjtud4d914cIwxgT4Oh5DMmHGBliEmZJnCLqwLskwmzYEpIBJFvlblEiIoNE4JxxzjhrNJBq21avGiICTd7XGKO9pBMXVDWOM2iXExvWNqGYVXSKOyCiycRMVTelEdiqbgVS3S5X6zCOgXe7kLxycVMMAGCdUeekI3ZU2oysQURk4RRTCkk3SdvALB0qWKB6ow/9jVobzt1rYAznTEMht2LVdRPKQ/bu/Nve+6P8BPNESgBk0Pw3prImzMwJEA2CEUYyRCZPUyjGbZJDSIjT/SUiKYohnO5Z0ryVMLPQtW1o5kk+4jJ+05Oz+iyUy4eIlGnC/Bs+jpiVsN5fGiGgKXbBGUowX9/5NmKGqmpOT0+7455jqKpquVwej3uJKMjlzVCacWeDoJmZ073EFRk8HrqmbT/99JNf/vJrsCrnCyJye3v77NkTg9LHVNdO8wbJNMLftHKICLnZrkQS+stEucJRTwNlm7bKbbv3cMQ8RtHLaa01SKWkJ7lSklKKccotKCt7qL3WZiHJqluYs/CUG4L1DDArPJRFNnmIIeTCDOasHRE1/IRJEPje+BbwRxUbCHOHVWacHQ5djBENpZSin+ToFosFRx9jtNamFLz3iYMBXC1bREk+dP3BkGNAZl4sFk3TCFskU05Kj19/y+ZJUN77yNMUSAZBYVtVq80mpeRTJENRGK0RxDRxA1EErbE6Y1Xdm/oeMvc5ZcoXaL8/jvFOaWjr9Xq9PlksVoe+SyBrsgBQ1xOyjYiAUy1ccgCrbClF9b/88stHjx7917/6b//HP/wff/qnf7pYrN6+fXt3u/3hhx/evn377Nknn718mSOtqYdhEkxwrgDplLvA9T2Uh1FquKjvCSHoXATKc6a1kO/zOPr1er3f73XjVZWdGAD59gGAAqARkTFINCVbZTfqj1ZVJYZVe1VduG4bnbyrjl+zZG272m63IjIEf3p6Ktu7xWKxWi5/td/r7EJtiNJDVWO93W415/Per09OMPPJAycbuPRn667zMbhYPXv2yevX35dUHjPxSk+trp2p3LJdmPzQk1VKwcXJ5ury7e31zZsfXl++fff06dOhH1+/vtSIGtB4Py4ae7I53ayatrHJh93xeDweu3489qMPEmIKCUNiHzlEiQlj4iisN2LUwEkiiQgwojV4v7f1ahpEg2gNVs6BsLaNtW3brpbW2slvISIRPmxfFJE4y4BJwJDJc5Ow7Mm5KU4pMDNylmTiiIgGAcUsVxs1DsPQpZT8MDIzR2+MaawRxBg5pURgLBk2IBxDCghcltTmGWicx3MpcpN0rkzOfYv1c87pXBPmpGrJRJSSEHDZ6jSjPWc7d+9HPnQiD/zOtE4TwANT98q9hSyfLQklGWdtpYOMYGpMtQKJp/6CqUDDzCDSNMvJQs4MrBDC7DAYp5G9H/qR944ffoNbLadzH3mwotEyTamC4unpQf9T8U8AMJfo/PA9ZRVYOd95SMB6vb6+fHfYHYdhQBYfQgg6YwcSR0AAuRc8K17z/r/MUVJVO5H06NGjb7/9oTv2lFkq2+3u8vLyyaNHIlELt5VzaTraCTD/yKoBYJHLQiVjE8A9tVhv8uRDSql1taYL6/Va31Dl6evqVxRMhtwuYozRklVOlKdx65wpr5RZ7/OrWBwkEalIgq6AvpNyh5J+7TwAUrKbOiT18VrzmzOHS1bNnBvpRFIMy+VSMjNIj1Dp0Jxxy2E4dl23qBtjwFrr/VDXtXNOqa3Hw0EA4hjMwqjaFEvCPDm1QLvz/WetresWgGEPiGjrytaV70YA2Gw2q9Xq5uZuv98TkTF27lp4pgkq8T5k0QjDp3uULKXEDPvuqJXCq6ur05PzR48eKYROZBE7AxP4bG0FACrzKbP2bhFRoUdjzPHQX5w//tf/+l//X//h//2zn/38yZMn37767vXr1wC03e4vLsJyudQrVdjU6gXn+Ws5VJOHnTEzEeZ8YIIKSgCnSaqiDjEmzTKtMXVVCTMCOGtZczQBROSYCJAAkSik5KZ5UBOaVdJrZXKFEFDAGaMdnOodFYWuspZ13/cFo+u67uzsLOZG+eurKx0JvN1u70U/fBi7XloRkbquj8ejOvvg/fmjE2PMzfbO4SRpon1TT58+fXd1qTmic+78/NFut9tsTkc/lAFTerv9/Fe//OSTT4wxjaskdxirtNNisVgvKkK5efd2e3vz1VdfffXVV//p//ufY0qmqtZ1s9/vK+fW6+Vms2ob54djN8bDoTt0Qz96H2JgGCMOIYWYIkuM7BNHTpr+MnPiWTMJgFaCLRIRoSj1ChHRqLdX/o+1VV27pm6axlaOjIGHyRDkHEiY0yytLDaQEVkR8Jl+rb4hlvKTISVOExFZS4RtVTlLBrBtqtur66vry+P+MCZhjgREhlAEWRPj2DqTGEIIWCA3DiKSYBoQrrBKabaEmcsp9q2qKo7l1ZlIMpAWGYmspi4lPH3PKpcFKb5m7lbLe1gi5GI8PHAX98VjXShrK2stgKp6a4GMAdggGEPeez90IsIshHaxWAgil3G7czchggTKfsffnLB+9Jn503PHnL+ERMDY+wmMJcJA/JgWNCICqdH/iIwnTbPZp+MjIsiKyiys+VY/HFMKiNj1RzHGWmNyWJRmrW9TiglUgDhmZmAASjGdnp4+ffrkH372y/Pzc7Udw9hdXl4/Oj+vKhdCQJW6/UD74rc8RCacoVy/st2jMKSJkauVp+PxOAxD1SxwNqNXrSciGqScfDgRUbTMe79c1mrO1FvrgRUVLZhpJigKulwu9fudcyFOey5lWj/n1tj57qTcCpVm6owxjwNTU67ZmOQ2YtV4AgCbRyHp7dR1HWtOzKxAKBBpIXO73T559Pj8/BwRt9tbAGBBAIkxcorWLgxIOcf3/Nl0ZYmqqmKOxlnt6l4sFhIGEdHxt5l/1DtXqd8CgLmEuu6UlO6jPY0VxtHrFlQthdvddr/fq79Zrk5X33/Xtu3zp8+CT6v1YhoaYxU6SxyToogajhBa51zlmpTS6HtV1Q4h/O7v/v5f/MVf/O1//zsdP1zX1RdffPHv/t2/K5lficn0D72jUhY7041UNMhE2JgpPJKcv5bGD31/ZuNzSrGu691upyy5HC7cDx5Os/ZKybF8KWRQ1pXU5RqGAQUAq2EYdNxWeZtuDN0VNzc3zjkfgp7vbrdTT6m5uCpZajChIi0hBA10Hj9+TEQKZd/c3EDik5MTZ+vVatV1nX6wbZc+JmZomoVz9vr6erVaHY/Htm1PTk4uLy8111eG9n6/V03Ki9Mza62SAQ2Sc846Gg7bm6ur2jnnzOefvwwhHI/9s2fPru72d/udcfbkbL3erE7WbQrj9u6q48Z7nwRCTINnBvRRRp9ikgQYGGLiKJI4ZQ01A8CGrDWAJDqKFBEnQVsWRjFAYBBYOCXU+oI1RGScJYW+CBl1rifDVMecbGaCe/cjs+EHzExyH4PevwoCCMwMESSbaxGJKREYRGzbtnLGEsY0orAdY9d1kkYha42xFpk5sAQfjDHWSF1RVU08UCWyUJY9KNCOcRZnyGI5zpIS4NQMYktuuly2xjmY+Z7pbb8Buf2oxUZEgcQS83JN/AfITN5y+yCiISI0zmmc/X4DLUtEER+G6SMsVVMbchGo/Hq5KOWQJvSxOIt/7FEc8MM3U8ZcQb05PKQGl0UzxnxcAYQzrP3RtSvnWQ7aWrtarXzfaUq3XC5ROI6+bVuqJo77fI30Mf3z/glENBbTOI4Mxjn37Nmzb1/9MAyDyDRTqNsf7u7unj59zDEZcpwZ+791dd6PwuYhHuXidErJIpWX9GLHGClGay1aizmsUwdMgG3bKl8A8t2SZoIyOGvJlRlcnzIRWpNRLejqS5pHKnRZsrTyd474JiaFiPR9p4RtnU93v4jGqH3XuFV/WtMXyDKzGb2YmmpSSqt2sT49OR6PmsbFGNvlAhFvb69TSk3ThDgS2uQHAGLmw+Fw7kdbteoUERGA8qpPeBSIiCRtuo0pVFUVqmqi5ywr5+oQwm63VywhO/J7uRIASCGGKSjKdzvhMAzjOCbmcQxayDwej/v9vmmaYUzv3r1j5u+///7NmzePHz9++uzx+fkpCTStzo0YCRCQtRvV2brAsADw+vXrYRi6biBrQghff/316empYh9/9Ed/VMImKPzBrIkmmTKmF0jDIEQcx9E5WwwZ5aYDRTIKn3m6cXN9wTnc7Y6aGU8S3zxhgMxcCPbq/nM0cG8NMc/g0ktjkNSXF+6eRgYFBLbTzIxxGMeiW6kNxGnq2znqTkPEw3ZnrT09PT0ej8aYV69eaRBGRMvl8vGzp5wghHA4HFTvsKoaRAwh6PxKXTdGWJ+evL28rB1pQ1QI4Xg8LpftZrN59erVzc3Np88/UdFpzYGMRWMMRR/GISavvLw3b944Z+4O+/1+f3d39/nnn9d13TQVEuzvbvtufxQOISWBIUofIguNIUYwkZMgJeEkKECs8AIAASGRtWgNAHIGZpRPRAIISRimtCzGiM6CIWMMEBqtAVnDIIiQhJkFldSTpgLcXKCwmAv9p0Vb7sriIcgwCIEwAAkmVfBV4+I5gaQURj8M3g+IaC2R5xSDiBhOSMZUDkEcUWVcXddKrtYNE0VAEtIk06bmgma9Q/NETfIsE0sT3bK8Wa3TYrHSNEyPvfi2uXEuf5eQ/UPTPfOywiw8C1CmBE1vE0EQJEPWVIQEhjjrbLBEFW9QssJ0kNYo4RHMnIElItM4pmJw1P1hht8/GiiUl+ZvmL4EzPwT974g8TxfKo7m48MYEFDgwW+X3+OHpVzRuTMqEQBy2G+JYNku/NBbZ54/fx6Et9vtmPWbEJHwQS0TckhIZEWSSg9GAQ2xX758+fd///ebzWmMXu3amzdvTk9Pm2rSNE8cP3oKv+VRjBTkjT61vlRuHvFpf4uPk3+lHGqoWdRukJREE52pUoukfXXFIqtfKYzoKb5hzqo0jR6DOjwlYKtjLlc3pYRoSuBZhoCqjTs7O9P3KEdGtdHhHq6YKEtK8Q2zUe3KhlH+yMQeqqpuf+jHQXs/NpuNDpvr+6OqAacQTe2cseQqRNnv9957O2H4DgCiMIAQkcUKgBEx5SjE1RUdp4MREZX7j5GV4GqyCOh9wSafgjoYkIkuzsxjnCSXD8fj4dCN47g7HiSLeo7HYCypNb+5uTndnDx99vizzz778Zdf1E2l11oSJw53d3d3d3cpSl3Xz549897f3Nwojv348dPbd3c6Qc85V1XNZ599dnFxsVyuCVN6aBQAYE5lL5cbZ6V6NV564Yhovv3KG5RspV5TYQ9NNLVDrK5andNQSiEppXEMSA9ief0h/af2NenhqZNTVlqYZEAmXZdSplXy13q9ZgS9Rsvlkn1QhtR2O8EMtXU6bFjF7+q6VtT6Xk7LpxcvXjCz6nWISN02ZI21tu97772geffu3bNnz5xzdW3X67XKbCFi1TYhhD/4gz9QApqoRJ11zByT7/ue0mh0fDrL69evLy+vbm9vb/fdEEWbjL0fandxc3N1vLtCSKM0x2OXGEJI3nOIEiKjqYCMKJmUUpnnIgiEhASWcOpAytaPhQ2SIAgI8PQkpBzr1NXU/ltXNLXJznp5mVlYVW4EHqRf82RoDj6XQI1TIGsACIAtTvQLSUkAvB85hRTGoeui98agtTaFmIIXkZQQgJwkss45Y61VebXJ2AoYiyTgc+WiCNcXVycZiqOZWBsZG1NEcz+DS3ERLcHw9P736Uj3nuUhQlv27XsLov9SInNJG4oDM0Qg0/KW5CRN+mQsLACgrYYhBBVFds4uFqsQwnsOXwP6clTlSN87tg8fMgPSH3zkg0Ko2m2YuXyZNcJYAHr4foWFwSDNdbRzlq3tOro5QNFXkQRILNgsV82itYdqCIMYNHXVbhb+Zh99zEgdSEwMIILMTGhwmoSspGsmkBQtEhlgoIh2/PSLi1c/2N7vrVtwhAR4uw1v3l1/9tmLxIMxaEQ3h8xdznsLhLNznAcWJdYTQeeqwGzJsCB7T0TeD01TseLM1ipCqDaxqiyQVM001n4MXWtbsmDpXldL38+5WKurH/KUQO+nEJ5ncpgxsI5BNMZYUw3DUFXOGlL+i0YJMU8Q894Hn2LgcThY61KUEHzKKgQpirYeseBisei6zllLpNXiJoTUdVv1gmM/qFIPSySDBoWjB4Dlcrnf7gjtcnEyjj4laZpFSokQLQiliJjefPfNi+XG1hVzNMY4xJTEIhEgGcPMzlqJxiBFEAXbfX9IzLn5uPJ+YE5V5WIMVVVrQfRwONR10w+haZqqXijbDpH8BPNy3/ddPx4Oh64bkkjwSrJwwSctSalgZBjj9fXtfr/fbQ8pis5s0AiGiPrRHHuMzFfbu9dXu7Efrq6umPnt27ft4lsO0Rhsmqaq3cnJql1YH459d6sBZ7EUKomsZc4QvHOOyBGZvu/ruhrHkUH6cdD5PMWqQuLd7V1VVRITIqI1ImCtC0GLGtb7YLJw1bRXJRqLRBhjcFUjkFxlrIj3WhuWYeiMMcvlUoR02tJi0YQQTjar3W5XN64UmyH3hqlpU+0LnXDVdx0tl411EuKiqkM/KEBijFF5VEQ8HA4n9uyw36/XK2a+uDg3hk5ONiEERLCIV7sbY7FpmsRhuWpBaOiO7XJxc3OzWDRNYzeb81ffd2Tk2fPHlz+8QYGnj59c3Vy/fft20S6bptntDqt2sd8fnRuWyzZY27Y1EazXLe/7umr3t2nfj30/Xl7vuwi2qs+Wrm3r/d27L774zAe+uQvMGwDYe/Bc+WHkJCDGGSBizwlRhtEzCANzZBC2gI2ryUUCdAaJCNWeACVOVNUiKACCFAVClIZMVdlGyNoKwbSLFbnK2ioFLZyAAULVdRKwaAQhJSGaqsFlCzGzCEICtBhziwdl3NKiKUPgRKKgQZHInIIXjr477rd33WFvhEUSjwOiqet2HMdxGC1SjEzkq2VjoUbf13UtkGKMlogcsYE+hiScIleYGDD6gII6iobQkMWUJAZOjIJmiGxNYhA/ekIchr5ta5F0dn5SO5QUwBAo9k5ZQOJjYgyTrRaQSfp6KpATgCbaiEiIkVOMUbc3p2SNCTHGmMAigBC5drkaORqDwHGC+qKQFnNDkigkBEApidssgjA6CxO1a1aNZkEEi4RAkLuS+CGgrfCewq2TqybSHrLsXCckwMzmAxVPxFkXDLJMU8H8/0nzgPXbIMtq5a4TnL0E1trgh+V6fTwe9vvtcrls65qInBsQFb5NAEhTWqBybg8iDMkV55QSWSKiEONysfj000//7m9/vraLuq5FIKW4vdsfL45Nay2i8PsRx4dhy3vPzP9ZtohkvrH+HSdtyEn8uXxEWzUQp6KIy7NdUUexuupwOCjWZ3LzEs1knzUQ0XusFHcL+FN4iZoiKwTEuUZYpKNKbqTDg9PUF+9L3K2f0lwqxbTb7aIPi/PzCWm3FhG1Wl8qQCU6izGqSIJkzMN7j3Qv11XqnYjY9/3+bltbZ+oa7qUhAAhF7nF+k1kCmqnf3t4OY7i6utLiQkFH53m/LniMUV0RAKA1FGW/3/d93w9e82+YsdAlAwwZWZkeIaTr6+v/+B//o86A0u5YXclxHFeb9eXl5XF/UGWDCdT1aAAVJNY65fPnz1eLpfe+rhclrqfM5C/VgYxYYOE0hBQ1q5jHvwawkPsCp3AM1k4SuwDQdR1kH6mAMM5YCAXwN1lFVQc86OWYAzD7/T7GCCKr1arsap3EELJe1WKxgHvGXL3ZbDQTUt1pbfw9Ozuz1j569Gi73VZVdXt7ezwe9VXN2pVTreT/Q98R0c3NjeqeIiKhFZHI6ebmpu9r3T+afOeK/jR+EQDevXt3fn6+22+/++bV+flpSmkcus1mdXZ2drJeDsNw3trr6+sffvhBiyzA99rXqqFtjNvv91pE67qu85BS4pRABCdrCMwcszVDRDIoMIG0VSMkQICAIrmlkBA5MaIAGkQkFAJkjimCCM1Df8nCAJAZJ/pQUrEG0DCnXzFzlmvwabIbBSMRkcBqLgwiCiHwNGgQAYZh6A6H3W532G2Jk7XWEDhnRCoiEEmSEksMPqmTQWNCCAKTilFidpXBpD3HYhBB5/6hECIwylS9ToiTiShcOY0gMCMlkDFRflhYfc/7zs0vzsrD89WQLMkAOeuVov8sgkjOkTEG4N5q5W7Z4p4m06G2Tos4Zho3IEAfOaQPH8UEzY5ZmH+jH8FcSQWWD95wn2GXR0mLP3TApEkwZCB6djRT6IBTVbWklQigQl5msVhdXFxUzux2d3c3V865/jhq9qYron1dRHb61Lx8jaKFrmK7RaSqqk8//fTXv/o2hLGurHM2pbjf74/HY1Wvx5EtZaMPH3GrH1up37gnjKEQJoGFUuEoiO7cpw6Db5oasjWciriJvUwykJQbc0vEJLOGXcido7p9FXM2uesXZzCUgpnF+G42m7mXWq1WJcMumIa+VFpgU9KMOY1jn1KI0e/3+/1+P6kBh6C6IurFjTGKiqcUvIfa6Y0aMPdITOl1ZmQE73f7u83JSv0E0dReh4hETjiKCFlntAjqJMa4Wm2Wy/V2+0PXdZJ4vT7Rry0eSJu11E6NKQ19f3FxIQBd14lICKEfBuVJpZR8ZH0zM6uZmJG5JpIdEWk5cxxH/XL13FPl9YdpzTXsULTWh6G2zjnjnPvkk09+9KMf1bXTuQKcqSt6HRXSUEKcIm+chVmmmDdMhLsStVTGusrpHOLyzrOzcyX9UW7/VZhEL64xpsy4LI5cffzkunJsx1kZn3Ot2hozzSAyBhGLGgYAHI/H1WqlI0/01bqu3717p3MP9/u9Ntjc3t6q2OezZ89ub2//4A/+4PLykoj04ynrKKn+iSodhuAVQB7HcRg71ZcG4N1ud3Jy0jTN69evv/7m1y9fvnzx7NnFxcXPfvaz5XJ5PHSXl5ftomHmk5OT3W737MlTkLS9ueUQx/4IAIe3++3uMI6jTIrlY9M0WkMJIZycrFNKu2OHLDHGQ9cPcVIqIjACwopRitLJ0Y8jxwQsjavWm9WyaQEGAjQGUYRjUEZCYhCBwIkTQ2JtpKjIuYmfL4bAEJAwc1ROkCa+ADCJUchUUi07p/gbLg02U5svyazJDbI/SyCIaMgRADMfdvvDftvvd34YUko+xFqEXGXt1DIQQvBlzCJzZB7GDhGV8WCsnQinZIAlCaAICguLACGhCBPZpCcPLIQAGEJCU4lM7ey67bWEREQiSU2vPKywwMwrF1OsxfCSMOgf6iYg92cWVz1teGbK1l7vBQFQlVDQuEezUpHEaV7SXiwWWW5TiIx8kJd/6BTKM+XX33tpfmqQidDqGefuVluNMbdEl2udreXHWNCzByHwewN9Z4vI2n01tUawOOdS9IvVer1e6x0bhrFdLprFsusOFEgEVeQEc9fze/QonMh1hiVpmMzMy+Xy888//4ef/bJyCxEhA97716/fnpyuY4ymumfD68aef+F84X77Q2ZKNPhwBlEBitWJ6rZT46K2rK7rFKaRghr8vrfzEO+tcMzzBPUP5URQntwwv+SYBR21njEMg9Zi9SALHVcdTFGchhwWAMA4jqoJoA5Smc8x+vK7AGCdUylEzck0L18uW+UsaBRZ1GLLT2CWyO6P3X67a6raLVb5QuQrQlY4EpG1lYgwiKu4qqqLi4vtdrvbHaq6UWqPplO65toRBDmmLnqZ+mTX930/pvvHvf5XSlyqsDTN6J1QiqnrXoehzmIpLRMo7A9ayjVgHRmsY4zONS9evHj27Bkijv2Q2Sv3WkI4U2KJceo+wiy8WpAGNyOLppR8GFiiMXaxWIzjOHq/Xq8BQDUFFWLRrmLdcnE2fCnNpgsrdKHvwawXXSIwXUYlChwOh9Vq1bat0qZKaFLyAxUzGYah6zotOWt5IuWBmABwOByePn1aVdXhcGia5uzsVKVU3r59q5fJ54f+il5ZZW+1bdv1/fn5+fX1tZKzNifrz7/47PXr13/2Z3/2ox/96MsffbVcrbd3O508r5Hr2A8/vP7u+ZPHyOl42LVN5f0I/dEQIKKxdHd3h4iUby5tRzl2ndrx4/EYYiCoJWcLggQiavy9HwVBFR4MgTVYW2MNWkRnbFVVliDrP2BMaRyDNY7tBDpaY5xF1XuujJ3DMFotFSkmDvSPwCnGqE1xORG6rwEzAjHHCIhSLiIRqYaiZPEiIQRm74dhGPb7/f5uJ8ELpxR8CuKtJzuR7WHy90F3aEpBoNVe+cPhQMaoHKkhQuGJ55aSpBQZkOyE1KoaByAJaKN0qozSOzCbLGOxAIFqnHQW73te7T0HXAxIfpIBJKXJxhafp3VlUcma2SxCY6YDoFkXzMQXASjdgJqHuLomoikO+k0tM4LveboPfDDOvOz98/mZDE3f56UPvFsCEZ4FW3lN/lEIevLB5ZimXqu81lLGE5ERTgKk0ler9cknLz7/5S/+oW2WTdN0XYdkcOLyCTMjlFXO1GjQ3FGrtsjMxrqUhIhevnz561+9CnEEIWvtOPavXr365MWT09MNgwAIIX7Yb1ZY3B9f8dlbIUs2auRlcCrTFk+m94n6FcW7ikAg8PQn5QfmUZow00KSGWuOs2xk4b9A7grgLIlOeTiu5NECeoQKBWvgWQ54jhiXW1cFIpbr1Xa7PT89U7KMhsY6R0d/zoJTP9G2rXJ8tECbUrJkyACzykXV+isxD05QHzMO/dXV5cRAsTYrDxTiNwoAGWOhVnb/OFTtav38+YuUvhvHMaR4dnb27bffIpIm3zFGdSSQgX21p0TkQ+j7UWU+mTnyFC5MNwcBMBblVNKmo3zhFAeGPJ8KihABsoAhA4Bc15XVc2jcctnqYC7n3Gq1CuNQ9DrUExdGVeEkxzyXMGWTMQUEufOtqipkSTwdwH6/b9u2seZ4PA7DqJ05egzM6Xicahlu0u6GAgMSESLEGESkbRd932MeqasJsapZaQvQkydPdAawEvROT09Lm5xyjDGPWNc9r/98+vTpf/2v//Xzzz8vJQkiur6+VuBht9vd3Ym6apVc1m387t27Fy9eaMB3PB51Zy4Wi8Visd5sjsfjycnJ7e1tCOHq6mq3233xxRdffPb5n/3Zn3/z6tt/8S/+xcuXLwHg7bs3X3755c9/9veffvrp7u5GRAildtXQd0QEICGE7rDv+56DT2JEkMwk4RRC8F5Skq4f+8Ejqi8AhIlelRiSxCjCAmoQCcRZVztjDSLEReUqa5qmsoYgaYYqPrKzlmVi1amTqCpbV44sGnvf/ldNd2sAoLmQBWMmMc0GxZc6RQJRr1a2K+QkL0zj1CYPFySFcdzv9/3xcNgfjocDxIAgKXhthWyayk56t0EkqUWaInWZPJOIVHVNpkZE4MjMkiKrHYsJBFmCjrlBRgDQHivNQUUm6XulQRVTlpUj1di+32I7977FUsF9fiIyw58xd/HpqzGlGALlQBC15T3LfMJksYmIUggKwinJlCx578/Pz7MhvS8TzC3/dEj5mEXedySTe0ICfHAKc89SztHA+4oI+ig7p3xqcg2/xTPdL2ImRau/fNjcdV/qYwREY7U/Fc365HRzcj4cdovl+nA4iKRh6FOMSOjIBF+avWB+ZFP4hkBEJADGgPBy2b58+eIf/uFXp6enzOycG6359a+++ek/+0NL+cAQROShiMnkg+UDSOQj5zhfXELFb/VTmpiq2ZWsCGNtO449sEB2qDyTCFZvavIAYMgaGphHdBV6YUm7JQPXugjqXEuMrNBoociq+F8prGq2Wr5Z7zHNJEqWXFQqldJlDBrjgCZasjGo6GZV6Vh6l1KKPrBEANhsNsWrFRR0wlRJuuOx744xxrpmIs0GMIEAEqckZIxhETHkwE0M3vXpycl+f3t7OwzDsl1opylk/LaqqtxuQTp8Asn6kPb7ozYgdeNARFrMSymFkFRmz1YmhTQPlfLdPnHLNbNUr4mIbduyxPv8PkQyVu/Ek5MT59z5+fnJ6Sb6cHNzZ7Mom65DYcPpTaFfYvJIjxLaa3miGFyC+9GEGmckTuv1+njsdF7N8XjILhZVuFtEFEDmmb5B+TkNQVSjVMMg/VFE1M4iyMlrlx+6x1TMeSKvMqvzBgBrrU4GfPHihW5gTZu0+6Cqqru7O+bJPprcl6UI+ZMnT0oRerfbrtcbPQVFGhSvbtsWUPb7/TiOf/3Xf/2jL3/0//hf/9fvvvvuz//8z3/v937vs88+u7q+FJGnT5/ut7c//vFXu+12tVgedts4DtaY7fXNOPphDPvtvq7r4zAS2cSMiCEJpSiM4+iP/ShAIIR5MyBZFoycIqcYuMRJhOAM1c5WjhpXLRs0xjSODKqsLwCQtclVhhOExOVWrSpbO8cWUEBSSCmUUFjDaJj19SYQ/WTKQWGJqhOIjv0p9Sk93mKOmDlOYwgYwYx9v91ury/fpRiTH0HEgAhLDEldqNaSdBcBC5J47wERgA/bO0RcnWysMWGMKYqhaQqBJPWFQATCwEpCloQMjBPpR8dJ5SMkbQDR/TMlQJND4glyeNh3VJ7BrBGtS4K5TUAyDKnRTMk9EjPgpPVmjHGuss4ZY4hs0riAYO7Y5lehaRrMCsrzAvADRyD4oXOdO6bpX7MnP3DA+TvzLxQLICKcO51EhEgXSX6LA74vA+d/gio/684AAER5b4CiiBiyCSKiqZuF9x4Znj5/cfk9pyQ3Nzcioj6gqCK/54AFytlycScqt2KJvvjii++/fx3z7PQTc3p5fXN5dfPs8Wm5bCJSKt55aWQejv0m7zudZ57Lq2Gz/lMhUMrjZtX9TArDifV09JkJEtW0+GHaHbMqgkIixXCXKK9cVMyj3VXjXkFj/d3CgFAQby7jUDxK+VrNj5UgU8Y3abVGfflud2gWrQLmzhljJqnk+y3IYq2tap2jN43SK/Mkyha0SDHGMPTBj7JYGCIBAFNmbAkAsHUIYkQQcblYxZCE4eT8zFp7c3Nz6I5nZ2c8tWZN4oVFL0WZPupvuq47HA7dOCDi0PuCpqapCMJ6vfUuhSzPKZIQTYE0ShFOoVE/dIMPRLReTVNsa1V5MEbroyigjk3tgMtqA+oLtcpu8ozIEEKRtkh5ZGSJXUhA97N+dhxG5xwYYua2bWJMTdMcDvvj8ajoMc6I0ylLfBQ0RXeaTrCJIWgKq5ZL/9ATbJtGkeq+71VZWk2SVnlpmqweiUgh8fLry+VyuVy8fv1Ge7E+//xzjX4WizbGoBtewwgAUDGs58+fFyAaADRNDyEsFktrrQ+jBlhN06pjXiwW/bH/5S9/+fu///tnZ2f/4T/8h5efffpHf/RH//W//NWXX35uCYa+/+zTF91hTxKvrq6O/VBydCLQ9DpFgcQ+Dygb2R/7LiSuqipFtqAlCsuAKSYfg4/MIMPgAdhZWzvT1nVVO4NCKJU1iACcEiTtahdEQiQBIXFkjKn0QoAkQEY0MUbvvSQGZIkpwiSVYwC1YUTFN9Q0lMlgc1uh6S/NOjhwmrY7Uee03VEdcHc8brfb47HnFJIPwtERogBL0lBARCrrXNNUlSNzL4xKRHVVIREy6vVq21ZytKfFS2dMEkh47zpUvDwqXZ+suoaUEiEgio5+YmZD77mD9F5/zdyrlSeZWbX9U56jyrnpqMSsIveYPCIiqrSTUR+uU+cllwuZo1YGAUBljjT8h8nJPnCf04EBlURoHiU8PB0pDvg3nQtM067eP+UEIjlDE0mQZ0ROVgg+/njPBwPCVIRQeSyShy9nFjGAHb1HEGOcCK7WZ/7sGHQ1ARQGJEI/jPBeyo+TTnmSaKzhIU+pjIlZjKlOTzZffvHZ3/z3vzs5OWGGlFJdNTc3d48fnWKagGsBUSXPEijALDaZL/qHi6tySxNvhUBr+MoIFRGbhcQ05B/Hceh6zYnV1UlGY3AaTG3nm0bTX80VitvgPB3BZkVWyQU/Ilqv15pVaAcnZ4hbIdlyPCKiB5CyckiJ+/S/iUPwQ5CpdB05GWeBDJqk+GEI4/n5uea41lpdLudcCjHEsV3UdT1diKL1EePkJoloDKPePLrvFQBW6Kzsdd0YAsjM1Xqt+VDi6MiIyLt373CBFxcXb9++DaGvqjqEkKLEGMmaoh+itUy1ZcJT3TfGyKWEoXkDCE0zgrzI5K5UvNcZgwWOy9Cc5mR1Xavecl3XL168UJvS1HXlLAAobZiIhmFomikB1ek3fd+JcKFwcyal67YxeZCtiEhMHrzm9wpIhDixl4/HY13Xx2OHiGdnZyoRtd/veQZ4lr1a8O1yh3vvEzPR1K6mj/1+r5vTGhNj3O12t7e32tut37nZbPQ9IhOYvNlsvvnmG/3apql/+OH7i4sLa+3hcCiV+zdvXispAQC0qKwMF3XGfd+rgJfubc22JY+P1G1mG6uM65TSkydPtne7GOPf/M3ffPXVV//23/7bv/jL//vx48c//vFX//W//Jc//uOfhnH0w3B2cnp3dcnB+6Enoq7rdR1Wq1U3euesj52uvHGWxyGEBCrUQGSNJVsBYYrsYwohRS5SdEKknUJRkkspYSVRm2EECDABWNKSWU5GhY0x1pIxBsSIMAMWXJcAE4eQRA1dQjRgokxlv2mA7UxTgu8pOVBsBQCUacEppcGHNOlTMydIyR+Px9vb293dVhJLCs5YbCtk8cOYUlo4A4ySWKNIi2SNFeskJu89WVPXNSdhBeRYQAiztgZIEiRteGEOCIxowBhgTgwibEya/AKKUtU2m01du3HsER1o2fMhwIso73likntrrA5YbWOp6cBMkUbvUCJSmi8iTt5UUEEryHNEFAFSBXtOCQA0iHzPncnDNBfhnkJUEoa5f33Pjzz0LFJO9p4FPXM3iMiooiAP6r5ze/VbIOgPfPD0w7kY/N67c0tGyQZYgAVW6xPv/dPnL9788B2S1dKkMUYY0mymmw4JBgDlFuUEgojAioxxJLSPHl1U1TTOr2kaBnl3efXs6cX5+WngRJKnyaZ7/4S5HvnBWcz/mBZEPRBkcSjNXTRt0mi98Kc4dxoo4leAR90KahyVeVt4ufpzWopT6Xnn3H6/n1OfirXVbFWf1xG2BcQLIajIH+Zh2qUBSdMvVeTQg08p+eCJqG1a770Sntt2qftguVz2fX84dJqOKIsVgE5PT2P0eo7jOFpL0QctA9vKFXhHWUJo7DiO3eFYGUoxxBiruo06hCfDGDF6EkBHIggRT09PD8c9cLJIACySDrt90zQnJyfqy6uqOh67lEPjw+FQtU3vRyGUKMJYeqwpz7rALCWhYycUEwaA2plhCGoXiIBQGMUSMGLfDW3bbjarcRxFUtuuN5tNXdfLxUI1WFKaGKQ6kff0dMJaFJ9gTsz3dQSadWdNehQhAIDydYmIrE2cdHiGunznXIqqoKvKG6hXQc+6FFa1+cdaq9VWEQlZRBoRm6Y9HA4mT7BWg6WUPQ0RttttjPFwOJycnHAGsYdhUDaynp2Wh+/u7oZhOD8/0/3TNM1qtRKBy8vLq6srY2i5XLRtu1gs9Evu7u60xfzi4kLvAj2v/X6vHC4tmuhl1YXa7/fH/eHdm7c6r+XRo0fm/Hy73b548eLb71598sknf/qnf/qXf/mXnzx7+tOf/uF//k9/+eOvvrwmub56yzEddnsQ8XEMKfb9iGhEg4BuiDHu9we9fK9fv0UiABQkLZwZY3TcOlBgAA2kUkpNXTXOgSSCydYDwBiiJTRgCEQk+ShE1pALHFgAyDCIIBARoKQk1li9SZVgr1ar8Awi+6T2p6S2M/BvZosnkh3OKmV6o8UwQbJ+HFOUEIIqoozjaJBEkMOE1kJiMjAMHjEsl23fjwbRuQXHVLvKkglTNQSSJBU86LpheVLFMWgUG1m0gCuErErEyEAEQgAJgJjBuYnr4Ed/dnZCRg1d5ojNfEzhAzNrM8hUUFMdlbKNtYxSwmJDqAIakqk5+ocaUufqyrlMITUJBDPIRMAhjDFGbQSKnJ48eUJEISX1jsYaziL8IpNI6NyhftRHzgIjLGXK+acwV2b1JcoENAXlJauQZqhyijAy8vEbM+DJq8L7ie69r3rQQfTwZZiR01y7bBf9YrVqlouUQoqeowECmi3u/IOzibDZMSJYJEE8Ozt7+uzJD9+/Xq1WSbhtlyLdd999t1wum6aBxLknpFL663srm6M8AmR4GN3MVwSyXLMCmIZcSql0cUwdfokz8Y+UC1O4AwVH0ncOwyAi8z4Q3W2IqCKUzjll9+jxqE0sfUEKDyq2JvcgDD7ovWOO0/yipGq6i8Wibdvr62sAUA2scRxt5Q6Hw2ZzOoVmzNfX10qftrbiPLcuJdlut4jS1k27qJmnozWWWMdlO2uMqBQrEQ1DbwBH33ddt1hvNPVhBGOcblIisNYScIwxjL5y1hmqjO1RiKCp6kVb+7FXT//o0aPXr1/f3NwITB3SYwxjDOGYFFxNcRrhVzjkAMAhACtB3RBZThOl2eSRVs4ZFGGB4u1SSrUzbe1A0nq1Wi6XT58+Zeb1em2tWSzamJWcOYs1quNMSccqzLojchNFwRU1gBvHMca4bFr10CGOumKci38ioli3BnlF+KlpGlVL1m1TUkzIMMncNili7DMdT79TU3bdS+M4Xl5e/uhHP9LNoM1FiqPorivV8RjjZrNer9c//PCDOtr9fs8sT5483mzW33zzjc4Jvrq60ux5tVo9f/785ubm5z//+bNnz5Quvt1uz8/PiWi73epB3t3dqRypzktfr9dt22632++///7nP//5F199eXFxcTgczs/P7+7urLV/8if//Ifvvv/ss8+cpW+/+Zq9XzTV7u7WjyOiMMhuezDGubryY9BlUQK5llSQyOC9nuJEWWAZtfALyfuo1Rm9ag5JB2eklPrRA9LoGQkMkiVl23FMPTMLEmO0nFQ7iYgYFJEoqLIACmOC3OQmOJlgKAlTvnYzu/eg6AgA6hw4F5s1rgKhGMfD4XA89MEnAPI+eu8JJjiKY2LmBiauCTPoDInKOv0JSyayIDKRTSlJSonh8voGEStXu6ZGNIlZRKlXyrBFEEIDBikyA2p70uTDtIm81K0gO+APXVp5mIfyxpq35BNMCBBj0g0JWROQiNRLUJ7wONk9IGUWExEgGzKagWAu8UzrrEeLoLRwmlS0AOD9Zcd7SjbM//jo42H6iwVnVRQW8lqUSCsnhAL3Pht+ewasj4/oZH34KIeeIzgDwADaus5Vu1iv16vlxvfDgEcR4SiO7qHwh6dK+fD1DHSoF6QUm6Z6+eLTN2/eDH60ecbq7d3usO+Wi3UUn5IYMwl9vA9xzxYOBCEPSSzXoGx30JBKQU7MfaViCsaoG13PuniC4gsLNEpZZbqg1pq/zk22opH6B89UrkpxVy+epst68IfDQRPfUhhWP1SCht1uh1nlQxnjddWqUIuaHi2pLhfr73/4thS5Y+SceTcxRknRGjQe9YobS8aYBImZaZLNswXqsLYax/Hu7u7k/MK6CGhM5Zhj0b9GSQBgEK01yFrRScMwHPZbPc6maVI6ej8YcovFou+Hw7FHRO9jlAgAEwzg74kIMmOV4yy9IEAlZAEwkWnbtrLTiEYlEyn1mrIA/Xq9zl1AXV3XOudDiwXqUGWSUuEYU4xJ0WubNc7KBqZMsFTk32aRZ8kc+JRiidKU/XQ4HIzxNS41fhKR69ubtm6U/AUAx+NRT03TWfjAUoiItVNbtk53ds5peU/RF91FmiIoKU/jOW1sK2URDd2Ox4NiM/v9XudkxOkRlsul7vCTk5NhGK6vrzebjSbWIvIHf/AHKaU3b970ff/JJ58on2u5XFaVHYZhvz/o1jJ5auH5+aOvvvrKWvvmzZvdbvfLX/7yyZMn2tSuv/748eP99vaTTz6RFG8vLzXhQxRI3IcwBt8YyyH4FLtuGH0EQ4nDarUqAKYulCGHZhqkHaOPkkTE+4FZqspWxjprJIYYGTE6axigG0VSBABrsDLinADQOPqQpjoiUdDuJGtV7QkTiPNpHMMwDFVdM07gBCIia2stwoREzigveilJlB4wN1YiUJosQgTvYwpRO8q2N9vtdtt3HSfRtBhAnGNjDIfIzALROQAIAigiQ/DLti6FDwAt0SAzhBhSSl0K1loGDCxI5JwDY9M0FeYjRj7GaCyFEBFFsZDJWKm9/QBwnp3sg6pwoWJoMEqIMpc3nmkw6N0HAMY4Y60xjogETQaFWUAgMVhKk1q1iTE2i6WaYlENEwQAEO2ZmSe/v4GWO/NlxSu/9897nHnuxRIKyEMG1qzWUODY4nf+6UpY+qDCxiqUp/nh5j+wmEU0brFYnF08HschxDGEMaXEMclDZLwcbrnYIiIMUxcBijEGSJ4+ffz555///Be/3Gw2jGAqB1K9vbw6OTmzlkTYGDcOnVahAN7fQ1P1YHaoSgGYHUAiIk4gE2wCMevsAAAAS+KUe+pposJbPVg9ZU1ACxqpLaea4uiYOcWW1QvGmTiwXqrcdWBEpOs6zdgUSwQAdZ/MXAScC70LMmtMf3G322kCpPGYPgMAx+PRmgqEvEQQenTxpKotIu73ncL7iKaqKpfFjY1BEE6CVHj/LELTHaK2u2msH2Pf9+M4WleRcWZWATII0acxeVV29YMPIWy3N7c3V9vtrZ71OI4AE4CvQ5Oub24QzTB49foK7A/DqIm+iABQjCyStKUKs/iUc7X3AwBU1iaAse8AoGmazWqxWq18ilVtrbXDMCiA2TaNAoCKympEpcXUYRi03olIysmKWYLjw8BRMg0EcxMaqTmTzAWL05bQ0ym59eCjiJyfn5M1N3e3mr8+fvyYmfUwNC9XTUrNocvP6TeX3aW7SA+73FB1XeuRFy84YQkpaYatn72+vloul1dXV8+fP9dpgFpz0a5fTZHVMatMh2qSvHv3rsDOb9++ffnypY64IKK+PwKAxg1VVWmUo4Lb33///XK5/uKLL87Pzz/55JP98aDp8unpRnfR3famtk6LNcft1g/dOAwcPAAMgwcgIOt9AKDRx77vGYSI2rYeR9W0mWzl1JadZ46LiAoMaEeBxlJpaqgjAWRA7yOzEAJFHmBSmQhRYowM6tdDSgIAdWUBAFkYwXl/PB5dXS1EyFmbBe9oagZWeqAI6LRrlqKICJNvmMeRMsl1QdKWqekeCV03DMMQQkyRtZah1CAfIuaR9SiAhIIJQ0qp73rQi75s66qq9BSsrRJzjNNoc2bwPhKxtvoQkgATWRQERFYaNCcQVNhTt/fpZu2cE0jamASIgDouk2HWijO/R8okipJs6IMQ0SAzabJRbo2yLCYLPpcMWGZJtp64bmnJyLY2iajNR8Qi5Dh3MbPVnnck37/6T3nMTQF+cFTlgQ8f5W3/ow4YlFsPAIisFbwPD1eyoqlotkd2tVqdnp4d9tvjbjv0Joye5P6gkUAHFhcdGQBAZXrdRyISoq8b99lnn37/+odhGGzdEFpBc3V5fXZ6/uji3BIwA0ie1SzAHyzjdKgZiIbsiYmIOepCGWtKNKD3cIwRAay9j9HKKRtjACaDq752uVwWPipq9yeiWiI1yiUgUuaqFqUw6wmUXEqRZ7V9+j2qNVh2m8m9cSKi9drSKOy9196eMu9BmVM6fW8Ivq7rdrVcrFcqva1nNAxdjNGSodxN6JyTrEWr5h6BBKdbSN0Y57G4mjNZDuJR5S9QMIWQOAAniSmE4bA/3t3dXV5ebm+ufRj0V/w4GmPIOGNM5dzJ2cnrN28Oh6641bquCS20VFVV13VFbCjG2DRVWXkAWC6XXTe16TtjjTG1M4vF4uTkRMURRQStUWLzer1G5q7rTtcb3mzUmUGOujR0zas3TUeoqrnmwP0NXLLhgn9MliImZjYWBWxKSUmbGnhpMmpczcyXl5frk83Z2VlbN8YY9WHaI0SZ4l7yqkJEpyzr2PW9FvJV2Fkyd4GIJNd91UOr4gpneou6Un1n0zTb7VZDQ6WAIaLCjACgeh0ppbOzMwBQTvXZ2ZmIfPfdd13XKbqgua+IaBiEiNfX14rGr1ar8/Pzr776KsZ4OHQ3NzcppfV6KQjr9RKzbILm8ctFO/R8eTzWdb1NaRxHizAMQwJkoJQ4CWt9FADGcVwul8653e4AkkTyZEYDgpBiCtrsB8l7LwB1U1ljJkrPJNZWMcCh9yyGGREYJUmKVeC8E5REyAgwYrLjpJljBRkhhHQ89sZWSLYCNMYxgwEWxEkMGqYeGJkGEj6wSIJQBrbONxUzA4MkTklU12gcJ9EYnXmnKURKPPl4VEEroSQYIqEgsBBWlpJwnRgAhNE5Dpx0zAwz9/0IAIvFwk4SQyNaJxwBDYBB5shqGoGIyBiWREQ6BgaRNGkRvucJF2+gKY1qY8HMVxXLLxmb1UeJTZVYXp601slMSVDovktCREiAcpslsKjMftFL0C5jzhIZH3rWcjwf9xS/4YEfKGTlJz/SHDz3u+W/k3/5Lb/x0YdgHlYtBJAm7UEQ0GHGXEKMyXIRGQBp2+VmsznZnPWHffBD9CH58NtOVXLUktHklOnp6/X65cuXf/ezf2its8YoNeD6+nq9Wrm2neDZKA9rDR9hQb8XrWCefUJEtavVPJXklaZ6ktUdM5m22eBen1Hx4nphtsP0t1QhSO+r0iejtcZyIUsVWd9T17XWtzjPdnWzgXSSk2ZNdAqnWuf9aXiLuRaiKV27XJKzEPzl5dVyuTDGcEwxxexpzHK5TMF7711lmKO1BMKaCOb9JIk5xolwp0iZkrNUUoqZgWOMSjHlmLykCImPh9319fVhe9hubw+HQ4ijiPDk3cV7P4Yjka0cPX36FIF+9rOfd12HIZBA4yptJVIuBpFVJ6cPzntDo5m2bStLzFxZt1g2i7qx1m5Wa2MppRhCAIFVu3BNzcyQ++IcmejDYtnoJkhZY08yNT3OGrvL5sGZJnOcFDFxHqpHiSmlaY67gMA0Vuvm5kZ9xrEfNd1Ugl4RxNAsSuO23W6nImhlJ8z27dRVrEwCk3VJNXABgHEYttvtl19+WTQ+NapLWesgpRRjiDEqg+/q6qp4a8jVSnX5L1++7PteSdHK84q5vU0/2/f9zc3NZrM5Pd2cnZ2pMb24uDAWmbnvRp0RWdf12dlZXbdEpCC2j0HDgnEcz85OPn3x/HDYEcpytUjWftP3dV1DiiGEu25cLBaREyeIkb33vR9FRDvZ+v5YDNx9DjApLoOeqUZmjgwhYq62RgZ9p5DlBBwjCFtEFg5xavBDnMiuKs2BGI0xaEhYYoxd16E1VVNreAcAhFTEnhGV0/S+nbs3x7MmmeJ9U0oi1vs4jiOHGEIchsEPo/qslBLzZBg1jRRmNtYzo4BgJBCDgqMXcQwxyWQK0HtEk1ICwuijprDj2CNK0y6NMTF4IQOQAI0AAbPW7RBAA26lCMQYXWUm1s5seLw2/pVz0dOeKzRwJkOllHjaqNP54qz1jt6Tec8BaEkCdS6qEpB1K+qbF4uFyQqGuaI7lbPx/R4ZmQcH8yvy/qX6DY8PPpiLpyAfrdiW9+tP/w87YAQzrfVM0GR6Scvw+dCJcns3J+GkVmaz2Qz9sT92HOLD457+y+kBsF4e1hlKkkAqsp9//vmbd5ddN6BFImtM3G73h8Nh1bbMrDMrLOUkunRYA+CDlX0/6rmPSsqoCmtTSi7Xm40xRSxNV7CQYjjradg8MclmrfCCWyqhpvTvzjNdyFJckqWmNK0sOxKyvhpnwvN7sIwmLgpW63D1lAfF13WtAlIpTnu6aVqiqSAXRw8ArrJ6gZqm6VKRYxVmTjEUi6wuk5kFJznDpHJUzqpFbhchhGARx3E0OphMUhzG3fb29evv3715o1QYMtA0TUoqFjYll5YopHS1vWoWy88+++xw6P72b/92bkmdMcLcuAYRVaIPSSrlmQMYxEobujhYu6zruqlqg1LX9bJd1E0VY7TG2KysqQYXAXQsVYyRzJTs+r6vmkZ3RYxxt9srCc5aq5KT8NDEq7mkzL8rXrAYmhAC8P19jrMJaIUSpcoYF2fnu91Or6ky+LhIScyGTMwtFCIqLFzIAbrlNCvl3K8c8xgW3Y0mi1lqYKFPqoaGioNqSq156pMnT7QfSSM5ZXhpGKFK97pjNWRZrVZZLU6MMV1/ePvD1cXFxXLVXlz8rmIYNzc3b99eAsDz50+fPHnSLFpNekTk7u7ueDz++EdfvtrerVart3c/6G7cbQ9d13Wd32xOlIvn0zDGoAZX3f/xeMxrMt1cOqyFIVPYEOrKEYGxSICYYU+KMQn7GI2rJWEIgsJgDabkJZbeayJw1sYkMHqJxjrCqmZmNFESo3WL9WhDNZE8lAbLDCKsV5w+kgO85w8KOKFmBIHKM9lbUCb8SSr7gRAREogBM8Zgsw0UwjF4IEzCDKLtJ8wBIIFQSgyYyhZFBeoEmRmR7xV2AAEAAElEQVRFEqBI1PkTBkiYQSSyENFms0HExMGB0WM2mHnAD1ncAADAuXfmfuuWu2bukDirN/OsK1dVGTT4JnrgsBim6UMxS15rKjKXxpyWPYnIJNZUFlwP470766NOoRw8fpD45q968KmHZ4c5gLtHucsV/x+HoAHeY0cXvzV9qcDMB1NVVcH7JMnZerlcxtPTcej6Y+f7YX5AMKXLFNN9zj4HigEgpoDGIuJqtXr06NHPf/5LJOsMpSR9f9xutxcX5wbB+1hVVpf3vUBGr8FHH5LrcyUg0mdWq5VkgfuqqogmMcJCsyqnqWGv5i6ais13Es40sABAR9Drjao9RSLinCvKi3oYWgVUCFoTDmWypDzoQ49Tf1pV6ZlZtX+nBGgci5zyyeasaZrd8YhZCNMYKyYNwyCQ9Ncpq1gYY2JUJhpUVTUMnbWVMUaQEdFYq/mKD4mZyVkWDCH4GKDrXEoxRj/0IuIIx+54c325vb0NwVuqOAWOkCQwc1Xbqq5xmnOc7naH/WH73XffxTAB7KULSwRVk6RyTbkHOM/50mOuqipxqK1bLBYEaB1VxjrnEsftdrter7XCqj44hGABl5tlEYRylen7Xkv4zpijnwSot9vto0ePnHMghO5jtD4AvQrqFG2etIGIpOK0fmrr0g3g6kq7jNTkOee6rtNrquIYCg7rcWr9W51r2XJ8L8AyTd3Q/TYMw2q1mjMMVEpTadX6Q/pVuje6rvPeP3786OTkRH/RGHN2dvbq1Svv/e/8zu/s93sR0Y5hFdLSm0JvAV0rXYeLi4u7u7vT01Mi+sUvfrHb7c7Ozl68eHF6enp+fv7u3bu3b99WrlEg+uXLl1XVpJT2h9ubm5sk/OjRo/Pz8xBGPbA3b96oZ339+rVzrj8Mh8Ph7u7u4sXnZO2xPxLZu7s7/d3FYmGt3e52fd9bWwEAwWRkuUj4oRJ5JmAfETFJDmEdGdf13eFwbJeqh8oIgsgpeGBumqnVxFpLmESAEzOijRYFGAQNpQi2csGnzFGAYkYUvyaiD5PgElrBNDHpXnFdnUrwvZKEvQ+KyoqI9179RUbLILEASEoySkgpgTM4KTZgYLYpJY5A2BiLBiFN2kwxRmNFmcO6LCpT6pwTQIgxCRAJGgfIwsDMYlCp7DkiKX207/EhCk3p48Y2ZR0SnFJeKBVcZZaU7zd5HknZ/PkWAEBQuEgr4rog2hqq25JZ26gmqDKB2JlOtbyfvD7AROcvffQU4EHw9D6Dujzm7K35t+nf/xMZcPaIeD8NEQrgAAA4JZr3vofImpqZTd2aekluWS/WJ4/g8u0bZraEWr+ckkhKAACCAIRWOGphn1AQwRowKUVCefn86d3N5d3dHbiGalzWi29evXr69Ol6vSKj8uWACIlZWBAJhADRGCfsP4xENK4EEGNc1w1KpCJHCQOHaK3VwrRx1HWDc864yfkRUYyTb2bRKOw+G1Z4Wcts3dCrur0gGVdVAmhsDDGlmGSCE0JiTEzGjt5rf7rqFfgYXF1t9ztbOUsmZdRU7bIiQpRJXn3f28qhIUGIMfqYtvvD/tARGc1sQEtGzKtFzRzIgKuMcyal6P1QW5Oir6oqjN6SQYE05XZmHMfVct2ulrvdAUUOxyORNXUzeC/dcPHkBBHjODZV1e/3fuxDCBy8QOqPh6Hr6roy5iQlNoE03THOkXGAtFmvY4zBSTOCsc2b12/RVMMwHPuxG7wyco2hkCSEBBSttQnEEJjK9OPYVLZpqpRCVVlCU9f1yWYFKiu9XMQYnKmatvVxrOtasAphJAPGSp05q0Tkw2Bl8p0K/HL0yA0Yevz4UT8Mo/er1coao2Pv9CqrzLJzbuyPrq3Bqn6vb5oGOEoKtq7HcXR1FWMUgKqpp3PPPtUZgcSOjBXsuq5ZLg6Hgxo4RfU1KiqFCcWQ1TG7qWjHkrUkFcglIuFECJxiXbUpxaYyzgBBEtGONS8iy+V6GHrESflP+4zVzbdtq9od2luvp7lcLsMwHg4HizSMncaFYRyaplk0Vdcdjsc9QfTeX717IyLXcVg0VkTWpyeff/5SRDTL96Fzzh27XgTbtiVj9vv99d21T75d1G1V19XSIVwfj2/fXu52O4N4t+/6hJtHz87t2g/DkuXY3X36aN2uGmsqMHbsjsd9Z6lOEYlIleeZBYAiM6KxYMZ+Z42zYityECOiMAeBFABDgMDgxUhKWkmxSBUYkIqFExsUiDEsDCZAw0DGjJIMM2uphSGluCbyQ2fxBFIEI2ytgOgcRJxucRKWWVIx4aeAEGMkAS2XxiTBx+CFGdMQhq7z3vthHIZhGIaQfBImSxwlaT1YpszaEQbW9DdFFkCSBAbNwUtTWYiIlivnhBgB0AAJ+JCQLACMPsao3ZUkgoQWkHS8vR9HIFwsFn4MCMNmsVxUmvjqzxKiUUAKp7OS7D4tswr6YgIGYcwDCdRyphiIQERCHJUokOKIACAJEIypiAwasq4mU5GrBAyQ+hrUONVLlzjF6AEghFEEz5bnZDOBgywiSmJCEGEDIHCPac8j6fdy6/IQgYmenf1qyZUpd76ommZ2JRocKF6gFdj54Pn3+27+5zLgcnTKUb6Xg84HLQ/PjViStXa5XBJwfzzeXL1Tllrf94Kk+SIAxBiRFL4AzfXzF6tKBmmJ2xCdnK6fPHlydXXVLivtrzDGvH37tm2b2hldJ8pAHyKKTGHXbxkHibPGwTgJQRuCadw6AJSGXUWHiMh73zQT4hRiFJG6VunRKdPVtAZm6qb6Ks0ajYo2J+TxdgDAnEqzpvbyppSWy2X0YYYGM029RvcDWZumsZVT7YiyXYio67rtdnt6eqovtW2rUw0g91NpKqm45Wq1OhwO5+enXdeRwXEctfWzaZqUYVXnXNcN6CaZsNvb27Ozs6qqxmHw3ofgmTmGIKAJgdA0lIlcnl6nMIDmbVVVcQwqhXh7e7vcnOi5FHflnFMemWKz1t5rWunxT3/DNCdqtVqVoFiX12WN3Iw0+Bjj0A9KEs4lNwkh1Dkpt9YGTpJbHkVElbl0q6SU9NgUtuUsXJUL1VRwXcy1BgVIlB9XUjH9IRFp27YfBskzkfRJzr1tZXOW7VrqrwCgmPAwDGQsEQVmxZB11yk4fDweUURR6JTSfr9/9OjR119/fX5+ru88PT29vLx89uyZ3lB6XbS5XLeuwvW6mBr5Tbw2RF2Btl2GEM7Pz8/PzxUWChxSStvt9tNPP/3iiy8UudEeVvXHifn8/NzWlTEmcRjHkQAPfdc0zW63SykN41jX9SeffDIMQwxehRsfPXq0XC+EOPjUDXG/3w/DwDzpyOadX0TLweeUaCJw3Hc/TDZKr4XS34wxBKiorA6z0u8JySAJI1iAXDodERGAjXlQlnrPDErpw8EHUCeyMN6jbswSY0yBY5hgZ218UOzheDxmvbn7PVA+q//NqhDvG7fCCWDmyjm1P3Gm/wO5CqZvbuoFWZNSZABjHIN478lQEjVHSUQgVy4+xG/nSY5+fTnUgqiHEDglRDKGECYxLJW4AgDCSSOz3LPGGMjTlwt2IAIKDYoIkdXq7/RDOgvwn/AoeeqHDyJKOaEtp4YPIesPU+fyfvngShQf/D+ZAX/s8KddNXfA5ciisCECEbKVMOMiPXnypD/uL9+9McZZq0O6YjE0CUSERXh+6JKvYUoJCQWgaZqnTx//6leVWsBx9FVVXV5ePnp00V6cfYTahqy+77ecB5HJzZoTTxXzFB21Gmrlyz4u9Vc1hcrqUDMEGkwgagl2ds8Q0aTXoUgL5hKv5K6nlCfZ6am1bQsAKuVagsfiyHXpVBFQj7YIY00koMjW2tPTUz2F3W5XVVXbtoiIJJqHEZHKZcQYow9NW9n8gKz2lVIiNCJye3urUV5TL47SE5pJgzkrY6iLijFmhQFU95mXyuo/tWNVsw1TO3LWVHV3HF68eLHfHb7//nsVsun7vnRhSW6BcM4Zg1lFxFbOEJFKL7VNpQNuc609NU3TVDUiWjf5MA34jHEA3DQWAFhi0dzGTOgoiHGMsXKOdRilNUVwivJ8w5QSy8RpKoOWlaUiualRr6nOJFZKsMZzkOUIFNhYVU5R3xJ86NG6rA5t8kSQwpm3eQYiaBHXVXrMx+NRBaeUf2eMOT09PRwOBnG336s5896/fPlSG96UKL7ZbK6urhTH1v+GEFTuQxtt9dbabDY6DfDx48faqrTdbpXi8OLFy9VqFZmNRQ0K9XLc3e2urm50OJKSpTXRH8cxpuRTjDEai8mH6IPGOspAVJhHm8dqsE3TLNbLunZAkoQZRQcphpB0s8E9PIcx5yIhRNAZ7zAxegSS3Ava3+clej/6FJNPbVsvVsuxHyJ7AaXjkSHtuhGRaO1UEXDunvAoIkmEpnqWwL0Y371ZK2/W1xBRizhhjH6MKSXvY/KhP/bH41GHRWqYqC7qgYFDFpkaDmVK1SYdDcnCvAAUgp8UoetapWoBzSToOENTOQ900fHGgmq/pw1WN/VivUogLOzIpBSIJk06eYjKyuyhI0pJoEyiwPzIe39KAHwc58eDiIZUVVN1Ix54BGYGRj9OV9baarFY6PoQEeDHBxOVb4AHruojr0KJaWavzt0nPiy/6uXOlcd7q/5h+lse/3854Pufzz6YkFgehAaIBkFQyDpK0RPak5PT589f9H1ft1ci6XiMmCexO+dE8YH7b6ByDYVZJBFVMUYg3KzXn3/++T/84pv1Ygk1E2Df91dX16frjXVE0/mrx5qTHT7COC8PEckmWIimIkTpxDB5JqtaPWtt0zTeD8YYlfLRgy2FZMozc7z31lalcyDl0WlqczU4xTw9Pv+QalxYhRkLaGlw6jwpbrhwahRCVBelgbkmUsMwOFsXiUrV4WvbFmEap1O6jZnZWaqqagy+XS609xQECQkEm6bxMTCDtWa/OxLa2lW7rtMEq8pjfTUIAAADSI4IzMgJpgIzWKst2qBZ49TW3FRgqK7d6enpanPSd8Pf/cPPb29vT09PJ3XurDcigswRYOo1REQCbpql3r117RCgdF4RkTFUW6c5t7VTn7TWjdTJNbXVLL9EQrqY2+22aRrB+/GiiXmxWAQ/ljJ5Cc8VcNZ3asW93GwaBvk8V6PwqPXSmCxAqIs2DAM5+/jx477vtfyv0U/MSiwFNSnHoHoahUVVEIIinJkyr14DvkIX2G63jy6eODJN3eBsDrx6xNPT07u7O0UFjTE6llEjHh01qLXkvu/10ihun1I6u3hsnHv99u3l5aX2KbFEZtaZpFN2KNS27Xq9rut6tV4sl8vFYrE2Jgpz9DFGP4zEy8u373TMnIpja69wCP7Fi09c47rhOI5jSLy92++PR/Wy8DDDQNCgW1iRAKAQY0opMVtEdbo8CZgzsKCII6uBfooSUjppFsvNOoSQAoMWT9PEZbcEIlQsBk50EAvZ7PI9wwhnrqj0z6RSONTsTYQlQQwcY+TAcfQ6MKPrumHwIUUtjKp9nzvg6WvhfoI95GGv+t36vDEOMUrmW2mtIbCq64C1FrIDBoBkQvTJWgtkYoyCwAwxxkfPn5WMIvuVBA/1JTAzlZh57ndkht967wl1tAmH4GPu4i3nVarLNM32ZmDt96ayjDHGFMZ8GMoFmaaOqv7Ge95K/292CWZedvZemaVuE4IIyB+kl+VrP2RgiaiSp37zpA0AH/hg/CcoYX34KBTwh1nvVPyd/JyIIAEikLbzMgChqypEkUS2qs7Pz7d3N5d+LLG8Mfj/Y+5Pm2VJjuxAUFXNfIuIG3d5a+ZLJJBAAQUWq1lksWV66lf0D22Zr90zX2YoI8KekWkhWeyuBU0UUIUll7fdNRZ3NzPV+XDMLPy+lwlWCatAukAS990b4eFhbq7L0aNH53kkd7okJkHxRFWlzNw2NmY2oqZpvvjBD96/uweaF+fgvb++vr5/8uTy6lxNsb3r1SEhM9TuHwtEL+4HL37joNlW20MrnItkHdAi9k1OixPN85EfH6oaQnKNr6GflCOVAQx1EajIJ1mZG58eKz+w5OmHcF2w7wgRkLLUEiacKz4UDmC73Z6dnYHLejweMQwA/kM1k/iHvkWqsVqtDuPxbL3BBR+Px8vLy8N49EXjCZ94fX2zWq00mRP/cHO/Xq+vrq4q/O48u1yzwcRDx14a8SGE+Tih++U4Ta7p1u2aiPrVcHNz9+LFi4fD8S//8i+/91m3Hobd4YAK9zzPzolID0/Qtm3XNCBRqypZIvO+yQduI2agVvoSF4VR5IiqGtMc0zy0A3qmsVyAE6Q8HbjLc8gDQup54LGQ0Q5d44vyFPIMKhEY2E94ZeXoAQY3zLayGWXdaZrI5TnzyCZTSogn6jaTxUxTLgiNqqJUXN1wjBHOmwqD1JeOdtDd8TOmPrRtW0eYAMTD9WCr4EoANniW+/v7aZqatjk7O4sxXl1dXV9fv3v37tPPPsMK/OY3v/nlL3/58uVLkB7mOXz55ZfjON7f31d62tnZ2Xa7ffbs2bDqhmFQs81ms1r3ZtZ1Xev8WCzDuD8ue6LWm+Hy6eXd3V0IiZ0/7u6Ox1HYO8ciIcRkKUG3Ry2RcjIMss3uCyMszUwlE7XyYhZQIUYTNTIRoaZp2r5ru4G9m2JCt7w58EWY2HMRaRcRItZ0UkqpZqTa5PJ/Btf8yHgax3kyYwjazMcZHUfTNI3jPI4z5NtwKIR2a+q2SKk/sO+W01smkkAgZkvSZClFnZtkzjlxqgDuFwR7YXYZJXJBY4pmnKtpqFZU0K58KGzsqTtu4UpPV1Vh8LxRhQAJ4HstHXCpyNYbxESmifgUyagQk8bj8ehcg3C271f52WRvp7WlTE36aGL8Bz9861G/oyBc+yhRXp5nGUDQIhz5+HO5NFP9l2TAWRwqf5hJaRAmZhZ3kscUccSaohJJ03RK3HV90w2XV0/v7u6a4zFZmqcJRkqVxPhjRL6Gk/HUYpvOztZf/PAHf/7nf14Txxjj9d3t9nwDFQgRYYY0HbZjLOfN0FA9/yIgYipy4cysmtDinXmzhUBrhSOD/AaFVSKCq6s4ITOjZZYWgyq5DH7A40SlBFW3YEoJGXDtKqkwuInh/LUsB6NcDXFKaTWsKyAZQmqaxjTXILnQbkMIu/094OK+75vGWy5/NtW5tm3b9p1zDkrLIek8R2YOM/TnaJrCdJwcu13cxxjX67X72olRnGcRKlIrdW3Fe5/qrXRiLCGlcRwxRZjFI2DYbDbf+973fvazn/3v/8efv3r5yszmEsqkxXjj9TA0jRNp2rYVzpJPIQSE81lxuQzVqNVT3KBMs1I1yoTJWAZJVdy76zpyAt8D0D6lZJpjJtyyAq078DBR5YWeF+6mLwIpWHlwmjATEM08T5482e+OlmvqB1aHsYAYJYRviqxaFybSCrKNop0VWdMYIzQIURjGlQOTV9XLy0tMShjHcbvd3t0+IIXF1m2a5v7m9tnLFzc3N3Cuqorixd3dXXbbRkBuBt/BQzw8PMzz/Mknn8QYv/rqq3fvrr33//yf//PtdvvmzTfwx3/1V3+FkQ8XFxeQ6bi5u337/t2bd2//+Kd/2Pd97fRT1eP+cIiJLDnmN2/eIEoAbDNN0w++96lavHu4bZrufvfw/ubO+46V5hhFlPkReolHKSqFEM3YmEQoKcFWOBYzi5rQ+eica1s/J2Vmx2rM8DrzPLPINM9t4zSZkDgmgb6/NE4YfQq5GtK2qKP5R20ndjJi/GgwO2filapSjGEep8PDYbfbH4/H6ZgpGjHGqKe6ciiAGc6vduqKPVkzy2wjZmeM8LeFSeFSnMoWyfLU82jqNXuLpDpNU99zjd1xzVdXV3UmDRXRAi2qBsClTqHGwhUR5XGMVMJZ59hU5znAaNX7ld9evVeR3PHeE3GOPFThTs2ylU0ptW0PdIdMIqkj9wHwkFfsowZX5g+TseVfa82lnsT4w7cs31sf0nryb7lFJjUg+C+vAUtNhY201Mdpia4wsznREE2TiJi4s+3F3d3ddnvx5MmT43G/32HymrRtO84nHe0cOjFzGXqTUkqa4BLgeJ4/f35xcXF3fZfDZLPb27vd5dXZdk1Qglsww8p1fctRPVlZaEGPuBeuOWiFjlVV45KwE2rXB7ZjrgJQ9rKyINDjS81laFL1x1qKT4gHm8bVr1whTbZTdzLiUxQjcfHIvSo6ut/voZkXQmByEEjalx4k9GSD5oNTocjUNA0x+6bhsvnmeQ4hvXjx4uHhIcbopBGx43G6vX9omgYPJFhdSAgOh0PTNDEGjz5EaIOMCkfinIAd5l3jfXLOYVz0erMl49vb27u7ByYR33zxxRe3t7f52uaZSp8Vnn+AV4QuXjZX5hyP+0NqGsgcVaQBrzc6jf6uTA14RHzxuhQPDw+N78hl7Ktt27bNRKoYc8aDlYHnG4YBEDQO5Hn1r1oEmXF3EMPhN8fjEaUBVW2a5vz8vB16NEq1bQt5Z1wDl9oHAj64c6xGTdxpgT9hGyCx6LpOSFOZKYJUGLyBWKShEf/t9/vz4+iIj8fjxcUFesDMbL1e73a7u7u7s9X68vLy7du3zIyWLUDlNzc397vdOI4/+MEPNpvN/f3927ev3759OwzDp59+Oofx+vr6hy9+cHV1Ja5BDA2ggpnbtn3y5ElSFaG+7+McLKaubV/vfou68sPDQ9t2h8NhGAYWubu/JyIS3u0OKanzUhtXIJEmAuadmVmMSdXmENCDK96pqjJ1Xdc4bn1jZlNITEyOWt90jamqsakFVdvv90oWwmRmhLG7hS2Fpe67PPRptRrQRl/dWw0plg4YLpeym2HNjfUkIhZtGsN+f3h42B/3hxDyFNeUkoJLbZKMVT9EMpOZWwCkxT3wMkMD1cOMjIXEJbN5DmbmnHnvvSNVTY7bwtqt2zXvKFXv5enTq5oILZ2NLsRhqum2chEn+1uubZ5nLW27XOaJ4ZHJ/S+MTho8wlkil4gcERPFhZIgZ5W6LHatiRJhVv23+8iPzX79Ov/ZF+NlQqzlhn7wLkMVgai6v0UQVl8ktJhj9I9Bwnp8CYS1I8LHALEUIxIhEVCuXNtcPrma5+nqybPXr18z7duhD+OxbVuxxHLaTFT2sRSyKxroY4xCLMR927z65NP3b9+tmzXs1MPDw7ub64vLbf7uSkmUSyr2GIh4lARb4Tfhn/B8TdsK51QDuwRKQEgFfBlfWCk5ISSwEsAsQGLaNE1apC84OZKnap2ZeUlbJSI0FyGdmscpzqF2+sKZ+YUOMO40AoIQQtN0ZhzCXFBTwl8rKWwcR99kz5RSGseYUipjCY4ppc1mM42jaocRDre3tyklJ839/T1YkbvdbjVsjofpcNxhKQ6HA+DKeZ5FyPsVvkjTdJpsF47DMFByMaT6lbfbi/1xfPebm9X795eXT0qrcXbbZ2dnWB8v0noPsHe9XjtmTN0IITjBpmNWjdPU9x2GgFbmDhbZKNWaOhVVbdgXOAy4JeAKH7ca64nXhlKfVCgYP8SUqhAPsN9aoQBAgiupjn8cR0wBgqYjAhcUxeEO651FBRpJMC4eoZ4vsti8ML7zPEMWeLNe1+zEOWfpJH1VRyxjbAP2fGVcw6nf39xePn3S9/1vf/vb58+fY5NcXV1NhyO46yC9o+QfY7y5uUlml5eXMc4PD3cpRTPbnK1++9vfxjT/0R/90e3tLaS++mE4OzvDVe33x4bp/Zu3Dw8Pcwjb7faz733qvW+7Xpi//ur1q1evfvGffg5soO8G51zSwMzs/M3N3WGcNpvt/jCT+Gk6xpSYIemI1EdTSkoOyRezoCMST3Hf962X6KY5hqgzUgcRaZzOlMEzRzrP42Hcp5Scd957UhUm45NnK8kfNU3TD20HOqH7kP5T0jvO/GEieBQzy3OJgh4P093d/f39/cPdbhxnRFFaFF7NLFFNYcH05ApApg9yuGVDCpEx+SYXIGLI882I2Xkfw5GZieDBUwRcqZjdMq9Wq65rYDeapgGUUreKFZWY4lzzN6oHl2tgtbRIf/HYUq3jZnRdSVHJrIdzC6n85XriJgLmQS9A0zSaiBwJu2WdOL/3MRpsCzmO5e8/Pmpc+2h51ciJfeR9qcYi6Dwv0bAupGo/eMs/igMuSTA54tyVjxhhuXbFionzrWncrLf77T6E8Mmnn+73DykG37Uppg+yey384WWAn4ouKDPHND99enV5eXl7czcMAzg4b9++e/78+dWTrcU8+11NXdYsTKiKl9U5lVeliBpaKQhVjIWINBFoJqhkWFLYxJqX1DIGF2IUiKw4Q0wRrtHKnHaAlrX/pObW5+fn9/f3oCUz83pYgaSKBem6DilmXRARwWRfKV35IaSURhCOcAH7/R5tKqgp4qbEmP1xSqnr2lCm2IYQoP6/Xq2wn9q23T0c5nnebrfim2meiWgaQwz38xymMQCl/MUvfoFBAsR5xvvZ2TqE5L2cnZ2/f//++vZus9kQZqGIMzUSPd9eTs/Cmzfv+n51cXEB0kfTdBAfvtxeog0MJhvA2cWTJzHOh8NhNXSQjxCzi4uLGCMwQC5lKgCYiFRCGaOLbADO7O3btwg7drsdKGzr1dnNeAdfiMGOwG+JKIS5xuxmhsCrRlTVSaMUwgXtqHToys9CXnt9fd33PVJJaPsR0WEa7+/v1+s1mEdIT2tkgGtOKcGZWVH/wAcBNF6v1uM4Qjrj6dOnKKB0TQOeF/YDNE0rw5EK5+X+/v729pacSKHHg4Q/juN6vQ4hjON4dnaWihYNFvb+/n4YhourKwDmRunps6t371Qt/vjHPxahlMKrV59Upt7t/V0MiqDkbL25vLxsh56Z265rfGsaRcRUpfGfffb5//a//btV1xJRbvRiipqmaRrnuWm6aY5kAsrh8rnGo62qlLLljXmuO+ERaNt2PXTBY1TwYXcMSVWoqOVQcGQkogUUaRvXNF7nEGNo2wYTcEval5+R7Xa7Xq/JiQg5x8UauGJVOKWYlZPNVGdmDiHNxzEli0Hv7+/v7x8Ou+MEoWly8xQrkzelFBZAdIGFuaTTygyEncwoiXp2zCUxNtZkzufGtpgSaNwhRCPeHw+b1Xq1WhkYKt7DR65WqymGzomIzGH/+fc/G1bdGAOeo2qfqQQTcuLLnnhYIiIIfkuhJ4TAnGdAMWcJd+fcPE3omG6aBma5bVvvIW6TdemXhZjjcd+2fpryoPSmG5IZVqvG92amC8Zi9Sx1k+Cfy8umx2nx8jXLN8aS9Fsh+dpizN1iE9pin3zo1OgfPwMuh4CGl9l4ZOWyFLAEO2navlutVsdPP/3szevXr19/1XfdYd5VDvUySKkpSD65kRWNSRHp+uaTT16gTDUnG8cjE93e3m63GxYBI8Y3ng08WKv4QL0X+Z+A5gt7ra5p/WfTNKgd4sCugtMSkbbNeY8VlXzsA6SnUOSBI0kphTkxixNpW48kCddpZWzcdrsRkfFw5MIDhPUEDRUBIMa+DsOQ9Te8DyF1nUf+pEXZ3Hs/DANKaK4IGO12O0yagoEW6Zsi0IhowHufVKf93nuP4RpEdBinGKMpT2MYwyxJmF3bdyJyOEzv378/HA7v3r3bnK3nef7Rj34EYabNeoAt+tnP/uanf/SHWAeNSiRt08eWnj59/u7m/vrufrO9/OSTT96/v8FlCHsU/5BTmhk6WGKc8cVzSM6sRYmCc2ODom0GfnGcDm2Z/EjF2UiR19HCynbOoR8xFaI77IVbDFqA78GWwCgheNBU0hTAvFT4z7gLtYSMZYQvwY3uuq5pupQSckQ03SIthnurZemcypuh5KyqdUrg0l4gCAjzhLIrZU5WwNaCwx6GYRiG/e6IPp+U0rNnz6Kpa5toOYmHonhKabfbAa9GKoaIpKWsTNk0DfjMyYyZLy632JarVX91dYErRyMTFnC1WkFWDCuc5sTM7B3a6GOMwux9++b11y9evPjtr3798PCw7p+3bRNCOh6PZ4c+ET/sj+M4xcQxakiUUGshNSOzXOxnEs6tECTixbIibKkQKZcObGY+jDcWIztHwUS4dU6EY9JoViYLEqkRKYuZJVVLeXB47gJH5GfCwibipOhFUO6vzcpPZKkU71NKKU7z4TCGOYUQjsdxvz+O0xjLICASRsxnmKJUHQNTgqHkTH2txVcm/NdZIR4vD3oMADJzjIlIphD9HL0XDC9g71zilBL7LPm36geEp54laeZSJeL6NNEiBay70cxYrc5hrB/qnLOi/0ygX5T4FfeL4NSz8T8lwdUjqmY6d0hpGNau6conEnMuTlvp1tJCff3ASS2vih7nxx/8hj7Kkj2Llt/jc/IXh7KK8XfVOj841T86BP2o03wJ+HKm6YsSsfHhMJ5dXM5hDCG8ePlyHA/7/Y4eJ820uKn8EUoAdW/H1DX+s1effPPNm2mcnXPMzix9+eWX5+dnZ9u1JSNSsqyNgD79cnIq1HTWRESPKiu4DJhCPLRhTr7JcVA/DAiywLIhIufc4XCAjUbCykXbMqXEwoBwmVyKyQotCIZVSqsoHAaUNzJJJMaaedeSLUg9CFQhhjCOY9v2+I649zXJizG2Q09EIAHt93uwiGs6Xmswqup87jQFnBBDcNLsj/uma7O+TKLd8XB9fT3PoWmah909hGG1CHJdX1+DWPuzn/3s4uLiv/vv/jvne0l2HOfbu4f/82c/f/r06eXlE8Qi0ZScd2334x//+Pbm7ubm5vLyCfPtX/7lX755/a7OFAOJF4s5zyM2yWro+r4XsxzipGDqyBrKzPMAV4puVKBAqZg2y5OMPanNMSxgfIuWaeRYdnyv6oBd0XlGOou1mudZyGqCVW86/lldOMKI6+trdNxeXl7udrtxHKNTMMhSSvf398+ePUMLLBEhLQZ6jOADZ5Mi5HJ61hZBvZQDF5NSAiUScwPPz89hL549e/b5558HTfv9/v7+3srsQkRvqfDdnHMXFxcovkDO5erq6ub2Pfwx1Ch3u92vfvOb8/Pz84uzeZ5jnNfr9bNnzzabTdO4yiLU3JeyVCPiEGKcRi1bkZxLZNMYQkivX78dhoG92+33qpo0BbUwx+NxnGZVpXGOqhYTKLjpcQbMaPwTIyF2LOqIiBonuN1937a+SSklo91hTEqJyDfKSYhVE4mSK3oOQiykxOacNE3jhBsvXd90Xbdarc7ONuvNgKiiVKDJyvw7M44pQVmdTEUIFdY4xXEcdw8HDBmMMR6PE4ZemxmEPpBu6gL0ttIYkm8355ZkHMuJ98ZEBeRIKbHQAppWlPVCMuAWzrm1W0VNzNw0jr2PMVIZdg4dtJQSsTPj0hybXb6gQWvBUa7207uM+VMBnGOcNWc1eZ6plumElEnLGYA8TcYDZ9hEF3qunFmZBjVyW+Sd+a+PYfml/1762vKmDyHl332ICGmWArOF8jN0IH/XO1kXwyT+0RzwiYqVY7EqjwW2Wv6TEAHphVMJF1dPRfjp/uUcxr/75S9jbGghz43DHk+AWf6eiMQxkazX688/e/XXP/s5M6Oi9rDbX9/eDcPQ9S2XgXpmj1zsx079g5MT5UKvL9LHMWXRZniy8shlEjJseoWpkV5gByd0yttpTjCVHBoEIuwC7NSu68I0enHwuFRKC7WbBTAaHk4wb5umU9UsAyIMSLwpc2GRk8GOIyHDOSvJogaJTeNSCkTUNI2mJOydc8m0d00I4/EwKdM4Tilp12d/D54w2legbYTca57n+7uHu9v7P/mTP9lsNt51ZO5nP/tPP/hBvL8/PH369PLpk816413z9ddfHw8jSPI3Nze73e5nf/2fbt6/f/HiBU6OO4XUP6UwDEPrG3HZ06jq9myNdDAlEzayJMyNF+Ksb+XLbAwu84twj+BsXOfqk6ll3kCNpWpjMe7OPM/7/f7i4oJKTUtV2zbzeGMR6HZZOsDg+HGXAXXA3ByPRwDy0xi4ttKSvX79GtA3lUo24gmwAeqmlSJm5MpkLSolSS58b1Q69vv90DVYwN3hYMwhxl7k8ukTKFt1Xffb3/52HEfkqUhtUYDf7/ebzWa73SIguLi4cM793d/93ZOnl0tAG5vncDhAh45Mp8Px+u27+5vbpu9ECMj8arXqugEkLOfc8XhcdZu2bUV9VMRGgi8yF1m01bCZpxjmxMwxqCmHlOaQQtBMb1YQU3NZquATTGTMTjjVgbtN06QUmsb1fd80ruu6xruUZLNZXYZzdvKwP8YYiZKQeSHxgilJROaFWcwZN65ZDb330rd+s9ls18N2u724uNhuN03feO/RBIX7Dg8RMbYIslbHkZktpePxOI0Ba344HHHN8zzHUAZ4aGJ2OdO17EKS6SmnMaEyxI0pW9fCdiFHLsc6TJjex5r7zrNRZQJ2qqoxap8omWpUYVAlPHYdgDHQU8wM1f1lgqSnKqkxiWmeSM/E6XEhFts1hEC5YhJQO5AlzJlneDTlUiFn6KCQiAMVYzMjS1KMpJk556sPriiClP7Dil3zR7Tn+uzXr7b00x875voMsprJafJEjYAfOxH58CR5mtF/aRvSdx7MbCacP1WZWXIqXG2HJ58bNLfb85cvXx53D/9n+D/nGFwR/louwcfed/ENlYVJ7enTp5uzr969fb/ZbGE9379/f7ZePR+eQmFQclxcz7yg7SWSRd2+fgtsI3AQiKhpGnGEn2FGkSRxEVIAD77mqeM44gVmxuIhlaWllRN+1JWRDFYEynElFUauWwqnxS9RF4QHrRbfFt3lqgtUpHC+qChqIVyQImMpIt53wDzZIlh6U1ayNOTWzDxPcT8eVfXu/gGZNwpFt7e3AAnCQph6vz/e3t6HEP76P/387fXNdrv9V//qX7189dk333xzd3s/Hid2vl+tt2fn2+3F4TD++3//5//hP/yHH/7wh9uziz/4gz/4gz/4g39/e4uGmarUSETeC/jOYZo5WRin+h0Rc8BZVr+F+buuDM/Q0mgkhULFfGJLNU3DxDWvraFSbX1eZp+1/ydvDMldUrEkDb7MgqwFMAgrIoq6u7tbr9coMzunKMAfj8du6BFJXF9fg6yErNeXCV24++U5El3UompOzAvaRCX61Q0TQthsNs+fP4fI9vX1NdDvTz/9dBiGN2/evHnzBtd/fX395s2bruu++eabzWbz5MmT2/fXKFff3l0/efLk7u4OXwrhxTRNaGLebreQRDCzOGWi1qzz4ZAnGPZ9f3Z21rZt7JSRvjhBTUFESG0cZ9907J2SYYQcWGnTnOYphmBhTkE1BmUnTqDWZOzY8MVRjhfnPVNIpNGIvXMaQ9M0m2FVvbX3nsWNcxznME9xmiYmA6+eiJI5cDtaL0LGruu7dr0ehq7p+36zWZ2v19vt9vzibLVauRP9YKn4nxu4p2l6eNjP4ySWB9/O8zzPYZ5DjBENfiklU0YIaWbMJwZMPmBHTTgzshfOIJtEhlNWJnlcwvxge+AHcT6GgGvWRKqa1GFvowJS4ss2F+MSJSv9Kdl7IebLPnjpaYQoRq08ifqccuHna2EnLQ1+xpmKyuzSC1qenjmHEDBHtR/Wtd63LMcsLefSv36Xz/rYsyxd6be+ILvq0ln2wcL+5z+Dlf5RHfCjEUmnT8lCXlarrcpkRkKy2Z4d97um61599lmM8y//9m9+9au/8/l2/q7FOt17oqSR2TG7fmi///3v393eI/Z0zt3d3r8d3l9cXAhZjKnJM8VwBqFHIU/ZppQ++Kzq4Uq7fRZ5DhN6UxkVL+R8KI+5omEJkwFCY5tnq58+FycPMcPXSLKxIx2LQixGRIrgA0JROBLgn3D5qup9Vo1GVdKYUBK2MssWc9phylUVOhsphBrf4CFJKZkGfGUwfaLobrfrhpWqBk0iEmP2Meybph8a7zDYR4sWBOwEkrkUZk30+pu3/8v//P/85OWrTz/9FMICJu6Xv/y7h4e9c83d3cPP/+aXr9+8OxynP/8P//vr16//x//xf4RUIRazhiwpBdVMjksatptt33ciQ+MFqaHI6YvXpw60eSoA8tIk1eTYypyyxGRqpeh7uk1W2M6IMIC6L2M1Khp+S5sCqzcMAxqLqaTdqrrdbuGKzMy7Fukj+rOB62IA8H6/v7y8BEn77OzMew9yFvabFZFnvAvxQShy4iICah7+CQe5Xq9jjFdXV0+ePEHxkpnfvHkDX/uH/+ynX/zoh89fvkDQGUL48Y9/PM/z119/TadWFtvtdiICte3dbodiOcKF92/fqipuxzi6lCyEyTk3DANmKB3SYQp6/XB98+6mWw1PL59uLy622+36bNMOfYxxf/9wf3s3jqNjoI7knJtCnENcrVYhJDNmcoliipYsmzDnnBKCzhRjEmq8cw4TC1iZWYyRiK+GoR/a9XrdNFltmHLLLA+rLlpE311eQ2Z24oVXXeuceO9Xq/78bL1arVarfrVaDU2z3gx930uDqO5U4IBbIWYiSSkdDuP9/f34sMfGSEmRyYUQQkgoKpmZknA0IlIyjDGsvkeppJvEy1C77kBmpgXlR4nkZNzyhqygESwyvGzjvcGNgSBpaZ7n8/MzBLUwI2GarW3IvCmpWi3YsWBk8LeAlOXyhGghspGj0lz/ouKMa93EucZ771wZKWhSk1cywYqlEKf5KEWDaPl4ghDwcTL6gYemhZuEX6g+dfmuj7/RB7/PX8pImfmR2/r2pPGD8/zjZsDf4oOZiEiJJauUElLvRCRhDmbmvYthfv78+R/98R9/8803NNViQBXV/JZ4hEuBmdVMDADU8+fPnz9//v79jW8bMwthur2/e3h4uLrYmolZ7V7P58+LZbknvV5uXR0iUjsV8GOMUDOFi0JUWJMtq3LW6YR4o5kP5KCQVZdzZY6QK1OqkXit2MVy1GGrsK01wNYi38GlE6bKg6SUQspSlHhZ27bA4HGRvsg66pSVpZ1zFQ5qfKZm4PeasqO6v9u9v34fY4opzx8Ei/sYRnPknHfM3vv9eJznebu9uLu7c9KMx7nrOlX64z/+Z//T//R/++KLLzDD6uz8kpn/9pe/+l//7f+XnbRte319Pc/zZrV++fLlX/7lX6aUzksPUg2KMeWbiMBWRbIrC2FI7xwoGFCWwMp771HZkjIo8ERNz0phkUjgNVWzhfI+N/5qKTtVhwrkBlZjkQczF2XKeoOYGfScu7s7IPNokcJmgJxySokswkXtdrum70Tk5uaGiLbbLTwZhKNLFJKqF88M8PL7ygyoqAA25zzPOmQpDzM7Ozt79erV1dXV4TCCJffHf/zHv/rNr1EAJiLMbcQJX33yqar+5Cc/2e1219fXf/eLX0J19c3bb3796183ZWS1c+77n3769u3bu5ubcRznOaoSKBH4XCwF1gpyaS9evHj27MVme7HZbNjJPM/3+93d3c18zHN/+rZryzwSM0NEO03BOSeNlzkxk4g614iAxpGfQSr2N7eCmDrnoAANdUxw0NrGqUboSokjSNBII0CGU8pK0czsKMvXdH2zWvXb7Xa9Hvqh67pONFVwohr9GorBCqvq8Tjt9/vj8Tgex9pnmEphuLpSJcoekDO8wfKofYUX/njhMDKwhx1qC8jQPsrJWEwYYprk2JxroKtrZmrmnYsxkLiY5nHMHUcppZubm77v126DacH2OLe2BCutVUN4GRzgSFlQKFp5lLBzUoh1QZawhIiA1k52UmA1MxQ+cKMB2lXviykOqloJETXnMTMjZRamR405ixzsQ+/7u4+6AvX2uYwsy98r/S3HPzoEnXn5H+QH9asVCRNJFJ1z1DRMiuTp6dOnn3/++d/+7OfL4KWmaMt7+ejzRFLSxISpGk+ePPnqm9eDd67xZunh4eH6+nqz6kWEDDDsI1i/Ro4pM1Q/5J3TIhogInEZk4xzgF/UMpUBGSoRoT3DzLquC6GUeEWQK9RqMf4LfhBIrRW01DINVEsXEKxYRY/hA5C+WIGac15bIHEtZV3nHJU9V7HcuoFyGUYYoHffod5pzLzb7SolJBb5C8tSIZrScbVasTAGKMWg6GHtuqEqdzZNA75GjGm1Wt/e3nnf7veH9zd32+2267rDeASAaWZdl/UgIWiF+iUzQ4wJSTyA/ZSS5I4kLUkMidA8xRAz/xnLiyuBkBDCFy2letzlojUW+tVQ9908z02Dtc2mP9euknZ9pkHBEQKNcM5pnJexgpbp9Lhll5eX6DzGP8Haw9CFtm2nMQA+6ft+TpnZh13BzAh0oAaFyfPLjYcyx8kKlL5JMPaZGTPqvfe47N3h8KMf/WgYhnfv3u33x4eHh6ZrLy8v/8W/+BdU5MCI6ObmBtvPS8YMzs/Pt9vt2Wp9e3v79ddfX19fIwYCQfrh4QEf9Pn3fvD6zdchhN0ud4e3rVfV29vb+/v7EML5+fmPfvSjP/zDf/bjH//hxcWFkkzT9P7du3Ec5xTHcZ7HeTweiQjaUszcdd39/T22+vF4bPtVjZQRlYpQslPYISLCkp8LMlVtnActdRiG8/Pzvu9jmokGfDUUp41kHGci9YP0rYf3hYQcdj4c8DB0fd+CQmilizqloOzMEnOuDRVUKUstHo/Hw+EwjfPxeAR0wcyZllUclarCXyZLwqfUvD6tJ2atLX3byftWq2UEIb9c+nts03hpYPPjg/KEiEFBloWIjsfjdrvBa25vb8/Pz4f1SlMWIlx6r5oPQAPDzJgQzpIagt1UAsdE5fXpsQJdNcXwmks3Vr8gTF9KSZidcwhntZTkcA22SKN4kfWqaUrJl6FVH5yf6EPv+22v+XZe9AcREv3Ogx+Du/9EbUgAWok5573CuUXAEyWnZiYkrBZZTFmazTzN7C6fvvzJuzdvbm5uICO9Xq12Dw/C3mISZuUSYwqZkQmrGqsXpq5ppimwpxfPn7x98+TNmze+bbyTVT/87d/+6urq6uLiQmMkdmqnlWVmxmNGyXk42rp8p5YyM0tJ+76D5BCY2zWCY+arq6v7+3vsoTkkI0ma+SS+kVR4fvWJpbIzzCyFSESOxbEc94fG+RSiFxejIug+Ho+wQap6PB69NKYkzmk0Ed80zTjOMNZt37nGhxRrTszM8xTJRCSDbG1XdK2N29Y7x0LWODGzw25/dnZ22B2H9cqMTZmE5ziGZDrvphiSWtN4nQKzi+McY+SeSU2U58PUdV1QI6JpPDZNN7TD/f191zTTNHVNE6YkjrpG5hi7YVifnSHCYKNVP4jIbrdrO/GuaxrPYkZpTnO02JCQotkDnX8ts0UNq64fhl7L2Mezs9XhcDQ7jVSzBdnNkjLzPE7DegVumm/bOcaQUr9eT9NkrBjbzJaIqGk758RM0b1zf39fm4IqhsEl3yUINZN4n+0RuniBYWy3m3keh6GbpmPFNqpmHnt3PEyYOVHCFxDNUrXjGGqEt+x2O8t6FxGWCyk+LgMKKkTERTUspTS03evdPqw3fT+gr3q73r59+/4Xv/jFN29ebzabTz755M37dxDF7LpuaDtAC9icQWczizHPrjh/cnbxdPvq+5987/Wrb7755ssvvxzDOIax7fvb29vLy8vj7vjs6QvIeP31X/+1SR5adXl5+a9+/M9+8pOffPrpq8urK+h/3T7sj/e3Dw8PN3e32A9UYgXxfn88PH35/OzyYhxH1ImjKs0p2bFtW9/wFKITp1kn22I0pnxHiJmFRGia1FhUoxNpO3+2atjmtt10XROIiF0iU05t22gInevCkCVdQwjTPJux916ZmsaBi+C8SOvMUdBgYk4kUSIlnkkbT6wmrKqtlzkGL03jWo6H6f5wvD3EY5iDi6lJKVm2iEykIk5VWTyKqI7Z1BJKtmAaAs1KhUqZYo4OhZlZE2tSNDp6TiwiTpOZGHvvmUkLPTPG6Jz33qc4iwiZtCQtiUSVJvu8pHScQ991+8PRSdhuVtFGtvTNb399db7idpNSIiNVB8MlIgq5y2wtofKhzMRkKQJwtnmeiVTYYopFpMgfj8dxnrz3LA0zO9+osLSdSRuVRYTNERGLixaJKaY5hInZQgzi3Gq9Vm40BCP2vlHVGGYuzMdl+svMjj+kYVL2nbKErKoLyz9brtMR1zYnZmYTSpZwL0oKTsZU1CDzUU54yh5xhvqvf6o+4NOxaEyqzh8ZpxiJiLE5Zurai4uLV69excOPv/zyy9evX7e+AfHSKEkjlE5ZtekpfxXhpIqQf06x7/unT59+9dVXQO3MzHv/7t27q6urSJSSfVCnsI/A7Y8PyZ1RBEcojkIIM83olYTaBi2aRD9wAEDhwKbhxag7wCnCecoNTGelQ9fP9UXwSMp0TPzpYb+rMluhSA0TAljnUkpF+jHnambW9Q1CLpclM8U5t91upeguTdMUYuBxNGWiRJK3ct/3t/evp2kaxxForQgNw9C2rVmWSEwp7ff7+h3L3RGc/+HhobZmYVWRVqLnGNfsF2MecPR935CEFCU5IoLMFpfBFTHG1nllldKXxcxEAqVlrFuVREaUDQEKEUHXuIgAJsW61QF8WLC6mGZ2OBx4oZlXN8YSsSCXi3+HwwFqFavV6nDYQa/x8vLyq6++ORwO2JkIj7BD7u/vqdSxsIaVRlvBj6y/xgyoIy70TZHoV3Qdp62vD0WfCz7+8vLyzZs3/+kXf/Ob3/xmWK9+8pOffPb9zw+Hw/v373ExzAyUL4QA/SzLdUSDqHXb+bZtv//973/++ed3d3c313dffvnl27dv37x5g2vD9Oj1ev2jH/3o6tnTzz777MWLF2B4gbswTdM4He/v79+/fz89PIzzVAvYJILVcM6FaQJX6+bmBpRpZk5kKQTvfdd1MenhcFAqkx819+O40io2TRNLI46NhEUAjaBqWBcQzqDiWGyKJ11VhxxmNSacUqi1G5+1SFOM0VlOtZk0mRLl0eZTCnVf4eMOh0OMCgpFTGEBhFp9uku4n8wwSJAAnAozRgwgI8/7kBnZpCmDLI0zSGlzF2JxJJwvA18Q569xpEOOKEtSFccYNVnuuYixb3vTeZ7nm+u7s6e9LtpqlZHxLng5pW9a84BtTSkLE4kI02mWNh4lzi0YudDDhclMxKpqaszsPNLfzD5JSZkZaJ/JaTyJftRB8/c4vqtSq7+jmwh3rnzBBflZl+n3h9nw0tfUUOCf3gFT9sEfpN6c2edeLWEK73q9fvHixf311fF4HMfx/vauxYABBPXCVOsKzMQGxUpNSS3Nc6aGtm378uXLL7/8Eo8rbMqbN+9evXoF37CoBOd1FKMqZbK8amUSo1ovNDPvXX2oVqtV07XoDEG7USlWnQokdaMvyzxwh4CwpBCeudRr8eLa18HM8K+pMKWR4CrZ4XAAoWa9XkP8Ada2nhyGO0YlomEYhlW39BbOOUtGaiAzcynRIf8wZVVlJ6o0hcn7drfbpQjtgr5awxCCamZlE9F6vfZF2b82HCOrw0Sg3W43xwjKNPxu5WP3fe+bCiZntlTf93GanXPzPGKA3Zs3byD7db69BOyPT8dtSqX3gEvFve/7OkvDOTeFWYs+ZTZ2MeJi0HqExTk/OxvHWYrcFSYr4CNqRXMZD+Fee8n+soozH49HZvfmzbuLi4sYFb/HoEPn3DzP0Oh+eHjINzcEaFODFI3ACL+kYsorZ5vL0ZRZT205tPBdY4ydb3D9IgI62G+//uqbb77puu5f/It/8ezZM3wQtM+ur68dYShQDNMsRY3EMleARSSlVhOFObVt++zpi+fPXv70pz/d7Xbv3l2rapoDVgx5ebcacP5xHHe73ddff/3w8IAOguPxuDvs0zRi88/zTCKo32MjYfGfPXv2N3/zNxBt5qKyEmPsuh4RcJhDDb+szN7AhmRmdtw6SGhp3/fr9dB1HZFCzVEtpTKJlpk9C3tXAE+KhathZuadNJ6ZvbAjphTJzHmfThPpg2hjlnA7jLRpmhR0nuZpmsa5BK/MSYhKrweR1nYMZmMmNjVSNHcwE7FUbydmKlalQai0GUXNAQRlwV9yzmHWkwid0PhFFab6SKIk3qUcEBDMYwixaVLXtFHjNE3roTNpx3G8vr5uzy6YWcSfxvAwm2Y8jyiPqbBMV464pymFfMl2soHAEUt6k90YGi5OroOSGbE6M41xjnEmopSsaZr1+gzMUV/mYWupLrvCoKZFsZw/TLQ+6g76HR6sftPyei0MEioV9/Ip33GGx4W/erbfiwMmInQlUWJmZ5TIvPeMRFbJRImIHa1Wq+fPPr25vjs7O9/tDgjrykVbZgIixDBGzIdodBqhxk4xhqZxn3/++V/91V/BpDLz8Xh88+bd97//vaTqHi+QmUGouq7s8pboQpcU9lHktJt3ux06i4BqornicMxj1LhIAxKRL2N9q4eoVFU8OfC7VaYY9pfZiTA8YowRRVBwSmvt04ooHQmjrcFKySp7uNbN89y0zhWdEHyoxoAfYNxxebhTYQ4iEjUBTpnnGUPcYI6plG1sIcqIiAExaQih71eS+/lcSgkOBvOF5jKyIhW1GnDNqHRcLDIMa9u281m7/+7uDh8hIhfn53AMY1JIOxWHmlsm4MNWq5UvI6d8UZUCdRy2u2ma8XAA1I+0T4uB92V4H3wD7uCjaLc8eKCjs6XjcZZSAIZTRxPa+fk5M6M/py511qhqMssUZCvcZe89PBCksmKZdbF0q1h/bEgt7AF8KEqzNzc3mZx/HBEvgrE1p/SrX/26bds//df/PaBvZK4QtJrn+Vd/+3dN01xsz3GFEIiIMYgI7iBaxy8uLqCQFUJCOf+zzz4zM0shlYPZXr9+XZ+Xm5ubm5sblLStNN1pnL33h8MB+rKgbWfJra4zs6urK2z1EgogCEjjNDnnVqtNSPfH47Ft+hrIprTg3HHWP1Gyvm+992ZJxCWN1Zcj/GryyGqpd1nVkKYBPxCRMjeaMEFJ0PyUYTlWi2CDEhERa6IQ4zRNx3ma5ziHlKm2hf9RuTKaSUYkC1svxMLCjr2DopeYGS27a4jo5MrzZVTfIywsp9owESHPkUIC5VxvfjTnw8yIGE3nXdNqsnmOU0iOkzEdj+M0Td633i8AWxOg3NloFjpxzuOZIe0gQiIuxYw/4zWqynyKJ5xzkGFPycBKKeuTiDSmuSadUKmsMpbVolrtdHrcvLSw7R8PiyT6KFutf+XSaf3B75fOvi6yiNRTPj6h8EKfanmef3IHXK/DzKBRRYVYmArB2LWdmc42i8iLT169e3f9/v3N1dXVN199LQaOe1qcsMz4BUdRMpmeiMQosTrnPvnkBTorKor7/v37Tz75BHtsGRkt14I+CojMiBdcvlAnAJrCXp+dnYUUSTDpTCpAilPB/YBPpIXejPSr5r7jdGAIkzP5tlFVY2q6VpxTMmGOmqA8d5zG1WZtAacNq1UPSdUYIwkDwaumuQa5VtiwqWjxZ1+SiBatftjBaKOC/45TmqbJmM24aZoUFQkQfHzlYx+P+e1UUNzqWVFV9d6Dj4NRDURZQGaepr7vNUYv4kVSyI0NTeMcsbAYmWdxrSPSh4c9Hmm0snRtix6SNIccOjgHdTpcG9xYzrnnGUqc6LKFuZmmCT05tF7Xij7wcDjalHUhGCkplRLDMmCXBVUEgqBwpTc3Ny9evICCNwb/3d/fV04ZYjWUV7z34mi17lOK3vm285wy3A3WFe4ObhO2lhXyAc5DRNBnBioLABz7zRWufpnP0UzTxN6LyNWTJ03TPHv27P3tjSZt23Y8jjc3N9vt9rPPPvv666/fv3+POAYD4xDaz/OMqMV7f3f3AKi8aZo3b95UrbHj/gEELqxPSml7cXE8HjFFuOqfMzOGEDji0ebDNDZN470wOxGXkjkn7Jp5iiKe2cWozA7WWESS2hxGRE7on8aTVYHcYnAYIaxZYifr9SBC8zz3QwcRIxESz413w9D1fY8wBUUGnCTEHDQjrlJLzjkv7MWpKllafpyppSQ1J17ESXHKD2Agl6sYZicMo1ib3P5LRGxIfbk6VMM83MJRSuk0HbdiuWZcSp8CxwEjZ6dMhuD/3Kn7Not2mZlmaStOZNMUui4JsxpN0ySkTC4phZCYs6o2M5MJySkmEBFTEKVPc1dV6wDZfKlL8JkowxVq5rxHnk8Z1qbs4k2ThhgjxlF477tuSNGYHD1awJMY1rcaeWauA33N8qC86mi/1X99OFWjvLfmvvWNxd5++6mqKf7gwn5fGXAOJbLzc6eEncs1iaomU2b55NVnX3311d3dHTuJIYLIUzLXGr9IZhiaZiQzmVnquk4Tee9fvnwJDQF824eHh5ubm+fPn1PZi/XCHsH2Hx1LZ6ZqqlmbVxwjXq4RfTf0+/2+bfqlq6PCv4exWJ4ZLtm7lkzUTlnaojqF8klOaoHpmZl4N88zO4kxMuvusMfTXnsGVLXIa3hmxgTWlFLbtuM4juOYUuiQFDuH2ThauMHH41FVk5EqxRiNXYxxtz9gKUCmKDvc4MmaplmtVtD0AQDLJXfE0TQNKuWp6GOjZxR/bdsWCvU4aVMk10tAY7jsly9fXl1dzfPctW0IwTlp29ZiludsGmeWBTcqA7xpGlxSyCqkWcwhpWQpoS+WMa6x2LUaQDjFnJYE3FgWBdf6+FWih5c8PhlBFaoSm80GE/Tu7u7wsiriDR+PPI+yVnMsVToPJRMogmHCHbJ2VDqA7lZPhs2PrBG/CSGAt4UYqB9W0DNBu/YcQtO25+fnZ2dn13e38zyDjI2vs3vYa4je+3E+3t7eqqpncBrMe6/MYZxi02CYwXQ4mhkesbvjGCGw6vPezlJiZvO7d+/fv6+aSkiOEZvO8yziQYmAdydhp863DYB0MKGaprm/vcM9UqOkWf4+JTNW733frVAdmBfDwYoDJmZjobZrhmHwTR6NwJyf667rzs7Ozs+2eL4Am01TqLs3Ft0uzoKUQONIRFiKcc/dHdnvLpIkTkbTNM1zjEbR1J1onmLERpKpzyRmGg0ds1QGwhFnzC8P3GUWcebUjSHQwvviPewyP0O4mFa1ooicg+Z5ns2oKVM9vM9aeImMyz73rp1DAOTmmWPUlELTOmdW+yHNTNiTfIsfquLPIhLClLLwJMHK4WJqTe3kHpida1DldQ5IW8CdMkohhJSCqiayrhtc0wVNIs5/NGXhg/T3Y3v+3caevk3K4lsy47Tgln/gbr/LkSMJ/ijB+71B0ERExMRGaAImKiFDKn3TROycN+2ePH3+2efff/36tbCPNimTc4xWs5z3gmlvQmYspyYwVXUJI9b1/PwM48crDeqrr74+P78YOlnerbIOj7Ca5VEqK6fBFxlzUOgSTJVwxKV7hArLLC2m9qKPs+zFjBsjQYkxCnuludZ6a8ewqmLWiohAuqHGvFRaD2OMUISvQWgNMFMpYqVFw8wwDN7LYZcJU3BU+O6Hw2Ec5zmGkDSEEJIB3kYyB22jesJhGIgULZUist/vwXjabLZEdHd3l2nY8xxLnZULUgRjh1wNjjzTlc1gi6lIoHRdAxS3guqHw6Hvuwz2FpkU5OUQlkLeACQfADvWGR5XC91p6Lq7hwcvsl6vK1YBUjECaE9Sycb4Lm4hg1XjWV+0f/EFod14fX395MmTw+GwGjbCPqYZVOplzR47E7MKwAo+HA5kJ3K1K9+u67q2bff7PaKoCmLXgGOaJkikQe4be8/M1uv1Ybcfx/H8/BxAepxnhAg393dd12F+Bk6IlQdkzUQYPeUcxxgQ3tU2OTM7HA745W63Q8CR11CDL0MsUH1YynhVB4y/IqTDpprCPGVUeYWVqejRxcXFl19+ebE9T0VemwvohbTbDy2CLTw4tTDvnCOnRqlru9V68A2krfOzLiIIDbfb7Wq9xsbufEeEeWJJT97B1UfSTFNS6E0yiVECMaraE13UBZGJqtkcQ0yJWELpYVVVE3Hg4Bo5YlU29MsRqsEOdkUI5LJHMgtcRv3UTKZxvusa77I9zEkqqVlW8pFSMZHSOF5tCIkQZdDYSdM0zTSF/XESEWuaBuF40EoJVFUmZ1yQZCYxIiMhc87JIskrBAIyo5hiWsTl5SLZSLxz3rfMED07kaqYmciSphAmPHfONYWpKmS54mOLCmvFqOjv1yC0sPzf3un6sde04oDtMdaoqszfmjPjjfxBsxP/nkhY9fOQbmY5BRURYUmMu57jVrZhPOx+8MWPDofD/3rz3lt3OOw674wJCmtmAgcsxKmo80zTpAn8vdnEtZ3vQw8gGtG6OP/6zZtnz59/79MXRJlrUC9MzZZkuOXjlHKnQHV4WV5KRHa7nXPnXAZbYno89oQvsla+SBBXlpBbyDJXZ9Y0jXctSxYWh6l1mfDsoTOwXq9BB7XcRFgVAHLdtKbdcDDImVwZqujLSL71eh3j3PadLzMN8V7E/qi7ayL09XrfAAYKITVNR0Sw70ibSsW3n+c5JUP7CrzCkrymqqjt1c7OOoJis1kdDgd9rLEOYBNiT8wMl4NQY/fwsNls8BrPkiA/ObQaExxwN/QaMOgtYD5SpVzldWgaIATOOV/S7lAG7hLkVswwkf58cwYomIosfk3c8fPQNdrkev84jpeXl9gGEN9o2xZY7vE4Nr4jE7guzJQkos1m8+LFC6wGbsEcs9w0/to0zeFwQAaMYAJ7qdaki1ew8/PzGGPlc8UYz8/PHx4e0BI9jiPEq1fsVN/OScdxfvv2/TyPxjTOkxCHEK6vry2mtm2dyLI0Ps9zOuSJ164wtFer1WEaU0rvbq5xi0MIzLZerwGPz2UkF3z8EpUB361t2/3+6Jw7jEcUYkUEhQBQEOYUN+v15dXV8Xh89uzZeHfvfN60JEjC2ElmXwKMQaSFHcgZdaO+71b9YJbMyPtGRIh0tRrOz8+7ruv7FZ4aUASSUUhxCjMqoDFGZpBdjSgRqXfinIfHEhGUTlCEqgEKAiPvG2aHByfG5JwLsCRmSuLY+SYHfDFEVbJEBCVlccyORaBGycR1CDG2nwgXnDx7Mu9917QimY/GGC+wyNKsDAjBX3DxoThmPKosnhoVn2Pl8eiIiIceny7sVdWUTRnST8rkiN1iahwzk5ASVcGNalRTSilFRGCU6S+OnTDlR56ZXek7pxK+GGmMoPikGGPb9t57VVwMVexnmVZ9V5pbX/Rtaeu3e98PDrgDcLOpBBknRmdK3n+7Ay6fLNX18O+VhFUvAi1VzJyHChosrxEJpIjMSPzZxeUP/+BHv/3tb372l//RuyZoaoSNTMRrSmTknKiSF0lF2URPI9MdZkBeXV19+umnb968EZ/v7vv37188vfTeQwEYmVmMs3s8QHuJYOTkGJAQZ48CgwsXQpShFc5jtlhE0AFVA0Ba3CrgmUgRYPRRumvbdre/xzmrM0Du1XXZDlIxNM41qmm1GsB+wmXXwkyJHPOaLxJlBsjsvQfIM4XZe48y8+6w9+JEZDzOZ2erKQaMVGN24zijbFklYbuug0oict/66UXXItasd7/fuyIULIt5QTHOzPzwoPj6MNkYAyWlcYuKXYBJrZ+ILAe+v8piOOeQYvZ9D2V/K2M84B5qaAJ8GCsfgx72Ywn8u7bpYzgIe3EU08xiKUyOjdicYySRuNEpTK3Pg5aPxyMqyjc3N+v1+vb29smTJxgJhccSF6ZFSmW322GhkJtSMdnn5+dTSIfDAem7KxLWoBHBc6/Xa/RQaaHvwfFAGQO5I6rI2AMVpkYIgg358PCAvRRSngQXVTWlpmnGOez3ezJDdihiMcbdbgdO2fG4b5rcJYWaLsKm3W7HzH3fq9Lt7b2Vfneku9j8UiRlEP1g3UIIFZStRRCsybt377qmZeYnT55gZnPTtXOI7CRqGlyPjI1K3gMaP/7bNI1RMkr+dEjbtuIhmmZnZ9vNZoOupDLOFnOFHTNP43w8jlNM43G2gpeGEBrn0D3vve+71jkXUnCuqFASZR1mTfDlZgwpHvEtOZlCikDInBCLa9rtxWXXDsfjceJpfNiJE8d+ToGVnRdVc9jAxCklw3xfO02+sWx2qO+7Kprhi8iMK2CYFG2W0mKneE0IwdjhdphxSurbPGMxatKU5hTTLjVNI2TmhZ04yRJpFYjW0sFlBdibppmZpcSyzMbs1GJN1k/+T1gYYE/jvVclYnYklhV/jZk0RA0xzmNU9d6DhqmqvnNe/BIUrE9Eze8/sOdmxo/7UOuVqH67zgY7Z4t6Nlh5NUOTcrYlKkOLpHnpa8uJhTKzSH/fDpiI2Kg8b5Lh9MeHiIj3FGl7dvGDH/zg7euv37z+0rtc8U2ln8zMVE/3kov4Wg4JldvOO7d9+fL5+5trKqW7h4eH29vbp0+fEgmMKdXb8y1gP/zZqWaMONeIiKzxzWq1ymWkZn0c9znrTY/uYt1z+BnlxppLwRWB1XI8HpkcSl+WVbQCOC+Hw4ja0nq9ZnbeP4q/cG3AJE8Lwqyq6D9piqyglISvgISqqs41ZhRjilHN8e7h4Jw7ztOIOQckFme83fuWSEIY8ZAfj8fXr193XQMP4UtLBhHB6dZNqUX9kYiOx2PXNWdna/iYWA6k/jWmwf1qmmYYcmNxvV+g1az7IVevLaZUJlIwIfoRkcTJOQe/iIRyGIb7+3tImEHBu21b77JAAWq9h8PBipa4lYka8zxvNhtNKXf4WCKN1foQ0dnZGRqualn37u4OnzhLDCEYpZiCc86Lh6PCxYcQvvzyy+xdmuZwOCRjxAoAhIBb6EIOSYueKBYKP8iCfAQ4pLK37u/vu67DgKPdbvfm+vaXv/zl5ny72Wxev36tZKvVCrkUbp9rG4mCimyM0bmsZ5myzHWDBamcr4onE9H9/T3kIGpSpbGq5EsIAUxsLvysfExaIYqHw/758+fS+N3d/TAMpBZNX758+ZM//MMvf/vb7Xa7Pxxx75hHxCVJY5hyqT4jKJ5FRJqViPiG+77HLiUiUmta13bdZrNZr9fDMKDvBckcp3g8HO4edrcPu8PhMI1hHGcS1mSN99M0ElHft6vVaiCZOIkk52X5GNZcCvHuNE1mnCgLyeFOpZSYpO1X2+327PxKRILqFGN/tgnjFEIwopCMk3loSBkZmpUJT/oppE4pOSfO+bbxwiQibdPiMrggvVZk7Mp25Wo9lGmegtlpxHXxLtb3/XSckRGllNDuQQXBzl+EjI1VDY25C2d2+icDQ04paQwhaIw1CqSTnBnujmCYn1ImiovktHJBk1zDTxuRKmEkYPWIUljTfz9fRHTylN+Z/la4a+nmiT408gsf8Zhg9B3FTcuzMtPvwQFnccr6b/jgogwtYAOePJyx895Mu9X6Bz/84dfffHlz/S6FmZw42Ahjcii0GJEjYyZm1pr/4eNSUmJ69uzZ5Tev3717B2MRUnzz5s12uwXdt2ka1fgBHJGPrBle+uQ/Glk1xVAVMACDIG+DdPjHd4tr53VpjAE1RiodehwR3KFACMYsgMfb29sYNcYDeD1chPEArsL21VIrcE4mp4m8d8bq25ZTSmbEnFQ1BBeCX3TN1lKxqipT33fH4/jw8OCkMUag58/OzlFoFPHAguq+xNdkNlyA93k2ADDtWISf8Fh6L3DVAKXxsy99RylTHLvqD4KmRhyVVi4rNJAad0+z1gwPvhPdVjX7pMJ3AyuemQ/7Q4W4w4zhaw3gVvg2YM7A6C4vL3FHjsdjV5jMVKYFVxD+7OzMCjRCRIBAuq4TkZhmz74uNYhCVpTDsX/Oz88xVug4BSxj7W2tSXzFTrQ0fSKzb8rU57rNqMxu4jIkA58+z/P79zc3N3d/97e/nsZglIb1CmcIIUXNVDjnPRaBiaLGkKL3nsySEZnOYWbh4ziFmOW6kAcT2zzPmh5V3dCkYGYu5rFxMc7gE9hCk0jKeOPGNxcXFymlfr3yLDHGVT90Xfdnf/Zn/+7f/bubm5v11t8+3G82G8+CEIqIpBej5BuJKQs5KFF+QFrrVx1qHwhN1uvh7Oxse36+2WyapmPwj5gxG+F4nK5v795f305TGMdxnoJIVm8FD6jrujmmaeha33jvV+u2YfFQyiilQWYPszZN03KorZmy95oSkXjvu35wvp2maX8Yxym0bTvH4zxNIhyDKlnrG5YIRlZIZhYVDGPGlo6gEHdd1zXOg24GUUliYkF6I4W9D1dVjWQ0ZXKsyVjqM8JOvPcirvFdkEjEyqqq1DjnHKZKFJ9HdQ5xNsCOlIw0mz4+DZ4hM4tBY4wp5DYkIhYvpmxs3nt2jRKJeAPmVUcHln7iFI1IMCB8DiZlfG8Ngisw9rt98Ad/NbPfDT5/8OLHkda3vuwR6frj1yydHbP/vWXAshSIXuTBjy4IQZlzTs1RoO3ZxRc/+NE3X3715vXXbOoE5TeEaQircx4sH2mJtc6PYR6G4dWrT77++uuu61LUlNLd3d3NzU3FMWwxPAQhWb6Yx1dfT1tvgIgc58k5EWLQBXEqNEzVW1U3R/2BCnahpTW+hoTOuWnM9lcXIxxgIpmdGc/zDN4pF0QReg5mRs4rsVrlbOs0HkWoOtq6yPM8RxHkhexcDZBTSqrGLNM0MTnE/uhhSGZzjK5pHHOMuTEDHqiqdyGMRTVU0LCkeTIxxBkArqLIV7esiGD18JsaWNTgnTwVtimZWds2634AJbimy1JkMVIRHur7PqGc6RzOX/ug4ONRSY0hh88okKMWReV53u/3gC9rzlEf+xpIwc8h1/RlEsN6vUbzFdxtXV6kswCiY2FZIxypgRRYCzVNwcIiOKgO2EqfJa65Pu24nmmanjx5gp83m83d3Z2qjuMIReL9fv//+bf/9qd/9Ec//vGPwRIHEzglXxis5iiXzGMSsGNijEzSdR0e3XlKY26+B517zvmTOCLCvpHCh8JXW61zDVu8M6aQNKTCIipNcavVCi3aIrLenjli773G9OOf/qHv2v/H//y/UFn/n/zRT3/+s59TIbEXHDX/Nal2fdP3LTvruq7xDcKstm036+327HwYVn2/KttMiSSlME3h5vb+9Tfv3717H5OO4zzPOahl71gtpjDOYY6p79t+6FarlXLqe1ux856NxXH2gng882I6NwzDMkc0s5hQNU+7wwjC+XrQ4zRqMm82p4wYNY6iy29R45RSLJ27zNx13dA1beu9hxCzsYoYLVlCZgayfghL4QiJoQi62aM8EiB8zTpqbITojggONZs4gfZy2XspJbZTsmhmzuVefzsd+R4W0+q8b4GBM3NKj2QTEzQ2jVW1G/raiy8iJhZVaWFGvK/jrb6T7fwR5voBIXf5yuomHzUOLW/it35E/ZOV9Hfp9ZeOmX+/JKzsg/N1nLaIEKV6oU6cWXLixTnftZ988ukXX/xoOo67hzsic+JNc8G1fM8MqfMJ8SgejtsQwtOnT6+uru53DzAcYU5v3759/vy5923KwuKPApMPlmkJp5iWpFgy14lZSHiep5Vf7Q8P3vsUT+Jkyxit7m8AepV0A5Mas8RamqapaXPCh7omRr/BDSDDNuV5iiGEeYqoM7EQe+ecg+dzZQTsPM+ukd1hL4Qn1jVN470jYrBQiWiacpJqJFMI8zzv9/vD4dB2A2L2lJIxSwE/uSCfxXhBzYrm+UiY9EzUdd00TUO/BqK7OVshkuDFrAItwiNamutRKq4MGiwjmpospuLjs95T0zTH49Eowaeie2oYBlNufJeiaaKk5JyYcd5Z4pldSqkFH0qZRcwSas+1Sgokv+szxgC/BeAUy0sFmAIPGZ9eDRaADZCVcM0oAdS3wPdjQCHId078r3/12/V6jZ7dym2GeORSh6taw/xEFV6blWzyBA/mQntsxCFDRWp+e3uLIuvPf/7z169f/9Ef/3O1eHFxAVW1GiUnMshusHcQrupX7nAY56TRKMxpCgnhRQWoU0rish1k5qSaQpbOxjCQ42HE3nDisc7jOLJRSsk1GdDWUq33pSPufHNGTIfx+PLly//Ln/1fHx52P/zhD//iL/7i8vJydba6fX/rFr3RmgVe6gB7W69W2EJOHIB9KGLWx1xZhDMeHmI8juH27v72bhdN5ymmlMe8N9YSUYymKc5Rj1MYQozKMRzx8K548J45V9aUyEoknef2ZDOi6piT2TxNNyER0RwV0dXBLITUOCE6qekFTZQ8M8P7BgWSZQaZmsaJCJsC0MS9q3hJ/vQUvWvk0RSg3IIB48PMYrkuUNewRO0mOe15NANYVYOmRvMgh/r7GCMccH2ZCB5AW3ogIlIyTw6blvOgMyXK3C5hsM1TnELIc0f8ZrMx4xhUfIPPTSktUIdT4eNjb7o07JSN+Lc0EX3r63nRwfzBt/j4PN/qlb/1l3jL77kGfCLSP06CHREpZ4ZeSkGYm6Yjs/XZ5uXLl9fv3s7TcZomKJdWd1XfS4vuJhxm1nUNujN/9KMf/fs//w/eeRGxGO/v71EJNjNw8WgR6SzPQIs4iKzK1BCZAHg8Ho8wemOYpxB4wYl3C5FCs+qwuf4JuQ4MB/6bmztdi9b1WPSY6rgbDAJCRaRmQt77RNaImBlwdXg77z2zmDHUKIlI2JRMmNS0OsK0GGN3PB5jTIfDYZ7iau3RMpBSIvFd15kdUkpeBJ6SiFTjOOZWq2L5PUDy9Xod5gDmjikp5YosJhphJgxSfClT5ev6pzLBmxbz5AuE6Jbg6jiGql6E9enaASuWha7GEdwTePSKTmNjLAtah8MBWRTCgo4aIJxaiNwVE8aBGjYXiTRmhhaHL3MRwDZCCl7xYXw67o6ImPJ+3GMBd7vdixcvGidop4EqNTqJa+8W1gSLT2W2lRbuiRVCZm0rQpiCyAzlgPXqDNi7c+7+/v7nP/852qV2u916ve77nkgdC9h2t7e33LZ5fcbpt19+3TSN9y1uX822s+EmJhMNSVPE3TFKOY3Gik1j6zx4dvvdIWdjTESkMUV3mhEpC7Wmu93Duh+6rttut//yT//V+3fXZKaqv/jFL7quC2EahjzhkYiI1CyRa1zmf6W+XzVNa5a889i3wzA0TQPjY8ZZ0VZ1DlHVEvGc9DiFlCyZMgmxc75NyaJqiNFiiEmjmpIlpTRIUhL2IrKSwZosFwKya9P4aQKfLkfkLOScY9V5nlI6ag4Nq2q0Mjsycs5lLN045uYrheYB7rL3vnXee2cpqqlYS2zeOdQF6svYyJRce6LuoyaYSsgiWeSSkKJKqRCrgWSan0foMFNxqykl5Tx6qAIPmiy7z4X9TKVzLMaI2abFl+cWD+eA7ZlZYWKXntJ5nsM0hTirUtM0bdurqpL6oqakqtWh1DNbGTP89z/4W1DrytXKj39Fv77VZ398hu96Wf3Zfn9a0I+OE4WPiKo0Ry7tkqopCauaeOfVC/v12fbp0+e7+4evv/lSWKTwTZICHaokN4xcOq2CE2maJik9e/bk4uLi7u6u8S3M5evXrzebTdc1y9CMymUxuSpJg8PM+IPlU674G/pwXBGXWUaLtEim8QKYUdivSk2iUqLLFp+sRnO5FLoofNazhSKmOoaZcgwhGGMYYgwAihfEBNi1ygfJF0AnwcVpmkScKYt3fd8fDiMzTyE5l5M8IppCYMvAKaw2lyo4EaE8jO9YJTW89yEG9HTWqYLgbcEVwRsB6cWXWnrZEAJGcRBR37Xr9dqzYMbONB+rX0R/VJ2by4XzgmOJgcO3YR2OxyPKt1XFE75wte4RSQAcxmlxd8D3wdth1PC9NPcp5q6kWvIMYTKzpmmsjFIBVB7mBA36lNKzZ89+85vf3NzcrLdn2CQwsnhltblaCHp1m9VmMzNDH3YNzuD7UcvArEARmaZJ2K/X3WEcieju5vZwODjPV1dXL1++DCHAAXvvd7vdL3/5y6TyxRdfbLfbL7/88je/+fLVq1dM893dHQoNNbGu5HDnqW42BzljhrRCph/PKcZ9JkJ777VMEcC3oAd58eJFTWIKT6pFDeLs7OxwOIzH6U/+5E/+zb/5N5vNJowTWGZZ2hN7qYSDkEtjZpGmbZuaATdNo5R9ADOTMepT+YmLFkKaY0BjUdTYkoc7RxIUNEbTZDbOUQNVlpxj8X6QjLqTc5ZKRRz09Xm+ERIWVvGmyQyyQCQo6BAxexZz5Jxr8oqRmBFy32UG5r0nVvyrESfCTFo42Cfl+ZrAVTy82jBAu2V9xGJO8ryvMTH+asUNh5SSLyZODOOKT00oSyNvljizZdHtXVYPPpJJyoNQ+F+naq6qCmUOWUpJExHTMKyLIeWa/hKblQHetCBM+TJ09ePjW/3i4xd/SJOu6S99B8/rg3N+10fUXHmZRv/+HfCjg4kzFp1/EDNtpEkUSXM437bt2dnZ+fn5N6+/UlXEkmgK9t6nKCCesWEYZc5SUSxpmkbn6Jx7+fLl9fX1amiiqnPu5uZmHMfVqk+lCpWvB3nwouJYpU3h+6kUA5DGee+nqUwDbH0IwUkGxPDK0/4206IqTEQ1B+JFRxNuEqSb8XrYOBGB2lGEZEepdleHwZGPxxHA7DiOsfhsZm4oY9f1UYxF/QO7qmkaFkfMRIxRZcIe8u6xaIwALEVm1ratqaGNFVBejLFpcqnPTMFgcs6Z8skxsNYUjQqXEhWdKhBWuVr1QQUIbGYsVknjzjnHp1UlIjB+YdDH44yVR+dPLej2fY9GHSICMI7ssGLLKBDiMpD/1TQXgUtTRkMCTtQiaFVzX4zHqOl4KY0bTm5m4whF/qyXtFlvUfJ88+bN27dvt9st8H/kiIgV8O2GYbDSw2alXVUL6Rc3lEuNoO46xHNI93HfQwgeBWNymnvw4n6/74dWRB4eHt69e0ekzjkhnuf53bt3zve73a5pupRsvV6T8es3r1Oy/X5/fX1ddyyzobJ+tl0hoc/+w8g5h/2M7bfbsSuw4fF4jGHOG0l4nufbh/svvvii7/s5hMvLy816nYvlZFiNy8vLX1z/Isb4+eeff/PNN8MwfPXVV+fn59gYmY1PZmaQPsYTDdeLIC/TviiHy+JOD7VzzknjnMtgEVFUjTGGkNjlx1ONY5yT4ekji4p74Vi61ndd0/qsmUXMUwxE1DTNer2GevYckqD7tfPOTBOFpBXDYHNqsXGu70AqTI6cqqaikkHFBzCzatJovhHvnXcuhCwDoItZC3hXfdir6H11EiEk7/E0ebNQI/4YY+vzs9M0zjmnKWjhXS5tOJYu0UlKwRZNodUSpnQKIGqeXVPw7MUTkYN21+k6RYSF27bVEH3bV5EwPPJckPOShj1uc/rY45SrtO+YL//h6x+722p27COhj/LP34Vpf3xhf38HXK/3u+Y3/f2PzIvOBVViM3OnkYVqSR1zkiaJuWHdrs7OLi8+iS+/+vJv5/EYNbJQYmfej+adm7EpyJEQWpLQ6K7euda7OM0k9L1PPtnd3719+1aJxDtN+re/+s1qtWrbVuMsDlOShEwNYRUJsRAJ0cT5sDJXEVFkrrU0TTvPQcTFCG3nCfU/Ii4+VZglz3XwfsYcG++M+ThPq27tHHJTVTVIBprl+mKmFzl3//Bwfn6ezFzjpnmGTQHLJTGzNExK7MZpClFVTTV6703YSRvmCOJCmNV770QO+2kYhhRVxGti5/w0TSye2Hw/7HY7Jbt9uEcW1aqIU3FKHJPacYT8chQRz56kTXF2JIcxpyDHaRqGYSoV3xijFwFjHNmb5uqUxjlA2w+CGHGc2r53LCHOmlLXtGbWqKGVZWgada5v2sNDnsM4TVPfrUIIfdfM86yJxjCbMDkZd/sandTQ+6wMIUbyCjvR9T2y7SokiTd61wZKm01ujqok85QCdMHwysPhUAH5J0+e3N7eQmUTUs9w8CKeSJzzTWOV+o6o6OHh4XA4dKvV5vz8/fv3xhznsW3RbSXMtt1ujsfj8biPMZ6dnfV9v99PIXjUwp1z43g0S8zmvXSNsxRqU5D3PpKa2TSPcxjFkVoMFslRtNivNiEEEWrFU5Lb9w87f5ymIzp6RWQYBmaX4vz6m69u3l/vdruU0v7h/nicsBrM5nJ3SktEZrbfH+sgL1yeb9x6vVZixzQMg6mF2caUVLXvXQhRyVT1YXqAB3LOTXO4ejIktcN+f3d7e7k9B5ZOjczj5Ho/DMM3d9/0fdc03jlZrQZNsWsbCIAzU++b8TQXlpmtbX039CbMrVfnGgSOIRERJVNNItK3gyUahnXXDeM4GrOJTXE0sWhRAjEzJtWLiCabFBrsfJyNHBkdnO/6YS0SmtaLOEvaNF2YY9tymNPl5Xaanr59+3aOc98NFkInLmhoGifiVJNjMkpE1nr1PgkZM88qKBh57+cQNCXv/TAMKcVGGnYkLEouJiX2c1B0iPg8gjAqqThJpkgkmC0ZJ7O5CBWwZ2m8MsLoQcQ59vM8W1LyOYf2QjGmtu3GKbRddE5CmPvWqyqnBGl75/wcJjYi1pgSi5Hzc5rF9OHhQVXJLAKsooaM2ERV2rYn8TFGCP4YqST1zs1hjqqHww4eYugH8g1TM8fU+Nah/TeGROpZrOihYu8herZHA+4M5yHm30F5ZmaiRyLPZkxlJEf2AYtWWDoVQBFAkNmpDeljX2sF9qdFxfO/cgb88SF00suGm+n7frM5a4U/+/z7f/fLX7gkIYyJ1Mg7byAXZH2PIpfFIs4RMhjnnAiTycXFxbt375rGT9NEZofD4fbm/sXLZ+wgXL7kOVPJqe1baeVWFIiW6VqNjGr5qtwkTmQxZG5z/priRDCFbXQnYXTKQsoL/XekONBj4sILq75ZVa2I24EUE7OCR2Y+jzpiQwCdc2UIYN0NMFsYHlwbWlDLbMrMRF2IS8NzwGmp5jEZKDFamc+DAmRYaCzXsndayEejY8F7bynh0y1r1ZbFTLnIjbcglj87O0M6DgYvCO1IZNu21TC3bTvygUr9qWtbVb27u1uv11SS40pIhnOtnDJfupZjjL45jTaq2XnXdWW6OJkZZJ6QYez3+6YMgqxxBhUrME3TbrdD+ymwEFW9vLzc7XagT19eXv7qV7/abtdYfNT7h2Gofcy45lQamVwRqqzEMVmIMFihHYSizpiy9GNu+sJNtAJOYtgUwMJ6BmKd5/mwH/FPbIYQsgHymM4hYhagScTMULjDExHiPIecKKyHFWB/X+ZbI1KZ42RmSUNK6fz8/MWLF5vN5t27d19//fXQd8+ePTNhACHYrnfXNwBFReT8/DxO8/n5+TxNWS6tiDAgAthsNkh8Ye+atsUgSFsoiKVy5IiN8kxPY9aULKVoKqIiTTEOVrN5VlIm6GmHMDUtP3t6yZvBe28xQf5XRDxL27ar1QozH2kkznV6dJwj0SQvjtiJGaq/pGgOFCm6PVpyvnmeIRT6wcHMaQEFwyWonmBns2rBTiljRaq5EGvqfyu3A2GoLOplVvro8ANhAUtjUmnipAp9V9xO8pzFPFiTiq5DzTXxubvDgYquJ6TEmLky+PDRSGrqVX2AD9t3oNDfdSxfX37mFFWTfZAElxfI0skuv0tNkb8rHa8n/G/GAZsgvzxdrxGza3y7Wq9JL95NhxcvXtzdXF9fX0vjJSR2nEJUZ8VXGlNFjzMKB/kIZWpaevbs2Zs3b969u27bdhxHUX13c/302RXQlcWyEkF61YzzxMTfRWPD01vjIzwhtKCtR1OJBuMuZQAfQKeUlOikIC2FoTNPse18NTooW0LjECajuI0mhGApEWc6VSVUW0FYKgOrXm2lsNVoAO/NXbBkRFRmJxt6f2nBM6zVWSqqk3CQmuexGAqlMasEOJgPKlN+iXKzbEoJ9tvM2DklYudSeRfOX63nZrOh8gTiK8ApIhvY7Xb4K6BaKw24VqR5sIwAkIHW1splbebG0uHbgcQEPYf6INXlSimIeNwCxBNIoBEnIabBAAxA31DJtiIgig9C7fz+/v7i4uLiyRPMtEcUAv+NdUMNopJKrMDy8LU4Ldw5ETnm+lctZVRwr6yoi2ANF7s9Q47r9TqEQHSaKo3L6NpM16/SXVzEw80M8ZWqEiXnBH2iOTp0rHr6vinkkjlWGPvNe990pzZZxEl/93e/DmEitRQy6+fVy0/wLIzjeCijR/b7B/Tadl1XpcGYqMkTpvM5m6bBSK6maXzToKl36URxhZTUEXuWtnGWAhsoi4nYKKqwmCVhUTNTJs5yFmqmkcjswEak+/0+pJhSCjP5MpeemYXz4Jbz84imhhCC+CZGoGuWUmp945wjVkckjogI1XGy/MymotIqgnlBj8fqnSq7ysx1zo+eOojgX6OU+ugyYahGtzrjJg9UNkjmLR+B6lAX5WSAy8hcgDOfDPnS0zPnPknxTdu2wt6IQNta+s5YxGIRg3ZdBwMEpxvLTG4rygpc2uV5kSN9q8X+Lq9sH7XtAq6vXNelK2WGDuiHld0PvvIHH03f5uP//g54qQT+j3zkdUERgVNNSEWEyQ3DmkmP+/2w3jx9/uLNu/ci4DxripFJUD2uC0FEtTmMmc1STMbMm/XwyacvfvvbrzabDWDA6+vr9+/fP316lZS8q2+1soEMMPLyOmmxlPWW1KWvoV/d8cpEajWiTGWeXbXFvmnrGaTE70ubi9RWMVklVTVXRME5xWGOSZfQx6LlmnPGzEWAd3lyuE9AzZCpm1M0M3gyvJ5KLm6l77YyurEA9Xu5Ih7JZZ5EXaJQtOu8dwgyzAxCpFzCYVwwfM9cpiKGMNdqcdu26/UahhjXj4SmdnON45jIKClYOWbWNnm+Cjy3LRqvcQZk9vVJRq7fdR2LxZhwZi06UERkhvHP7FxbH34rVGS8DNxgLBeIUbAdaEdG4p7K8IP7+/um71arVVwoOYP5BXd+d3eHcRe1/xs3cZqm/X6P7ZozlcLAqoRVkJggTAZMQhwRa8lcgdIzM4sQ5jku9ycvhlOlModVJA/lxUeLsHdCZh5hExszNc5jMVFO9uIqP99KyoU2JNqpc86YcHmvX7++v7//9NOX+4fd8Xh8/uLZdrtt29Ys7Xb3iJ9qq3SMcb0Z8GTt93tEIUisyUkIEZqL6DsXELFK1qWqppRS0hA1L1fpOUnKbExKiomnxswFGSOyxMQsj8T3ERNA94pzl+qjtgwWKGY0wD9ub2+ZiCyRspGSnuyVYIKTESH4S6eguQamzjkxIs41XVyaLZJIeuQmi+til9Io3tfUPJW5hKnMJtLScVB0abIJ0jI9MN8+gd7tY+cqRI/xVTOLaVaLZqTLC2NCWaqYvpM5TWrOucNuR8VFbTZb731IEci/2SMJoKXZqQ6YuXKBHnmZb3c/j/9azpAz+wqNPH77yRt+sOzLiGd5I77r0/9byYBPl1t+41kiKTnviTpbPXn27P3bt0+ePd9sfn13dwfjJWSkmVoqIi7PtszmQ0troJkitH/+9Nnl5SXa/PHA/Oo3X15cXDh3ajHKV8KGlr7vWjhdyBgtExQ0kmfKFguXSjBC+GzcmeGi5nnum7YmiAClkStbGVeHx+N4nLquQz5UIURkEviv82314jVXYz59egWNa++KFRkHdAfllzVdjJFMYghk4l3LyIo0aCJhn6K2Tb/f71NS01DBzArFw9TC0uFKclWmFGVhx1erVZhmYLaolcYspOW18M6apokWkXth7BI45yklQKbQgsZniQgcM84DB1zZZ7vdDuOkQH/r+36apliKBWmhxkUFbq3gbVwMDUQR18xUY0ph+fzjq4ErVHnIVXhkt9uBjYWZCqvV6v7+frVaz/McDinGuFqt8U0xbeJwOBwOB7S6aaE0V7oZtlA1YQSsr1glKiT5GkIhY8ZqZwKgIwiq+MUcrerO+TGHnAosiY1ULHVTyXS4s7U4goBJiJ331XngVFwSaFx8BvOTBst76eHh4eHhbLvZ/OQnP/n8+997+fJlmsP79+/gMO7u7uZ5rnmkqjrPuAA8YjFG9m7VDhiqs3RawzD0fR5cqKoUrT5EbDmAC9OcUmIzU1JV40woIbTYUh5RW9yepZQl1q12B7Vt2/gQ69ROxtAiYW6apm09ZpbEGJiZHZmW+MmRw5BDIY2plAxO0u6PDTusVHW0jzhBdRvX39S6ABekFPe0tjg65wBQ60J5jbJHyZF9LdCwd1VMA5+hqo7Y5IS7qqpqBD6UzbIIsSOmrA5mkjJUp1Zm1DIzZFBxf/t+BUhDwXnU3L5cgr8svnECpWsm+g/En+mUWZ2ih7qAZd3rJL1HfuGDZf/W4+M/cakBn5rDfr/Ht6fUbGRsGG9VfCE71/h29fTly81m9ebNm2+++f8Nw2Ck4qRO4kQUiJNo2RNShB5FOKXU9+33v//9//gf/yMAt7Zt7+/vj8fj+flZSkE+CpIcc7JHEC59tNzV/uKf4hq1U8PcsnBSSylVGAGhepxD7eysSkkxqFqELySSaZo2mw0eDF8m99WG4BBCRy5qcguBYnxiXAgn1TpurVLjOSmqnAquNS6yKku7IrSEeBAVyvpw4uPQiIXvhbPBwlYedV0rLVVtQisFUVrMKkBcEtPsve/6Ri36RoZVB/cjjszIKLFY2/mUklEKMTRNA/6vb8Tm5AAgO4dMuilS2HCcWBMRcd7HlJxzqLbi2gBrJw0gFtUrRDSgpQsIC3U4HMySmTRForI6aSl9WVSyfzMDxgD7a2ar1arvO+ccJNumKYuoYA/A1Q3DUGXCXGkKgBOtaXRFGpoSAYDBh2twzm2329vbW2TGw9A1jRNhIlFVcYmIyYRLNh/KcAusA5v3hVGV8eQSAiJpzlPvSJyTlIySEJtkLgbVKjiXlBq7K5Xm+NrCx2yW1EkTY7y9vvnhD77//Plz7/3bt2/fvf5GRNbr9eFwAHa92+36tuv7/mjWlKIMIhtlspjhitoglOMPycPtKWkKIYaEGCXFmKJhh4zj0bE455Sg02g1r7KFEa3P+9Lud90gIk4ahO7KxCRaZvaxsPd+1fewPCdRF1Jx5IWEUMJmM42YQJXSGLPx0dxg47z3aMp6lGNBRPk7uD9Uqr8iwuwWaA1VW+G9h4NJeQ5bHgVopROk2rqgqVlMj9MSnZQsnCC8oho1nAYAL0Fp5xw02E0Y7b9c4wMizIIzs5QMyBCYz0wCDnNF42qlqVqzb12Bug7f9afFIfU+lywlu164yOqPv/X89FENmIrz/sAB1zPUDFj/Hj74nxCFfnzApxYRL3HEqe2GF5+8GndnX/zw5q/+6q/CNHoWJk7MRGymlDTxaYl5cQhxxdxevHh2dXWFXISN53n65s27YRiYyVilgCqCjgMT+ygJrveg/lA3ARGxMBu040B/yNErimexzD7CMwCMcU6xlz7GKGW4R8kpLUUjZ0QUy1T5uYyUd86fQlp7pPemas5lNkQsjfkZ8S6zWivyXMi9GYOqfbT1yy4fmwq1LZNFKbNQlj/jOinDUCkVuWYia9u2poNipqqr1aomdiFOFSQ/HA596+Dg4d3RAgvDPY4jfCoEpIoKWK5MO+eapjkeDlTA2IpF7/d7KzB+9akVXVeL3uVKIQwBAnAsETK2mhpyKbdrEc6ErUderqqQ/iAiuHArJVvcRMyKCIeAq/Lee5G5FMIRqzVN0/c9IkWgr8yM1dDC9cP9pWKGioPEeB/G6zFUuO2aOrfAezFDHKNwD5XLdjjuoNjVuhaiIkTUtr5p3DiODNVw78QRhtILkfNsRMy+yoDwQnhkCeVxoSPUpMo551xjlhrnN8PZ8+fPr69vLy4uDsf9l19+2Qj/yZ/8CQjnfd+2rVfVFGJu4CZqO0809H0vDaZQYG10DvnAxaRkMudpKPOUXS/qBWFOKQt7pSzHppqMzDQ/zsC36KSLxMziXN+3qANj+2UjwOiVlER5/6SUvMvtcPv9fuia6XBk1CYkz1cF3kmsbDRNR0A4qpUAxd671nko8holoHo1/YDnEEaJV5aai5BytDLDA9X3EFLNrctjbgsYI4hk7UJw3XMsLqxF7I9qks3MQojza1EmzWjhOxnP4iAdwJho6sgTmaq6Oro0hTJiy9BUhq3iXVPWlivG48oMD1vESfXr2EdJ58e/efynk/elUjFcXvkHr//gl8xcpaWW3ve7PhHH0un+fZzrP26iLN9ywm/zdpYfdGna4ftf/OinP/2pc67rOnQfyuPUlUsxtSJ1eAYAE63X6x/84HMYpnmeifirr7562O/zI/vhDXqU/n7wKR9cJ44cUxfuH2Zn1rQPbGG8Xc1iSnCHVtjtVPzco69vRkR1Km11xjnmYl9pCMiKymbKy1s3MVYDV+gKhxaTBggagflRPynSxWKhkB8DZLMsK5GLxFxIVUTUNA1ALfxyWUVG5g06T03j2OWpCTlTpwQH0Pc9jAWuDZ0MzFxmKTok4jVZx3fHb2LRFcGgPYQL4HTgqrgUlfFFVqsV9CyZ2TdCRBidW/FJVZ2m4/G4h6rANE339/f7/Z6ZUYSu1VPkuJSHPnXwx6jgwpWu12u4EJDPzezh4QFZOBLxGCNELKEUZoVovVqtuBDTuEycxBuX4f+iVp0rZMAhqo5KmoNjIk1pDmLUCGMafCOu9QJN/8axhuhZPIsI9X3b9y0oz3V7xBjxRjESI1ZzxI64aVzft0SK16cytbqqbFZPUDXC4PhrcoYg9fnz57vd7n/5n//vRPSnf/qnzHw4HFIKqjoMw6tXr4pPTVMIbd8Pm7VrG+yc1WoAwgFkBWu7BGPQLIBNm1KKQeM813KPb0H+9ySSh8OTMLk8B1dZE6WUNMe+JzIjFGa0iKZlC1IIBNV/ZCIIZTJ50zSoPcUY5zBOxxFWAre17zvvnXPSN23ncyMAHhMpWa9Z1fNY0m4lxwF8guhckeZOyUpQ1eJG8Gl+kqpWM5LpC86d9O+WbszygD6louqd36U54q/xK5W4xDnXNr00vp5GF4B5jSwRdiuZb1qmXAmqOYYUIT9aJMQlIDb77jz1u49T5mqlQlfv7NIaL/9ZP8uYoC1SoZF6I+prvvVUv3/k+eNDHv+vcPiIXMljsT+6YSVNe3F19Yc//aOLq0vLuGh0zllMuAFaBsXUL58/JKmq+sYx6bMnT58/fRbnIMUiv3t3HZWgWZqSirhKT1ieZ7myy99LIU9V+8tFuD9DPYnIBAzVECOLjNME55EHys4TF5IUFfYvnmQiSmWYIMZ+TdMcY86hUzTgclFT/UQqVcxqqbGhXSFcIPH13kPtAcQW+FfUbKqTds49PDzM8wzV3zoKAn2ucC2ulP2oOABkn/isCmsTkXNumsI8x/on55xrfEjRmAChwybWF1TNECQEKaXdbmdm8Hz1FsDB4LIBngPprcApZDSk0LtqtIFU1XuP6b9mhkqz5o6jVDV2uJBmIZShhdBLJebDN8XeQL2ZmdfrNXYFANLD4TDP82azefLkEonIarXqugZDc9+9e6eFkd41TYcLixGXXUOQaZqW3G/k00j6uWh24qZ770OYDoedajRLIoQapPfeeYkJVt5UI6gJrowyrGQlLJ2Wao4WyYhyzck57rqGSIm0bb1jHg8HS2noOi/ElhybpeDYGserru+bFv5+aLvWebFs4ruu22w2zjWXl5fbs4sY469//es/+ZM/+R/+h/8hpfTLX/4SV+W977puOo5EBLeqhYkjiwFfTdf0Q+e8YOtW4BoH5hAjwBrHcTwcMGMR/0R/edu2eaS9eFXFpMtafPHNSU3aMbVeLi+2IoSYiRcNEVZAXXGkqrvdDg+d977tfNc3cxgZIQwlfBCj/aPvuqFf98O6HwY0RXjfdZ3zHOegMSHHrYZIiYzd8nn3ZYBYKvRDKVp43vvaFl8fhK7rmjz1iNyiAal+BCxM27aA30QkFDIjDmas2cmBIaxMRYWD2fm2dW2TUt5RVhT6YOWO02hMJG61WferwUkGk/A419PCwnAZ7SqlPaS6zI8dIX1HBnxyosWYU+kWqetQnXHN6Or3JcmyXqcVWHzidx31BR+QsP4+QPTv5TABtiJGkLBQFkfWdsPd7f788slPfvLT//gf/j0zp3FmPs2eW5qJ5aIQkWCUh6PN2er586dv377dbM6meW6d++abbz777FNlEhIjRVIIixbtUTJ6usDFgd8ghsXABuccLZ6NlBIJp5DENbljpIRvH5y2Qrip6NG43HQUjsex73uiii1HTZknkkwtCYYNVCZFBXVP6XihLTjnjscjCJlpQUSqCRMc3jAMEAjkwvKnMkyibu5aUq0xKZw0iqmwNU0pk1dYsusG7wXA8jiO2+02hOAcx1x/yhEMqq14GJCk1soZ8tp6L/QkAlUajmMWQgK8vNvtcvHbzGKEF4eYJYs5v0KiVu0XvuYwdPihamPhmyIyCFkmHjTpAMIzUr39fk/l6QXCgcey65qUMjV6s1nFqOM4dsNwfn7OzPg4iC9uNpv7+3vU/uH18b2kdIKFEErvUGZI1d2IhLvrGmae51SjByzjNE1QDIVRTtEdj0dwyphb1chMZsksqcZVv25a13dnWHDIefqmQZABMSysBirNq9UGN73vc14FDMAyzSdBD6T1HlkSkqqmadhnu4/NM8/Tn/7pf//DH/7g6snlb3/1a3Cb+35A9fTm5gZxZw19xnEUaZhZF437eCSLWEq/ZKePxynGqOjwKdXcCkc550RT27bsJETEHJ7I0OWMD1Whpmk4Ru/9ZrVerfuz1dqduGZtSrkP3kqzU6VVUuFnMDOeFCH4ktIF5DrULFLMXTdExGJqkRT5X67pyoJiUh9zJiJS7FbnuIDVJCKWzUKeYwhr4xb0pabJtBVAvOiJAojinGuHvppWIIY5S3E5BiIii5kZynLakGj/5VxryE4XWGU11whVQ0jZv1Jm8Djn0E7JZdpE9nJCKf4uVHnpLKuX/cA7Mmc+RH1Zzd3/s360KIqfPugflHTTf1US1ncdWcqbIMpBBh/cNq2RieOuX10+efK9z3/w1Vdf/fbXv7JSMa3B73KhlwGLGRGbhtn79tmzZ33/t2A6tG0bk379+s0nL55Hp60TQ7Ko9sHNqwcvSImnHVZ2bXUGWgSW5xhg35k5hGRmXdcxn2a+lvN8VGnIsRVnr1AaQpg5RZsj6IWY4TWfngoWMgohemMjTTHg8hJlnlooilFhSuTEhF3bzCk6yghVnnVfFI9rRF+3fiqTEKvH5cKvqbk13KcrMlII4YkIaKorEh+86LzCy6xkgZB3xgtc4ZdZ6U4GGGuPkSJmwhmWtwbwbyZjExFRLJG78y6WJssSpOdGWO+FCp9ZizoHAgIqqSe8YMqTBEfnGi06X7SgnlopD3ddnvWEaIBIh2E4jCPy+2EY+rYF5ozvBaQhqp6dnSEomaZptVphMfEtUpnPYQXJr/sTV47fIxdkIy9OiNkohSjEZNp43zZNDGHo+xgCpD/6vj8eD943UD5BFWCz2YAXttvtri4v1HJ1f7Uenj9/vj0/O+wn4Mmr1QozHphZpD0es7qIFD52jLEf2vGYdVc8MwbtqdI4js+ePdtut7/+9a9/9atfXZ5voeXeti0uWx+TbsAJMCYztlIRrKmM5TrLrsZ2pgRVEDIDf0KL5UUY2nY+aPLes5MUJy9OMI2FcmJArEIszKuh35ytzs/PL842F5fnjRPnHBffP03TNGEv+ZTS4bgLYSJSEWoah6CncT6F2bVt07imW1coFd/Ou5O0JABvMwO8zwtGW73daDOjYv0K+JRODtgi1qFt/TAMIlRdWlro/5Rw3IsQE6umUpNG7YOYeUm0WeaRmkJKCeIqYGYJe2ZHJM41OUcyTkosTFQmWVkapyN4YV3XAc8vptWHECBUbJaZrUYqfHJb9gFaWar1/BjCPHnKk3N9pONRH1guAubfdRhnzvTHDuI/e9TXf0zC+q+eBJfJwaiRgOZjkigXEvrV2gk9ff7y1Wef397e7m6vzSxpNCNfdFCpZAPLn3F4783Sqm9fvnz+5s17sOyapvn1r399dXXRS5OSOfAIMEnXnZrEl3cO266aflnIzC5fpmRRUyoNSKc9quqcOxwO3uWUV0mlPLfVH1RiKh7LaZqIZJqC996yPCxXeIdEtFxMvTyW0/XUZBcpHR6z2iCrpUwOILqWMBEMLoHN+h1dERVypccJThQFVwS2bdtqjCg1wROk0lE6TVm9EhmhaqzPDGDDGON0mIdhQAUuqQ39ep7nGJRMyEQ1693Xp2WeZyeCCBreaIm8xRil9IowczTt21Pii1yktMeMw5AVhvE1UVCsj2iF19A1VB0qHCQVg+4yWYEPh4OqmiVUf5HUHo/HaTrOc0CoYZZHs56dnSEbQH+2EB2PR0wRoJL911p4xVTwSxhKIoUXr9Qq59wwDPe7AzM3TbNa9Va6nzebdhiGtm2eP3/mvcOFrdfr9XoVQthuz1TVbJ1SatvGeyci6/Wq7/uXz1/AxaaU4hy8uKFvha1pmouL7TB0eCQB/qdM+2J8Bdz6tstjlVNKIUVVvbm5mefRzP78P/77/X5PpNvzsy8+//6nn758eHiIc6hwcYYfvWNm13jLGFh+BOp2hQOOUSsPbhrn6rcgCk0YEGTWOF71HbNNIbTmQmIm9c5V7CF3XLss8XE+tBcX2/Pz8/OL7aofnHNSZOoRswFBBU8e85gBJGy32xyyS2Zrp0XBEc9vNNU5my/nWYij5SxcRHypelQHTCeJxNNJJFPD1AwOJqLJ1TnXth5SG1x4mnh7RV+dcyzmGJapBrX57FIOZgZ9VVWZjBa8xSVaRrlS4JISpkUhT2FmIwj5jUTinOv7vm264gUbO/FSFUwx97jd44Nklx75V/r4l9/lfZeOowYW3+qlHvOt9OMT/j0PX1t3/qG58z/RYUQMH1y/OJh+RkTkXDPPwTfd5ZMn55dPnj1/eXy4I9AKLAvTo2T1wQ2oyROZet90Xfe9V68eHvb7w9GMVVMM6ebm7tUnL4MGImcanXPK5D4KcJY3pm6C/Eh4D90yEWEnJCetllrfpYLcIslrVn09M3YtlU7WlMezlIJKxqWtaCg2qpRSVFVjZ2QaFTSHlLJIr6q2jbdSGNbFXL8lRn04HFBdc86J5IyzpuxcCFlEVDHtuQyfqYtTM0Ucrg4pU4Vrr+wheIjVahVC6LoWzl5VYwz4ofE+YkSxnVYD4x/g24pNoYoUccn+/SIGqrapeiDvfVIdxxGgqDKlxLW/qIDJKS20gWQxI48X8qJcukvdoge6yYMlTqoFtCin0aKIxcxo8PXe63hExHB3d/fk8hJZ9W63Q6IMn4HIpiIBsczswxurSeJiFiHMJKVJtyZMeeSl96vVCoPwzKzrOmidotiGhrfVqh/H07RmMMiGYUDX0N3dnZWBE/gTcsqrq6u7uzv4177raGtGFONMZf7mPM/OcUpxtVqlFEERypxeteIs47/5N//GObda92dn6z/40Y+fP33SNKCm8+EwPjzsMWOKhB27erPqrpPCx8GjZ5Z5JHWX1kdYMWC+PMVd48/WQ9O6OQY+jBLT7B2T+K5t0L+Vi8Gy2Z6dnZ1tWn95ebk5W5+dnYkQ8OEa7s9zRJQwTdPd3d3Dw4OIbDabpmk2m03f5/541J5LWTqlKmUc4xTGEihw/ZqZseZc63312vUuf2CslvtTSyGz7m1m67omRq2KMRWOymNv6JTGqGrrvHNOSmE4g0ZCvmmZjVnM1IoRyM8mlZEJJX7RdJIEMCNxYMahvT6z0CkTWfKUbiquUSST/CHRLNzU77o0+B/Y/8W/PhxqUJfL6qTFRSH5Wx35R6da0J6/+9XfepxqwPb3gLx/P0cOsbLfNTQ3NOzUuWSJvdOovu1ffe9719fX3/zmF4fDAQpzMYUaClUTSR/SpqDLYdvt9unTp2/++mdt23vfishXX3319OlV13pNyiW3O63sd0ANy93ctu3hOClZbgwqtqCWdZsifAhT6Aop0cwQZGjh9VHGyrIzm+c5xNg0Tcxz0ySlOYQQs1rsiUaYf2B0BRA4R9UHVB/PpTYM1hWIOQjza1swyFlIkadpwgWDMwluVKUf15CZiMBEvb+/r3JaVvSKUR/1RRWEmdfr9TiOXdfVWbypNCwNQ8/MGiLoIdX3Q1HSFboWvhc+IoSwGoZqZPGnWnVTVSkounMumvpcK+2qvwQ7Zp5HcM1wPamwqX0RCcFNR3VZSvMuNgBO3jS5lbYG78wcwjTPhpU8Pz9HJ9V6vT47O7u9u364319cXACf3+12WHkEOkTUMvummctMCKlUZBEsDui+1bsDBMHdxC0Yx0MI4WK7RQyUUjo0Y9M0SM1XXQ8txlXfDl2j0Q9dx2aNc957sAGSMTODRFbRJnw6lijGGMKsmsx0mkbvm9xXfXHxsNut14MZ39zcrNfrh4cH3BdkhyEEDKALMSCquLy8PBwOP/zhD//lv/yXz58/nY6Hruum6RjnNGfBczHTpEqUx1ItH8lyj5SNWt9QmVEmC2rI8qEGi1VEukbE9U3jQ4wicpwCaSKStm37pjUzNRRu/eXl5Xa76drm/Gy7WvV91xJR0ipqm9Em7I2HhwdAI+v1+ur8wjmHTjFEGzWRxRpOMeEejcd871iq5KG5MpI1e8jH1RYkn2KPEuISE2hKMIanyVoA1GNpTUxF2KdyKp3PS+S9x2XUha6WJPdTORERSzqlFNOsqkJszCIO9JSm6ZzzRiKSQ4Fssoym6VjKXtQ+HqFti+FyzIzWB2ZeSl39wz3Xh96XFkla9Re/M/39x+nIXZCwWIn+YXOM/ymODxFwbDviZGrMMSXv26iJm+7V9753OBz211/9xV/8hUguJTpZ0soqqH5KWdar1ThHMnXOvXr16s3bd7vdwXs/hbjb7d6/f//qk0+hIlB86CPJSXp8z2TRDlu8gsH+I9/Ce13hONTnBKEWdrnmsi4ps5XcS1XJLcgOJ+2qRCTwMDElmKFlYGtMRgRRZcCwrmg5UcFFmblOF1imWRhoH8qoRFqg5fAWsQwwxgvqVNe6GlpQaHg1fHod8wD6Lvw33htjbIeevZsPsW+aenJk5KpaUytcFQA9V2YhWylfxSJwDTq05EFVWWupcomP47her1FDNU3OOccG86dFGmUYBkQ+9bZyQafxFayQ2/FLLSOB8UrcTch11YgnlDnB+MF7j/TX5Z7pMM9z23kWu729PT8/B1DJzIiKiOh4PF6uVggIuPBWcJ6mjKlwRZLJzI7HLJqGzEYkA9d1Mzvn2s733YCvibCp6xvfCMKyYRi6rkHYkUOcMCcvMc7oMopxFmnBhMcFI9wZhuH8/Hye53me4GOcc1jzaZrOzs4AY+x2u7Ztj8eJS43fe6+czXrb9n/2Z3/28pPnInJ/f++YiMi55ubmq/1+j6VLpqbZhdTtrarMxuygMKyFv51Kbdg5lxpKqkrGJK44bBGJRL5JHI3ZbdYrZu66uB66lMx7P3S9mRGpF9cN7eXl5bDqHdMwdGhbIFZiJ0YpxXGekNSO4wjvu91uz86362G1Wq0cZcVQZhbHxCzOc8g9CyauAg8pq5d4LroIuIU1nk6lvTA//tmrUbVUvDhSyrIhvihC415jpmqNQblwnQz8LGJVRUiq6BVZGEYRkVyTzuuvVXzDCOnv8lGtaWXMjWEUQkCPe0qhaQY0OKSoeKaWtqviPcQZ1Tthwf+A40N14fKFHhl2WjCKPjpOhc7lbz8IC37HUd/434oU5UdHFf2ARzYiM5LWt0mja1pxEubxiy++CPdvfvaznznnUKh3kkV2zDBhkOmxRsw0TY33Xbd+2B26rnv27NnNzd+Id7DX79/fPHvy1Hm2lJwXTURFhm3pfbmUQquXSqWLF7VVKr6NCoKKbR3ydKasp+G9Z6qYZE55qyEjygNt6oi3aQpTiAYtV1UzhsIXyA5d10G0hktPcNd1je9sMaCJy8wcV6BaK+MTaushrvns7AzODIKIeM7BjKjPfI3xiahyfXHB2+02la7feRzhhlUhMpClNkTk/fv351eXsALrvqMC2LZtTj0pnYDcrutC0WlamhV6/CRUWLgGzlhG7/2uzKWPMUZNMGdlAQ25yHo9EOnDwwNIQzXVbtv2cDigks2FlebLRIQacKDeeXl5Oc9zjCoi0MtMKbUt6sSERiZfurcR3xBRSgmQwH6/r3IxcI2Hw2GaJjQNX1xcII0Wkdq/SIWIkMpcDVirojPF8zyv1+thWNdqCG4Zcui2bdVyDo0MntmyhxBBtRvl5PUwmBkuL6WE4YyQUoFTGYZhs9nc3Nwg0np4eNhuz9cit7e3ZnZ5eT7PWb6RiPq2U8or3zbOpQjeWdM0P//5z//iL/7ik09fnJ2tv//Z99zaIQ7josEpJiKSUiimHMEum4gxB02UdB7D4XCImjUogMljEgDyP3PiaNE/yqISSalrnPaY0LWOMTbOY34XMzvPXdduNmvvvUgORhka0cRJU7UGRAQH3Pf91dXV+eWFpZNxqD1slvlfRcW26ExBhs8556TGFrXySgUgO/HRqFZnsrFSjEaoAbpqcA2kbCRG8LkE0PfC7GTQDsFl0zRQFuOCLNYwbnk450pLcDaMGcs9MUPzF0+KJ7SZ5yL9FqYYI7qqwM0Wdom0AoRSmN6udB+BY8XMuhDcxoGl0O9IXuFK+HHGDMvMC6Fy+l1Z9bfnviX++Ycd3kgY+o/ERqSmjnPYeIoUlqf9J0ap3YcYPUpExJwcGVESYSKXjNr+LPrh1Y/+5Q//2W9+9lf/x6rzjZqQztPkXEOkRsI+E3AcGZNN0yRtP8fYOmuaRhr7/uevvvztb+Dh+mb1/u372+cvXr58HtNsrMbqxdetzx+IXpWH1jRTJJm5a4i0maYpxSRdO88RaK0ZE7GIM8sU39VqhXqYiIQY+4I3ipmGICJt0x6PUzRl38/znIynaQIhIgR1vks6x6RJjcXN0+QaFyeMCfJCxqZxngIlJJ1g8VQXG+YkIn23imHnXdt3q4f7t13XsZOoabPZhBSBgtZ+wUonwTMA8amUDOPom6Yzyzhz27YpBPCMnHPqPZ7nGDRqwoONGnDf9xpiTNo6CfM8m3Vd6/0aw+1jjE3b1mGfcGZWgGIpLchEhEUGJqyqRjRNUz8MWNsJBM4QXJ2iqNp1nWchs+k4rlarmCK8zsPDw8PDw3q9lpOwETMzPI2ZZcg0Qxcmgvl6jJmpgEJg3WA3cFVI+pkd6MFN0xBldNr5BqwrM/Nt+/bt22QWcoMm7FdsGqdxvthuiAS3A5pK3gsA/KZpztZruNvVanV/f+uK4iOpCblVv2YT1ZjJt01zcbGNMarRat06xyGQqnnvdrvdixcvMtQvjbBnZuHkxDG5J1fPzOzrb74chmF7dkZ6v9/vvdAwDHuhqMZs19fvvPdE3HUN80bEmkbOt2f39/dNi3o8N00zp+hY+qYdD0fnXOO7w82hb9pE9s03XznnXrx48XD78Nknn65WG2FR1TlOTZflnFzuDmBmdHvner8lSykLyJT6DtW0DNtGY1BVpkRJlBkoiAhZ53hOnsn7tvWuPPirSomAx23btm3EezHWpmUiRazHzNx6Iw3zHJJOczwcJ+/aJ1fPzjbnjnzQMM4j7iCi3spUCiFMh2Pbtm3bUyKOJFH7oZ3nGX0NRMTsjEV824jTpNG0aVpSBcwjIjEEZhdSUE1t550Ren5UKWpyTSfiSXia1cyCkSVOieFYkdw24tqm7ft2xmhzYhXpVisTicrJHJtrfKOkjojYNM1dO5DOTiSlUJqzTVWIxAk715Bw369EXEyGx98sECkLJY2qcTpClyauV1tTUSbnGpEcM6Ghywr9G0+fcy5pIvdxDvktHStLD6OPmia4BsGxqAmd3iKYzPFBGzGKosA++dHvzdzi05ZZwbcm08zsMcQ+xaLwDhKU/DfCiP7OgwvDfr09+9N//a//5j/99fF4HBoX55nBPzKzQnAXETa1wvIlIkR2QrZer1+9evXLX/5tBU7fv39/fn7mG0lkXj78+t+BSJwOX+amVeB3GZ5bKbrwgvSPZAi1OqQsGVxSHcdZGs8Efo045zA4BWhPfXSlKF0gjSMiS/lDnfO1VrpEjXzTIoPBezFXp+/7w3i0QsZGNuOLeiVwNrwMalDH47HrBhSDRQT8CHzNYRju7+9T0QAyM9gIowSClWZmEyHN8s7VmcfInJCaw9vhN5WyjvvYdR1UEs/Pz2sBu/KngNbCqyHcqSaYi1ijmfmivaeqc5hQt0aMD9rz8jK4qF5475HyhpDwey30DVy5FEFKwOn1IxBMbLfbm5sbEer7fr1ej2EGULxarXBa6B5fbLfv3r3ZbrcoVKMP5/z8koiQZ2c/5BxK+MhoITmy2WzQuNl1XQoRsQuhQmEmIufn5wCB06L/u5ZFUFHGrTw7O7u+vsa+ur+/x9oiEgIe2Pc9MuDVasWuIdKu6y4uLm5vbxFj1S61PMFJabPZtO18PB77dn08HlHgSE3yjRwO+6brNpvNdrt9+uzqi8+//8knn6QU1uvt/f09vgj+ezwe8aBhGjH2OfZtNbJYcFloeAEgWSapH2Ry2RLSqU2OmdFfDgeMU+GV4ls2DprqaWOI6G7f7/fTfOy6brs5g2rmfr83ygLUJ5y2pK3ee22aEAJ6XgHLTyGzr5NGvMaXcZNUSJE1abOFBAK2BxdSVTohx8kU6s4WNRmxlhiFSu8v9kBZMVe7kwtPU1JKYqRiwtw2Tdu2pLE+6bQYoCQCxnWG3Kgwm+wkLx8OhwOuMw8FL9jS6eIXk4lpUfjjRUH6H2qoeQFqVlta/5R/r48A7g+caDWntqBP/Wc/94PDGyVM7PnujJuyNvN/5eOkRI0LdkWb/rPPPvvX//pf/9v/9/+r845dM+4f2t5559U4lRKmJtUFtTWl5D2rmnPus88+/fLLL+ETx3H++utvzs/PPn31UjXFRI3PTUf1OuoSn9adlcoMDVoQH+Z5AofeFSIiEUE4s9423H7n3FiG3sDVsQg0qRrxRCnGSNCATXmXM51GE+L8aExTVbR7Qg4acRmVxv+mzM+B5QLNCncfE2oBe1YEm4jQNoOmCy4oa8Ukiej/z9x/NUmyJGeioKqZuXvQJMUPa86ARqPvXMzOvu2uyP7o3feVnSsysgIMgEHzxuk+tOpUVWZlZhAnZqr78JlpWETmOWhgeoDrUlKSGenhxIjSTz+1uqmSn2Lv/e3tbdu26/X65uYGeUoiauetCEFjpZSAdVJVR9zNOmi11Wqphbt/HMfVfIFyGl8A26CSQGyz67rFYgE2sa7rbm9v8RacG54nDKb3HooqVL1TMHSzbjGWBhjeezBYQZLisZ1zB7iyCCwSKJIQApwGnA9vBjhhpDml5JUx+8AA49YgUsWTQHtBa+LVRARVK4g0wBKComqaZij9dC1sCDMuThOX9J4UNtBxHB3lwZzNZmOcELHAUECNIaSxXq9Nxi0WC0v5X11d4ZFQmR3TSCxoCIjwNV4WTrkL7Wq1iDECTY3XQQxguVwy+wu6vL6+/vyzL0A24sjH6LvubD/0AOjd3t52i/mzZ8/u7u5Wq8Xl5flqtej7fpwG0QSWEhhtsFaZOcaprjKwbYgJpQqfyBWTMzMf17JyCEEq/H+K3iJGQGtj/5o6dwV1DNBTKlx4MFamaYrj5B3P5m3bZTrYcerr5IgpLdy9Xa3QV1Hk0EkCh2ncrH5KNJgKDQsflwg65wzFgvaRuBES51yuiZ/LO6r3ITCczoyBEhFQIWGucw2FRsqMQFRsWTbTp7YtmDmRzpvGey8CccScg6wsKuMYd7tdcN42V6r6YKbKOMBmNLVHX6+ATVN+k1Kr5LkWiIBWTIJCSkrBebum/X8oHao+5Hs+7r+ojFU1ZEIDtOWgA+zI5j07wf+h+GhoOS06WIsTCT9jtlz81V///De/+uWrl58t2rabLzH5zpEoi0jjvFQWCt4upZREReTi4uL999//+7//h8vLSwivq6t3T548CY2LmprqMWrVS8cjXs8E4o2lWOiwCFJhfZMqdWp7RvTQHJcqfgkp6SL2mlIiMageoWciF8SEjUlKiZSIvAilQt8PbwnYq3EcEVesVTKkiRUAOOeYGNBElC2CVISKaOu6rtS2HuHUIEqoUNvAY+ZCDW1uNF6NlZqmSTK5DOByyxJHpSSBc5MJaCAAtrHDERA20Wl44Fga5NlOtoQxZgE6iUp3BKRLEcLl4qXBKURMIoSA/CvMc6hhTIqqet9QCY8jomjcmUXOugJC7h8/fvz27VuERhBg32xu9/v9qm2apoHCG/rcKge1QLlcSkQK/R5eAXXDtvZyFKHEKlzp+ofnbEODafXeN5yZScCqvVwuEUXAvDAzDBoYK7PZbBpkivH8/Pzq6qpp/eWjc4y8KxA86BsAr9q2jUKz2YxI1uv1+fn59fW1QZBCCC9evFiuV8z++vr6yy+/7Pu+3+2vr6/v7jbnl8+++93vPn78eLPZ3G43v/rVr2az2bc/+rCbtft+1zTNNA3gb7L9K6WonSjD2Ww1IpWI+bL9a+rK+Atty9hC0tLdiJmZkyTrcEo22vVyMg1NSZLmuFGcpmkYSRR2IdAPQ9pPMTNOm4oSiRbECiG0heYFjJhT4WxPhUvSl3oK8EJT1WWcCybDlJ+ITEikUa4vF6GkSTUrXaekdIh31mLN3IOUEpWUcAnUO8lo6lwclVLyhZxHyoERTpQbcjA7FXHemVby3ktMsDaEqG1nXYEEciFuK8ObOY64os2y0+ghRVsL5Pq4ryNtf9WfGMUVPXRwTgcckT7RPRDWn6L+D1g4YmI6yuf/Bx1f23OJ6WDvHMyith3H/vHTJ//b//6f/t//ry+IHXswgaemaUpJePTeM2HdHyIMjeOJXNu23/3udz/77POp9H99+/bt9fXj5y+e0qEB5OFQlcMTHR5OLA0MTAoieFIYgyGggZs1fsdin2a0S2gaMEWLCMoBhYlSmqZJiF2FabRlB4CixV2ZWUlUSz9iLt2+yrS6gghtZzPnHEqA4EbgPdCnFsrp7uZWRFarFW5hEU4pECpVZT4kSqnUX7pSfopyF2Phhz7z3msSDtT4kPXEmJsIjeMAWv8kMqVxsZxric8j9wOpagFqCKnMrjAMpdNqHNHsvQT3oO1s0EIpX44xto0HJKrrujHmlhWYJqheOHNEZMqVqy6zUjq7afHRDfA1DHlvo/NH3/eLxcKV/pgYzPl8ycxXV1ewHg6mYUqr1UpTSmlC6B48Vs65EHLQgogQL8EdTZHgTccxe/+YBUwcLLBhGLqmbXyYpmnsh3k3izFOw+jZpSmSqMTMqtH4MD9rb29vldL5xRowtNVqpapw1C4vL9+9e9c0TTNrbu5unj9/7iYiorOzM0ABEGy/urrabrfPnj3z3i/ni+V69fTp45/+9C/6fpQ4pZRub2+TEkB2t7fz9l3zX/6v/5e2bVfzWQHkS9P43W70pdTNpHMsyPyiSA7Njy1kassS00F1zR6LEh/WcG75m/sCYlegH/BhhTunTPhnWgpSG8+z3W4R5gFrmIXHUegsOfU71bPGzDGOTsWeM6XJOXLB4eYgDAHQSVWdb5CAmiYwciNQnJzzJ7pESmk7kApCKiKu5BmdJ3bk2dXhAxFhl5ciETlm75rgW8eHun+qbBcR8Z7tRqZ9MVneNc4FmBzeAaWf5RXwz0QUJV0sFjCas44vcQJcvyklEidekGVha7V131M6FuCHD22ITKgmFcjV+188+bqpTrWQAxH9a0PQKSWEYSTPPREJVpZNx797JvhQPmQH5/pgr5TqFUDMxL6dLX7wo598+5e//Piff7eYdcxOidSxL8h45xyzwwI1+857L5xiGs/OVj/84Q/+7u/++2q18t6rys3N3cXFhfPkg6+NklofqwpXXGi4pwjKQBvn0GZMmA/ysVTu1QZ7JpQwjeVciLFwQBIqLA/RKpKkyknFKxMROyI5wOhtNfgup6kcBXOVKiCJM/PZsI6ptNtzhTICO0FVEXCGHoLahhTDr+aVWl5AVXe73Xq9RugSA4i7pyk2hTQKGUQ8Sdu2nnjRzVB2DC3Ytq13uYM9XC6oHITHiw/qDawLrUYFLYlhR7rUpgDBiVQo6amA2CE1zJTRTBXUcsX4Q4easRxpgE2A13RVhxYqplIsbFxE9O7du/V6vdlsZrMZgOW73S4lcj60TTuO4+1w613uJey9v7m9nc1a6M6bm5sY4zAMXTfB5sBdjAYrpTT2vStoLxhVWDbB+1A6R0E5LZdLuLygN8H4WO2ZlEoqPAZC348ePRqG4fr6GpmI7XYLM2V5tsyVIUR93zdhvt1um8YjZ+G9Pz8/f/z48RSHlBLot7Dq9vt927YUqGkWl5eX4HAehqFpfNPkjpYxxq5rYAk551arVQittVLQQo9KRCllYI4vBNQZZT2bmU8G9YDv8nH4SnWiRN4F55mZnWOD2RLlzLHtHVsMlWw5dMs2U+koQZuiJ3KNnyQRSQgOaCBbbFh7UclWEW6qTBjeNOUOwbUFmcpq9Me8N1xFp4tSJMTaiIkUVkbmRbD3ynrIMWsWUKqaVLk46JC3CB2qYyK2eooYp1haj5tCcs4p+TonYjIKoma33SOO4pxruxk7n6KYyYLZkUwf1J58/UG1+uBR/8msNLuUjRiDSFwq5VKp9tPrHxMV8734Mx3r7697vPDHP/7h/fffX6/P7MmIMs6rvtt/BBrr1BU2HUxcNaQkt1wu3439xaNHP/9Pf/Pxx78Pbcd6QDy2PtgQ20uxI2ZOEj25MSXH/Pz584uLC2RGVenq6urx48sXL16kcUf3TKHK/JHsiJbDNmTbtmnouTQ5MKWbjcriNtkGEKEYJSVr5cvKTqsidEiNNE1EpOxchUSwzZMKiw2VIBPRoWTQFe4k7GHEhxGchBIFfgfw7Gma4Boa7AgulKkfk2Jl/SURMtcQEhauMDS35RpDaY/oMzXV1Di/32xVc9XvbrcjzplR+DGmg7VQpZtjmo6xbLV1ZeQYWgUnDRyLKDoCABlTzZnA0u6CJwRIBOa5FJpcX4hBTP3DLLAsIBcmJshTfB3DiGgzGJFgNGy3W4SdodGhuuxbeHIAeQ6SscQkLLMAA8UVNkH7rt2xbVvnqeW2tqjA7Ii5VtXFYrFarZAwRgQbhtRmt52maT6fX19fX1xceO+HYb/ttwBzTdP0wQcfbDabu+2ma9ppmgDBY2Y8VduFUkgap2mIcfTe9/3OZXs0EkgIvcdcw7OHnAMzzDRNohG9qtCmwrQUJlo1Mw+bAvbe48VTBbmy/UjHUhi/hoOTZxL2QDfL5aCifTVJ4hx6RWB/ktxa23vvHKkmp6yHLaxmDNWWAc6nEp+LpbNZlOwRTmXh2Xamom7retkTzyxlFGSWWuSY1ZGrXWRhZqnezTliPfU1YdGGEBJejVg1OddaAmsqPVipJLBcqen3vokxogakOLUkIoCSYL6WixWXqLIhS2zKAH1AgUgthKWUOdnxoJ6778jWQ2QSgxyzHhITfC/CfHoFUXKH9YDpcPQvKN0TdR7+8R//UVW/851mPp8rsSbxOWvyfwYI9KkrXOngvDeY3Cixmy1CCN/9/vd+9Bd/+fHvfruYzxWUOsRcKyrvY8UpCNHQNF5El8v5hx9+8E//9IvVatV13X7Yf/Xm7WK1XjaeSgl89RRf/8TFa+y6bj/0zDyOQwjwkA4JG4MFgZsmhLYW5c6FpJEyyBnUnGQqnFyewixWCg6IyobMJrmqqsYUga2FryOlew8WOlwZAyiiPMb0CrW5Zx9VKTcqlc3YFdfXN5rzx1QrJx+yG4fXRC4zpTSbdyEE1TSVdoepH5rZTETatoPEFI2OHYyDGGOSqe2aOAlYosxLgzeMXHuuwYjRwJMmpAD0pcI45tzBocEB0gnn3DDEQgeYSTHNlYH3CecPvwLfa8MOGQT1kKrCkvV60bYtCJNDCH3fz2azq6srmBcZDFViyESEc1CVBLjZ+fk5PGC8EYwG8+nt7k3TcKnRwkLCAzelnZRzbhxHHVPbtk3r4dqGEFarFTSo5T5dqQfdbDZdhxqz5nx9drfdMPM0DSG49XopvPSladgwDFdXVyKSxG3jDv0Nt9stbA5m7mYNGPaHYWj6vmlbGGegVESOJqaELvGppGmZPXN28pqmoSkXkePxpGTiY+HotuVqu+P29tbEuq9IGalKE3KFzEppMryVaCo8DwdnyAQovuKYx2HY7ndSOohIBnZpCDlVmSoiHaEjj8o5x47YESl772WKMca+3wH3Z7pBCkW8pX7SMa8tlwSw7Q7OrTjIQE9C6jRbb2TQLXdQBswKsW8DQs75Mkql+oCUknOeORdfqKYkU62A61ECyeA0Re8a1/ixB/zCpwJYCyE49svlkohUGY2HYWFbMMPI1QlK8muOWuHdV5n3/dH6/Iym4SoZcXxl+6RW3k4NeFq886+549cdQUR+/etfM/MPfvCDEIJzOfucLYtyRYRivvlaqfSSw2GG+f/04U51sGpRgi7JGEJQbUTj2cXlj3/yl1dXV/vNnXNMokpCxM4zKcfSkEdVRZIUpiQWRSzlgw8++OKLL2OMorqYL6+urp49e7a8PFOilLRpApEAo5FSygNFR7NCRM7n+iIIytvbW+99jKOBQfAYeTdK7majhVyJ2Y9RCuyCVRWtri28k1QoEfg3cqBGmb0b49Q1rUVQEdNGdz/IX6uUxaPC2UVy0XsP8PBut2PvsDfW63XXtJvNBvIxhHB3d8fMCJ865zabDTiqoKucO/BoOk+oDGkK1RdsnfV6rSlO04Dx8blIxogsciMUdrpcLkMIwGgA+QwBfXH+CH1woSRSYfvCF+HYYTNjVPf7PXKrdYUDdooJcYyMKde3b9/iBU2cURFzBmlOKdlIElEIYbPZZIoAYGS6Dk4eKH7gGUO5qiraL2Lf9n0/Wyygq9brNbw9PP8wDM+ePTFwKTYUbDjU7WQ+isJ1akuraZqm8YhAiIjz3vhhiBjt+aY4DOMwm10iQ4zZn8/nu90OVoL5QyJxv996z03jkcmGtH3+/ntdO9/tduMQxyHutj0zJxUR8f4CC2+z2dzd3TVNsz5bnp2dLRYL8IqIRPYuScPqrKQKkEmLVboDL0RAJSjGBA2qsYZhcMAUK6o3a6lpyvUtZlhoYXcyhW3epBbgffEhPXy+cZgKaN8juoAlpwpdxSnRbrfrh54qakYiCiHbASJCqaJd5AM3+DRNSUqNosvPYynk5XwxjiPOh9kRqtr3OE3OOS0oB+xQKe3LHAp/Y77vMI1MnohcOGp25AojfYzjvJvh7iIym81kmohywQLqCIjIez8OPaCRIfimDTHGGMeYxqn0q7Yrjyl2XeeCTyrImpftgxro2Pe9UjaRmVmEnNNuMR/iFGMk76IKE8+aljxmDVf2Y0pOMxUaP+Rx1v7ryV+lAo1i8dh6S8doTSqgqtoPrk/IRkYSrnDBUlPT3zNHyBDU5SaBPb27vX57/ebb07enaVouliopN4Gk3C/qTzx8oYOHJv4zaV8c98LRSkSkTN4FJhLfBJ/a2fzi0eNHj5++HocUR+Uc2wkheGfcp0RETM4QXaKJhITdcjm/uDj/9LPPUQAqSa+v3j17dA5lpqoi6pxL+TpHnbDs5yzmNEehAUytRbMFnczYtKETISHRnI90RJoKkU2KQsSSEw+HalcVEhKKYrLvRHPs9/vLy0uLiMKXevToERWJYJU2UIdjnJxzqAegIo2YGU6hK1XwKEiQUsAeY1wu5/gkpeQ8kSLWN7Zt56oaTZJko9G2rZI12WWkNodx/+jRIxT5sHdmy0OMbnd3+31vShcjzMV0BYrHqp6gI29vb4GJQ+mqxQA8io6mARAtDIjxYGNwIE2g9ixKaYKbmUPFlAs5iPPxYdu205QMYwz/DMoe/mglLsUV3LVJxrwOReD+YkVN04TBMZh3jBGtnUOh6mRmaHQQoZCoZUxhPyFyQIW7GCYUXhnJ49KPYYGYOTb1WPJ8i8VqHGPwbdd1r1+/hlbe7ncwyHB3hGctwO4LGxfutVjMgobIGffpXZMoTSnG3F3Dp6QWziEiVR7HadgPuIU5oHSPDrZM3FRSPHpf8rpjOE99FMP3wM+KGzUNOEzYGJUBoBn7aYxTqtpZEh1lBFVPyRJxTWQ3VBUtHWOMoQn7zfb29jYW/oCmafpxkAKT5gJcmqbJ4xbHwp0Oaobs9YUUSV+qlEFtKzCz6oEhEoMQi9cOAjWkIaxAIAQXQkD43YbIhlpVE2nwbRM6yCh7a7spSuxUFOGxpmlEEK/O7DE2uVwKGejIp3TgA7QPtXJSv871xDOY9rVBA+jpwa+YDPy6v+Zzij6qZ+Hk1g9+MQgTeffq1as3V6+fPXuBp/HmAR8d3+QE1+/vqqjvNz/3v+Z4AB3NSkKaDQ0f2mb2/Pl73/rWt/a7ze72WsVRkhhH24cCkBklZobxVdYNiQqz++CDDz759DPz+d5eX93dPbFSEJeRXNFe8P6Rl7g6IgI8x3rIU9U43axFoqwMcnCMOUZhZnJMSmnEQ2o6dKo/UEgyOefYOoUZ3sf2qqoCw6wl6ASv1Hu/2+6x3M0RJCIrs3GZxDjHlIDrloprwuJCb99eO+eIsk3NFhAryWYpAAeEl7smt/+DoyYSNTNb5ZPv7u5wr6ZpttutJZm09BoCI3zTNEBrw5PebDbwICHl7dZwi9H+CNyNli12VWE0rAp7d1+oQ/GrPQMGGQrVPsHwGtzMl66IsbRbh1q1X7fbrX3XllbJuDMiz6BxeO/582HYY+XAacYkGmIOZi5GCQFwGDpc8Lq4slVNjOPow8E5QFLf8KUQfNDQzAwRGULO3XIGt3fX19dtu1uXwPjbt28/+eST/9v/4/9+QZfTNL19+/bly5d4nn63h6Zfr9fe+zjJMNwy8zAMZ2crBPCZPZMn2mMZDNOI9Y8xb5r8dMw8DXkYTVWkAqeoP+TSBdkCS1pQyrY4bT+64/ZBzEzkY5wMWGAnWATYdlZM0zAMKZroEyJJJFxqjE0mqGOn5gEfiJHzTgGFgB56bGNhoHgMCrhEL3ImaJomBuNN0SWmVOy0rMZIQdZo8pmZqaC+64BlUuKSUTWnECdgDcQ0DsPQzWZEwuydZ8cOdJhWspzNZSYWbrqmbdsSQM3lGD73pBp3ux3qNbCFmZk8uyY78cUOYxia9vx20CEi/QBc+Rv0jo2D6fhvJpO24X3wIqcn68N8Gd+gv0OUNJvN9uPwu4//+fHjx4laVRUWR8UJrl09Ev4aHVwZU1lO3d7ewtP6sx/1UnPslJWV1ZEEOTu/fP/Dj95dv/3D3btxmjypZxdjFM5doUmV2YN3VHMciYi1YdeP6cmTJ+9/8N6rl1+FEJJK3/dfffXV97///ZSSiDZNTlaxI5VTa4AIWw2PKCq5AysSbFREQ8niJBTwuENRLDxiH+PI3jE5IMnsZV3V+JOZJamSkmOz3VJKSaW1PJAmVe26nKjb7/fILMKCHkp/YsvS4SKIpubhlay2obRMgTFzHfJCMphL9Ck0zjnPwbCaaZrEvDpXmrXhzGHQ0LWI54/jGBp3eXkJiDWCY5Z5nabJKovY6TQmRK7wtKY1YR+YR+IL2QjSiogtG3tzjLFtOgv9mVWEkTFj3AxnaD6t0F4Gb+FCZ2gOAefa69zzxyK3cJHNyun3o2uC903T5CJmLezfUJng4Qql+1BKcblcQhBni4QZyLW2oFcWiwXRDG+tqsFnZw7Xz6iotsVce+9TGrG0EMRu2xYAmVqTed8E14hMIjKfz588eTKfz2OMZ2dn3/3+97ASnj592nXdV199hdqkYZ8Ds8a3FdOIB8bchRD6fowxjkPMzm7hqooVKTHzUXMCG/C8EcqftGq7aZAFjNg0TcweI1m7QffFKBcHMZsyBWZjJbnsqHGNiEiUcRwB3fGeibwwcTrShXZ9YVLHdcGCeXikwP/krsnL5TJG6TpqQ1MHXbSg9E2SMDPda9fGzEQOYV5mRn9755xkBj2Hwg1V1MsclLeICLErpNO+YACdJx94ioPtPlUFiBVBeNEYY+RijHKARZVbqkxJRA++NTOz0jgMMeWmcLkPW4ohtN41tY3lnLOk4X0FfDJl9Yf8kM9af6KZfDtZIZld4b5y5eN4xskP/6Lu/zptjSOopjFK0zSffvrp06dP/+JHf0FqauRffdhIaYU7/bdd6qGjIsM6XFbNVhKR5XL5wQcfDdvt7dXb1199SSk2IaRxwuoSEaennrRzpOocu27mU9Qf/ehHL7985YKPY3LOvbu+RRkGESEshi+xOuJyHT0MF2SW9x44SrD03d3dmVFZr0UqBSRI91KBSmpkg7DS8RRKATmDZr2G8iXj3WSmggmAJ0cl5wooVt/3CGZCN8xms7u7OyKaz+dRMuezcw63QOYG4hgaCKm11WoVMwdTrhqC/a7ETdOgeyuCrqhphispBTEEfYlCZJBUd6o+MFoZYsBRXEjHeyPLQc4uOOSCqiKyGmMEC6OWkmVgmgq+XREB1tJ6YZom5L/HcRzjCGPc2MG44vnDgYuYbkZ7GUuoGzataRpEQWGaYKih3pC+hQZS4ZSSuoyyadt2NltDyKLjAhE5525vb6EA8I5Ugd5VFWhqeyQg6cZxtEGwP+GVU+EncaUpyDRNKaq1fICJhkKpvh/7foQcjDGiHOji4gJ8KSGE7//wB+v1eYzx7du3wzA9ffr0Zz/72ccff7zf79m7NMlqdSZW00meWMZxvL293W49kaAxAzMH3zZNI0lEJucCgufFsJvieID51JuCC0Cp3lO1vM6BJVXnMpOwCfdacGvlROL8GKPKQc7gpv2wB8hAM4BDUqVx62ueiD58oo5rhwtWqRbm15TSrGmZeb8fnHPBB7SvqIW+RWio6tZ1/5VTroZo4Gk452MczTqkyoJROTw2bJj6jsSCEB1c0q7rlMQH3zRNcBxjSjJZ+iZ/g3LG3fsGErvYo/nzGAcEBbE4D/DMWfDeD+Petrk/biJ3okr+DcrFvpJSipJExZjQvu58eggL/XU/f8N97eeTk0MiTRJdIiH9zW9+8+j84oP3PiLLKv/JDFj2HDBCm6Z5/Pjxn1X74jhVn6KiAjvVOeeoac/Pzz/44IOvvvxgv7vbXF+r0+A4MQm5KKllV+g1AKnGDLgUk2+7OE2r1eqjjz76/MsvICJ3Q//ZFy+/9+3v+OAhcTJlTM71PGBBnyjL+Xy+3W65IopLCWD+TFFJpZt9nmzHmnJYUotdSYZDJoc9bMKiLOvsQ0D71moeYUBQCiN6bKpUVdvSaO8wxM4hQjuOB64AxHJjwZDjylAJ3jOirJKTo5xSYlEklZk5JQNMZmCzqkIQp4wE9k3TzFfLxjOgXs45FGwgr8klZwxHNmc6I4POUFVvbm5SVa8FJW0JXSICDSResCl8UtM0dW1QVaSNjTc4laoVEy54AOCVqIT4iGgqtFMYXtwRf/W5SVSGhYsIKIJRZjOOI9iGl8ulMO33e/j6ULFQt1OhpcRdcuGsITALDA11Vt57QIuhZff7DG4fhoE123nb7fbZ8yfr9VpEAMXCkGI6TBMQ0X6/Xy6X3vu+PzRTwiufn59TacsYQkvkPv/8c5SKgf/kvffeWywWm81mv99fvbnu+16V0Z0CK8e4P6lqXTWOoxscu9A0Tdu2zlHbBu+ZSKcpNw4yU3sqXMr4omW+62WPAxFdq/yxdWuzXCskqmSlCo1xpKImY4zOc4rI6Ac9YHYK6JryTlFV5SI55dQPK9vnoDixDgFmbEOjyk0jzExKsDk4owQOKpaZHeD3ptrtT1VRu1RRukTKjoUz2SGXONnJiOV3L+NcdttEmQnSSNSTSIZeYzs7szAyZLrLDyZm4iRmLwKi7L2qKkvTzLz3QKJhkE3omRTCIrEUw32Fd18dHtkQx0d+Zknf4B/e/26tgx/867/ZOAgxpeD9EKdZM7u7u/vFr391dnYx71BfwcAc/ynXshVQv+qf8gT/k4fjQJ4kq1Kvknnnnz59+tWrLzbX16AyZnYq6ryXZLRQzMqSbdUMwCHicRy/853vvLl6C6E29f1XX331+PHjxxeXVKW3v+EFDYwmKoi/GZrGl6oVlCQxc4zoq5NUVcmJIOp1YGOHCW+IGzNjzXLTEvPXQmZpxriWVNN+v99ut+v1GuW/XdfFKdoSn0qLtxij8oHyTQr5O5VCYaQqkWsEvtf7BgIRDzCbzZwnzRYKee/HcRzHfjZbMHNKKbQNe5fbunkPiuN4aDPcEpFpCCq8nng2V6g21uv13d2dSiZfRH0Lnjlklg8KIWy3W1eYN2BOGW5W9VCOCVwPWAOJCJ4oV+A4kwhmFWGiwRmCnWw9FoFVgRey3W4XixV6HnRd9+TJE0BsoFaHfiKi+XzumnBxcQEbwgSNwaSHYYAuLMipvMtSoSvRUhMcSp0SMwOWRURGZA1X2PjC8BVzgrU46Fwi7bFQfCNYstlsYEm8ePEihLDZ7HDC3XaDWEgJrcfXr1/jkRB+B/CKcthTVDWlvLadc8OQEXMoAybOva2mwjumpQTAFIbFmakiYvQF6iwVeIcqPiaMABEB7FO0leoxFQPl8XVKh850RBTTxBMREXKUWo4QHBFFyqF+73xSMZkpJCpqOXh7fugwswiZGbPWOH8gN6VDrtqshEPSulI5eP4iGQ7JFMlL91DYyiWiYy/rOIiIkFQeZ4nne5qilBUu3nuh/L4pJWL1gakyUkWEXSAi5wJ2EBosmshSTTEmbDfvGdEgZhamru2YGTUC9r6W03EVzs7E7H19bJPydWoVf0qlgborWLxvUFV2TboXi/5mBXfyYPQ1+sKllJIIBBl79+mnn37yySex8Pb96cfJKKSUXr9+jYqRP/dxFB7PWThRImpC03Vd183ny8UHH3zw4Ycfnp+f+3BUJ6dStkHegnjm5EOOtDjnZvPu8vLSWrtP03R3d6eqEExAGH7dk5mbS2XC4BzYJrGBMtmd5amqyRrbTrV5axc04Vj23gFzwXzg5jJRBZAqXhfGLCBCqcCm6p/hnRThEsC5H2NErNiX5riWUzQ8rYF3pKq+hWKGMwqvLuNjOcPfkOBxFUNIyv0JclGEvTs0H145hPDkyRMiQu4TzXF3u10qtJfACcNr18KWhfOByIVl0xTajbOzM1cA3tDWNuwIYqPAiQpSCT9DQHBBdeLJ9/s9EGEYEBFZrVaLxeLq6gqlSqHqhY4xBAQdLrj9Wts9yEkvl0s8MBaJRZJFZD6fo9rbpsbMLyCu8XjosWgOqBW3tKXJMcLOCHhAWyNAglBhU3UXxjMggH9+fv79738ffSy2/f7q6urdu3f7/f7Vq1evX7/mQlVNlfephSKRDgnXSXIpbQ/bDssGizPJxE7RSquWs8yM/WX6gypFhTnypXkRUgM4zZdaIMs1ZJ2kOUpsis32YypHoaNRYA8ngRAV51xo8l3qnW7iAclsswks1LFcLpFHCKFFAV4Be7MZCieK09ZP/ZAme80DziqHDl+sh04ta56IjkFnU0VvZ7LIvuK9JxYp7RSxVqXCwYUQAPWqn1kLrzu25Hw+n8/naL6EGUTsyhdomNmFtXn0oDKr1SQd6+n7R/1UXFL+33D+1x3/WhX54OG8cwl7SSYiYU+//M0v395eCSVmntKklIhECSkcAtiv/KuPQyhDS6bt6xTVv+l4+L5sxCXqVEgjswuri4vu/PzyxfPZxTkKBjWpSxomIY7MyqyiCkY1Uq/iUpTGcdu54NOs88+fX6JtAXnvmubt1fXtbjclikLQxOyUOJV/gnywFOgpESklx+odeUfn52t0YIVSEXJTYuVmjAiM05QSOR6mMUoyokQuLL5UonbTNIkmH1xom6SUlIiCbdT5fC6aphSZWYUc++AblezQPHr0CDYmaHWnuA+NY6fOk6bUhtCG0O92++2u8SGgiVgTphRv7m6HafRNSJo9eNtCntlzIomNZ0eSpqFrmnk7DxyQL4+ZPbFjTrNZIIopjiox+Awn3u/3Z8uVJ6Yks6ad+mk+W45D3G4GpmYcpGSRJ4sZomthjPHxk0sfmJ3GNLZdaFrvPDlPSaaYRigeWA/QNCICEyGE4AN3s4adsif2NKWRXC46opLIxwJD8RL+Tyk1wc26Bu3Zm6bLIf1EpA4Rhf1+P00Dq6Q4jsM+TWOaxuD4u9/9NpFcX7++vn797t1V3+980KZl15Jz9Pr1K1Awdk3ThuCZNSXn3MXFI1UWoSjEvunHyCWTjcpmLvweIpLSBECQL11JQYvYdd2jR4/Oz8/RniiWzg21nde2rWj0gWfz1kaVnd5dv4nTfr/bpDS1bbtcrF1ob+52zofZfOFDk6K0TUfKV2+vX3/15u76SiVKmiRNq2W3WLbE0QcV7Z2PiUb8U5Zh6qc07keepBmin6RJ1IyRU3RMwXEzTUmitqFhPZiYDbuxH9DqgERhK1jfBTavl50jzsu4dMEqulaZVSS6qjbBQkdKQqxKwo6UJKYJPWstXt22s7adNU0n4pgb733rg0xx1rTnyzPvAm7tiFlJk5AYjZQLwRmGIId8Go9/7KhpAweepgFWYz9OY5xCcClNRGLs0wifjjG6EDLqojL3J1Fmzy5odlQO6TDYNzFOKUUihTpjp03r2y6oaowjUSHFcmrW+WzWtW3rm8zinqbISt7lVEu2xphAQE/k2rZtu1lMiZjVsTqeJCVS7/04Dbt+F9pGyQffReF+1OA7Vb7b7MhlfwMRIyn1yrUPaju0Vre19qXKNNESu9KCYx2GQWLynElHqaQY7FsnWkc1MStaYOVPzEhzjB+ENGkUSkJJNf8zbYVfjT/k5DlD/QsMjd1u88tf/nL9X9atl1k7YyKDsaVjqo0jRVhZJBB8MKsfPPnPeogV2uWxJqcULi4uLi4uuq5bLc92220XWkJN7Qkkr1hVWTVqDpw+f/78+vr6D3/4gw9dnNLt7e1utwved10rcdR7tX3ffKjqYrEYhgNgoSSQsr8opK4KhVkc1Tzg/KoiGgFNPBTM4XMr22hD45xTyS/lPCG4p6qgXUUOEsFhOEzmre73exjwWrUE5hJ9JXQ7rzp2hRAWi5l5BlDMNdAUF48xDsPeXF4ztFFM7JSYyUjpbDvhgvt+sOpAXMGi33g2bNRYmiA1TYPs5vX1NSyPcRwfP36sqqBTJgjcxp+Y7Tb48BFD4YUvee4cxtzvNs45dh4+fdu24KtarRcFuEvZMdUcRrq9vd1sNsv1ipmfPHnW9z18XMxI5wK0CCLD8Dh3ux1oMTAp9qj4FjLNiFrFUjPKpcM0XplKfpqI0GcQlx3GPfxydFOwhDQ4QKgUaEpJBg/D0M5nIrLZbLxvLi8vu6774x8/efT4MXIHzPzpp58i/OC9b5u8Nna73e3thoibNhCR8w2IruAbhaYRpmmMyr7vRyJqW7/Z7DabzbxtnHO73e75i2ery9V2exdCaLV99+6dGWGWzYXIxtS40oM5paQpC2gEn7SEMU0ce+9TEmu1WQc5bYWfOH9UfERzyMzZ6Lru/Px81s1Sn7e2rSURQyEhA8KAucFxn+KI4oKsZuTQoFAzLaVndIdwYt5tidudhkNFJCWlh/iiXCFzRtc1OibFu+9fuqILV6slUlcg4ENsuXbK7TGAt2iaLrRNNJ7aAnDB1Exjbp05m88Wi4VrQow5ueCIE6HkGoHM7mQY69epn/b+YY44GYb8mKPDxq1W7fX/9fnlkyNs3UOq+uE/VR8e7CQTdEGKsWDhhZjSZ599dn5+/tc//Ssh8VRiofS12vebh+Df7WBmInbOE/vlcn1x8eiDj7717up6HAYiDY2LU94MdG+S8D9aLwDG8vjx408//ZSdc15Soi+++GL1wx+mlLxzKaXgj15NDdd/PAJ25fV6PY7XsbRutZAvGqQzsypDjRGxhUNPhpGZiXRKsSkRdNwwpeR9IKIqB2ydeXK+M5U6HNDZE7mua6FsGpdrYX0B8cJOHGMGX4DFiQv+hYhypJQ5FbpmpBKx1kuqm6bC14iS6Bijq6QSosRpnKgQ8WPfclVBhKijBe5sz8OAkOPUHTiNI4gpUkYehdLHFyAmSyuqatu24zhJSXWnUlyLYAMko+WlELoEd7SD/auKbkUm/iDmMLlJJhERFkTyiQgNjJ1ziPSiuno/THiS29vb1epMYjRusqZpUGTVtu1QuCxSaXJsbr1m+AJpmiAEMQ5QwFY9rKp930Ov+9KeAVFrQAS4NLRAyhYK1beNc2E+n/fDdHN3u1ydMfPdZvPHTz6BiEQgEXFs0TQME+YxpQQoK7FDPyhm8r5hdvv9HpislGQ37jabjWd3dXV1c3PTNM16vf5OjN///vfX6/UwjW3bvnv3Tikhlw+zoECBtMxCsmAp1p5SDjITWNlTkoolquu6zWYjQkisNJnZKieMcRRzKpfpWxzbVq8riS0RAX9tKjQ7dQrPoilYzxYqh7Eou0xHijtKUo2p2K+orIumJEyXgKj1ZPFTVnUZj5pEDplfLc5JTCLqM7FU9CVzTsdgLiomjvce/GVIUPrCDUmGGy2ZVBHxrokS21nXNM00Zq4xDh7byint+r7ve3akkpl8mDjMZk0h+iZhHw4Ziiot/TD66RsOM5ukSvPVGrdWvX+yDlbm3KbowYc5+YodnB2tw1/tzMDMSTPPA1ANzjlN+stf/vL95y9evHg/sXjnRcWxIZAtC/u11Bz2kua5/687ytsagIIdBXJ6tr746KNvf/KHP4zDIFMchwm8P8xKxCezkucpdxEYUpwQuHt7ddu2rXp5+/bt1ePHT58+cR7waTYc9TevDFzfNFBKyQWDYh14AMxSdpxjjOZoUrUIfPDDBDF0MNKnaRJxFh9umsY3jom99ykdcrq+UBJaQpeqqAbgOfC6UICrTOBCktLphZWsrklVXeF1MpUZQmbpgpoBMJjgmqPjLBFSXJVCFWZGltrESiy8oaKN3utIUc8dLADz41En413ThMyhA1JitBwwayCzCnSdZT2h0hDLdZkWNMdpQ6mvnaZpPmvbtmXyUVAufAC3Y7WjdZX3HkE88GI6l6fDXHnLRyxmMyESkeVyzcybzQYVPs65J0+ewFVC2QbCD6k0scB8ceHKiDGO0wDiF1+ayIrIMAxv376FGr65uZkvZq4gS11hpWjbdrfbtW1OQHIBCrVtO/ZTjHEYR+/D2fnlex9+4H3YbDZPnjwRplevXr25vprNZl1oLi4ulqsFEbPzzpMSi9IUk4wTdic7H1U0ST+madtvt9v9fv+HTz6FxlovVxjkb33rW4+fPSUiwAW227uz1Tqm7OJLSSRn2cpZApgTWSKWhGFvZ52pZ0akXWSz2bx7d5stQudcYSIzFetKzborNR1YbyFYq4YDtgjx0nEch34UzqsUe9+2nu3xlCaDg5l4NGBBigfeSpFJq0bxltl1zikR5TajoGomZpj1SqSWZU+VJkCWR6tULu7rSiyBmakUQ4LrxnvPTMANiMisDU0T7HlihVimolR8IUDEroFERUEETHZo/fl8jhXLzMtuTgVUD+Zpk4q1lVOrtFpuf4OPV/stfExEmF3qUoRkgrr+OaswUrqnUOkhPf0vHQ/rwcwCH0tEdEyppeB8GMfx7/7h7/+fj57Muhmeh5iSJO/8g3r3ZCy+YVz+Fxz187jSqkFWq7Pz88vvfe97m9vbzXQ3xVFJ0VaTjmdRS+XZFGO2TKex67r333//9m6fUlKREMJnn332+PEjIR+aIKruIVrw+/Nhc4lKmL7vuyb3x4UtUCT4AakYK2Yfi73k65RODEBu56nBwaopR7qYWZM4Zs2MiblE1VxYBDBRbZnGDIhtS1OdXH+pAheQiGr4T049OscVlxOu2bYtEdA9cT5fx9KhJZXmQt65pmlADAnTwZWYGJf+EBB8XOJ7bWmibH0XqCDLYC6IyN3dHWp4YoyOA3iSLS9oggxqlVhKWi6MY68VksXkKdoncOltbH5PTs+TJMU4ZFuqhlYhkuFD/qIvTQDblJsb4hX2+/3FxaNhGLb7/dnZGSpKkWwmIlB39X3/6NGj29vbpuvMCnFV4rbvezjEphWM29mVejOMG2wRzDgX9JYtLawHIoJDbN7zdrt9+vTp3WY3xu1H3/rO2dnZp599/urVq6cvnq/X5yGEly9fvn37tu/7x7vt08ePvJt1XSfC4yhELilNEX0pRmQHbm5ugEfb7XYhBGJ3cX6RzR3nu1mjql999YZFpzheXV1961sfkuM0SfBeK0AsZSzukQClop4TEaLQMBwRGAAITkRev36tpZbPssu2YbH86mwLvmWIFrsjNikiAX3fT2N0DWDAhxonLpXrpoNrIAXQUXmz60EiQb1NU7LbpUPPaZ9SIgXdOpsmSKUTmqsKBe1RDZoXQoCS5mNwXPn/4BQ655wDA0x0jqwoCF9MMtVLCNbkfLmAiVk0KMuUw1dYVBgN9Bexu2MNN03DrCJIbC1c6RdHx7Unf/qhlT9qIqi+Tm2O6HEA2f6vuK2UiJSJ7pUF/ylHbQ3YCDNz1QBZNSCApqppCiG8evXqF7/4Hz//+X9SYu+CqFTurOm8Qkzx0NP8+6phOxyzY2rbRh9dPvnhD3785qvX//2//x07JtI0HQXSTchChqaIUncOzlPbPnr06Mmjq08//dx737Rht9tdXV09f/4cmk/A+MxE1XwUvXiKmE8pmQK2E0SkEDiHGCdVsEseuvqcWKzKZIsYCHaoDTiLeACE1OI4SYVBKKGmjG+EYkB3hGEYrm+voZ5jjAiHwG/r+36YRpAjzufzfrfHrSGszXg3hV0UmB8GseAnZWU/SklUyyEfptM0Ns5775GNw1tk1IynmEZAqPDwoarF2mw2CCwjomhNchbz1dXVlUGI8SdXYL3Y9icmRVPa2WoJTZsTifBgKoDz+XzuWKcxEWej3jmCEUAl2GgZa9Q4htB6P+AVZsD4FbE1n8/v7u5CCPOu2+8HGDdd4wHexgXzCfO5C8Eyx/BrIaGMUmoq3Qh8hVJOVfdJw3irKuaXSp1VSgnV6haDxSoiophUyc1ms9318Prq7W4Ytrvd+aPH19c3RG6xWL148YKZb25upmn646efPbp80XWTRQ632927d+/6vgenBNLwTdc2TdPO5vDgkafIGZBucXd3t1wu73bb7W7z3e9+dz7vMFzjNDnv9ZgXxfbdVLo5UbGBIN+HaUS0YLvdws1KKSHvGAvHu5YIZyr9IrHebLTtdrVaNXPNFVpvLbmAes/az9gyi8WqaIK8kr0LRDqNhRG2+KYxRlWChceszJ5I4enm4HORLSZMastVVT07rrqJSEm9Za2GShDyuZ0aIxzCzjnnqfzscQEEz7VwnptTYRLecSAnbTtT1RQP4D4ihfRDHYH3vglh1nUp5npRItJ46J+BkBsfe5Ynv9aa9UT03z+ND9nxHAg50Z33tW99X8qfOCISephqkpm18DvpsRtdTvCmF06e9hiHoprHWzVKapvmn371y0ePnrz3/MVs5vSUIUsejEU/8A7/vgczE3mipM5fPHrkPP3s53/96tXLr16/1MRJUlFgR0+I/xvno2ZT1xGHEN577703b94A2tC2zcuXL58+fQpcHDMi0XmRIZ4BuHg997YfmqZFCDRVdQKiBAaObIlLzlxaZkWZ2DEpqahjlySCdgTccloK5rz3znPwwXuepklLk5/QGD19SqWwGBsVyd3N3c45Z3SPVBgzoOqQ3kOTA5gFWcyJtG3LnLkpfMF2WiGBL3zalMUHO+dUZCoQXCiJOthbr5wpDkrZOoTcrAVZjNGAUXgqPGff97NuEWNcr9eW88ZF0ECesjGU84iQm5Ap+MQYHmCjpEJzISJAJzU++IJDTikBLwLrgTLtYrB8YYqaUmrbmY0SlTDmZrM5O7vwfnj37t1qtfro/fdfvv7q9evXZ88eSQGewLKB3nr+3nvIDeMKqdR+YEwQYFdV0Bma4QU107bZEZ9K/2Cwl2jpBo25ADjIvovPV6vV3d0de4eE9Fev3zx79uwv/uIvNptN3/e7fg+0RChdk1NK2+1WVXf9/u3bt+/evdvveghW773zYd52rqAfHPskcT5fqqpzASUA69ny+vo6xvGvfvbT1fmZTJlnY7fbTdPEmhcMDlJFINGktoggh2LRzpTS9fU1eE5UNcbctKOuN8OqMwUmpewYA2KmJE52JTcERxn2ECz5WIBvtVThii/TeFqggHHEeGgg7SqAlfeckpprS8W2yIqkNMpxDrkJdS5YXklVPcDg5TCf0jkmValexCL2zpH33odsBCNKlLNULMy50hL4Bns7sF8hwCYHCwlQMPbe73a7GCMTuRLjQfitbVtQf7c+oITkQFNTFT0bNMRm4UHJb5+faGgpRGMn80L3Ur/117NKJkecWVXAL3j/NK2UNGuqyatUs81UP7xpBFV17N2Ucp5/HMcB/LGOiYQcp5R++ct/QhcU7xwoS6pDqjsd4jP18eBI/RkPJS0851qNjiP2TF6F16vz7/3gR//pb/5GRKaU4fJm79i3DD+Jxw7Bec+a4vn5+fPnz13pYbDdbne7neTvHkUViOXkfet1UC6bwT5SUG+mWlJKcUrmbMUYxzhZ/xkLkLqCgLDoroXLgsspxn63JaLZbCaSXIXD1BzCYuRKU0q7ba+qFxcXXAgf4KlDhSwWi/P1Gbgh6xRUSmkce81c0x16uZsfPOY+x4mZ1+s1wneKzqnjCMFXxKVAAUA9IOKaUlLKreZRhbxYLKBHDXUFIQtDarfbXV9fo9gmhHB7e4tB3u12EJ2wA2az2XK5nKapH3au4KW7rst9D8vw4gmpSo1DkcOksLQfFDMKokD9SIVgC+KVi7/unFutcuMBVU1TtFAY6D+fP3+eUnr9+vWsaZ8/eYqIH5E0TWNNEXAj3Nc4NW3lUNVmAy64FH4o6GYp5RwiecBhSBERRtJSofaC5s2Dp9MxDC/39u3b6+ubvDYuLxDUEWLE/8/Ozrr5bErx9ds3v/3tb3//+9/3+2G9XkP7YvU2TeN941xoms77zNMJyQujB+v5xz/+MVbjECesLi4uqS1FvL4j5uO0hRarFAP47t07LLlpmlLKbTO0eKtUQhdaAPzYXxZeshPub2p7HqNnsYRFqto/mDLDMpbSKxpR2frrRKR6ABhTwbTHqhjBvHBSp7kp0FHG1L7ODjFqco6d4xC8c2xJYkKwhIhUSQz8nEMgYL+ZzdrsMGjmEUKkgJLwMcmXqnbzTANQzwLGzWocMNGqlqhmmLxExKKQJHzMQynHMY96Fu5rTbtvrYyx4+zB7HMTy7Z4anFN36jLvs4IICJWqmDqD1CIaHW4dK+MWqAAVPDQX3716ne/+90wjfAdlURJk6SYopISCcotmPleZfC/x8HEJZV+GpRn5zk0yrxYrL77/e9/+NG3pVDwjylCAGHDaIk+WdDJFACxfPTRR8vlXDIQN3z66afTlNBoWjX3YqJiZ8lJyraCDsFvW6/XIGqwhQXRgP0Pr1SZfHOgIKeyN6hMk7O2oCUUzLkKJUd34e7gfPMCEeRh8qSO1MUph2UsXGnkUzYsd3d3qOq5ODs/Pz+fz+fO03I1R+wXD4C3Q4d5V2oH8eTb7ZaVvHPmQ3PBWCK5i8qo3JfeOetyiGewrFtTMUp2XbderyGv4XWh1OTm5oYLM9QwDEBvYqAQXAW18iH7rgrOegRgodgsDM6l4YQWojEE3qVAT+FxzmYtDA7ouRDcNE2PHj3CyGCU8OJgs/KllQXnCO0WEX7Qd1iPhHEcU5qur98SEQQWjACDowMjjQeGerAcG8bEwOqXl5dcCGEwMrE09oE3hjFBTh25c4CoYaJheZydnY3j+ObNm/1+///5r//f//bf/tu+H2fdAgHDlFJSWi7XZ2dnEMFg4Lm8vOxmLfaRmbyI2ztHKMadzxZwidq2XS9XMGt++tOfgholw569w894eCoRVxOLqFy3jW/JFyJ69+5dmW72PtNiQ+cB90dFFuNDE9ZT6ZxBBRJsQl8KqhkBBqwNLUHgVNp12M7F5zB9sGymCUSeuZ0J1f2LRKjwoJnZgX2Bqm7nnHcNnE4iUqK+1DVxwUJKKeZBcCiVtlH2PGOxMjFgtusxWev1GtRXZ2dnRMROrawUbULMZBERMKqGEJwLIlI4P7J14oPrhz0mLidTCsHOcrFGAgtXg8rH+ncn7CiVRK1Vr6omFVTiCqlV5ZJj9i6pCOmU4t12048DOSZ35IZyhcyaCtM4VXq91tZ2a6o0dP3hyZ9YnSu02Cd/rTW9I1FNUn+TEIv2PlECMeGvfvurly9fSgm0EilMKjqAxOwh/gN08IMAM3hrksg3Mx/ay8vHP/v5/7ZYnznPy9VCSfop812YdYbD6dFQQOVcXl6itUvbtq9fv76+vh7BgOqciMSSmHT3qrRsRs3hWCwWq9UKGhdzn5UxGL0o+9Un6yzPNJ9M9mGCncEpE5risSfWmEkZuQAu4nQgU8S7x1KWkwoFUt/319fX4DMax7HxoQ0N9BNoxaiE5rz3cA+AGeHSrY9yI7nG84HvFzscQqGMTTbbYSJkx7HJs9k0DfwqmBRALMcy7AYppwr3RET7/R53vLu7w32p6LD9fr9arUAfzczohAi9BbGIi0ipKqayUSER4ItAa+LdIYyAssa7YA+jpAfTvdtt0FIQbyEiElOx7pP1vUcKAJOCSqE2txBmpHtrAx+DbENqTGQQW1DMl5eXuALmxTJwWjpJmCOupWLbF6AAUF2IOW+329VqtdlsfNuklPp+XK/X//D3/+Ply5d937fNbLlYz2fLtm1d8HBd4NtJSYcTq2hq2tDNWiNTs0XCpKzUNW1wHtGXy8vLtg3mgGaDWA7mLBV1lQolXJ59OXQ10AK/ijESOe+b2n1ERMR0pBZaLlsAtvuyTDiuR6i/dXKmzVEqXGkYSS6l1ekY8GVfx1SKUCwdCYkI9WBYNtvtNue5KWeRtPjczJxEtKAgMX1t2zZtCxt0uVxaU86UEujWNSvjTGHrnFNNTdPENIoItp4lUwCipiS+9ByDqMRjU6Xdi2JjVQUm3JhZsc5xwa6dGzse7sLBWwTiRL25P62URqtDCmQyVUyl9/VlEaRHavLBc+ghxUwP6WBVNpVkAlvv+cF5aclxMTWVhTVlwJgo093d3T/+4h9vbm6mFFOhsXYM6gjjuvoPUb10rH0Pz5DNEHYIcC5XZz/6yV+8/8GHgIFYxAlhw3qC+fjwTI0Pl+cXtujbtru+vo4xJlItwP1UhAUfe+EnzwNDD1zHVNgoo6SYBEacnXyyEEUE7TNPrn+QEXTY/1xC4jgnWbdwyWlXLmgsbHUt9MhEBJgYLGhkgEIpwiHOtkIap0oBE7MaetkEnKpCICaZ7F0QhWvbFlgPW3hcBdJtOrRAXi06WrjrPNKB3nv0CcfGhkpGDgn4mu12d3e3efbsmSWAqZSQchUbxAviV8zO2dkZUEi1ANXiCpvmg84Df1DTeNXcLLnve3jbuI5lxE3OYsBjjNY3PjSu7UKTuU7l4uLCHfC3EVSUXMX3zG2yBQwNqhUzMPQfZpNLlrQp1CjMuZWFZU+h16G2IbkwX1dXV2CyhB+PgMFvfvObv/u7v/vd7353d3eXUmLy3jWkzjmCTDfrx5QoEfngjPupaUPTBjxGCGGaBhFZruaz2Wy/3yeJ0zQZP6VMUSRbnFTcOPzJqubGcYzjZCYaZ9czx34xoXgqKGAMFxUDzqS23qO1p3vuF99jovi6jV+PgIikNKU01eK46PjgXDAjDIsEM2g5Bc4Y5iORoiVmG0LwFWELEcU0Il719Nnjb337w/mi2+7umtavVqssZIiICPZojKPh523l49nMK/UFKiWl9M5xKJu3ZWb4aFkFMsGY2+/3SsLMbdfNEH92Tdd1KfdzI1Xl4E/y8Sf2zYNK0b5+8kX7FcvYl7ZaVOnLkwven/Gv/+spJyNiziXyfGorPKiD7WpGk62qBy+ejLqMVETmy8VXX331i1//ou93ZlnAZVPUwxDg2lKe79/zOHnhPC6wwpxvVEi5Yd8u1+d/9Vd/Ddyvc040W7sWX7pvnuDztg3rs+UHH7yHlbdYLN69e3dzcyeJxhSp6r5wcoX6Z6nKiqAt8uMqpXhYiOUKB/6dU41LD9sKWlIs+TGQ8Q3MJcfGhfO5wiIdSl1ToZQbhsFsRiIy75BYYJvbLWynceG0wq/QWFQwYuZb4DTQ4FmgHiODFF0IYYqD5SNhIEMNmK+GSDIyvub1UlHhwGoSARdAPkO7E5euOPt+W3r9skXqDOdssowLirgWAQh9I+fNxUGBmry4uEB8GMML0DgRWa4Bf52mKTRusZyh13qhbojjOCJuHNNo2vrVq1cVLJmpoLfwmiapbT9S6TcAKbnb7UxK6sFUYnjneE0LurqC28LPyIkgqR9CWK1Wy+UysEMsFLr/7du3v/jFr/7hH/7Hxx//8e3b6xijxHR7e3t7ezsMg3PkPcMi4SpXqkkccRuaeTfrmtazAy3XMOzbtl2fLWOMd3c3tlaRa9R4YE1n79gXHndVLSlYxCfMLjTXDYETdAVdLpfAE2DwbdtiSZtdVe9fU/P3pfOJxDjapJWrJHIUX7RQc/m6Yz40PIbyo2ImImKENzVvAUV0cszSbK1EkNNxgUProUSXy6ULYX1+/v6HH67Pz51zxKKUc1LMvF4viQQgidm8RUIHpboYHBD1WLzBtobNglmxJsegfYkIiQwiwvWdc6Lqm+CbA+bGGkkxHzo612P7oMqszZcTYUuVH6IV8Wc9L/enrF5UJ+q8OvHEX5WHalHvXf9QDa719VU12DrLt88EooUqlihxQt+33/3udy9evPj2+98yZpny6iwqzE7pX0fQ+Oc73LHudzUqW4i8a7yPXTf/0U/+8uNf/fJv//ZvITrVMeyjdMz76JRSGUTTAT/4wQ+++uqN936cJhH9/PPP1+tlaByXpIcPQap+pThsleBjLvVIy+Xy9vZWVYnv4+Dx5JlOjh+y/qyKsaw9IUI7xlP/+PjK+VtmR8PdKa3lAlS1L+AjiDYIBXaMUOd8PteYc72pFPxhiSFMDUsWBQZTaelj6U9wSkhFjODpcB0pGCs8hnWaQ4wXltM0TRcXFwh6U9lprrQqmnVhNptzMdtjjGjGTMXmgERoGp+zrf0A0zU4z0oS0367G8dxuVxqkpREnVPnsjL2wXtfN0uwnDER4cPtdptS6ppWVdETArH0JNM05Xoq0aia0EiKrCSUKMZ4ff0W2Wu8DnhFuLAccHHcY6HjNq1MRdaEEJA7lFL7a8HVEEKSyTw/C2Oa78uldTE0lojEKYv72Wy2iPHdzV3g0LZtCC1K1D799NPr6+tHF5fTNL1+/bqbz/q+T0mJWCSHPYJj56xLjwKp4D1QI55ZoSpa7ylFp9Q1gZIoTVKkUz3LENmYEdsFzgiqfPZ9NZdKN7b2pBymuWOhu7LrUyW77cx6E51sxiOZrsCkHGlfV8q+M1vZURw7B2/NSG3RgrEEhJi5aTJbSFMIYplBNp2f0BYh9qxvsjGBNtuz5cyhlJ8lNOH5i6eff/bl/u7OM09x6Lpu3i2wMC4vL53PRYz7/c5nkNShdUSJNww2Jg6YLqIGxAZlcBLlIUgpbfY7jMahTN8FpJwQJTIwPwJpaD98Ek007+XrLJ5qSA/a2pVE8lFE7XjWvuE4EeMPfuVB7fsnXjnvQT4OndvfhPLjYjiiJGb+xS9+gXo+d1wZ/ae8z//6Q05+YDjBHIhIybXd7Ozs4q//+q/Pz8+zXKgKzvQ+3K4KK0AAvf/++3uUkLYtyATwdSv+e0hTPhBVbpoG3eLkGGOpquBROjyCgfHc4Wr1TNnhwxEY0hVQHyBCMF2hDFTVXDc4f9gJOEIptzffxTnnfIaY4XMEJKlEPpnZ/pRTvKIG9qaK4U8KwaT5KJC8WSVwRo4YJM38M0uZh0L5671fLBZW1ws9DVAuVCwQXihJAkBMRM7Pz83U2O/3KNqhkqXmwkMJz/gkgtr3/Xa7ha6yyCcUHgwFBMlh0/R9v9lspmnqZg16GzS5t3xCAc92u93tNpxdvQnJYC3xA5RtIMSNvJ1oxuXivhgQeMPmt5k6ASTHl7pYoMfxp/Pz87b0PsLTIu6Nx2tLu2gseLOH2i6XbGHXiAg8LWbe7/q7u7uXL19++eWX4zje3t4CVOGcC87P2m7WdkA/VQkIh4wcq7Kmrmm6ptE0TdOELIMBc6jSea6C+JofRsXuqaWtK1lJ3zZwf433TauAbR1W5QqlcXJrvnec7PGTD7lKNJh3bs9vk8LsbV/YK+AKrtTm2RYzgD2VOu+madCiwlV1g7b34egji2KTi+LyF+89e/z4MZcEAVqwnJ+fX1yehXIAjWxurnMOtoLmiqwD+QbeCI8H/vlaa2JjknccrDV4wpKzuv9+GiE3fMGN1sLNZBp9zfHgdFAlb91x/tgm69+gg+9P94ne/Lqn4ipFeHK1zBZ25GMXrdCGTJ7Cgcf9OD+bf/nq5a9+9asQwvn5OVDHqooqoP9z6OBs31DZaSLiPQvegrzz4Uc/+tHPf/7zX/ziF33f90MfOOuhGI8qrJxSYiK01XMyTSlO6cMPP3z56ivbTm/evFmtF03j4UaP48jHatgmpoiGQ/pquVyC+kCrCnEisnk8nVQmyVb2IU1F+Xb5W2Vliat2SEy5jS4+gbvfdXPViAKGVJXhwqQdqpoHLtQ5JqH2+32/z6gi761uXLtuxqU1AvQEbuqctzWaUgrB416+1NKgiYrFxuu5gwMHu8FUiHNuW4iRvfer1Qpb3aPoM9J2u3306BHaFALZi+gcld3oCmDNwKtcGJG4cAWnCixjxkqWWW2bUgKztBkECNzBR8d0I4SLB0bmGObF7e2t934xn49FNKvqNA2QcXhms9mnaVqtVvv9HrFfnI9wOluCrZiAroyetb+EN1xPfUq5azIMC+DIVPX8/HxfTetms4GG8452u90Yp/l8ziH84Y+fwjaKUTSJd2E+D455HKcYQTUzeHbOM96diocXY3LONcU9pSKkABqapqFt1/N5572PCX0nk6o3s9hViAHbUFw5N6kg8LlCooWubVxTS2Q9ziyatrbn1OK20rECth/oa/wwZq4Fb1N6KmuJQtvCMDuJS/Qblg0Xx302mwEnhdUFfxFLiKuYloiIJkeEgcLnSeTy8vL8/Nw54nAIdUDJUQEkamlq0vf9crl8/OSyK1RrIlkgeO+J2HzrlHQYJq14bTEDbemaUBkrhJdC/IaIuq4L3QF5AABE0zSJNO5jCKFtAxFNKXrf3Fdm9VvXh6qSHmb2xAyqw7RmUZ3o46NLlS/qccTbVsv9c/7Nx2HV5Uc/QUFLdM5NKSIWABJdlEn8+te/fvv2dYzw+dS6N9ODHCH/YcfBCcY7et+klGDy//CHPzw/P4cM8lVPITtse1PJfMBvWywWP/zhD+FszZeL169f73Y7AENgvllw7/6hhxYFAoIIQCH0GMpBxwEK+1zKn+z8Oj5mtmpBM2Zz2NxN2NGWvEHMmcpKgokNYwWft21rqFouWWToG2gpQ0ia4YLglSvtZrHi7crwA0QEpRTIpseK/GEqfIrIB/vCGgH/korhj0ZA8HRjjJAgVNLw8FCRtNaCUUdlFyZxu93CCQMI1gbQJBreJVSUWzbsNoZENJ/PUeIcS89aWACuMDP4wuZvn1NV84aI32w2G8feUrZgZqASMMCYYKhFBEgZLsF8uBHI1OJeuBGkKiIc1gsZoT9L4E2FbMSVJjOG+kanJqwZKcWyIkKiWDO20haLBYbdF9pk7/1ut2N2yIZYeEktzyoHnLnpnmmavM+KEAi7VFoaU+VhEB35NKFwRJhOMk/RFe5VLFf7luWDzeqiY0Vei+YTEWw/u3KcfG6vU2/2pnT1waO640wzDvvV5ANRJmAPBaoNGnmAD4z4zFARMUY0jsT1z87Onj9/nlNsqohkEEkIObCx2+1ms9nTp0/L8/CzZ0/atkW6pB7SE7vBXlBVicQSIrCbbRzsTAuTqCrMaDgqSOLAK0BZHdbSlCJMDb0X8H/Q7rm/QurPqSTRTr7C1WEfnlzh/qXoWEPfP7M+vvmEkyV3oK9CZIcicWLPrSYiYfvSPu7Ep8gTz/x/+/u/fXNzHSUNwyRCmoSVWapaJBKhlIj+jN2AidzX8FkbGs0ReSJPuTg9EUV2SWliZhENfi6p8c3KN4vzyyfL1dp5HtLoA4RjIAoqjaoXdoWsQ4Jy571T8Zzazp2fLYFGdtyw666uduOkvplPouI0SmSkGZiVKImgPCDlPnFTjCOzek6ahrPVbBq2UxyTxGox5c6RzjnA2Z0LRE4jaSRPAZCNspPJswTHjQ9NaJk5ijI1yg0555umH0dXChMRs5rN27YLSQYi8T7brVFkjJGcIxeiSN0LLAMoukXXzoNvxyEy5f0D3UPCcUzBNZvbOxKN4zT2g6oOw6CUAJzGHkOnh5iEnVfi/b4fx4mZhelut3XOkTqpYvLjODrKYChElQ9VQMLz2XLWLfBId7db75r5bDmfLb138/lsv991XTubdc4xOD5jjKIR5TF9v4MB4b1HyaCQuuCFcqc/y0mnlKYUUVCYVMgxTkNGRktJj0XRN5tNCOHp06ftrJtS7MdhGMfNduu8x8IYxnE2n7ddd3V9PZ/PHz16oqUQC7q1aRpVjlFilK6bt+2MyAm5aUx4NtMuMOOwPGBlTklvN5mOCq5Gzm0zr9fraZqWy+U0pv1ukETQ+svlHP2DAc1l5mlM/X6U5FLk9eqyaTrnHDj1Yxzi1IuMba7V9podC0kpNo3rZk5jdMVeydol+ChJKLnGkXPtbIbsb4zjbNYuZt1yvlivFiAX8I7P1ytk6Kdp2m7vYM0IEwcvTI48Kix9CaKa74Wbto0PntGH20mynTWO42azQcDARF+dQMmSUIjJkbKkA/y+eHvZSqtzK+TzP2FKLKKJWNuuwQ6FqQf1Y5YTgvBEglQPesd6zyBgSZQSpbPLs9AF8tR1DU5A5TQ4+EJwZ2ertg37/dY56rpmPu/YpcWyff/9Fyizbppm0c0W3YySBA6UiCUjnEVENJ5frB8/uXSLtll0QsKehURZk0rbtt5z03hEePI+SNM0DUSFE9s7IcdN69qZuCAuTKLCbkziSSnFze1148mJnzeL1WzduEadd00bVSZJkyQ0SkJZpip7DnRg2DyKT0iBjOQ5qtrxulJ5YV6yL0R1XKH/qBhPKDbJdcOV3rVMhK0ErvIFcshOOlUmKf/uQYDhkebnvJfW1Mp9wg+hNjHIzAo5ctVVATDIf91ut7/5zW8e/5f/a2gaTSIiTYNQ9pHmd6jF/ZouEP+eh1nBMDzm8+WLFy/6/fbt2zdd28YB4HuHGBIxkzGAElFuP4KgqK5Wq48++ujll69CaLuue/Xqy2fPnnRNGMZ923kRoWMgAFeBL18gM7E0sn3vvff++OXrtm3jdEBv1REwKm6ZVkf9XhhxVZ2mKZB3zrEDBCOnME2+wMsxK7vfj01pFeAL4JlKXwE4QOAMQh7LlR7PVPzaTL9XGvCh0D6V8kekLbnqawQf9MBH0TSxNFSxpnjjNOIruQTCOwSQTQ5qIZSw/J81fLV+iBhntdYLRFZdA2cRrrOqWkMI45u0lCoXSLAjRUrVwE24fm1Ep5S22+3jx4/Pz8+HYbi7u3vy5MmLFy9ub293uw2iAubdwrIBH0vXzTHgfd8vlzOj/kD4Gg8AH9TyvrYkXMapZdrwtg3OueV8XqJTeRi7pkVgHClzV0DU4ziZOJjP58ZzSTmccKAvbpqGHItI286wJIZhCr61WbD3YvLeq2uCq1iZWMmRiqi63HUbkQNwbsRxCo17+uy92Ww2DP1qtXKO9vs9KrhsfWrpOnWyr/kYOQXFRpXP5IMHTyf8fl9lgsUKOkoPA+99nLLXgF1r1zlxwqpfD0nKWkk3VVraJsuVsjoD7kEQ+8I+a7GBUOhoANHAvrNWXev1erVagTslxgiz79GjR6C0sxVSe3uuCXhQrCJYBimlmOZRhVMO8iO04BkWo/MFrcmcMZiimYheRJzLCESLWuPkerkyETqcxtLnBhNhDjEC47H0abUJslkwAX74sPpTnc7QKgptwecT1XaiYk9udOIHa5Xpe3AZ3D9Orl/bE1Ai9cWJyKFo7yDcWVT1Adi0HLGC/dMvf/H7P3wc41ipAKjpIxjwf7juzeq0Xos+fPitb/30pz978d4HWPrNrDvMBOcCczu7jhdhgX77298OIcQ4Yuu++uplDnyRAzizXhk4LHBnZg3ibM+ePctKmg6Z3drmMuVt66MO0VC1MqyqSgrwkotPoKowe7kiyrBsouGbqFLzyOCaDQjRgHwhFZpG7BwtojaUakW4cVMcqLSXJyJEm3Hlvu9TzOVbOFC0w8wIsqWUwBBies4V0N+Uu6YwBNNUuiabBWBjVdvOvlQBaWnnpwXB5AtrJsBN9i5mNdsI+KpqhUoNNxVzBEoUd9lsNsAqwu+PMW63W+hRLCEAxNbr9W63g1uP2jaI2hhHNG5DM2DElm0JceFssjmCgwXN3XWZscQVpnu8CGLLsWrmWKb6CNbkChmvL8l13EJKkQzQ0YiRwlhRVXSutdUOTZMOjBa5sWs25uIApzD3e2Bp2/bs7Ozi4pyZ4bpdXFz88Ic//OijD87P1zgzFLA3lwhnLctwZA9GD0VKKSVAAVLp9GzfxcvbJJ4IVj32XWyR1zeqRbNtxtoaMNPWfrXntwi5rdXaA8PKhP2B3TorB1YsqD0vLy+fPXu2XC7BXbVarcx2rPcyMFB2F/PFc5HSYqVCY0wmpoiobv2biggyFLfFqH2BX9VBCCy5zCmrCsCpZRa89wZZlULXpVVD+lpWmyrhrzmoAkjbTNm71x/qPe17ctg5h3H7xtNODmauUcD3H6B+5qN1hW9qdRincT2RRETqVDK5AzP/H//H/3F9fU0kLvhxHNXAQSTEdXXUUc3yf8jB1Qw6F1brsyfPXvzkJz95/vzFANPYqUhECAg1EoGdY2S4nMihWFA0Pnp08cGH78cYVVMI4fXr17e3t9aOu9ZkdGw6aeW3QYyGEC4uLqxWx5VU0Mnk1e9STx74t3GLUGrwRSSlCYrW1mgoVXpowioVYzAeNRY2SniENU2uK/RVyKlga9UVqHAcl8ulFpJkvIVdn0s0qe/7aRyncZymqe/3KWWnGRSY1rEAMtcXtKcpPGbOTIoyuZLiqo19izGkqpSZS39GKkCqQqARjZs6h+JjBDwEuhzI5Fo04ItascsaygY6CZ7uer2GRr+5uYFSt6QsgE6QO3d3d7NZHjfv/YsXz6jgZZbLTIwMve6Oc422DCw6IhIxMnWwznA9rqBqIS77vkcZqC0eo+7SUg1slgTeMRYKp8VisVoujZ4slO5VNkQ27MXUyzZKhhwHnrcdxhZjsljMu64dhn4cx8ViFkJwwXddBwqO+Xx+dna2Wq3mbRdKJxjoaROmemyVqmZvAXOEDD0GwUwl2KM2pHg2KTh/+noFXImRU+pgV+VKTRHev47WwfnyA1V9IGzFNqUJJhQYoK/4mUp36hDCixcvAGrJkTPvyDvXBPIukSY6LBvNdVktXh+L/1ACJyrESPRwsdJERCkJUw2UYWZhchxC2zl3oHKyBQAjG78CdpOq+nKL8PmCULFB81WjmgeF3n15eP9zc0JM+pl94NypS3ii7Gt9X59zei8+tQmgNWwFisR6WKAXH7ygLSMxOBUzEx/oLE5eMsmUKC0Ws7vt5h/+6X9ESSlNyjCCqng35zB59e3/eTX8P/X1PEDsYxTn/Pri8tnz92azeQYr1swmsEOVvDq8kMtYvgay4zvf+Q7iKlhPv//972OhqLXDlpGZP7YbTQGLyItnz9MUPTs4wVjo8bhvJVUTUU9zvVxqZxHSH/tTKoZqV9ibpRBEU8UmQaWzEBXf1LwuLYCgYRhAlEhE+/3eTrb9EwprYyjE2q6w+BowBEvUML0ikpsJpqwIa92ghSaTSk9Tw3OJsdFyLjNFbcNJFMukCZmTVH1YO6a4SKpKXABvtv4tqRQCwVmEZEGrOyRogZdR1dvbW3xdhIAUw60xgKDXhnJl5vPzcyLa7XaXl5cY9vl83vc7CyavVitzKLmwWTWF02oce8QnVBUsJXCdrUrKPHUMGiIBehxuSUm99xhbtJZS1fl8HkJraoMFOHmP+ERN2srMua6mdF4yqZR/ddrNmrPl6tGjR1ADs67p2jCfzy8vL1erhXPZvnn69Ol77z3H6JlZAyNv3qI14ZGws211tPsSxUniJLYNzVCAjjE1aU6hbVV6SMrXF68/qR1o+yKuTJX0p2IoGCzIFphFVmq9broZvjIsZtjBKDRAWgFBiLY0LLFpLZ5D3mWI+tg2x70koyCnaToQwrPPKE7lzGeHnTKmSN467mVbtqm6i3LFNdRP4zRN6KyKMIzV1AEySSXcZZDsIhkOgaWTKTb3RkrNdK1o63nBX79Zg94/jrXpEQ73XzrkfhsCyiigulnRUYjbpjvUf2AWotI7KYejT98B+mM39JeX5x9//PF7z57/5Cc/8Y4lF4GpqhA7okITfe9xiejfLTitdJqZJhdY3Gy+9K559OjJ7d27/X6nIsrkiQnEXnrwYh2zKwRsrsmtXpfL5Yv3nv/h4z+2bcuObm5uNpvNer0kclQIwughremq+mksu9VqkUvsk/DxsJzIAvxaxfqEi0/gclMTUNIc4oEhBPgKxhAEIzTG2IQuHpM9ncAQDGFr8VgqUqwt7d+naQrOWwbXZwyRIvsLR9Y5d3t7u9/vsQO9z1E4HHjmLjQmTcxxgWxyhx5qmdiISyN62/ZUegumQgjlCpmiK/HnpmlCk01sNBbE6yMC1hT6IYPXQkaHtoG8cyUr7Ats3lWgaCJCu4JpmvDW6GeA57+7u4MrzMUGB9KYiIZhWC7XuBrQyxiQ5XKJEYMMTym5MkFUrIcSVj0YFsE5cH3YbOJpfekAEQvjN5fcPJbPfL4048MxxHEqjmMgct4zkweCHUHjFAfnXON8Oo7rmnMDqZj9dUrz+Tyw67pusZj1fb8CKZKIalRNAM7P5/PHTy6/973vrFYr5Ok3m827d7foN4VXSGlC3K72LKlSkFJql+0EC5VbmIeq8ABV+jKEIEkN1FO3uz9RpXbfVPqnHSRGNUdSxWZPPEUtPpkWs5uOVQWmDxh4VcU6NDTDYrEwHWwBAOdc1EM5kFah3ax9HYsqer2wd7FPSWTc7Yru1/l8HjpEsIJvguihUQSzJlVyHsRVuSYiitKBvopLKgcmOBzcWPpCTpIrSvBX5CBsiGonW4+tZ33IG6lf0ywPM3G0srnti/d96/vHg0qX77EcKmWGiFrInzwwMxNaOPMDt8bDhwctuPxuWDrCoF2inEzN14oxusB/+/f//dmzZ5fnFwx8HlQIuth+k/kg/1E62Dk/xtS13aMnT77/ox/e3r57+cUXwixpIvLscopfVYkcq5IjrqwwIpI0Oec/+uijzz/7IoSQJIbQvn1zvVwuQ3Aqp1uUKqqdelcQcifET58+fvPmSlVFEpogPWRPZcIp55ryQ236cb2H7U+uEKybswhZk0oHNFc6k+BzUzwnprqrqmsgBaCJh2FolytYylAq0GRU/C08Ule6uyNAHQ7cN7kmFR4SJYILy+Y2MXOpkgQoCRqdszcjjoOBywwb7O5l1ChzWedILJw8Kv4Hro/gMCgIiMhrbqOGQIIrOWBXZfFDKQIOIWw2G9gfVnqBnGss/MnDsO/7/uzsDCwEGEMQo+KRwM1ydnYWS6PJkBsaVkwmJacbS78pvHiMcda2WBWwJ8ZxBI4GsYcudn3fo5gQUvVktWA2XWkbjHQduEREhMn54Cx3uF6u4pTlhs8F2VCKBHp5LgBU51zjOfiwXq5EonOcUloWqs7tdstOfGA8cD/sRC7wGE3p1LRcLs/Pz733b968AYxAK1ep1mcnMg7jMysMD8i8+HKkA4lb5Y6EEDVV6f9SpckPQMDy1tZDGpKrIx2TS9dR0FrYQq9TkTBcU3qBQoszsTmXbILdCzYcQlNGaQe4nBkB+CGpTCkys6PDG+EdJVGSOMWelYyk1nFhCHAuZaSkBWCIiIJvQ1sXWB9wbUhR4TlXyzVeB0V0BvSrw3L181BJpd2XfkeSkA8a8URVpwKpqxXhfS/5644TwVs/2MlqUVVlcQVgdHKRWmErC/O9Lj3lcCYly1XEbL1irSUSzZRQovgbM08CWTb93T/8/RgnuxmC3TiZ5Bte+F+bG/63x5+1qlFWck3TTFG8a548fX7+6PHZxUXWr5RUC6M2M+thKDGpOA2C/vHjy/c/eO9uc4sT3r59O00TuPfoIQ+YjhP4rjDys9KLFy8gK0UTK02F65wqewhKl0pkw/Y5UbbEypk5OGNGPaqTqSClufBppEK1b8I9VUw6zjn0yvWlnhUOHCKuWhwLqCstzdeQxHU+32sqvU65ECPg/FAo5uH7do1XSoAlU9mclg+GKYAxh/lMRFBgKSWlHMRG2sn8Zrjp5k9rQReqKkh229wbrkfqlAtWHCoc5BWI6Zk2wuvARbYrW1DaIplQqERkFJj45OLiESg1bm9v4e0hvqqavvzySwSxx3G8ubnp+/7q6iqWJuSIahRldkSf1HWdxOiIWHU2a03tee+JxDoB932fVHwThDQ0mZXFDB1mRjjBl8JuLDbMoPeeSguK1Wq1Xiy5tNCJcYoxUsraAtq5WFdgwnJdg4x+07ahaZq2aVKM3oPjkIm0cd5pXo3z+fzx48fwjYjQFyhi2TDzfr83BhLTavd1sAlNLoGWaZq22y2yAFjwyHAbjqGWFbZnza2v/1QftlNcWVy1fsW6rZ9TjmGYriAbzBQ4ERou9/hziKlAq8EhNj+eCmILIEcjCc+X8s43wYWcIZKSPcFmiaWtSNd1TH6ME74bY4QTjJ07odqwgoUSe98E5wIRgUWHS/xZSioEV0YzaWwliI5Qiu/R9CVWHO8Ws3EVyuFEeNZzXUtIWxWp8B/USlcrW/Ob9MQpwqaODZ8aWDkaf8/HrJeTqvXXOSRNTk4+8MjIIVlylLEw58kCHSawVHWM0xdffPbJJ5/sh76ck0Qju6P6mW94yj9NE/8ZMFw2Ac433gfy4fz84sc//vG3v/XdZy+eR0EDdmFmPLwrcJK8LDw7z7A54jSIyJMnT1AGAKn9+WdfwluKhaYYhy2FVDinuLTtDCEQy6ztLs8vEMLVijr8JOplurPW6/XJahG/CnEQq5ZzVBS/BWnt5zzKJRximDIkQQGshXYBxyxeEELZIrGIdm63W7i/TWm0nAq2K8bYNZ4kBkesybO2Xc45ERGAV+ZWmgbCOEBemHXCBXetlJLkAqqSesy8u/A1mRl+J5KmeB5waSEMAG9MS4/0/X6PTC3khVFjYqyg5pkZYOCavQvzvl6vYymjspSVqr579w6ujJTKLvh2zrnnz5+bVQQbQlWb0h/QpKeIjOPYhjANmVN6HEfQgjLnHRpyjVZ0pX8iAFOh4MMxyEBWw6SAjQUK6yZ0mGJQafZ9P8WIZdDNmru7u1DYTL07xEi5OHzGeUk5IQKCs7BcLmddJymqymq1ZGaAw0MI2BltGxaLxeXlJXiwx3F8+fLlP//zPyNluN1uP/vsM4yAKw0Wcbtatmap4hg9Yn0Tmg5FUwMzlNHB5AAAxcRJREFUr9dr8LfUaHAq4WULzutxWpeLi19LT3dIcuevq2rjfOAD8EfvOU+molwph7PnN8yHKZvDxncMUJVrAoqhF+tV6FpURQPhPKaYSNXxmAqughSdZM0CNmtAi5GdcmE9q/JsNluvzr33gEOa0MZqTynFWEJovjGZJqUPqb3dMAxQwOr4/Pwcd0cauO4OUktFLl3UUiZLSPUSOjFKHrSHpKBBjdNeS7TSl9IvOU4fmAllM9uULia1gYujXir22CZ40WbYJs6uaV1DTPLXV7bTDgRvWgVMTOHlNc1HWXGT10OcvPdC+rd//7fv3r1jn1nFx2kahp6d6r+OiuO+Gv7zI6gxYeS4CV03Xz5+8uzZe+933axr5/v9fogTIn54RzCN2LAws/OlukDTe8+fffTRR0Xu+6+++moac9wpFEIZLhUyphHN+DgYKJSWy2VKkyu4ifu2kn0iFULBOWfPIyLGKERoDEwpyVSvHqrN2EpnmGlVbyGD+SB6bB4DVIWhSe06MM/B9W/r2NSniFhjJPwKJzUUnvqzszOL9HIhmLUAHR0bwly4M6m0XPWBfWAiSjL5wKg8sbojV4gMIfiAakGpNCqCUlUxHEr7ZLikwzAA2YTk1m63gwQ3OWLbCTisGCOUHFqfmnOsqvv9AIPAOQdXeJqmJ0+ezOeZJhfIPvtZK7zeOPZUfH3vfXBOSikXvFVYGFg80FsiAjPC9BNewWIDqooYO6LTpcY3e4fDsOcS53SevPfOk3Ou9ZlWpSmlbvg/xiiS1/l8Pm9D8N4vl8uu69omiORU9Hw+98RdaBbdzGlOVcCNRlOp/X7/+vXrf/7nP3jfXF5eorHxYrHQJG1oRASsnIBDwtLCynHBs0euxzdNF0KrmtP2TWko6QoW2hRt3s7HuparECLRqe9rnx/EQtl3eJH6oGMvKlQV6r5Cftntailvu5JLUROOUPFVaeU+ElHm69BDXBPPZtsH4ihOkqKmqCUVldEP3ntJih1hRzHug/cZKtG2M/IulX7AqfRSA0VPDhTNOteEUFjtTrah7X2p0vAPeqj1ONSf1J9jX0jVoOlB4UnHMEzbvydx73rW7s8+Mzt3pMgJuGifs1TG8lFfn/n0kXCE+pb1n1VTnaZlJ0TevplKkzgY9dfX17/67W9Qi6aiIQTKeqh5MOp+X8FUx//igiUG0oo5eErh7Oz8g/c/+uLTT17Pv2KnEtM0TUTOs4ceVRIipyrIIzOgGUD9pPj08ZPf//Z3iO+No7y5ertafAAGqxit4uhQgK+Zt9mpAuDGoJlZrRcXZ+fDFL0LMabStMMRPYDOoEqbIr3tCoTE1rFSotK4m6riEDWyGMnxXhNDXGzJWDrtWPADiVVbUjCKsXWD81Lleoly14Ha4EDMDD/4cIgrxMLzALyS1RCbeoMpYDrbHAtEX2GeYx9mPc0CgNh2u8X0oaVPkgkIUsB5iOjs7IxIYozTMKIKT0TgKFPh94fva3aSxDQmWZ+tkS2GqrOkMu4LTg+E9WKMjx8/ns1mNzc3CG+0bSuSu1asVitVvbm5KanfVYw5g4vhNZcFasa+qyVQT0Rd0+y3dym14ziiyfQ0TU3jxzEX9cJxgfsrhYLUlwoxuMKH5pjqRKZaN7RtzixMMaPZ/dwzEzsF8tM5nqZJCH1syGX+yzSbtUQSQrdczl2BxjSNlxjXy/m7aeiHHRGtz5azWZjNZtM0XV9fE5EPQVU/++yLi4uLn//85xcXF3d3d9vtdrVYpim+efMGjbDAvoJXMNnlfKNVnAmjgTCGryD9+JmrSlYuCQhfIdeo8tWohI5qOWli2lRm3ghJhXOdit4Tf7h4LD03bQPa2jZrqSiYA5+zKV3TOlKRemp2Q8s+JfBE5WRwqLqOSsq5RBHBqiNkDUpzXyqeKPpV10a/sGvbzreNLUL7AVFlZlblxWIB1Jh1WVBVH7xJm5oo1EbJdOpDYvt0MLUKx2KB+aouuday9TVdBYOtdap8TY7/vu5nPhhMJ48KNWyYofrh8ff7yCenpc2FHdVfpS4RJhZiUREub9g0DerMFqvlJ5988uvf/bbvexc8ERmFSv7Wv5T9/nc7lBKVnlQpavDtk2fPPvjWt99//wPvmr7v+2kkIp+reo5GP1+hGqWzs9VHH32Etq/Oua++enN9fW1bwibbdtdBVZR4hfcsU2ya5sMPPzRwkyV46Lhhs6aa8fxA3wH318BNztPJ3e3h65yCGYNSQnDwrrgEl+AFVmGojJuIVVN61FkCLsTuQAVXCy/mg7SC82R2sWWIU+kNp1W+g6rEgRSya3AUWODLSpax/eDjIrZvJRxmHSNZQEQItVGBjmuS7XZr1zmRdN57Rwcha3BiSwBvNhs8KgID1iDh3bt3u10P0Wl2DEThbreDYzcMA/K+yJty8V8RsgO0DRfs+957hrFiE8E5SZxTazGOMF8MLjuVjs5gngqFg0lVAbpOKc3nc4CcpbBYw4tdLpdN0yyWM9guuQg7JcRambOxpRG44kOhC8rNi4YLXdetl/PHl5dmssPfWq1WoFdj9vP5/O3bty9fvvzii5f7/f4nP/nJ5eUl5ne73bZt+/Lly7OzMyREsGCkpDlijEmPgkNS2kalCluLw5ScpfNtJZhetCG6/0WuNGutOepdxnLI+0oVP7MlzVVkyHSwXaqWM3rMFmI7i+9Z5LZTqk8UWJxU8AqqhyJpjA9Tzg2P/VCK7KPkYvgYY5Qqdk1FlxNRilaDfjAcMYYwqYkI8WeoSTM4TAzWo0GVM/CgstDjwz6shapl02w06h/qX22KqdL69qeT8+0gIqvOrf11Wy1SwDf1dajS4pbetSNAtTKx6lGsrzqEyLMokxJpVClUdiM2T1LlJKr8m9/8Zr1Yfve733XEItKEkFJkdCNhoQxF/g9mx1ISRx5YZ+ccu/b87PJ73/1Bv918+sc/KtNquYxD3O12bTtrfJjSUZck1UTklVJKcbGcxxi///3vf/HyS1eqXa+vr8HDoAUWDxlxfwHZHI/j6MWfn5/P5/OhH0MudnRCykfLUUWV3MESdM55Z83Uyq5mCXyIqAC1US+4+z9oSeFwZU1nY7nqRSNVNDgUNoM4TmCL5BLiq3NpJTJ2UGbTNMToEWKFFYwgMBfXBDXBWqKFcIJNJbsqdopXq/Pu8PB2ux1YnIimGGNMY0NzKQjY8naTSOucc+xMl0MAERHeCGobXwSc0O6OhJMZTDYa6Hu4WCwAqkop9f2IWLdWprRJwGEYLGqnqqrDYrGCILNIeG36MDNYedHgj6qQhqlwe522bVUZFhJVAiKW1guQEYg5e9eM49h1naXu4M76RiDXxrFnVpQhnZ2tk/L19Q0RKehKyiLx3ofQTNPUhNB1jc+tojpN6fz8fLfbMGcYY0rp7u7uyaNLOHnztpvNZo1vb27ebjably9fwp16/fq19x6tP8/OV8G3q9Xq1atXME0w4ybB7QcEUWF2uIqpzUS/jXAdX4kxepe9QDnOGtoP93exbY1KTB+Z6Xqsp6HAptISw07gY3ew/sQ0DQ65l5ex/Vvfzt40t1zDQ8lRRnMYBmJlJXM2NIesoohoKrg28iqsxIA4olirnEyIWsGoTSldXl7iE2wNRIy896kY5VrBleuXrcSs1iN58kN9ZgiADSbvERlOqlK224kuwzVNeNZjlcOTdPAWbEZqqgwyTepKIxMqbkYZt7wI3XE43Wa26Nn815xII2ZGoPUegpeInBIVJ8YMZC2Na/BqsJF//bvfzmaz73zr2/APQghqdkouB/r3K0B68HDkqAToQ2hUxfvmyZOnf/mXf/XpZ3/89S93MUbfNihA2A99iXFhOhWTAtmFoMdsNnvvvfe++OKL2WwGjgUD69qg+9JBHc+glXdIhz2sT58+/fif/+DCgcaZH4q95E9YSQ+WeAg5HSsaVb0Zm0BIUiU+ygUPMourylH8GgoVrelRLuFWEfFVkApiummapj00UdGqcsM5RkdCPjjH0XvnPYO7qe8Zop9LKtF8d4OQmBOsJYkFLos8p6UDnSsVVmSkInyAnnrvRXICGE12nXPTmAFcQOEi14sQWSxNjpk5jrm6CTXERomVvQQR/ElVz87OgK66ubl5/fq1c24cI4rBEOythYuNGBxWhIKBjjk/P0dVMV5kt9uBMwtirmmatu1CRbQSY5zPO+gkUye1/Y7cymrZadWYa7FYTNMkieqQPkwHSM/Nbg9FBWSy4Vwuzlbb7TZGWS5nXdfd7e5chs5lBbOYd23bEqmIOKIxpWkaYGWO4+gcte08pXR7e7s+P/Pe73a7x0+fb/e77XY7DMPnn3/+6tWrVGp2r99eLZYzrGfj/LJAcdM0yq7G74hIInVNaHyoV765pLbsa1cspcR0+FWqksIT7Ws/87H3Y5dlUetlY0IZqxeBh6mwqNZb++SatU7FYXK/ltK1ZrL4U1FyZKexkkpuJ0gFBj8NO6ZMU5wlQxL1uUpeExwnBpugc67tZuy8FOi73RfuBy67XC6JnMgEOzhW/GK2Z40crQ4AmNS6J7YP43Ni4iC7zKUu+b5jzVXgoR5V+2t9/dqEKr/iHbMDef+79kkt9E6MCVsz1ZUVtUlHRGI46sgJEfmscg7PZKuNiMYhqrAD1X4T3r59+/vf/34/9CGE6R6YqJQD/RmzvP8GXS5K2cChMr7z+fzpi+c/+9nP3n//fbxdkpjSZEgfOg5rEBEiqPP5nJmfP3+eoqQoXTu7u9u+eXOVkobQAraQkoqQcwG5YWZfYAeB6Ih78tGjRxC4zjnBUFcFFYBY1RvetqJIVvkWGaaCSZbSmtfihya5cAVX+tu7Cp6Ai2iBO3Gh1oLKMayKbUIkQfEtCwKb8WHpZF8alWhxIlNKItHyvr6AS/FeU+E6Bt64vi+CkLiFhbK1pKIt5OUrXLT5taj6hYjhAvmOpbKWmdfrNRS5lByblrpMjLl5wKlQPELtwb/81a9+dXt7++jRI4CcYRZAr2A0LAHGzCADMpeUSiwUj2flsCZ6kJxmZu/ZAF/MjGyRmU1Q1UB0m6wHgcl+v7+5udntdre3txCaln3AWxiEmwrxC7OCi5iL2+ScQ56vmzXL1dwVzqa2zY2lIUwNLjSfd4hz9Ls9TKXlcn55eYn4v6peXb373e9+94//+I8xxh//+C+6bu6cQ+nRF599/sEHHyDJvd/vr66uDCtQQiyHccNimORQpcMHry7ngAsu5hCY4eK1mNyzRWjfrUFJdtqJ76v3DrtU/Rj1n7RS8CfHyZPY3jw57Z7OOGK9rmOhIiIxpSlKTBJTSmm1WgL6h72JbYJaXpxgL+i9b0PA2kD5TSqMJSBfw8+r1QoWGMJCCMBogSVD6QLaaavdXlDuhaDv6a0jxYb1gGiNzR0fVx+djHM9p/cnq1aC1dRHE7ZcGVJ2L7lX1izVgU/ccUCbiKAHnSpX961/PlpApoOxUXMAwTWuoCup2JJffPHF559/joezapx7y+t/Xgd/XXfCf+FQUpXoYNeoEnMIbbdYgXV2vV5Dpx5G07G6o4GzIYaAaJrmyZMn7733Hnpop5Sur68NpsSl4shVyYl6cWgxZbqum7UdIDn1A3OVmThZsu4YMV+rUtMZ1XyTScmmcCNrwaGYjysVVSF2jmUNqWgI2zxSUi8m96FdEBqpF5ztDV9KI+zilAP7ZMo+ltKXUPryclUrYpeyIDDEoitlV1Bph+xgVf1lDwbPz+pKMSnb7RZKd7fb4UNoO2vpisrpmgykPL8ys+W2X7x48erVq9///vfTNH300Udo/IwXjDGCluvs7ExVsX6mQkBtMxhCuL29tZcFKxYe2CBUVCivcXEIUBFB20cMnZbIsFlgUCQAbFMhciIiXBlSEgXKGDoIOMrxA1FVVJWgjApIb1vbzrmm6WCNYdDW63XbZghY13Vnq3Xf9/1uf319fXV1dXt7Cz5C6IDr6+thGFTzAuj7ETvoL//yLx89voDZ9Pb1ayosKJhiQ4OacVkZpke0UFTMF1gttZzFEtJ7bB52nVpe10pajrm0TsSmXcF+loKuOEiAe+fb3qR7asO2s21J07L2qFxVvKCmgwsFdBO6UFqGw8FNVXvm+hWkYnzEfRvvg28tmaJ8qJ4ahmGz2UAsIPuLlaCl+RI2JhW3uy1t1kyN2d0fPE5evDZlICWga2Cufd0V7DpUfI8ayfGgI6oGGi+rS46Lcqky+2xz1WKKiu1iIporD0pVHWlSyZgBrXoZ2VWiCki9hUWdemKNOcmXZFImoK6jiDKT4+To//d3f/v29l3TteQB90VUgUU1SlKipA8qYHfv3zcc/2KF0sNfZ3LOBSVlJmUVndRT1DQJf/jtHz569v7F5RPvPbNKGpkHp+SJnQtMwUnDKagESSxC3qHwY1wvFz/+0fe71pPGMJu/vbm9ur2bkgplLZXSlGLvOJKOKfaO1HtP6iSRJ3bMjnUa9sz64UfvMSWRSDJqmoIrIRRRkZyByMpVXeAAnFTbzob96Nmxkgp714xDRPHufN6NY4+uO4tu1vpASZzS2O9Yk6Y09j2JdE3jmdFkh0oUlEQ8M4k03jfej7vtsmsXbRPHyRGTaJqiaHSeYhp91cKdmRvn0YuUhWRKjQutb1g0ihNyU9JhmJqmAwXxfr/v+13T+EmmMY0lQBASk2ucb/2YxijSj6OVTPmmAR6x6bpuPp9SIufY+xR1vxscByrJG2ijruuGIaOXVbXvx7addd0cAmWapsVs3oYG7DHTMA77fuyH/XY3DeN+u4NbFWP07BofWEklekdIPjWND8ENwz5qJE/bfitM89VyTPHTL/7oGvrpT/9ivV4y636/jdPknQveLxcLlTj0u7YLT589RtleHKeuaWdtF5zfbbZpys0ejOYajwHHIqWJXeqHjdIUGodaXi2wZyvu4EKALBL7YVit1/PFYrFcxpTarpti9I0bpt43zjcuyjTGYbGaN13wTZgvz0I7HyPfbccxctKgHMh7Cr4f903nmoabhp88OvOc5p1vWm5avz5bXlyctW2bRK+vbza7vh+jKs8Wy24+c8F3TTsNo8o4jbt+fydpaoP3zMv56vz8fL/r90N8e33b71PbzL/48qv/8Y+/Hvr07nqz2+2wJjUlVu2aRkS8Z5KkKaZpnKYhpcmTNo4bx7UWUVVk0PHvoHqjqBApqzipmr2yb8k1SV1SJ+SnRMMUpyTKjrxTx8LEPrAP5LyyE+IoOiWJouTz3p+mCTpahJDoN7BbrVqqvs4co6iycwHZ8dr9wjO7KgHJzGgAjH9UUYiE3HPJtW3wnmezdr5oupmfzUPTMnFMMiQZlCZ2KTQOAaYoOqY4ibIPyi4pJSUlv+0n33USVROlSTwH7xv4bEDJDcNgbbZB+paSDnHwrU+UosZUWLhFxHwAX9VTMbOy3PtH9g+due0FreACs8ylkrAgKg5mxOH6xwlWPXiYB+eKKrcHVK+4CDQxslQppUOooHAHjeOokkhFUozTOE1jSjGlGOM0DH2ME36OcRJJIinG4ZT40J7y5EP7AWRmZIlJFqSpnXPI5Klq3/f/8A//8F/+5j8vFgslDT7ElIIPnl2UyESe3cktik79DzvgCH744YevX345n893d7eztoOpVHtyqopAeghBNbePHcdxPp9/73vf+/jjj5tupqpvX795/vQZEY1DnM27GEfvDtZuzvNzslmHx0pEXdddXl7e3N5571XJ0pCADNS2vD1M1sf+4IWYywi3htmHwEQkTOqYks3yoTwUUKbFYsHeI8/XtoeGr/D1tbAMuqoJNvZSKMwehmqeJInIvO3MAUVGU1WdC/PuUPsBQhx4eKG0t0OwtN/t2xCcossxtwXlOE6TaxpNqZvP2xBYtQ2hDcE7NxKF0p94nHqsSWwYy0jFGKdhbHxAs3pXcZLYS6GIAuatRXFxHThecDJCCWBAx8dh3BasFnBD68X63dt3aUwvXrxwzn36ySeqauTGxoiJaGrbtmkk+MRJpela3+ToQv5rga5Iod0Yxky8JSlHRLT4/arkvYfT7wr2Sgv+Cy8ohRWk67rNZrNarfp+3O+Hpmnu7raPHj168uTyzZs34zjMZt1qtez7/TSN2Pqucibgj8YYte+bWbdezAE43+23KNR2jq6urlKavPfL+WL2uCUikJOoslPyTViv11PKyIbXr1/jgf/rf/2v2+32O9/+9jD0+/0+OLJiKu+9FICFCfE6LEFEVDUyh3QtPp8/+J9iktfx4TdVjVpgFlJV68GqyZfVU+FJVXawfJ6Qfso3uyfu7ev2a61fiWrRka98DIA4OIgn6BMTFL5UN4RyuEx/cQgDMOdwPSmpKmilscGlSkz4Qi0upZU1EPshBIQPY4xgVEXSAZkmc8qbprFOprUErn16uuf643Al4UUlnmSS2b5iLkp9cdNrdYTjwXPqP9VxOzxA7bJTld23vI9VfDx4i5M3pQMIq0pWSwXMoWrtHnx/JtA0lhcWVUqUSwKmGJum+fjjjy8uLn7+Vz+LKQYfnOOYJu9D8CFnglnBw3VPDf/7HTavhNYfbfv+++//8dGj7ebWueCC18Ql/X7UIhDPjFUFcdl13fe+973PP/9cVOfz+d3d5urq+unTJ5SgBZnoEBAjFqCpiRgthL33zrGyND48efLk+t1Nob9Ilne0W+eLOFZVdgfSXSpBZsr7UI181QJuRARsiAutVCBerK2mabxvUsq9eIloEmFVazMgxFQqX7GdMIr1Jjc7VFUntJhwLEyoWPPECZ0vSqO6OE4SE4KxXTd36pzLaKxpmrh09XFVZZeU3sZSShtN7qBoBwp4GnMsdLvdslIck0h0xMO+x/RZ1BcESWiiYFAOC+YjqFtbPxDWGPYmBDjx8FDHcWyargsNxBZaVcYYP/nks/VytV6viciy6V3XISI97Ps0xZTSGOV2c4elhVkwdYLwcizcQzB09n0OpvU0amn8rDnAdVilcDvMOEulPQ4faLc9kev7DMBW1Qwy7wcWnTUtizqlwG5MY5GG3ATvXYfMcdM0w9gbFC6mKXg3jnG1WnRNM47jfN5N0+SIk0x9LwhXxnHyTUDGFkzX2+12ktR1HTg73727nc3a0DQ3N7ch+GGSMMb5fA65M45j23ZtO9tsNkQOAMYiLokL+zcdQFgEm8FEqohA5RKRalSMmmrJSWbpJLnCpEQRuRjBQnQsZ2tjnY7USZIKjWUnnIijWuMejP7KFDaJj2+dKGCqtO+JbqCKdQQLgIgQ55cK+qSqkoSIVPLDeBeICOmGJAfrH1dG4BeuCEobiChvOmaoagdulnZWZuHAVl2PADOf9M6pDaB6NCzf5AoXZq3I7EXq0ZBSAVWPFVW6lioPx8bfYkhcumJjSGGRa+H5qQf5wZklOsLi2edHTFgnx4MfpvIZYtZ2uZSS85RkUk2qiUh++ct/evn6q5TSvt+XFzvkZogIBFv6kI3w5zj+RH/6wK1PRIvF4sMPP5zNZt1i3vcjGMyZmUishKveXdM0TXEIjRONi+Xs2fMnXAIjr1+/Bv1CVn6a8YfMzFbVwwfKOi3m1dnZ2XzWAR1TrwM6pnFhZrDNWY5WSLlCDOEhx9KRlyoGf1JQtCuC+IjljjEOBa1jebi2bbv5HJfNXfkkJZVUmq6gqkFLgs0CSpBxBv/JsKzix6eUSB3i2MzsfeM5eA79bp9TcTHO2rYrrR1SBYf23sOCphzeT7APYG7DDwuFZGfWdpqEROFhU2mDA3JaVxqe26jaFkKB0Ha7Rf2r7f+2aUJxg+xk59x8NkPh73w+B/lD4/zZcoWatHEcZ213d3f3+qu3y+Xy8vJSq9IRpJbn8/ms7eA3SIF64YGh1RC+CyGkBL422u02GHOcg2A7FQ+JCwGh+c1l67kYBf/GMU5TYvaIHyLjC62PHoib7a0PHBqnlPphFxrnWbvGo62vFmAdBPqs7dgRk27ubhE8d44QJSaSWdt1behmzbt3767evJWYgmNLRavyOMZ3tzc3NzfMHmL95uZGHYPKn51D6gpB+N1ud3Nzc3t7y8yL1TKpUJHFVAmuOpdZhKw3cnw7x9awHfjVqbiC1zSRYir2/vn3/1rLdKr0sRwf9cl1svDkqGV3fS9XHfUX69uZHEil5h5byQoCbedKLhgmVUVdFtxWSLNUSGqx11BHhz0FLxkLA8sVuef5fL5arVDDjXPuD+DXHXamnW+BHNuzcpzslwIFkHuQugevT1Xs8GS06xQGVbAbvH5TCCx9oSfzFQ+gaW77wW5ktu8JE9bR85mdYg+qqkSZIUsptwmy5bXv++C9C77v++VyeX3z7he/+B9/89f/GcHM2Wzm2CWJeIByUYEyqG+LQf5T5ubPcjCzqguhJecuzh99//s/fP3VV3GcPt1/kuPt1bsnUs5gZkbkMBaCXxH54IMP3ry9IaIQwtXV1fPnz5um8QSjL4mI87nJ2cHC1oMxrqSSUtvNnjx58tvf/d45J5JizNhmTIccs3uyd6G07WRmUPGZ1c/F2MxenTCpU9FUynC1oCSYGUQNkAVTaTwwmzEzA+Hnco0pYyNDBzvniD07j3SNSnJlqVm8mo4FB/Zw17a7YT+VVgcG7ph3s9lijmfo9+N81rahiaX9eBbrxHGKwXnrEQJCq/P12W4/mHTYbbfjGE0E13QfkOCr1SrFyETB+/ls1oQwORe8V9Wh70vsNFdKxCmzbBIRZyTagXOfiFRkuVzCFEAQe7vdIrZ8dnZ2++6Gmefz+cuXL1eL5cXFxdgPIwm0JpL0zjlhmi0XGMB5E5rSAwp0mNvtHaYVFU2bzcY1bpwyjb5wbiIZQuDgmRNKcUQ1qrTzWVQkF7NDrIWc0lrJwnrAyCB5iTKe3bA/Pz+HboDOU00Id7SzNqVpHCkEF4KL0UGRLxaLlCbWzI/ovZ/NZv2wY+Y2NMjCijglPw7DlDID6G67H6OeXT7aD31SGaZxsVh0iyVWLEDd4xS1tI4fx/Fusx2nOI0wpFyKkgpbggpKHrKiPRGIZdbysuR7RljZZOoJUZzKN6VMg4PqlFq/mhow8VIrG9MWdEz2XsWBT6FGqqcObi27Tm7BxTeVCpRrl8WRCsLfOQd2yRLQPjwPLhKTzLpGVTP4ufRP4xKV7fse2H7n3NnZmXOu73vg1bHNJwS5SacUoygzBx9UFLQShL1E1c+Hl8scPoffS+bLFTK+kLnED7bswYaoOMLqI1XtI08miO/FHmxeqLJ48HMo6bBUoI550vVwvh4nI06ugB+OiZbuJSRw3LMQRQi5+SQa8UO+NPx0ygUkf/jkj3/4wx9EpO/77XabJKWUHHN5PAzAg1gqoX8BZvXNQK0/NZ3MnLUpM08phbZp57PnL16sztZt00U5QqsnstFIIqj+PmRWmqZ59uzZ8+fPb25uoNvevHkTYxyHWEqPju5rwHIuoGuPUjOVp0+frpYLyqBBdc6BXd1WA5dYinMOj2/BJaHSNhH2vgvON843PrQZyFDR4kD+GhpwGIZhGqMc2LKQ4EE0KalS6drrfe6Php1pfpsqKzl0o7SdKYVD38zSaZqSSEpq6EFzSbMCSxQnQTcVrrpQyAFNk/B40HC+kHjAD87OYtOIqpBC3eLWsDPm8/nFxUUWxt6zc/PFwofQdh3+zReL/HVsJOd8CE3bIpKYioeqVe3EOE1EhOsDFwo3GkLKgsMhhJu727fXV77JoKrtdpstht0OkgU2EzNHlSFO/YTIsMMFaykADxKNvVOpzPaFT9t7tvKtkPs0CExGqjKaPnd9VufCYrEahmxmSUnwW7jeZBxek4im0lsphLBer+FLuYL8cqUCGwh/nB/ahsgBrFfc+pZcduU3m80fP/0kRe33o/f+4tHlarVCpwERud1u+mnsp3GS1E/jOI53d3fX19fyUG7PRKEcY3pNmt1XkydHHfL1xE4PTrMklXQU5KyPWiXXHk/t9Z7I2yy5Koe4PqcW5fbJfZdXDgmI/AC+4o7mwrIOZlYYMaUe7ygDmoFpVPBoaPmQDlH0lNJ+v8e2YmaQmlkNvRWAYMehQMAdsNkHuX1f9RQw2unUmF600avjw7UStQVpt7PPv0772jVPZi04j0AdicLVcMSshLia/dMk+ZPjK9evKQ9VsgWnpIe88cGIO1mgZCFsly0WOyeTGrOGphFJMaUQmjFF8m4cx9///reXl+fn5+cxZj48OmyMYg6Q8jepzH8td8e/QvsWS4SJvHOBNHnXfPTRt7fb7Waz++qrl/1u75QcH00hHQwlBRVLcUP9j370o3/+539GkcZXX311cXF+cXEBEkEiIrX8hzI74MNVkW1hU1Tz+fzFixdffP5l27VRcq8bqGEqqRd7BhGxOm1TBt57KR0gTO5AIAJjgpihCXEp1IbkfOMDeSo2bKZdhJOENZ1K/kMLNZUZxXyw79wUo6j6nKoprZmILfymRCG02P+Zj8l79i5OkmLOQ8dIMSmzI/aiTOyRshVlZZpSbFRYBQSo+6GPMQdd4fJ2XRfTiL5sSYW9Q7ecNCZV3Ww2s3kb0zgMw2KxGMZ9TNElUtVulsfkKKpJxv4jqioG5mdWotVqtdvtFovFZrN5/vy5AdRhaU0pojJn32/Pz8+LOlQ0n7+7u1PVdtbCDLIAsqXnu9A0jUeVRSyNdFQV8rNpDl14MZj+mNaYSrcoVYUKh+lTNKWqctOE7XZ7dnZGJYg9DAN713Vts2vevXu3XC5Rv4S7IHnRNg3OBN6NCllH3/eqlBQF1n6xmG02GxV2jdvv98M0rs/PyPlh2HbdnDmvjcVidbvdvXr5ehpT0zTPnr7wgZUp+MDMrgkhtN43u12PspOmaVpRDo6ZNSllQgkAZLKpdlBIjpyrGKPwAmxzeJpDrV0cO8cTkeTwLB27NQ9ehI61u1YZx+Pz889S1ZvKMVdUfbXjOOfhXqbdLUKLM1NpyMOFMLWA6g92CVcGLg5EzlB3p6qTJkeHFClqynFBtIwUEdi1QHo751LK9nERszlo5CsQuI0YEdExNXIlonNEVlVh6+PZsLkszGbfqqO+Nhf3b6cVsMsVrlkqwWciQqWWFtClzYKdcHJZd0BjMRQrnkKPebIO80jgg9YjY5AeUuD1kqrGq2SYC7rSOScS8QF5ent99cknn0BAT9MwTcNmu3HsWDGT95XlgynhPx0g/a+DUpd94bEmoshssXj+3gc//OGPnz57FprONpite64yLrZD8O4ppbOzs5/97Gdv3lwBYnN1dQ1q3/urgZnBMFyvD0RXSNLZ2dk4DSKCFS8SQ8V0SsdM6DY7WNymC7lqg4PD9uFUegMjJ2r5UZIDCSJyxrbVy2LiYZrGNJrTLAXdIwUS1TQNWlBM46iFcwNSYIhTImrnM/yqRGPMxWzkeIyZcMosaBjacCJ3ux1cXnBOIXUKfQyvzns/SUqUaTowp/CxsJNDCHjgKGmYxotHlyicyPZNhZIw+msEb9Bbl4iEkrKwp9B6HwI7JyVUMAzD48ePnXNtG7bbu9VqsVjMJpmICOUKU4r7oR/H8dWrV9vtFrpht9tFSaFtFqsFNC7aMKuqtUlYdDMiMYIqrfjCMqh7mjBKmCOzshEwTGlSTdM0hODQkvkY4p49IVdSa5hEU/bOORBQw0dPKfXjmPKtxbnQtjMiN46xaXJuHv7QYrFgn8nxnQtTkmEaU9TFfNWELk4SJwEwJxayNiyVcRz/8Ic/INYdfOucU2VwRKCr8d12s9ltxzhBCmNO4RBLwa4DGVAXcULeHP7d8zG+Rjgctptz6IPrWBA5899wkVp0mMQwELIlC+0w+5UqxfzgU9Xat9Y0VBGPpML2bBQ6Ji5iKcFHGMPS8LE0SDZljOFtMhTDWcQ0FSSmJXqpFALM53OTeFpMdqq8eTv/XzzULN2CnYMANK7Wk0CCVOW5J47myWVx1JLzxEjC1w3CUo+wzbhdvP6TVOlns4SKhHTMrrbHnKt6JXpiX+gJUyHfsb/WN6gvnY5q7DJVoZBapa9z7je/++1nX3weJbmcmRCkgkQE7D2qIlqnNvVr1HB93I9OPxCvZjqF1R39Mf/LT4pAsfd+jNNyff6XP/vr1flFKn2fpALRmblkmowKjY5I/OC990FAwszv3r27u7tj78k7osyTDIkPAqAEzWMdreMInbGcL87Pz8dp8KV3EFEmF5Qq/ELFWcHX8bSYHXg/mZgwJk3S+AAGHFca7lIhzqUClXIlYkwk6JAISl4qmKApDo1np3k/zOdzsELGcqSUNMk47Lu2RXbTOWcEI1CcIYT9OEQV4CeZGQ0tiCiWbsrb7fZut0XtkAlBqLrZbMZOU0qIr0IH403xJNt+75pA3t1ub6eUFosF7AzYMah6Qj8iM0Hs8cx4hz5D9whfSi9sv1UDRVTISQAdguTabrequlwuzx9duiZzRvb9br5YPHr0SApIjT2KoMQ5t16vNab6H0DIWqDgIQRweC2XS8xa4/y87Vg0sEvjJFOkJPjnlPDrcjYHhjkOoxZ4M0IaIgL1bEJNVff7PV4Bvuzd3R2MntlstlyfS+705Zh9jHGz2ex2O/ZuSrEfB1XyPjRNG0IDUdt08/X5JWwLIqfsbjdb4PgMNz6OY+vD+dnZNE1Q9t57kF5Bi+z6fYwiIkx+HKIkGofoXeN8I4k2d7t+P45D3PXjdrtHB4Htdt/3Yz+NiOFv+/22H/opjkn6KSbiqDJJAs9BVIkqwqdRXxNrQIlnQUcaD4KQ8KeUlMhNUzr5OpAEphW4xPzdcTy2socOQEszo+vDXLFaMZgioVIKAeYy3HosjYchse12uMVsNuu6A7WOlGgZBEipGsrRFCxvVP3e3d0h43B5edl13X6/X6/X0PemkywA7qoaOdNb9cua8jtRhzhMvhmqtOigTJCABVmmyeaL8Sf7h/MLp4Kv6rM5JQWfFb6FL0pVgW36zoaRi5MgVfiaHtLZU+mrZgcueChDUgUYltXIH6plVGstOlZpmH8YBvXJaJU3ycTMf/jDP3/44fvksuoax5GJunaOp29CQ0RJonen8ZbqeDAQLdX//+Yjp/6VqGk6rAFm9+K9D/7z3/yXP/7216iPhHahwht8Egc+DGOS2az9m7/56e9+97vlchVCuLm5efbsmST1pZHImNvFtzFGuoeQ9MxE1HXNsydPP/nsU9GkBWvqfV6IZudCkSfNhUZExFq0iEYRYVKzeX1VeRILUahtRUfkmb3n7NRCx8SoKTUhTMMQQtA0pdJsJwEctO8lJlby7NCaUNKUCgraLDPEk5um2e52SdM05U4+iNJA9B92F/nsv5KHnnakKWfBE6tw4GGaYoyzxSJ4H4eBvQ9tq6WVUMjtGYbFYtGGoJmsTZxr8TCWeyZNq9UKIWiMBgJucNmJCLFxV/rI7vseaCAprCPz+Rw1WlRaX9zc3Dx//hyFNJMk56j1zs9BeMnB+xDc5eXjvHunmFRWqyW8ZCQsoPsNz9L3u+KFEFUmMkQhEUHOAo+KWcYEWQ6eigvShkZVp2lMzrehCc6nlBazOYlev33Ttm0b/Hq5iOMAgNs4jo6DKjsOcTqY/LD5gJQGdADvjjIwX6giuy6nitFZHovfOTebLbz3wxR32zsf2ta57W6vfFjebdtut9tXr15hVEkTSsViUrP2siRhnqYJo+e9d0QgJMlemgDrnoiobTMLW3HLmMjFOKkqLLkYo0aB8cHMUPmqTJTLL6XQczKh+JiIs/0KteecQzCACvRMSjMuqFs9LkAynar3POlagvOxQ6z3Qqn3/3rwsY75lqkC98YYgaAPIcC49AXkbOG9tm1T0hAOnZWhYtHxkwtJOKSBVDx6uAiw0/YWrmSsnHP3n/nkXewTe9lU8Py2qr9uHB684P2Bqu/18If/yiKdUvB96Id48grlFvmyR0zlOQcsJFVCvj6YWbOqOn2Nr3tVIfLOvXz91T/96pf/+8//Nx9y0eo4TU3TEBMlLX0aSFQySeTDxzfo4P/Jo1TTes9E7JvAfHn56C9++tOf/vSnv//97+tK2domwpc9MTGD5zxRYub333/xySefuNJd7u7u7uLiTCh5crY0cQWm+6tEWHkYhvPzdftVC+UEJy+RejoU+TAziUbNLATTRGmKJJqJ0VmYmelANJOfXHWE9sUOV4VsHitaY2w2iHUc49gzdzHmQdDS8G6ceqDw2DGxsFOR3JIssEtTlCkS0STqOkpKpCIxjaUm0pHEmOBJqyogVICvYojiMGpMiSaNyBtJiimydk3DqvgyiDgaz85RYOc8zbuGJJJIcC5lc54RNYD27bpOJDJR23WQ45vNBpYKgrSLxcKiglxYTVS1bcPm7saxSpriNM1mM+9cYibV7WZDqpeXl2frZRPcNPZt41tuh90+C68QgmeROBSeMrihr19/tVosZm139ebt27fvXrx4sVrOiWi/3wfPd7udpIRiz3EYEHZMMcIaYKLN3R26MJEqMrJxmlQEZlrbNPvdbhxHSakJYbPZIDzLTrUUW7tSPj6O42Kx2O/3Z2dnXdcQIcjRpZSa1o9TH9g1zivntBkzhxDOzs4+/fRTick1bSZUKeXLgZ1Mse/78/Nz7z1YrJnZs5uGEep/uWzYhZvbjWtyQ1+0q/W+6fv+448/FpHlfDGbtzFG5xubCyLCBcdxhD4Aq6UvfklKKVFaLtYpTsMwMGWzQBJJ6mezmWgOoppnI1M0BYxbCGAqTN45UjcMQ5/Ab8MGfXDOqWjf98ZwwoyxaYlIJFGVZcwS5/gH1L6f6Ax3j1CCisVsGRNmrhkMbcOa/nZVGYL9VQpFvHNwu3N5Xizskr7wB8xmi1RY5X1zwPFZ9vfs7AzWs4HssiNRcZ7XD1//zJX7UVsVJmDrUZJCuYxrIhxygh07GSi650A+qHTvf/dfPMx7sesf60GnCmTOw5rUjlDr53og1H1dVoNNt9NxfvvhO0DTOPrFL35xcXHx4x/8UCShvAeADucpxtH7xjsvmmFkXx83rtXtn4rMQruP08/q9yJy7JNGIieanG+YOSVdrFb/+T//l08++ez167cIGxp7sEWgnJJ5sarKzpHT8/8/c3/eZMty3ImBvkRk5llqufe++1a+B3DpjU2im1S3KKplJjOZTBrNZ50vMDYSZ8ZMUrNNYBMk0ADZALE8ENtb7lJ1lsyMcPf5wyMi81Td9wiA7O5Ju1ZWdW6eXGLx9ec/v7n5yle+8p3vfGe73YnIZ5999vTprYiJFmoFsxIMaI+1XkZmGYD6vr/a7T978XnoYoCgCITEtesLASItfLYAwFgoJAtzBQMidsy+ZSVnWZnVLY0EAGYiqRCOZ0/jqamJYEY0UJnHBGbOFGFmfewAMTCaZgBmQBA1ADEoKSk1yzJDaZDSvLe1dYxqoWNV0CxANo+TquY5xRiJSUH8QQkRzCRnFem7QBhM1L9CgOPpmKYxhACq03kMIRCaiUnKAqBZpvM4z2PrWIAGjWoQzJBck86MgKaRCY0kzfM8S5qxdl1kZkcYI+Lr89GzXK9fvyZARpCU7+/vb29vA7FJns6n6TzmYQMAm80mqxBGETocDsc5eVcJH+FAPM8zEsQQ5mkSke1mc4inu1evY4y73U6zzOMUiOeamPcefKboeuWMU+EfFfULBmLxLAOgiWZLQ9cTYBeiieY5BeIkcyDuQsycmAmBc5oIu6v99tWrV+P5OE/TNI7DMKR5nsfJSTo3/YAGMZCBTPME83kYhtPhLue8Hd7vIwdGBlTVjnk6nebzmYhOiKYqIsfDnWtKrLzEXqx4fP1qnmcVePHyReyG8+kwnaec1USnlM3MJOec0zRv5y0HPI9HrVADEZvnLCLn48lN0mlKMZ6ZOWCp8OaOJZun8B0ZkJKEIF545Snt6+vrtrWdpCyooKmaImLr/DONpVv2NCWzgjhDVH8vv4WI7PfQDwWnJisSRBEJgVqkCi51w9qlazIZa9lMkwztZ0s0IuIDJ6TJ5PW3uJZr2ypMbWY56zQVDpli5Yv4n56noMCS1JPmIOIBNg/SIOJ+v3dT1bd5Q4T4aDt3W9PBD8In8AUqc5HRl3VBUsFQAOAVlYilqyA80qy/jEL9onMuFPMXOIQGttRI4Uq76AONS1/uIl5QUV68sC4e9FrbP07O6gq60uR7e0NES56ZS/KNb3zj9vb23edvOyOdqFKFw6lmZCbEv3vYVnf+5U9tGv2RJi5/i2mLAYdAZpxV2LoPPvjgt37rt77xjW+IiKutGGMpbzNDvZhDRPSI8XY3fPDBe3/xzW9dhaBmd3d3p9M4DJ0SNkHgKxUWpBxatZrcyjOz29vrz1++sFXVOaiheXMw1JrKKIwWgaiyKkLhikoYa5w5LyUE/gzMaLIkkv0gA4rBGRtTKnkXL/UpiXCylAv9YUopdARVs7acltsHCqKSiQjBTCXNU84ZiTypiQCEJYSOSHlOAOBvx0hl3Zs6T5ZqFpHsTSJFAREAYyjV2ItwUfXB8Tz3dth0XSDsd7vd8XgMSDpPoEpiJBaBGJnUcpo6YksZmDvinHNEIjUAy3nSuUC+Y4zb3W46n+5fvuy6LiKdTic0G4ahCzSdj5oTBMqFQxtE5P71q367ub+72/bDs5ubw+Fwf/eakZ49e3Z8/fp8f39zc5NF0jjtnr99d3d3d3jVcZim6f7V6+l03m6358MxqYQQTocjIprANCbVyd/3fD5PR1RVoQK3yVPp/utBxZyzzAUtrKrnY8nmikiex/FcuGMbxUeaprs57Yb+8PoV6lUkPB7uTLPjnNPMACDzBCp937vhcvv0GahpFgXEThHgar83sxDCbjM0petc1mrZzPb7/X6/924T7z3/rRDCmPL17c3pPH3+6tXru8M0zshsFUMjIuM45nlWVak9wVTV0wSOU3WTxUOjxSs16LrOEr548QoArq+vc9a7u4MHObqu++yzF+fzebfbVHUuInI8nJ8+3YBRStl5ctzTEjUzOxwOd3cHfwWn2SLC4/H84sWL0+ngcAFEjKFXVdECY2zKJoQhV+KXR3KyCJALqXV5Gq4M/dUXEWCpgn2D6FvFQh+rHF9LLSHVUF2+nYftzlr+i2LO2ds1uvZ1wKDnIPyXBlJZgny6vuliWDwUwpfu74M/YYU6ZvL+YFpNmTeE7h/88qsej+/++Pg7TzBrGvrLdPAbqCiLiVSh9hfaF8BpQh/HRtZntqshMJApgqmEPrx8/epb3/rW03/z3202G8mZQ7Hjuq4T1ZRSF0u31BaU/s9ykIMPClCtkLVqDD0ivv/++3/0R3/04sWLTz75xLWLiMxzDqEQMiy6s+i2DIbTNF3dXH/44QevX931fT/N46effvrBB+/FLsqcRORLnqYwS6TJrJDLZJWcs9cBayoQqlIKohI5xC6mlIgcWV22ESKoapqKJxcqpaXvQ6Ka/S0qHIjIEImB0czMU9GSMxNxjF6RDM1UN2BH0mYBszwnRDRRJWFmNQk9ARakYsOmSu1aaGaMkJgdFMhY8tCgJik1MQMARFp6V6iqB6AK+BMIkJDIYDyeiAjRck6BOmYmQFOxZHNOInIWOx5eexLXLRv3OBGRHP203bVM1VnUwGKIIqLehRzRAFBN5uQ++nvvvEtEh37wqw1dH2O8v78/H0+scLvfRyTT3HPI5ykCoYGkHDk8ubqe5/lwd9f3/ZTz8f7e18/Pfvy3r+/vd7vd4XD0iN/5dHD00zAMr44vFEs80EuBDeDzzz83s03gvu9zSi7ZUwWET9UhM80pJXSBJUsRsEeVY8eqStyllJBsf7U1RffRmfn99993cBwihsH7+8LVdjMMgwuHlAqk452333KP8PbqFlbMySEs+jLn7IXaXRc6ppv9jpnVs3qAt9c3XTc9f/rs9av7EGbHfAHAOI5o4sFMEckVKOo/TRQRGyGRR1YLYk5EEXKtMlfVly9fnk7nrus2m+3Lly9fvXq13W43m507r1w7nVfXFlVxmuYQAoeSufzsxcv7+/ubmxsDPJ5O8zynefKbdt2w212FUGjAC+YomF0ykUklglh7O02RrJVlkQZvcuZW0sZV7/Ld5uPimxoXtk+a0d+KOJoR1p6qG3pPCbfUtV/BJ5GZ3ZBypet1/FpKjxZ2xnZ9rJgyrQiGL3qp9Z9NDrhSbxL4jSPzwFhZ/74ez/UtHj8G/HKaGx+1/n3gytplEOKLrrmwlovIeiLfYCyViy1ucQlyP7JBwKgofzStWPYkOgzdxx9//B/f/d7v/bPfbef7yJbfTQG+BIf1n+4o5hoAAKKBgbrdFxHx6urqvffe++lPf+oRFQDwpuKIi+faFj2UZgA2DP1v/uZv/umf/qlDM168ePHkyc0VX1mjD8Wgaspmq6az6+lUNTHr+z6djqKJQoTWZ75VI9jC70oEVD9HRGY0M4Il2uPX70OEuBBG6gOeHVGpxScroxhEUlsYUvlozAyp1BhwIPV+36AAMM9zIHYHpWwhESbSLGIZ0TgEA8hmjJBhYe/K85Q50mVRUMHdzMnM+r5XrBninM1sms9tTHRWh4q4vHZffzwd7u/vveedZ6pO8+RFWQTIzPNYOvW6jGBir7tHJNXSLOx8PH02frq/2f/Lr33t5z//+cd/+7dd181TKfCQlL2vsEzT1dXVSY4uL8QyqKZJZjPNgohMgQOnaW6idxzHw909Ef385SsOcbvdHk8nKTyUvc/4NE1m5OyYPjtSqTQR0aHm7s66g6KFzhqHYfDiKBfN1/2Vj1WLE/oo3d/f86qNgXvMMcbAV45UBwAnWACAGOM4pXmeI+Ew9PvNMFWD5nD3uiF7U5VEagUe77M2jflwf1/sjPMRgFLOigTI7hYj2na7ncYkIpuuFw6iyW/NsfOQSYhct0lZYI6/k1aLoepKxSttxnE6n8++SFJKXnjtI/bq1V1K036/Z+abm5sYo+PIfIH52kuSP/308/v7++12O/Sb169fH4/HELrA0LKSKSWAuN1GL1ggovE8z/Oc8sTM7qATLTuxSZ+1DCFayJHW0mClqpejnmZtv6zPeXCFJjTW51At0M+P+nw7LKN8XTGr8/JC4yvd7XauaK+vr7Fysze9zkv5xmJYrB9s7bDBm9TeWkcUnW2FZ9dWbRXWsveL7BV40/FGZfzLaN/H17HquzZaEACw5b8I3pADNQBY+D/9Tdfj9fj1zAyc/A+XwDcCgtnir1rJ+T8w8RDQmaS++c1vvvv87WdPn4pIIAbAnDPXgoSu2zy2Fx45xBdx3191vN54EJKBiEjwtCgxgaFpCOGdd975wz/8w+985ztWi8+cushhTO0d/TohhJTmwDGl9OzZs3feeed4OAGAl5P2fR+dkUPNyS6MlrHyTHWzbZmjitze3mYVr38VEbZSsedOLYK1BIwHxtvXYyy1CmRAjj90/kvLzYq6NNO8PoGCmyJqSEiArnCpchshFv7eUNoAo6O4YJWjcr6YJhGoQnNDCJZFLYcQu65D89ImBdGApcNuzpmQAodsmYgwFBu8Ge99H/0TV7GA6j3AHQMMVX9sNhvnomJmlbQdNiGEeZonYg/ZhRBCZKeiHCufrSt7j8qEVfu/EAICmOr5ePjFz37+4vPPx9OZACVlrjUhDnb1PuYm2nXd8Xg/zpMrgDbFiAhAMcbj8eh+AyICguN3xmm+v78fx3G73f7is09PpxMAcQjPnj3re3j98t71opl13TBN09XQMbNl6ULcDRt/fQ9Hm1kIFJDIQGYvsA6Oo3Gj8HQqBVdebnQ8Hq+urohoGIa7uzvPjHYcuEPnwkQtdtL5fPaCqxjj6/GkqlOac86n0wmEu64DVF2xT5NBswBUc5O/8zzHoe+6DimM47jZ7omw6wNMcJ5mrKBZEUFCN+YQ0Kr8ldrDys2FZjW2hIinIQFgmmafRHfp7u7uAMANppcvX97f3zur3X6/v7q68aFwQy3nHLqY5uRAaxf9TrxFFOZ5xo5zzk4slWtTJpHsc/Tq1au7uzu1fHV15dFpoqV0uMpq37C2VktvVCR1ny76tV5qaSSwzjG3JQ2rRCGsRDrXXpx1akotjcuWzWaTUoFfmaGDLu/v77zx+TAMV1dXHtVwPzjVMMwKXGKq1uDfD4yM9Ut9idpbdBstCFartRvr6zx+wcfXWUcF3vjdX/L4wvPNi30fts95dC9XohBEEsBDCwUuJwzAauYF3dpcrx7Xrh6a9g/KpbBoajBz8ypSHHW8O9//6Z/9u//lf/6/cQwp5U2/ned5CDHNmTGslGtBTr2plvdXyHI/HDgIq78UqiFhoAjg2tetFzNgDDlcb5/t3jf63d//2l/+xZ/FEOQ8dmSsAoro5Qo+WAwAQGoBGEQBbLuJv//7//xP/uT/41WwP/35L66vb5ljH+M0nRHRTEEW9GOSjGjIaKLMmPMcQ9j03fMnT37wgx9RYAJKBB5bzmlmiyGQSU7zGREddYXG4KGHWbuuMxFDQVAECrxOEHiSv026geNioRQIVd3pFPfEzAYaA7P3ObCslojJFFyZNUcE1IBVxOUvEIEH4QAgpYnRIcMoaYYqRNRDYWYixohIIipIYCCoYllFsjdYXXvGeZo1z2ZGyKZzMGMAjKUzgWnuuxB4A2AYXGPFGL0eMQIAB8o5D0NsJguA2wrEyCIZlVQVRJzwwlQ75pzzN/79n3kb+dPhHgCg71JpzdYBIRq9ePkq50JfoGpyHLdbWofmAPRwPnchTnNaGyieywSAm5sbM3v69K3tdjyeTqfT6ec//4SZQ9+dT5OLyCdPnnQxdj0TURc3zBwJAAAVttvNNBEiAhMipnH0unxmnl8fvXFhqCSRYDTlhIgDhfHuMKeUs2aV+1f3m81mPJc6H69qExAASCnFGEKISTIRgREzj+dZMnpwyHeWqNxe32y323Ec53nuiUQTVeKIopBMN5vNq/vD7c3NsNn1TH3g1/eHly9fTnNK3ge2fiVDRhNCBARDZKx0wZojcxc6rtwUZqYCquqGAq6alLjdFkI4Hg9m6qQuwzCcTuPV1Q1gTmnGAAr26tUrojBn+eyzlwAQu36a0/3h7Ljx8/m83+/3cdhut9M0ff7ipZm99dbb0ywpiVq4v3/16tWrzXbQjNvNnjAwRVSBqgnQ29EAEaEVyjBrm8KXunmtAC6BZQBXk2tMFqkCuqDEhepLa2itaeK1JvD/YkAPxXggkgKHGIhos9t7TbNfRDRxoCzz4XQEwhjD7dMbBRFJw9A5SapqZvZmxqvGaIiqbhxQlTxLUvwN8hnRkwhuiyMwU0wpmSIRcXC9jmaAuLBrQfEDG0z4QVWulXVS3Qw/fOj8OS/iyev2BHihXNY6vpn77buICCBiuSgxK8qECL2k2C7j6uQUsg8uDav4e5vLZbwuVaE9wnBdvt6F3eFqGAB+/vOf/+W3vvn7//xrHQcvih3Hc99t1kEMA4U3qN7/rAcippyJ4ebm5g//9b/63ne/Q6izr13XEi3bAQaqYorWWNDIzLbb7QcffPDJJ584Nf/d3d17771zOp2GoWMsuEcPJNZVW0qMtBL6OJq/7/spzYFjMGDGwI1RhwKBWVCA1lupFCkW9COqLi0lHk/W+kOA0jMclu2xbNry0zePgoICgOaLokMAAFD3mB+EvgEAzYzddzEjXUfb2i0YqiVRA+BZMhhhxlzbP/hpIRbmprNoCIXwq+uGFntsstiqw+TjSUQGCmIhBCdPtwrOXINFRZOZ5VR7TgAgYuBwe3vryrIVpzFz3/fO1hQCevGuiHmfA4/m+ZyGSsi8HTZl8KmMsru2CCQihoUw6Pp6L2LTNOVSJ2Ov7NU4jgRKoJELfWmLT4iI12tRKbgsLaScfzTnjFaQjg7Pzaqq4NhXVUs5E1HhFEtpmqa+2/gsxNAzs4DzMzjLKYcuuuqNMd7e3qa0QHPNjAD3+31rtmOwtLTC2jSMwUTEOb+6fvDWFEMX/bQIaqFLlQ6QV8yaD8R3qq0yVgp4LRaXpewhd3fftRbpAsDNzY17cuM4dnFoAZXPPvvs1avXTg8yTZNIoZJIKe33ewD4+c9/Po7TZrt1hlGnNnv9+jWAulvstBjMzAE1KQAAk1c3FRLaVTB2vReaEqkU1G+gPAQAs+VbRAyXekJXdDEPthsiGjV51QAt2KAS/mfLWzszvFvbIQRGSmZOleMFhFA7Hvp9Qwh6WYfTXu2BslgfLdzlCtyr5taFYWa6UpwX2KP1XVa3+LKEehvP5eugHuuGqra/+Mrw+M/Hx+P3xerxBqlq+uIfIpTedghLOBsAHKbrPMbrpC/ACg7elHd7ZzcxMkAXIgCkcfrGN77x/Nnbv/3V30xJ+ti1FJFezJD9chHmX80J/mXGqP0+DJucE1L8yle+8o/+yT/+xp/92bbvz8cTxaBYeFFLDbN5N6PWWgQc/fHVr370ySefOJrm5z//+XY79DEi4vF82vRDLkQBrb6tMEy52WjOgBDCzc3NZy8+BwDmoicCEjuNPiMiJvXWvW4kKSNqMc2syZ32auuF2Kap/tlKm0oFhUu0lGeoYauqXNVo6YeBaGhoZs7CcUF22BYVIkBhkHCzuA1+OwgJYKHIKdYlGSFHQwEnsClMmf4iWTJRaFuomXGl8mgluQputnKKDcMA2rzSwtJX5EjVZ2Xc0DlMIIbQ971U9sSCr6lC30k8CEsvBBE7jUcf6kAsBrlC8K6u920KtBY4tr1jamkWMaUy26hqXR+HYfvs6W3bUzlnAuFCfex4JmW4QN8gIhB69YiCdTG0AfFJIQEFCxBVlVMwBGelKKdB3G63HlImAo8Yz7P3hCCn4M5J3UZEZHc3AUAL90UHbulHUr1ADxUQHCEiehJRK7FDjPFwOt/dH8ZxNERG0Lpi2+Z6IEl9vfmqKG/tfgwta6Au7MVlkUoKUVpIIY7neRrTZhdTSiL28uVnr17feXbMfUQz8xZewzCM4/jp61fMvNlu53l+/foeObjbbWaRKcaIBLvdhpmdu630DK2v0BKZLfy7qMbytGjmab92kJtPqz8Xnb1qC3Shg5uWWt+l7egKs2Ko3FgODmiTxZVF3L3/7XZwoR1C6PvekXruszqzx8OH+KUPrHa8VMauNYRt9daKeNHK71INE9JaU5ZeT+u71KV44ZAsgw+KRbK9QWGvtduDTx4sywefP9CJABfx2Dcc63laa1YzXevgdo/1L+2WRIv3nVUIsN9ujvenb37zm8+ePXt681SzhBBSypFDU7j2q8Ghfw0d/CXnF/vDJZCqEuJ2s/9v/ui//d5//O48jb7NENGbNHjRrNuSXu3TXFgyePLkydOnT+/u7kIIp+Pp1atX7zx/LlIae1kJjLRdsehLIhIo6+/29vZwOp5PY+BYEW4AoGRFX2rO7iAys/vjiJ7BXUg/pDYz4dpFuO2RqrlNxar0XiWTGFsEqfkZVZELFBWLTbVj5fxqsqbdCBEBtAC2Vx4qVQwaEcWqONfGe3kmD7Mhdl2XZTazLsTS6KI0j/K2P0ugqckXD4sBljjkgylvtyvuYy0gWZSiGQB40iuE0HVdzjnLjMCeIJznmTkiE6J3iQzOzAAACDYxt8ZTADDNY60IX14/5yyp+O4iklVcPBIRguV5OswTAsUY+9iFEJiIeBVjFBURrqlT7njwbBwVglhYCFMVdGEz7WXwgVKwnKrgc9Ej0A8REafpXDxsU0S8uroKIYiomAbuAGCeZ0R26EDzg/2Vs8yH47LwoCpgZk45AQDzjCH6xrnabU7jfHV1ZQ3+CsSsYutt8gZJ9+AT73XSFFs7p3lXa2JRM/OQ+OvXd33fp5Ry1tPp9PLFK7dIpmnKeVFjPuDH41EVVCUlOZ5P+z1ciRyPxxcvXtze3h7ujlfX+2fPnt1e33DAYfAapAtGqmYQrBVwexEFMwEiAvOI4HJUzd3M37LvZMWSu74RrPKG69GAWnpERIgEhK5TqaZpm4ngnKDeHejZk6dutVxfX4vIOI5cCZ9jLI28isqEN2imL9HLflrDcqtoiQy9AbH1sKEFPNJEl4cPyNKqdf1I60VVhFVpAP+Fz4kP3ZiHpNPrK6+fp51mZuucK5T7uqeL2OYIV9GJdovaRwEfXPqxMtZakwCeXzRAxO12+/0f/uDtb7/9X//X/437TSEEUWVaGMldIQHSL62D4ZdQw7+knl4MnNBFwkAMH3z0lX/5L//w3/4f/3sMXUopeN2yYanDA9Pa0oSIUC3GmGYhoo8++o3vfOevzazrwosXL95+6y0iYo5mYoZ6Qa5WynXAUzhMvr13u90wDMfDqWxaQjfrHMZUgC1qTET1yQMR1XwnrqjVfVK5srO2EGhRMLXfcJHptcTwcqmtVqotA4Urnltyap/VUePtFz53E4jtjlS7u7SgSL11gUG6+pzT6HeJMfZ9iSUGZisrtfQAWOtUJOj6+OCmVmOzUGNfZpZSovpIrrbNzFdOSjpNU9d1iJZzRgBmy6K20BlqDCHnPKZZREULYrmBuczMeRsCMVe6hhCCdxfW7Ao4oLezIHTuMGRylisCRMQYOASOMYqVxCEBWmPWBfCqemamwIgopu4F+BqQVRNTVTUszpmZcaAQAjL7SokU3cza7XY55ynPHux1trXT6ZwkSy6lokTB9XpZYwEBwOexGTFUGxKU9ROC62kwmKbpPM5Q6oty3/eANM/znDXnjKrgnrg3CYWSwGtLca3Pyk/F0HdNhZQZfxT7cXiRE0qcz9N2ux+n6Xg83r2+R8QQw+Fwwgq59xudTicz2+/3U5pTSiF0TgT94sWrcTwx8ziOn3/++f5q1/de/MZEvviXPVjkUdW+RKSwKOP6Up7vxKLJ0InyqXbiWtKCJWO0ymW+Uc/5dtZ6QAsyITrco5UsUkPAIbpb7/Gh/X7viG7PjjXmcP/p1O5Y+W4BL9ThpWx/w7E2QVQ15eT8Zf7h4/dqlv2j63yZnMcLT5IfPM9jlflFjwoALvyXb32BwgZzV2t1IwQzuyDigEerE1Zm4wOTAYqWreOrZnjhXPsvhEFEOGCzzohonnPXERH9h+98+/33f+O3v/qb8zyb6RrDvbbUAL+EG+vB8WuGo79ouHPOIfA8nUF0M+z++e997Sc/+cn3v/fdSAyIompWextIsixgZQTIhCioTZLk+fPnP/nJTz7/9LPNZnN3d3c8HjebTZNKWkqelniUiHjnhhoGAWmOrChERETiorEcYWCEAEZUGzNYWZpcyoUXDhrfVNM8MnOwErltM8tUhp0882BgqnYRnFkOgwJwaDNlDTdQxUz9XOp42hJeRg10Adp02S2AoMUEbnFmrEa9v3uHndeJam6hYiFEWnVtohVKAglUluaJrgBEJHJApIbaaMIx9j3VgD/UUDMiBrKh6wEAwRrTnmd/nU36cDjsr68dWbrZbJLk8/kcQuhCseJT6YVeIntY21B6mtAkNQRpUZAVKFfScsBW7RJGQw4pJWf+ai8utY6oxTytrm7HWykY1TXvA9L3G6ieR92AgIhe2OoPM2x6TAWA6hfvum6g4XyeqGSdDWEBb/rzt2yiR3G9YIlqT3WyQuwAHA6Hw939cRgGhQKJJ0yIGBkZec7ranvvvSoGBAB6WQlZBlARAPKqofoDbd3ElKput9uc8+eff06lznW+vzvc398TkRi0YqRlOVU1nMTEEFSJWQGmacqljeYcY3zy5MkwDMTQdUEqj3Td4NCuVuMTS5S4TYQTaPtyXkv39vCLkPQLropzHiin9Vds5XZXy5gM0QGM6+HS2pbDW/8S0e3trX9+dXXl67lxDLT2D+tHWh8P1M3jo0kqWAzo5TUfq9vHKrk8+aMr13MWU6DeSB3PtRZiX/KE7UnhclH9qoffKDz4qF1OL1DQS4Duwfub2fpl2xXWJo+HUFQAGtNKoJTSsN0cj8dvfvObb7311m63y9NMtZ3ZWgd/8YR9ERXlP0BKuB0hRAQgjkBAQE/fevt3//nvf/vb38aenda2pLIYQUBVA5fla62jCEsXh9/66m++/PyFiPR9/+Of/GQYBm9ow8wP4kiuxVTFd8kivMTcjQvEMcbgHcIBkYwoAFrKJW3v1FhNvNoq+IyXeL+mcpYxr/mCpor8/BazXVtIAOCp4vXz55xNBOqeJHLASLUkVt1Vm4I0W9wm/5aBEmIr7ViuD6pmqjXAVYYZiWgzDDHGqUJem+fqOkBN1u/VpKEDjgBANTdJ5BYVY6mgaEPEzB5ctpIjcB3DHIMH6Mxsmqa95kBAgGgSCE2ygmEMANa68Pb9pvn3WtFqqhqQHshorgVXiKgpI5l7O+7HIkSvWacV0KYBxJr2xTqA57k0mVi3uAYA73zVEhOqCtb8WjJQ0QxYRiPnvNlscs7unM1z9jWB5qX8ZSV4+H0ZT2bXtQ7YcXxyx+SkxKEfEHG76Yk9LB/S+ZxzBqucR5pNtRu2DS3c3pcMs0pbnD4CORUTYX3mA1nZArYhhM8//3yappub28PhmEXO57MZns8ThRxq57sWQ3ItdT6fQ7d14zCESATnaQJ1qKm9/8F719f7foie1c6SEFGlmJJlf6GbuugW83ozFtxZdUrMDL6A6uHyvcgMRUxX2eD2uk3CrHd3TcaTIYVVd3CtIGo3m8ZxZKT91VXf907n4nXhVpuC+0Jtir9okEfC+5dUV1K7ATKzWgYAp7VvV1iG5QuOx4oDEWtA98EY+qJdwKrlBAOgB7fQB9+1B4bOo+dZi8fHzxa+fDgeWBz6pgbRy11sgWK1e/hUlVXbORdr6rouYDifz7vN5m9+8L2PPvroX/6Lf0kxCAhfqlVEBDB8qGv/ThboX1kHv4kvGgBAVLDkPrvpdHz+/O3f+72vfesvv/k33/9uxCL11ATEnEZx3bUGJHdd7+Lj/fff/8lPfvLjH//Ye+mcTif3n7JqJDJb7D4v6nIxDUXBc9NbiMjMHQdmzzoQOY6RChLDkzleHWSqUt2sFglk5tiFZk6tzdXmYq6X+Prw12pmlpk1LtZFfLsFUR3QqoCLjFgnX0t2VkoMFqryaCaCe/j+/K5TwQgRY8ceBTUzj+TnnLUy7+AKKdZekythSDsHADabjXdwyjm7n79EZc0yqNd0uI9YHgnQcSgeS0gpEUmP2IVIRPv9vvFM+QmG6MSHfpfG6JRSCkTBO6WbBSJGlDxj39fn0RgjMIHbNJ41iCES5xVxYK7PRrWsyN89pUSBS95Hq/seQqQyMj6kaBCIgex6f+Wvad4QhcArpbWix0MIqTb8JqJxHJkLoYe7j81DgtXeNzOPSfozO5WNr20OoUO0NPd9v7u+aasuiwGAGA7DsNkVHtDz+Xw8nc3McLGr2tI1M6Koqv6m5RMGooiIwQPXK7DFep1jDUucz2fvqQcAajbP2RtL+GDCyl5kZq+c3m63p1lCDDlnGcdC9Qx6Op1ub69/4zd+g5kDsVeuU6FwqluJ0GzZd5d7amm7S7iA5tblMet3L7u15KSWWqa2Z1cyvJhubYMvA0KIsGycNrweSc45S8oYwvX1dc6ZGZ3DJNcGcU1ViyTPxUxpZmcXXkmYN2qjB4ef46aq04aX4D9pIX0qrGGERBdtbNuButb8b7zXY+Vdo3SGWOwhQFBQrCvnwdfXT7v8+Xc30r3Qqgt2dD00b7QdWoSwrdoHchlrAhnW0998xNo/1S9CaETkdYr//ht//vbbb7/33ntmpqIxRMdeGZiqepOGL+2S9J/w8LuDISBhiAD25Nlb/+P/9D+//n+8fPXqlUmOzrwYwpSyf6UJO99ELogR7YMPPvjZz37GzH3ff/r5y+3++mq70Txl1cjFd6RaTxJCyFbJF0PIKTvJbRteM2diJAATEarJeN+O6OlpAKvdQF2SlvFX9GUtlx3roArrokGh5rNX66E5hdUaW+ri2+u3n75YVC9aHzYYjsvxd99+x3uLNoOg3U5ECAp4xxTFjMgQcZ6yyGRu0RMzF24QUYWK/9IKNzOHrXaF6cXhnbkSSA1d72om59x1wRtN+rdi12nKrb7FZTFSeZFmnrtg9Qyiqg5dn1Ly5owxRozFiW9gzj5GF99uKYVAIQxE5HA5H0XmCGRJFNW57EFECU3VQs9ew5uzMkcF8VZIzW9uIUSFUksaKnFpm0oiAjWVMlzezkGz5DkZApfOr2cz87ygquZqfPvy6LouZ6l5wdLDrsUGmsZ1DshxHLuuG8ex7/vtbldkqxkzd4Rjym64nE6nLEYpHY/HKRVyxKwFDYBgm82gBgQaqBPrfY05CMjdF5/KMjUU1w6l+w1YWVPac7pCffXqFZXmhvTkyRPXvj6YYuqQfdXF46xDNJNXqa5yw5s+TtP8ztvPY4zX11cxkKoSF6iH5EaSXK7jYAm3ydqKtdY3V2eHiHspTnvslhfwETBFD9UWfvVqAVOF97eNvP5WEwhZJc+p64b9fu/r3P+3WWDH+wMROfa76zrV3Pe9QxlcQ1drmyhEMdWc6DK39WBrr/XWA93mjTo8g8OVHxRWSq6tYURE0qaCynTjYlis7/vAhXigyFrElxoNRDFryu10ZSqZmXmRG1SaCrW2MB5E0f1bvkOx8oW1kNXfgYJuL9xGCr2m6BHYqiUEDd/8XUCFVeu9pLmL0Snaz+fjn/351/+Xt//vABA5aC33LC0HTAnXbvcvqYl/HScYHpkw7U9VAyMI2PWb26dPP/zoq5999vW+j6qiSV1GxNi1iS+/eA8RAxF5+5233n333Z/85CchdC9fvnznnXe8VaqZZSs5OVtFh4hJcgmseYNYx0z55kQgTyu69+zIFCICMy1wAMw558qbShXi5OtAsppemFC2An9BBWUAlEJZXpV/rIPYzWXUFRVRoCWoDuDtr1voplQueRLUzM7TmOfUjID1ICAiEoiIZFOdFaHJFFRDMkRU1qBMJHC5rx6Emk8nC5GdIsoHyv3103gOIWhuIKnCiEtE42ix44DUmtWnlIAx1O4uWL1zEWkdghHRG8ECaM5zCNy2IpoRADNvNpuc5/Xgt7eWmmJs6WEvVDueT+M8oYFbKl497y5aMReiLwbzQiAHZFBF2rskRcQuRI8AFw9mTm4suucHQODbT8vc3Z9OTivmr68Vm2OVkS2lFCO5unLN19a/y27/0KkfRVWPRyLq+96jAknNGypP0xRjnNPskNpNKKHjyKGFHMwslla+viU1ibk1U8qfKsjLrDLNXEp8MnAW62WD1w3rCzjGbhzHEKNfk5lz3YN+ZsmQ1Au2UEeeJ2Puh2hqT5/ebDabrgshUmAKIXjBoq7KgQjQCqtX/eSSLqOoQA4V9IdlfxG2ZEoxc3WxbgEQgBB19cnymlgISbBeXtzG8gXvZc1QgRdcuSTH09mVsfeUVFXHK0jFZ7VUDgVe2+sPNOvjT954wpL/vtSaD77VYuyPL2WXXunlXLfo2pL/WjRxA0hdXrZdvI3nsm1B/ZpEREi1n99ynSYn20pbG0ZfqIDXT3+hgAHAldujCidHbcDl+i4P+qi5YQ0DKnAgwB/+8Iff+Ms//9rXviaCAOJ9NA2MkAzs1+3N8Oskgx/3TSIkq6BYU6AQr29v//E/+6ff/e5fz9M5pbQbNvf390M3MDfExMXTBjAjUtWPPvroRz/60WazM7Of/vSnV1fXPmimgLSQV7iMozZzCIfDwbUgMYYQmJhKsYcQQdd1nmFyIIeZgaF3RF0bd3CRZi5lcKYOtSpt11xSPD5ZKwMcAISwBE6av9u8DSJSAM3Z19lax9QoHABA28Dn8xkNvKqn+cfNwCeDUovllsUqaU1GgQwRBdEE61x7N+x1cJJc/XSxJ2RakVe4JvBgAJ1L94K2/4kIk2c/ikQLIWyGjYfdPJrqnYWY2RMrTklotvBROKswVUy4WwCIGAKtJUjbnFZVb4lPxFJX2nUdc8m6EZGXxKiCi+ZVvME8WBOrxmVmMW3+d7Pk8pzWVbNYCp2xiXUFawFYDxucTicirozQc4PLSm2p4jl7Bxh61w1V3Ww2/tPNQV1R6jNzrK3gp2nq+s2w2fkJChWOTihEre7L5ZunjUVEKlTe064istS9VI+krecHOng98m2Rm4Gq7q+u3CO3Wge/3kRmbbF5hGlUVSbigGRwOJ6ePX1vt9v1fR+Im1Rs56/3F3lvswciqK4KEQHL53MR2T4dMUaveijq0xbv0Jrx3UYACqtdEyxQS9F8qfsC8w/LRlgVILkmPh6PABBj9DCPT67ViJ1HlTx0hJfady0GH8zCWne0t15EH5Gvn7YmHzjB7Wh69LEyXo/z4xGGSy2LWLzYx+c0sXZxwaURwOI5MLOAYGHT8DMXPgMXXMTY4ClgFmh1v7XF0R7NqS2xPWgdCAanqsLLL5rb3u2aBFXQ48VAMLNKoWtwuM3Xv/71p0+f/vZv/CYimglhMDAPPv86ILNy/PqArLppSp1NeWZVVem7zVd/87f/q//6X/9v/6//5367TSp9N0ANZbinCQ/AAvM8me2vtk+fPhWxGOP5PH722WfPnt36ZAiUrkzgeRdbaM2nlI7HY6w+Qc45RALAnBRMuu6iIF0BTMyDKLD4oBdczeUFHxmPZubfQ0QEUikMAL4TvGKpiST/ihY/g70qtf0PhcBv6sfSbkoURCZXXa3MwGqErT2PAznWmWM/jevhRcNQY0dS6vfbQl5m3/UNG/uSq2dWFGhgFPTiLuZitbiTx3UiiGickpVE9UREREGzHu+Pt7e3xGAIWYVg4a1t7OxN61jlnmxSo9k3ROQlxFCFgrtiTtarWm7ti5IDcwgiydRUFSrIkS0Q0TRNLXjerJZAXDAnWYAshOCE+9OUCoWIo9BLH1wbxxEiT9PUdX2MMcauScmu61CNmWG7EykhhzHNmnMW9dVLtdE9EXkPiZQzM4fQufp0XS61q4RP6zzPnuhthVtee+3RSA6xsYnVERMXRDkrAKjkquSW5ddW17ILaqCyoSv8mjlLSskAnMH7/v6+3wxeO7cW8R7FMbMQmGgIxNN8TilNKcdI77//ftcFKl6viUjzrVp8qz1PW70E2NQnVepA4AAAKUkIS4rKc3Nl6V4Kx9pQpu0gAJSmg9dLrokm3zWNOWe9UN0wcsU/DEMIwWnbXTe3xEe7oxUoUPnkgQ6GS427/uSBnmty5MHT1k8uUFHrkay3M1vBUwCWW+AqlXnxLTVoWeEyiFUMrgxlddoDKiq2bQe4kGyLTdB+b/q7AF/Mn5AWaCu86Vi988NRgBofX6/LMg1grvkREWtu0v05jx8jotX0gxtiXur+53/+Z29dPX329JmoKGTCICpAsBq1XyMT/KA+uE3el7vUTcHMTKX8g4kQsxnGoX/+/Pkf/MEf/M13//rjH/7I84giogJqSkRQuFmLIHCy3M6Qmd97772//uvvurz77LPP9vuNl9Mse3WVS/AhOp/Pac59N6hTwKc5Eg999ECjm8bmBpUZIlm11hERiNfmNxAZmpk1vOta+6JRSgkJAVHB0MAKlzoBADLBKg1WRACYqnpPoTKz5s8f1HHgdRVqLXZcC6DmW5RXqCKAaymOLSIpIKJ5fGVlqyYxVLXKDdSqIDhwCEG10D537glR1QpgABhil3NqMrGBsxAxBPL6CjMZz6Vj+TzPpsULCSEcj8fD4RBCqKwRJWAgVrC1QNiwWsUfrcoYVpGotc/NHNKqubKpAcJm08cYS3Ew8zRN7lACgLfcaJrG3f0Yo7cwajqm+anQrDGxptgASvt6Mc2pEHYiEwDM4+i+LwB4xrfv+92wOR9K211EdFYZrPlFM9sNmzHNbWavrq62260BNd5HrlU97777rqre3d3FGPu+V1UFuru78wdzGyJ0vY9Y65DhHNp13LLjZgooXavFaQVO0RbShRlK5bR1wNNKZLaAG2NkdwoBgDmuT6tXo9jTdrPp+/5wMJBOTZ4/e+v6ek/Q7CoQEc8cwZs0kB+lkkfVdz0jgVrOmbD0SXQSrjWexsxM0eOfzXD3Jii2CmgjItBD4mJbFSX6OvR0mO+ONpUxxrtXr11ceJ7eZ9OyTGluU1mK8d4UpcTG51NTqlUWwVpvQjnFxJa90FSyLoQ8Cit6RLskyVkP71pzLQ/zBS4yNPVMi1Zun2PxdwEAfHVdvGC9xYOxffBUTVHSyjdbFDA80sHrP7/ordZO8PpzMgCsvApVd6L7x1UfO0Wcb40YgsNYPvnkk69//et/9Ed/dHtzKypWu87BP8Dx2BW2L9bBi5pnYnAn3tyhD0CC3Kvm3f76j/74j//mu9/rQkwqIXRrdiFbwQEAHV8zK+AHH3zws5/94nQ6A4B3lysFoCDWrJNKagNAqnA4HJqmDCHEELbb7Xa7BckqCaD0CnRa2TYR5AIpdrYGa9TEVQ1hFK+9hV7dciDCNd0dIkqt0mnWp8fBgNhDlq4adUUap1WaBKw1hZbd+XMLer1GG8CnqQoXR+1qhvkiyq0aiL1Ol4i4RoRcVWBt2YSlMgpSksYBUlCdHjiNYQHRkFFtN9vCRDmrGELSk4yqioE77kRkmiYAvLm5LdYJYheHrvf+xyNUfJZCibq75iCiLoQKLXlTZkilSBm3CpAJycyc3dB7PIzjuNlsXNe+fv2aaryuWjUjr3DjIgqAMfYevnGaiALnyQIAkkE1RdMQAiHHnmPf+Zv2fX8TgpnlnGPsobb8i8TTNPV97zHtaToTATMxd9OU3Kve0nCaxtbWt4uDd0zy+Z2myWfTex5vt9t5nj/99FPy3JPbMZW9BHkJCfjcTdN0Po8NsqBibTnV8L+qLO351odfiowUS3l32yBQMyMG6oP85MnN/fHU3MEHkhAATDWlaRi650+fbbaDpHx1tZOU+50/sxTCHC0prfWM14tc+DZtMTAzY+nP4duBKv4jhKACXqwIq7wpMxtgizpQhX3QygiuKYZFGHoGN8aYs7aKXhcL3sONiHa7nacSfLFN09lyqW90y4mIagnMG1xeuzQ71nb/+kwXG01LtTVcJarYJQ4cEVfpHVvd60IftdsVQfIo/uzuL1IJ/q0Vp4K8sZKqTVazyaACS3HlFrejjWqTjf5nWD/KA3uhfdLWx/qhv0gvls/dbri44MWIt4o6IgyRp3H2ufze97632+3+4A/+wLGdwffeG+8E8CtGmP9+4ehlYooO6rruo48++q/+9b/691//s6vdXkUDRcCFOIIrCT4ipjmHEE7H05MnT/7xP/7HX//6nw3DMM/zixcvvFVZ23iImE1B1RQBLKX5fD57Es53b9d1wI4kR7u068HnmBqgrHzSZqFFrlyg+3+pas6zW75dN9hS8w2NmctJ3q3mIPxgZkNq18kqWPEIbUuIiFfzmBmqQdAmC7Bmd0REoLTqaxYMM/k1PefWljiv6mKxUCN5/toAdbPZrDeAXRQ6MzMxs9c2TNMEq5BgE3lYE2YucQAgxmjZ2Sp6DGxm2QxDqMXaJZwwz/M0n0UEsaBkVTV0g+ODuFJRmhlUZDIRtUJqf+zopSyK4zypqs/1NCZVVbCGg3Vyj3mc+r5HRP8JdYc7IEsrJar/l+eeb25ums/nTs/5PN3f34sp59JrEgMfTmeHLquqtzNypPrxeNzv97th4+uQSlK/hOtFxMPLx+Mxxniaxvv7++vr63nKt7e3p/HsVP5uVHla4e7uzvFfx/M0jtNuFzzw4FmJ7XZrFd7cHrsIfZGUS3Q9pblC2Rd4oF6CdJbd0RwsWOz79WmuS7KknAvoV0R8EtvSwpqT4oDM3Pf9zfUVAAhSjHG/33d9aMuvisSSgbbKKrnWCs2FbcvVF+o4idRiZau1wo5r09olF6vvDgBq0BSwv2aMkbA0t7Ba0uZyHQCICQAcrN4ew58qpXR3dzfP883Nze3trQckrq6u/b/amVgBnlaG8Q1e5mPDZT0jTZmZmdrCTtNEIhTte9F3aG2vND210utLpNNWx/or62d4QHKytg/Wq2g9QevHfqwiH6jOte6HlXr+MhT0+g0fjNTyiG8MTTfdi+iQh3a0q3mYK6U0DMM0TV5F4JmGb33rW0+fPv3df/a7iGBgIuLsFv9Jj9b68Es/p0aA0veDd8T84z/+4//wzW+ZWRc7EcM6x+X11wB3oidPnqRZnj17ttlsxnHcbvaff/7pW2+9xcyl79VF+KKwGaSUutj7iHmv9WkapxD3m8FA5nFiRjOzChL2b5e9KotG9L3XftdaLgUARIE5Orqq7X8iB9sZGjiXRd0D5rQVRGR14qByPEmILZYLK3fcd6mkiVZYM6i2NjNrlSaV1KK08VlrZddkjT2DABHLsiYDAyEMHodrd2++bA0Fe+Q2Oh6q76I2sJJIoAW0bJVhIOfs1O7znGDFnuHSzVUv9l3PMcTi97SLpJw9w+IYopZgcz/YNynWoLSqQk5uXQ0YRQu7NQxgiq6QRGToehFx+6Aben+SvOp472PlOsM1mWvQyGGkPM+ZmYeudzpJANpd7Zl5PE/39/cUw253BYix63b7fRdj3/f39/ebzcabJF5fX2vKjhDWUrKcXevv9/uUxJsZA8A1wle+8hXJriNT7EsNdIxxt9t13XB3d8cxvv8b++PxeB37d955py3L0+kkXoyn5rUurrldXLj5SFzKx8/naUoppaQKIlL41VWaun0gfH15F4DBQ0kqIcQ5JwA4n8/jOMZ+aDuo7Q6sztl2PwzDcLXbxhin8+jJgq4PDlDPeW6ryzNSbkp6pxQEEM/8rDRNyxRACQjPPg7rDeULSSuHRsvXiAgaeSSrvbjDozyM1zZC2zUIhohd183z7L2KreYsfNbcWnW7NhLv9/vj8dhablDFczFzVVmLi/l42OGx5rtUeL6GW4TMHwMRfY21gaKK7izFgSsFvJ5Tfx7/nj5KgTXBQoie3H2gets5689phSTFVclGO81WbvF6tdgjK8TMSrcsM2NGAFQtVrZHl9vZRJ5iAQ9TNBnEWKPj9YpF9il4wi3pRcibiDxH6Dk2l9pIJKoiSkYIyh19/c/+dNh0X/3Kb4lITQCvPfpSCmAgBG8kBvmi4wtTyF8UjF5xgGjbAoAxq2z2z7NGDK/++L/97/6//+//tbveqY7IT0SS92Qmg3kuqSyKIavYLF03KHT/4g/+xf/2v/5J1/d9t//ZTz+7vn6CgGrZEKb5TBTASNW6fvOLT17OCbo+UmAF3HRMBn3XMVE2DcgcQx87EVEtBXNJhYg4sCiUeGlKMfbICEDjNCES8RA78jkLCEYllRu5qOc8Z1fPzIwMWdKyGRDNIIvKnGLomNkJOCMHDEsjowaWJlrYnZyZaKErUWeepFZI5zetVdSmurCIq6oR1jBmamnssrgdE0SYRUUSM6MYMfQhNo+hbcWUxhi7YRgCFq6Ymu0rzmvVjsjMWWVKiZBjjFDDfb5xzRQAQ+AQghE6dlfEiFBExnEkRSJCAZmFiWOIIjLlZCaY1WkxkNTLCwr+M3QioiabzSAiYjj0Wx/8eZ6975OrVQCgUNriAmFQB3aByBRj3Gwc2iaqGiP2/T6EkNK0HQp7xqtXd9fX1wo2DNtpmhDKNBGSATIximbM3kfEx3Cz2Xz++edeKeTSP3a1E8M4HcYpBgKgPI0etunicDqdnPauGRAiMs/jOJ4AoAt9ms4myVTPx8yMY8pXV1fb3aCWj8djDP3QxWlKSJTUEy7SDCbJScVUcyDKLviYLKspouPAV/JUsUCjAaCVjrT/rVKZkmQEcusfoFR8EVHfB0l5TjMR9MMwDJsYYwx8vb+62u+maepj2AzdZtPHyCLJUwxSy3b9Ikqg4NmpsmihyvSSBlJEYBFBYAT2Gq1xHIeh8+6xLWzuKz8lcb8/Z5WsybmPCGOMIRIiiGmIxYI9n7NqdgyRVrxV3/eq0HVDzhmQDSzl3MfueDjP89zH7upqN46ngPTk6a2U1gvRhSkzGzkIwLG36ySv+y4Os6+JyAJe8zOb54Zu06eU+n6jTuLNnWhqRiRjuaKrGC+2UTV2u7xdtB5rLQtmuuruUG/qD2GmhR5lWQNrTZnNVJEImwAhLGWx/vj+2iWLjaS5QEC9Vq2GYYiC15Ejotb2jioSqrhcinTXP5vmXwUoqK2AJjEBgJwHnx5SUYJnYnBJVCB6JsOaa2K1zFSds1cVEb/3ve/dXD959vR5Hd4v4aT8L3AgYs7iuavf/u1/9Lcf/+Cv/sO33n3n+TiX4I/mbEyBozfysyyhi2nO4zhutvsnT57c3NyklIj4fD7/4he/eO+9t72GrOs6EQPEEHgcx3EcvT0qFBAKbjbDth/meSa0GKKBS9iYUgVOV842VEu1BXohQeRIpd/ALEJlyRJCmTtqkqKNtoiYaCOZg7rKHYgEtmhcKCqzQDOabdg0lq97uERle+SZuQNIzfRug0zEawvXGxQAwDB068WDiAQYQnCYUfCOAmRuthORK2wAAKAlCSoiUrvXVXAjVhKVxjDVx66PnRY2t/6B7KZ65JxTmqDuGmbe7/cBipWtVqRw3/fdZnCWiRBCVwsRqlQtFB9YioAB0S2GxMwx9q6Gm1+V7hMzl3LECh/FGnqxav3UsMespesljuPoRSZZ5Xx+GWPsu6GWGJG3vzVaEoreLCjG6LwQTpVQao3MiMjpgudpUk03NzfevIEpOj0yGoTa4c79m+1269PqIegQwjzPnhTzWucQwtBva9xCPSXpcXgPgbhpm3P2wfTXjxyEvRODikhceR62cjTbmLffm6ADAKhU6gCopm3885xijM+ePfHx6ft+6DvVXMqyN53nxQHAk0rUAJL1UFGrbRkREYAcgOGzxszZsogAAjEYiItlqdQxzfNpvpcTADAzIU95PjtVmSEihshce66sd9aDQK5bwyX2UJ2ueZ7P57MpDsPg3QkZ0IGH7QF8FhTLZl/3NoYvyxuWkW/7N4TQImrUynNhAayo6nboacFylth72/vrKW4yqingutPFajxg7YMWXVg12jrCjIgMS85+vU6a0Gj3Iig4ofpfa2g02ioZsb5aaJ5uu3oTav5L29JWw25aicdWyrtwyZqVXKnnAwyxOs+opfN5YX9o0m1tqpjZlKbb29s8508//fTFy882m03XDWbORP8PBcj6+x9ECH03zPPpd37nd/72h9//2u//i29+489TSkSdGaBVunzmaVYiImTJ7kGypDwMw0df+fAv/uKbbz9728w+//zzt956Bmi+z1U1J+37jXPNMLtBHYhonscnT24dYCKSj9Pc9SGVms5iqmtNbuWcAUqpa4nOPVpM7rAhIpiilXlsm7PsWys5sBrDsLr51Xvf0qpmoC1BWtE66mIJLuKvzCYCICbJaNj8zmbjq1pD7pgZBXbHep5HXFU3tuqLtrtiV6yQSEXztdwSoouV7Xa7nU5HosKtIeJywULpox5DCMEluJELsnEc3YjhVQEGMyNZZBQpHj9Uzac5ISLHEBBTspzznLJWAgdEyzWEI5JSShgWfgOZK31Sxcd5S6g2QURETMwcOSCWbriI2FdMFtRZafPlYAJVNcMQAjL1sQuhxP0AwBtCJ5VZsqdjXQV6mtnr0X1NEtHr169deQAAEvmYnk4nDyBPY7Ek9vu9iDCSMzZ3XRfjbr/fmlnO6slOVb27u2PmXYxJi9dIVIzLrmNXQhxXbNUObaPAzOdpbGu7/vIQct9KhOFS8lwuXTQtZCQA7mUtopmZh6HzFeh2gOdotEITuq7r+9jUMFZZ5zbE+l4AYIY+LUtIExiglPeUHFCFf6VU/P4WnmVmf4+UkmT1mfLAgyLM8xy7wP3QJPY8p/YYWFMkXeh9SYDHUBx+aPDixQsH3O33+xh7AO02gyl4XbvVSBUGppYZXclHf0MrGu5xkHLBeTmjhCtIZhZNda5aafJcpr72NKuVoYiXEePV1EPTX2vd3GJ4jxXheuU0rYxYQlzazkQArITngEvKEr32Bx1Dtr5405vtFutRCqAFE+B5WzUDNXUkflXAHof0K+U8tdGHVUbEzAzV8MJAcBtiMWpWpVHMLClpteka2Q0Avvz8hVt2f/VXf/XB+x+W9AmAc2ktT/93GVn/QMdj6BYBgBogKHF8+tY75+NxGk+/93tf+/jjH+6udnlKSXWz2Yg4JV4wMyTUlAyw77t5Soj4G7/x/re//W3PssxpvLu7u729JhIz67rONOGKwNlNkHkeQdLhcHjy5ImNJwTGQOfTKcYIBg5sJgoNBkcE7qPPYxK4MNwKbMfMQ+UGgsgI2Pd9O6e8LZFq6TvbPmwn5FRoEBCRKvTdapEDrpIf62s+NqTMU74cQlilUsyhntqkfFPAIktcxBVws+7NnCTLA+Banb9C7uOu6uFwmOd5GAYGECmIhK4LkTmlNJ0dS4VpZX2WZ7alww8RFTpMkPk8e1hYCit94cUlwJTOc55qrp1cP1NN1ioAAThuCwCyQhcjVQpJqb00vAxmHXxy+UWASsIDuQ5zRrQWHwaAAnBfJd1zLkWcCga5BP1UrCp+OFf8FzM7bMov7v2LoKYbAaBlZ1U1huCwvRjj3d3ddrt98uSJU90Rkbu5Q9efp9Hv/vr1a6dX9KXYIqLTNM3znM2du8LtJWIhBHcrXWU1SaoX23PBEEEN9y1SGC/E4gPpXISyXkh2M3EPBRE1J68+KLCMPo7TmcD6vu/7ngN2XbfZbLz/YPHnGImREkJlxm5SWGRxywiDu8WODGsiu+u6lGd3oz0uEqOHQjVn11spxsgUcm1Q4SOZDQA0JwkhhEApKxNMU3Kd2gw4ABiGAZFzTi0G6fzkx+NRRPq+9xK7nNPt7W2a5qac3JXU6qohYmsAAxdqhpa9s46YEgCo72nXiz44OUtTfkRAxESlWBwR8bIg2y5Z+R7IE1vBWluMqn1l/ZCPP6kPQIUIsKV1yWXmAvHDSxhBe45F0xuaOkEKrkxiAgMEDHmafbc3X96NrPMK9YeXcPByg1Tgvt6Ivj1BWwdVcuX10De8gHeZqLcoSewYI2UdxzFwh0jf/va33n///T/8g3/lpBSG+IASi34deqxf43jEJuF5MlMiknl8//337158/tXf+u2f/exnp/s750p1JI4qeK2XqobQsRkAeLpx6Prf/s2v/uiHP1VVA/3FL37BjCESAJiiC9/D4QAAXdcpWN/3IdC2j8MwqObdbici4+no0TARYWFEBFrCKS4IAne8ibPknLOqeb4zpYQAxIjIBOrFElhhKbACZ1aL8sLzaDCrwDW/VAEdzQLFlX2K1ak1g6Z+2o1gFRZbKTyPKHa+2/3V2sYYhq5qFkUDqk2KqFrbXgULoB2XTqWwgm802dcIKIigK2AIjzeUMx1k0Bb2nJauO8RgVVy6uqrDpQRls3DAcRKRtJiqhO5PL4OzAm2JAtVw7mazce8BER3DDOTZHL87M7MbRmXEjIhIKkb6wvCtMuL+/uhxYwBgQqLQ9/00TeN58qgyAAEXUiQ3U5jZw85E5M3qPZGPiLe3tymlw+Gw3++9NLnBtYZhiKHnSqPtCYvNZuOgYgDwkfemOl7uYmbuOrv/Z2YcgkseT3MSkZkAlGbP4u0PVQOncZ6qBU8h5pxJUhIrOeAqx5YtvNa+fvgKlCyNa6iuUvGtdJbS+bKNOagjqAwANpvN1dXVdjtwxXj7aS3w6BRs8yQi2jK+kl1JXEB7oBa0dF03zcXf9WC7xwNC6FRnH/nNsHWEVFPwOeeApJpPp9N8tWfezPMMJtM0iZiDn10UhxBibUBnZqol9PL69WuPUF5fX7uscBaO0+nkVqYDIZ1QrL3jAxLiB8P7UITWHgGImGU2kBBdogLXNFObhRACmgurqhdrSdX6gg9+byc/0MFNLmF1D2yF1Gtyr1yq9szwZC87L6MBWOG7Kjtr8ZCpou0IDB40kVypvHKENM/YWEYRsVr38zSFyuGeayeTrguA3J7Yt0TAwIBeUwj1gQixVHRQmwwfAtfTpSyyjUWoFK8B8Pnz56o69Ntpmr/97W9/9BsfvvXW2+YNb///JQQNAEAYADQTI+Lt02eb3f7Dr3z1P/zlN50uYJ7nEDrf6S4XzKzvu5xnIADUOY0ffeU3Xr44HA6Hfohe5vHs2TPPbJmhk90TAaKhahf43fff22667bABgB//7Y/Oh+Pt9U3O+XQ4cKXcI1uyRERkirvdtuu614f74/GYczIzKaUIzgXf3AUDXaa1LZSiIKX0V2+ruSljWKT8YlHyZR/iNmhmoIhrlWAubgBgtWfq7kXPrhXdD8u28ccu58N6vy3OjZmZiVQwuW8/AHDOSK1N1uqjOVVy8Ztd8QRigMXpBABf/1AotxhqI+EGU3J5NGeJbIiYZyni2BE0NU++HmFRJ3tTESHuETnneZoScwwBkClwYR41MQD0ymPXQF3vSX3MOQfmfXetDqGb5yZ6eFVjfXV15bZdCEGhZIKYws3NsNlsfD79IQFgu9kPXbi7u3Pupc3V/vr6Wmpl6qeffmpm0zQR0dXVVc656zovGL2+vj4cDvf39+7d5pw9heyi3BVtF2IIYbPb3t/fn04nRPRco49tCOF8Pmf1ioN+t+vmeXakLhXIvc6zAAAydX0cur7yWGhbD2xFKxTJjRceQvu8LWCrxVGpkG+UcAvWRrlmRozOyMhIzukdIoVIm83Gi7N9fXJYAj9tCkSEuZShq4AYJCkhrtJCQ8vTNtiEAxLLoppnEdntdsXaE1MxJyFPqYQEVABUsGNEnqbpdDwTkTiCspjX2LKhrVcjEamAmfZ9L6UVoyHi1dWVP97V1Y0jDwIHVxbep6uJC4ASnbRHgVZYI3hQPZNoZmqZiaF6faH0Hr2gUsDSEo3xkYpdH48/fyB22n+F2qkFqjmuq64ttnI54E36Umu9Ej1Kuj1+9/b5+nkeXDy88847UIGFVIPDtuIk852LFZsqK2YZNzkXp3YRjtTAMoG79f2aaUOtKwAs4Uoz895hrjlubm4Oh+Nf/uVf/tEf/dFud1Xz3G8oFvpPeTwg0iofGlhOc4xMGADy9dXNe+9+EEL4249/lPLcd0OuXS9U3aaDWigSUppyzmYyDN2TJ09ev36dMyLi3d3dfr/fbrfMXseZWhwyxtgP3dV+t9ttNkOXc/4n/+Sf/OTjH//4xz/ebba6IqxoOgyMCNndaEQ8nE+IGCNT6fpSx9DbknpZgi4QqmZmQktlJREt8sJFACKaLq2jaRWDWkdK/ZMq8gAuV6Efs69As0jF0rXqxLddIVrYBorardaAZqlZUi2R2BX9UyQ2s76PzSl0b9Il2jyN7vlFDsPQ2Xbr47MdBlVIpojmtUkikrNiLGBMAHMaBK9QOtyfREvNhm8NCtHMArXN6agoAyPV0pKvDYsCoKEZSs5iCoSb3bYfBn+LeUrNZeJahVUsY2r1JzCjOfQMRL3MKYQAXGSZfx2Jzufz4XB48uSZIbjR4GV+KaXTaWTmOPRERBhijKAFLaWqAUlTBrMEqdlYvpGdsPD6+trFqC8J10nn8/l8PjthiMt05xJxs/7u7s7j/95T+XA4cCXA8s0yzrOqdt3gytUnv4oLETFQtFKKXdi8m/WJKxuxLcIvks7+S8u4EzXwREltbLaD5329Ia5JJoJh0/knfd97fxFmDpGbpl+rYQAIIeSkCVUhj+N4PJY+B10nXdeVWh5kZDPRpoNdLzqcDQx1U4jSvLfp3d1BKtlLIFIIzbxLkg+HQ86ZGUPtCYFI4JynXclrmKLWqq1pmnwEbm9vh2EwNTfyTqdZxBDFCDEsU2+r6qw3at+HB5ZscZMwrlyq3hX3xhdR66fVlMpavTFz5cYqwsSH2U+s57sgcvfNvNRqvTCaVmrGxFrotXOapIIvqKWp/7/wCqzlWzvnwc9wtdtjJR5rUs/3uVdMepioadl1ctsfUay4yE37NhMGVr5Uk8hUISouyotJkkp5+GzihH0GOs9z38Wf//ynP/7xj//pP/1dQEVjKx0HyuW/bKb/IY56s4eZYDQIsRdJzAEAN/urp289B6APPnjvP/7H73l4bQnsi7qMOJ/Pbj6D5I6DIjx//vyTT38uIn3fnU6n4/GIyJvNBgDP49jAL8/eevrkyRMHKQzDtaNdjnf3H3/8sdcdopaEMTR7tvoxPmt9iALmDH9tcRBoqZgiCsS2ArG3NQcra6nSyi7SLXBsGwNxob+Q2uiQVqXrtCBfZG0SWk18aAWkUI1RS6MaQEArtBuIqBVK6lmhomxq1N0qdUNKyTVSjL2vWWYmYlUQMaLAIV5f9X3fE2NKydCLceJpnPu+H0KnqtNc6qeJec4OV8GKKnVT2ocL2FCTWJbNJhKGOc2TTO3FFYiIzDRnDcH3PGANKSMTISPCPM9g6Fzc3r2urSUfLm9nhDVnKVk5FqTrNE2bvt/udp5edWsgqbTksSmY4TQl91yJKSeZ8uQNqn30GHDoeiP0J3Y8s1stfp3T3anruo6DAgzD4C5djPHVq1fzeey6bsqlyZKHlKuCxBijN8M2MyfLFBFvtZRzJiTH3PqLMHOMBSKEwGPyrpqlO2HlgjA01hqhFRFfzEiGegGOhSqn1+JorSr895zFzBBgGIbr62unyM05E2MtqIWUJkYKfR9C6PrgHTiYi/TzlQyre7WJQ0Qw8kxKzvlwOL18+dLMvKEyETkqlpkJSaqMDbU9yel4Pp1PbvLu93tVZY5mY0lPeDEYBxHxBqD+8IdDmsbzkydPitAmG4ah7/uuG2LsETil5KYkAJzP59ev7+c5M9Pz588d/L8Ztp6FNbNk4upAWivDnNGjU7YM4y9zhNrJgy6yTovt0kQQro4mAeoWWLq0+Y/au6CpifbhRYUOVmTiWs78nc9fJery57ITHZ1QqUAZmIi8OAGqmi8xPDKobQ5C8HI0QDRoXQQiIwBgWPpRNFtAURGhkWsgIgPBqlbExfPqK6rasr+oqi5vCJE8j1g7ePgyBTNv9O3TA2abzebb3/7W06dP3377XQMBYM8Eiwqs2uT90sffX2cXc8ma4WxI3fDhV756uD/+3r/42g9/+LGqv5PzxnWahTlO89gSYJ5jY8Snz26fPXv2s5/9bJ7nvu/v74/b7X7OiZCnabq+vk1pIiKXBWby5OYtLwX50fd/cDgcfuu3vvryxYsYO8tC1DWx0hSYj48HuOZ55u22Lhpr6THEgDWQazWps1aEzQ8IIcgkqoaxBLIEZJEyps37KcHAVS4HAFZuH1FpZlzC1G7nQY2UtjXtTrlWROtqB5Zi9AZtlVJwWRZ8Sv78wVQAaDzP7RVCCFTWmjn9iHevIA+vISBTTjPnbH2fss45hxBEldXYS64NiIhDAE/u+po3m+fkO+00TWOaiShNk4tCItIC7AzMXpoFOS/9mFOaEZGYPa3uuBs311ratfVJRSzBeVXtqn3sgW4E8Hyq50EAYJYyKTlnR8188MEHZnY8HsfDiEBA2PgOPVnrGtfP2W635p1uNxtPNIYQvDiYKgGIz3I27Ti47uy67nh3fzifwopEwgffFXZz6F+9erXZbGLHaU6ImOYRkKuLfGaOBd0NjIhzLrVqVEHpZiklOZ4OkgQAGpuzWuFPhksF3OT7AwVcV2nBwDvS+8mTJ8fTwbU7F2CzeW7Cs2Y+XPv9vu+74itbiRE2EV92GRAh59pr1QzHcby/O4jpnPJ2u+UQNwO0lWygoAYUEAgUY991Qz/nJKYvX7+aUvZ2uaGLXOcXwTUNeKI35zxNmNL06vUpdPHp7RNmEJHAnRtMADClueu6w929E4iK2N3dHQB0XQdqjXDUDanmKTZMctuqeOkjtvHElXfXjGmoNrpV/IcVl7H4Zg/mxQxMDEoJK4ChqrkA4VCgVSuVDG2yYBWKazaf2yvN04VV77W1cYYVloHVXcaaaPeirLUpYDVKl0SJEcBhurxeAC2U0h5ARMKCYXNpS/77Et9ba3ho2IRQzQeghrNog4tQKt79IlpZguusmPMatiu7kLbiTCysLgCu6XNO8s1vfvO//++fMkfX14EDEeGvxsLxax5rjxsAANQTuoAIxFAqzi2E7vrJU7D3/vBf/6s/+ZM/efvpczOIMR6Ppxijk/gDgIOzrNocHXUfffTR6XT0PnFzTofT8e3dfp7n4/GMiF03hECgRmCRwzAM58NxiF3XdUQwT+WyXnH0wKJvgg9WoBKF7Ij3eqqWzhlQFHabbj9k1Wt9scYMEUqfqnUIGi6TxM2Abem0OaeGZDQzKMAqMFPnhHFNUC02AFVQhEu0Ba2qgJqkMzMymHVuBkF9VLcqEEBFnGPLIkR3s6ijgsMyYkAzyyo55xi6fthMc0ophRhBUUXElKhxDpe6TCauO7DAWLiMG4ADH42mMUmh9CqPHbsOgEBNsiGiaPIF3/V9qEQ3IuKJNw/JQuU2cQ/SxUGMkYlceTuhoKSEiGaSa3tHrpHG4/HIYfCeCtj4xQxdEYau9Rykddr41atXze7xXdyITRosyEE60dAVtj+/f+i35i56u9liW8zd8+fPASBEOp/P/iTmfRJzHsdxux28yRIiqvZS0eBX/SbG3smwnF9sHMeUTsMwJMqQZlUld84EFcUpYqzCT5ssXou1tdpwb0FVnzx9utvtUp492zKOY1MxzdHRVenqhUtdMe3ldgoqtX0voZnlrB5vSJIbeKoECUpL3QKbbVKbmZ2JzJFQp9Mp11ZR6y1QMVZLkRURxYifffq67/vNZoNA5/P5+fPnCDyNiQK7SeejfXd354i52+sn7gL1fe8UqmAk2Zxiky6Tjw/gV22fAoC1rOkqFWq2cLXCSiUTEeKCrmoyRFXRFljo+iuNJqXKwOVbsgLAt+s4Ae0Dc8Fti/Y8Nc6RzExlIXb1l1DRMU++GQOSijqwxsckpSlYIKJcO2G7leb3clMSFjSoBRFxYhFEVHPW3qXcm1bBfX/n0IcCBSQKIYCRi4mF22hRAFVt+2+VB8R/F1h4q9vPtb5nZjSS0v6JXr78/Ic//OE/+kf/1BQUzeDiqf5LHeixDkQwDN3w1vN3Dq9++uGHH7799tv3d4dtP0wTeHq1uYPtF1cSku29995Naf76178e+8I6e67cet5adTwff0H44YcfDMPgYedpmq6vr2MId69fq+rxeIzFFGghFPF6BtEEAOZd7SW1J19bAwBAgLoaybYWXfq3bYO1jrZsAyjtn4uZWRpsAAB4Cena+2n0EVZl1np7IKKnPNrd3bAbCph54ZFvxqK5f1w9YDJQAKQCkmoGH4hq6bUeiYIT7jQdn7MmFLOsVnRSwBJVE4Npmghws/E6V1TRPGV//SyzyxEiQgPvb++VnbhK8zBACOhufgilwhsIkTRGxkCaxcE1Tvg358lpKBwj43AqFwH+ExF3u51WSI6qjtMUQymlZUa38Z3n2V0Bj0iFEJhizhq5lLG6MhARryXzeRw6y2qO4drtdo5pc/9bTK3ixrXiyNqbutPs7qDXrzusDBG7LpipVyL5YzPznEYicnvIIwSe7CzcGtOEiICll5TnDlwR+hUOh7txnEMIm90uBEoJzMzRAG2tmKitiBS0sq09lhvtRfyXGOPTJ7f7q53LUJEEUFoFqyqoCZf964Pm6fVFC1Yb09W/Xhzoe7zrun7YuCs8TamhgrbbLaEjcsDMgMqmE5HA8ebmBgBev77H2pei6YymhJpcrW/KXTfkfH754hU+pe1uo4DDsGX2AmVRTd5DzCm3AGC/3V1dXQGQagohHA4HWXUetFYEXHKtxddqQ2orNwBcB192GbIVM0YLkpmZKSqYO8ZE5MwHTkKpj0LETUr4/yI6Dz1I9V/XUWUprSodzIxqmqsj1EKSWqk9veODVu4BWPmvbYpdxKW6eIhZVOd58vsWaEUIiJjmnJMgLZ0//JkdNhG8Uc96OfrSWa9Ra9WWK3he2bEVkrM2TJpP2+TgWtGu3kQNwHBJ+CFwzuKuC1RG0BjjdrfJSb773e9eX9++8867DKxmf78+wf8wh5PVIYCZIoWbmyfvvffe6XT6N//m3/wf//v/mWu3c2dGNCsLQlV9VxB5pD2//fZbVzd753k+3B83wx4AEFmcZi+EaZp+/OMff/zxx1ebAQDuXr32K/sY7IZNtaOXjQegpticVFjFdqzwQi8VNVwbR7cwkR9E5MJXL0FV6wtqY0njhbKKV4zq68PF99rkgurUmpWcULsL1QxTW35QG2qWHkRWNiTVRg5aq+C1dT+ttx7H0Uxa4BRQEbHrN8WqgKLFvZGXZ/JC7bLgEkdEkAkQiSFgqNeH9gqBl6SUH+SiH9Hq9qZQIkatdpMAATXLfDpX1icz9/C4tnAItUmw61T/YolLT2ekrgPIOSMyx4g5ewQewOasOhdX2C/iPx1UDADDMOx2O/er3A/gnPsYEL0FpKmqh759Ts9ZKLC7rVAFIteedOfz2ZXHbreJsdBgce2f0fd92mx8ZDwJvel6L/BVbPTFAtDf3t6O45hSskqQ6RU/KU0i4qninLOIYfGlwAvwvI7XsKwiWUehKwDQVsm/tbiziuK5vb1xC8Z9GqkE4PWLAABEQcR8zyKiWWylHGiYNLflvV7/85zcUvHFsN1ux3SnalNOdi5T4E5wCMFMmalULojknLvY7/f7nPV4PJadu4pVLHKpHlpj9ZvNcD6P9/f3h8PhrbfeSimpelEkuOqNHByuBQDb7dZT7zH2ufYNI+9RkTMQBorI5Ht7rUH9l8fGzYXMNO+7XGSjmUHtcSQgmjSlJJr81RatLwpQvD5aQYPbmz64fs0XFJn2wF6seNhSguxxl3YpqUBjAGCOIuq04WbmxHlUYEzYdHY1R+h8PnmOHBFVQVU8qe+t4zwQIrkQPorI0ufrweTBii2sidq2WIuBaWZ6ASEDgMZ7Ur/7eDIuS6/UAFjN1AwxtQRMCGG72bhhcnd3h0DznP/dv/u3/8P/8D9ud1cuexvF6H/2o2g239UIYB5oYb65faIGXezffffd73znO2+99db5cCQKnvT1AdTK4z+m2VXbMAy//du//Rd/8RdEnFK6v79vHMiSshfad12IMUpKXdeR5y0AYmQiHsexJlDFizHagxbTrzYdMjPEJR1gZqCGRFq7F7RIRtNh/mcTQM3WbjqySS6mpURvLResgjmxRjJhVZKLNW3jez5nJzisen2VjGmaPuesyq78ylNZRW7zwuyIiAAlEN33UUS8zS6xfwuJiAxUhBm60NW1nZnd/5AYo0npMekvJTWH14VYX9yIiNCYiSiaGUgLZFnf90kFC3OZEFHXRcTSpCjnOeesl0GgYRjcRPDgVd/3Xdd5Q3tXPO41AsD5fO6HzlWFmcUYVcVVoA8LM1MdPXccQ+i40hN6jBERJacYil0TaxtHn6xYu020WJ+vok0/cAyeAfUz3aJ/+vRWamu8ssDQsiR3ju/u7hAx5zxl8ZjBfD5BrQlW1VmydyokIg+KepgtSWmh4b6FR9EdA5yzKsA0pSnNKSUvuW7VLMQLqEdWLsEDdQWL/jDm4OlVbysJtShg0aJqXvcFAAZpvZuaQF9vDTNTdf6TpZHR6/s7BBqGLby+Q0QwSilV2pPQd86Y6OCAhAhuinmF99OnT10fSy2lbfPyILZkZtnbPjBdXe1F9O7uuNvtACm7iVb2gnnpec55O2yurq78srvdbpoSIiOaGARkNWGkB+Z1UxOwiiW0P31sYJUtas4rAktWM2ffK5Tv3iOkhWq9qtNLP5pKypULzMn222WthoKnqZg4zOxBWPciRWZa5ZhxBRy2VayirQcKJfDjjdeyM9d6wl2gebSgklKapiknxXFuFy9ZJMvNdPBPnKMJnXm1SaumRNvzXWhKD7boqnk4ReCSCqpCmcG5gaqxWRLS1etl5qY1q/zlVvxHRF0/5Jy9QLPvuqurK0cH+HIRsePx2PWbGDtVJbzw3f9THE5U9CgNXI5i4QIgsIIQUL/dfvTRR4fD4cMPP/zOd74zjiMwYSl2zTWoosxMMdg8qRUmqWfPnu33+5cvX3exv7+/7/uN589i7LuOW3sTd9Q8UuSdYUTEg351AS3RHreXAMBKJB9UyxZlXEJzTfrbigAZVpGP9rJtw5stkbGV7YXtUg0kiSv3Qh9RsrWvUM071kWCZhkEFJRWRzu/FCpYkzVliYrM9Qkd/QHOe+AuIAd0VU5EIZTGRGpCULoYmaipcgjsoDQtpU2IeD6f+37DHtoyJ2XDwthvZmBkRFYJnACc2fs0jVK5zNRjoCnlfAaARogx59nZtv39PPzrktcdrBijc42+fv3aFWdfU8UO6Oi6jmNgxtbfbB1/s2LEkBmm6ayZCQMietslhzv51BNx13XQLCpmD4D78zguCQAcHeZfTJLreAaHPTOzI3dSnltBUc55Tii5dM7Z9H3f9QAwxOAeLRFN04QzNiPgfD7Pc3ZTNUp0BJlHBdxMd+NAxLLqOM4NW0CEwUwZANwWArjUsmYPw3tt/fsV5nlWza7/PLzn0r8M5krX5rykgZsT7EPRtIWzwDYkOTMzo2PdHR+DwICgiud54uNRtfeEXQhBRdwam+fkztM0TSF0+/3e8eQue/0QkbrfXW6BQOn34BkNTfnJEz6dRlXlwB6xd3F0fzj4Qz5594mzfbl15Z0lmRkIQwii4hpxvbpgpTLeeKz/t0W5xON7pUVbQMz1FAqhcyPVSi9USrP4CMSutPDx8SEMF2RnAIqqApvNxnNepgiAYJaTiiTRaS3cbBULyXlJTkGdYsDo0fIGv3Kx7C1GfPCbfDgej5Jhsx1845xOp6liMD0I2hA2PghZ5osuV1ThM+uxa4LPK0bvDycv72NmJ4pz87DrOkRuXEVNUHLVxH6pELp2R7ediULpSO+4zZSvrq5c+qhkANhsNsMwMIV5nne7q81mG2NEQCb+ArX4n+Mwx74Clig0anHKAd57773j8dh13e/8zu98//vfv7m50ZSrolLvKS1gwQiBmTGlBDD2ff87v/M7/9f/9Wc5Z+cdNMWU5y5EyYZk6r6tyJhKA6vj8dj30ckmYYGWaEVCoosnqB5wU4FowGFB6AFAhXaDN8+By4xO08SPde1FzkmlWaPrpdbkGqwUg8uvtQnfuCNkLllnAYjdwr/WtrprVlV15hAiam0EY2SnHquhbAAAA9hsN9Vcxa4bYlfAQZ3TKMYlbqyqsQuluEK1484LYd0TzSmJLIk38JLwmsVEUO9n094dkVqNI+IAtd1FSkk0I2KI3PU7UEtpmucxxoFqroeIvADUa4paY1o/fGN7bimlNM8z6NLP0ZVTq/Tw+Y19p/MUY2QWBCYpWR6pXBCu0T0hHUJI8+x+qssR17INbtn3/W63Q8Ss0qZ1v987NgoJjsej47f9Cjnnvu9NwU84nU4+iqrq8oSIYheAioWhhSllzjmrQGnAEIO7+I3CTMRevn59fb2f54yns51tFC+bVhHxHHDRnWu8wqOjWZZWWsOVDbVoi4ZCxcrJtNoFVuE8LYRQBT22pS4iWbJpyaRM41wpL8oDSPZEiUnKKaV+6CigJxrO56MqMIVxHHM+tTUpVf2UUBNQhUQV3wAACAMh56SAcHNz8/LlyxcvXj158sTEKDAyetDRMx2OMPDV1dpgGEJgxlW9n9Zia/hS7Vv/68Lu8V9y0nqR0hseoSCTA8dm9/gbaMW7ETKgtkFW0aIsas2nz9fr1699JftFfJHnvEA98LIBQ17Vtq1nVhTad83MhYDVPK6IpApBd/2aZ1AdPcpoCkwBEcHQC9lTEjco+74v4sexiLACtq3HqIWq/Iqq+tze8c0JAI2hvrw2cY36rKqSbHkfZg6hJBRrP1FAxM1m45u/67osJVjadV0Xg5/m+9ZpS507TVQAgOk/fwhaHxcytZ7BBgahC2Jvv/22qv7+7//+T3/6U0ATVJOlhFoRUEsgOksuyHiCt95665133vnkF582O1o0OeH7MAybPhIRzIUsRkQiBx9PT7BRTRMAQHtIXy7uRfm6iRyEFtI7M6tOvv9eNnNJtFZlgBWa11xVqkjXxaKEFThgRS25Hqvm5jajtS2zgoImPuczNLZqXNgx284x84iCegvCGGPHJZlCXetRSsV6NBCR7Xabc4FNARZHn5lRLHbBC3sAkRhbOEcrBAEAVNRVUcE5MwNAH6L/b5Z5t9liZbhEXRoJx/3ealxhGAYgnOe511IwVgps0GIX+t7BlugEy46/80XSuAZ9YbiU94i9gbbqoO1uy0gi4jSlLkPNzPnYswoRQVfcWTOLoZTQAJdkmEulcRxVzR2dECMz39/fNwkYQri6umqLrUUj55x8uFT1fD77ILtQa8aEmW02WyJyJYoIKWUHpsYuJE92pnQ45O1262VUblxyYFMyM4/0NCEzjqMZ7DabKSVVaLYOETEbUUwLh2VBbuKbymaaCkkpDUP39OnTGONpPIcQzuNxGIYQyWnAEZFqt7Hq+kKLuvtQu93jI79OAQPAOI6m6GLNiUdU1Rc5VdQLImouEIFhF6bJfN5Pp6MLdGb0YLU/T3UiS/MPKFv1oojWXXkR8cqi+/v7YRi6rjNRRLy/v/fJevLkSeH5Yu773qlwc85aq7NCXCC6XCuRmjf5WFzWPf5QSf/iF784nyYzG4Yy0TkJInoCAiohhuNGmdkkt5WmVjRizpmpcMgU0HJNeB2PR6ppL999rrM4oFZsR1Oc7dlsFcd2NceK3g3d229rZXopACxaSyRXmi7umitLDnRNcyYipuAdd1rgMGyHXVOQtKS4QVbsV02bEpHRwrhUPldTNeqW4pP1T1sF2dvSR+TtZglfUFX+BhQ5IFPXEWFApIXdLRAgE7MBgRmRB2PlshAbYOW6fcHxBg36JccKUUOrn+5aORJ4OQEBzK6g3/XXYT/Z5uaTf/b7//zff/3ru+0WI6lByrnvY4w8jUmSISEqOiRynmcke+fdZ5999gkHINIQwZRV86aP7ESegHHjfXtk2G7neQ6hxAlbKT15XH4ZBBYRJjYVAIiBiZDYWf4hdp0vJvc5oISptXrGRbPGSnzTxdCWOIARAlW+e0TAshs9+AyIUBwPxNY0zYBzzgBGgGpeBYsiZQ/nnEVTypOIAOpms0FTyQtVctPHZXVpcS9mLBlKTgsqhBk8WQQA5+PBm46Iy25EEZnmhBCINGWt9RvFYmgXyTL5dprz2QhDKtWQInmSorRE5E7u3elstQeqec5zPnhslhFR5gSOgBAlLwZVMAXXmm4kqeVAxgxmOmw6Ve3iQERjmpndGFLH3RozIZqRiRFQF7vIvaqYKSKHwMMwiCT3JKZpGvo+pRTdIAPoqhmNHAqzB+Gc0pRmA1PQNJ2ChAGHAAHQkADQJKcuxpzmBs/uht6tDW9i7/fygOfQbyTI6XSCUm1GOSdJOZudj6dyd7AY2FTybJqViDruyAJmmOZpnue+6wD0eDyCB+0xDl0/zzMa3N/fm5mIjfOcUlJfsIRipgAKliWZrYgd1EyVAKxaD2vti9WXff/939pu93OePB5gitNYIgpEBOiYGu8PqOuI5TRNqhGAmNXK2r5wp1TVLIrKnPR8mgGoD/F0HOPAzQBCJBETMTERm3LO2/2Vig391TTqq1evnLAz50Il5oZy27NYyjiLdGVEBPRmYZpnJmIOsfaFrLamSYZpFiK+vrmdUyaiYdMfzycFyyqI1nVdzjMzd91Q5UxVvcCIhLU5jplzJdeoJ1qSHLArMGYDyfbXf/XdH/zgR434peEuzSzNGVaKkGulNVQrp/nf1f6bsRRPMiLEWPJoV1c3Td00HamqZGARH4SCTZWCq2FzhncjzEYqgAoGrAI5aUFMktsBQuS9maCwd6nnO0LKBo4BNAVQBFPJTAAgtUAXNZe4RSFkbvqVW8eF+knTnVUBLxns8jkUbDetjnZNfQS3wdXRBoiIkJ37Ht2sqHpkObP6VQtPGP0XA2F94WFmhNh13ZMnT54/f/7Jz588f/78/u4u5+xxlZQSBXbyZ6QSNGh41Lfeeuu999775JPP9rt+nudQQYDFfw3BLLWqMqqFB7bCIjbdaxWe2kZPanERrLCgfqTatbQF39yCBiiR3vXaaAKriTAiXFYOAIAb8otYgdoWtyEMkwrYOk+pHmqzXPO1znRYHYhih1WnvHwLvRtpuTUiBlo6kbUB4ULcw14f0gaBmQM79qoGGAHAzF2r9o7VzmW3lurOv2iypIrzfGzxqzZEIllVpqmksjxW4T4f1fYsbQ+aGWBrX6QtREYYTISjg2wTEZoVzARUW8GFglQCzmEYnPHUDQIrIHDjuiW7rguhU9Vcv1VYP7N4ts+n/nB/HIbBCXoQURDUoOOgakicRfPxHGNEJk/Kc1dcQHe+AcBdeQ8JrjDDJVTjwD0R8RZhMUbDEjwAAGfwjjECUwjhOE5dHDz35kk+50AW1Zz1NJ6nsQQ5mpNhlyDkclSzua3Y9j+e/pymCbnQUiKi47R9r6nlEAKF6KAzqMkOX65tefgIVFtNWskQEXn6sFB/EzmyrESVVjvXvWGLJRizjoV4rTasTraVD1cFwIWkbRK4SlHIOe/3ezek3NP1nIKj27RWnxNRSs5KVth4bBVJ9p27Hsl2+DlJUozRvVtEFJG//du//f73v//06VtYkVNloAxVte/KLZof7BZGU8krU6Y6nSvZ2yrNWmrsgbBSRMvWYIzLBq8Ssmy91jtOl14shuAkeFiBtB4MkLKmSkKlVucoGiCar/CGo167f+ggLHx0AEBgthUj4PIOlzVFZEXku83VZqgp3fUVVivmUoX7CWoG/pioAKXRW01brhbckjW0VQeO9a7+u45fzQn+lQ50ChuAq6urD97/8MWnn/zinZ//7Y9//Pbbb89TqdcGNeAWFgPPq/nqHIbh3XffffHilYiIGAVUy2gcAqNYntOmZ19engVUZVgFfssUNDlT4W+8IhBtj9oUG6+IyGGZdGyX1bxqUFq/C4XGkqoOXmCEAJBSjrEAarB6eKrq/V/rFZbC6BAiMwekzMJQYk0558hFu1QFfIG+1sKRtYZ6XXJQ187qnjX3/iTuSq5eH31v8RJPgxi4SWoEF+RihN1mKBULWFq1M5TrEwRkgVVNCFe2ZP+EufVSFNdPrX5PK8Dbm05BUajqyV1VNcXdbsfDEIm5H7J5KEz6fmAucc6W9FJVotLSoG1qRz+l2naQKDk+AJlijIQ8z7MpbIatX0rBQoiBq2vi6DyvfWNG797q7kOaZRRV3W63ScUIxzQ7qtZ1jPe2g5oQqYk9iDGmecpJFAwIDSirmWXJlg26rutDV24tItlEBPchSS79yIg8ij/nPE2F/DJNo2fyCLC2FrzA6BKR0QInXK1nAAARcXrI/fUOABpvgxsoRDTNknPmWu2Gj4iT2oy3263cNcfwFQCzr5AQaTyXxGR7Eqz1AifLXdeFrodLS6It4CZy13rxgUSCVUmLVk60Fy9eeP7ofD7P89x14fb2NnIYU6YV5LtdpKUaL2SsVVrAL0gDM0UEDoEamu+TTz65urpqaHCpWGVXwG061opWGpHqys4o12f2Au2V/Der0K0mlNbarXkd7b2gVm8W+9XW2r2lKnxXFhaHKQmiNqvDFphLJk9VmKsqqmug4kYvmuhikFXdJ6wwMu1Z23NbhfJ7ONTjDE6D0FZDWz0tVw+XCr4uCI9wF5ayNtxNzqIZkCIs8ssFqMs9xxI/nuxfTvv68ffXwfrGTxFRHdYIdnt7+957H3z26S/+41/99TzPzLXfNbJmCcRZJScniKCc5yllRLy6unr27Nknv/jUeRiIi/rsuDhPbT/TqtNt35dcr0jpuLMec1gBm6l2yGlLv5FPWanfKFHuNjsAsA5ImInqEjWyCj+BlfioMN3SBEYFHCyybpmCiKKKNZw1z7MiccDWzyCEoJLb70QL95ZrFy70pcviCStbDQAUUTV7n0QtAssYoVCTiGwHUiXx9sKuUSRzZeQH8IQaeSYF1BSLAQEATuHpKl9VPTaoqqKpGSuaixaURtMNSDy45KJLEiURcX4PqAQ67jG77uSAXhobgtf/RGanNlys3tqEERCXi7fR8Nf3M0UkZ8k5w0pqr2U6AExpjNttygJS3DVFOI2nKWX3IeZ59uchIgETwHkePeZ8dXU1TdPd3Z1n6H0x+0UahoCIsB9yzkOMqjDPczdsvVopWEhSRKQYmFkg5Nh58x9VPZ/PaeVXeX2qiMzznOfZq9fIUFZIXWiRM0C7tBebCAqVQlwVEG2dZ6Wa9ZjT1Iq/20+7sD6Th7VUl9VStonmEBnOAAAhkE9s7Fiycd2t5WlVzOycMjNvNtl1sG923yCw0kNtytZXaL+v/9RakXg4HHzuxnEMgbquu7299XQYMU7T5PM7TedQ6cz6vodaylUFCz6+44OjGQc5548//vhHP/rR9fXtNJ2a3WwKGcX3cePnuwh0rbDKj1/TzJzMr0nFlhi0S8ydVRfZ97X/kkUtm4U2UEjITUwhxhqLUgVAICsBX3+ApvuKouQKWF4Hhes64fUze+FGsJzyZScGq8aamcEqaFwuZGitAeRFucub4XBSubYf6ANEWv/ZFMOyT1aDuJ5yWhOQ/r1Q0Eua8x/2QMQQY84Tc3j27NlXvvKbv/e13//T//PfPnvraSTOSTBiCJSSOIg3paS69FGIMb7zzjufffq5qiJooI4Lz77EGJlYVwgpq8FnEYXaVwpW80JL+e/FFKxFD9QNbDXF8njhSu0V6hfAxd58HN4AAAghmBXaoyyVjZKd+X3BRecsYAVj8thoWHvzqgqo3ipPK4yinIkG2bWyYqQWky9ZRmQAElEiDoXnz6wWqjJFH/y2mB3f1HCtawMSSpimHCGEyIzIZioizkMCAISBKQBASompRKtcAM3zbAhMce2pI6IREiIwDdy5VoNq07SZIqJSu0zUTLGkiwHtYU+uFCLegAtXtdeqKgLO7CEiWdbMBgArSj+srhudz0UsZGkFGIjoBpBbQtfX13Ho0+n0+eefO1TZtex2u/VrdhwcAu3f8ns5x2EIYZ5z13UUg/N1mxnHrswOc1Y4nU7zPBPQZrPTPLppkrM2Nmwcx2HYHs+neUpejnEax3nOqupcWmvr0IfLCKtgvUBmtcC+qg5Dd3Nz49gIH+1WpGfVOABCruApK5tIpzQjEzkiPq+4MAHMIIQQu+BGAxH0IZJBguSJCD/XZauv0vP5nFLa7XZU2WDW4vexyF1vW1u5xetZ5lpVzIyuYq92+z524zj2fe/mtVszbkxQa4xYSdS9BKYpHnikfa3a5UTkdWuHw+Hjjz8ehrIq/Fg8QwAwo8u8JKyCCmWnrCzFi9tBKRa1EpDjhvxq2s1FxLLpVkGF5cpY1EoRUG6xAhhiOxtqTHF1f1Kn5yUwU1ADr0Tnh4MPK+0LAEFVGQXBfEW2Bdq0Xb0NmWGLdqy172oEsGFcm5SnRVLD+uIOz3owZw8mD1Eb27NeFNKAN0I3MG+XXTXxr6FNfz1X+M3urx+OR1BVBNrsrm5un7777vsffvjhy1cvwrDhQJql3/aWZZbMIS42ipUG3zc3Nze31y8+f9l3jR1Czqfz7e1t06YOpPRIg8tcRCRvt1wlS11z0naIrYINzRGB1gljZUo37d5kcV1zikjtjqrLMlg0JYBa9SqQmd0yDWagULoO18RnqZbxLHJAQiqt1lxzRKYaMiW1QntLXjOKCFKggmbmxSrExT/mWk4KlacJmEiL34xIXj6kYEnUOR9SzliksNc5uBWyJKVUtQLNihNZeNURmfl0Oo+EzOyQbKgoWRe1iCgKbosQGjMrgqiaasWwABErKDKjKnMptDBkCoVBzO84104GABBCrFNPNYVtIjKO4263i7FrCB0vtcpSujG2Dd48bC9eaqk+XxKTaggBRD3lgYjb7ZYrva373F6p/+r+LufMYLe3twDg5DAfvv+BTxYAOG+G0ywQ0X6/P51Ox+PZ0dHjOIo4G+KcJJ9Op8AdBnaAa1aBM4zz1FFhwC6f5yzejRF5SnNKOeesBoEo1xSPH03Ulr+lNJShFauMr6VaXixm6BUjPuPuFAKA1RKGEILDg32Em9HmfzqmgWpll9vW7gaFELq+0Cc4RUxrzWtmJmo1UOnT5xMaY+wCz9XDhsuMb/s6XGrl9SdWPVFVTSm9ePFis+k1C8fOOz33fY8EMosjk5nZE7TOkwoA6FyrNY24Hr3Hh9WmZM4w+vHHH7948cpvFLpYgr16EUJoZOnryWqzs9YsD2SaiwvXwe15in2+kk6NmGUd+m1OneGje+mSJ3VN3URr04CICKBMHDgQmJoBFhHnsJO1GeTPBRWwFpYLqRmBmbSoc1kBiLDyndubPDB81pLdT2tywc0PBKBqdGBJYhcXvoryJdy9shfMHxZX0U4zU801ahhWM35R1fpLH7+qDv4y7VuNKAvcGaSu63e7q91u97u/+7t/+u/+7TzP2+121jlLai/LhavFQGAWQbJA/PTp08P90dd9QGQehj5ut9s8n3a73TAM9/f364FqsY62OHTV1dI10PpD38OID5NhS7gCSFVNTc0Vqiqbijg1Zl3ukvOSOChfZyLkKsRjFfHm6czYByBPwxIRucMEZl0XiYgMDIqzUgAReVlaImIg7V5cjMyCDvNI/trmQMSkItkMIU3F83bl0fS0ZJM5hUjOHRE5MF8S65d5JVMzxaQSQoghEJWEqJmpWR+j5KxqRJDN8jw5O2bOS9cXfzYjVEFNCRFzKTTyULaFEPohUIhe4JTn1KbPmWdCiMOwaTY4Ip7HuSlU1RxijDEGka4vOcvj6eSSlCYiRsmqK+69op5F3CMfz5BSnpP7kXh3dxf74erqqsXktR673c7VKq+Ibfu+J7BXL166fCeiYRj81byozPWW5+0Ph4Pzitzc3Mxz/vzzzwGg3+xU8zRN+/0+pXQ4naZp2mw226H3SmIxnaZpt9lgbdKVcwagnHMXIiGboeRERH2IEzjPG61Fh1X/gRFtxV4O65BmbZzFtaWmhw08fpNzNjGMZmZIC1QCAEr6edWcpingEAJTNFxYLTmQKos4W2GrXEKsKeS1idxqaRhBmdcBqvWBbuP676v4or+I7wutvZxPpxOBAcD19bUDr4ZNr7XSRlflrdjIkIs8vlCH8Egjtgfw4drtdp988skvfvFpLbWg0n54yV83dU5QW/jpKur5YO5slYOzVeTML4QrJ7DO6YK7bPPbHrI9OdKyGKhU2K7DcktNeUrJfQ8iJxHkYrrJ7G+BiByI4EInPpysxoRV3kENwQwFgFuUw8xQDRzMfllJvV61D1Id8GgIoHqxuAp4AqhX+jwwdlaHeqZt/ZGVlED2hfumV/tVw8u/vA7+Mu0LAAYeRUFkFkkhdDdPnrz1/J3Xr18+efLkxYvPHM0/TRModDFmMUNwDgpfQiGENMvNzc3N9WtV7fseVbuuG673Hol69uxZjNERLn5gSxl4QlFKD2oiUlv0q1RwKV5aTuXFar/YtUJtK7UZSSYFkAUAgFpyzw1ZoMg1uJRzA/QC1KQmVqZlUO8ZHNwacNmOiJGXTmGImLIAqJMwEBFS6d2tqrEmmJsuaZ6x30KBQAxAzExMkZC9byYTE/ddICIxGE9HZu77ngxKBlp0qGV/TaOLqRnEEL2e8u7ukPM8dP0aWMQV2KwVcuVqNURnFnSjmKlUc3KSLCJMzsGZmXlOp4AEAHPK53EEAFDruu5wvPNF4m69b8yUUuwGJ2pOKU3z2V/EzFxnIKKTPF9dXTl9436/jTF6h8GUknpjZgNfk4joSqfoS8lIfHO1d32MtR+wX3k7lGa9qorXV+6PDjWw7CKiFCubMfM4TV55IpU74untk5SSie63m9vrr4rBPM/jnK/cfuLwJOfjefLFNvfzZrPJeT4cDg5eI6LQdRtVEbcAsmWJMQLhPGWB1HE4pwL4WscA139qzfY1x0B1wSe7avd3zzl7HypmjiEg4DzlflvcXA8JtBi1r3wfUlVVATBFSBTYrRmPN0gufrOZuBVO4BlG8zoQXcGsmoZm/DIx5GlUWzl/AOBF5FoTwKG2HfPgx9OnT5HA+dX9diISY0Q0VXTbdJ0+WMv29lS28sHaJx4jORwOL1++Pp1OvjiT5Nbo2ir0qcScSzEZWOV8bfpPKhSrWdgNGAQrDw0Rmw5uFnkrm22ChVe4VK01zUBLvsZvGqg+jGLhE0QEBO56EdGKFDYzRmNcbAEoPMvl2WiBOi0WjDn9va1Ay+Au76r6VVW9YYOZgSjFJUfYJPUDq6d9USs7Sbt4sVygLHoRQSfWxAv9ratWssUOakmpVdDDzLwey+/8YCEaSAPptYt/kTHySxx/h+ptp3nm3AA49hwCnY/Pnz//6U9+9OFHH7148RkRiWQTbcvYn8izMojoerDrOmYax7HjEGM4Ho85BTN76/23X7x44ZUMbQrayvN4kdc8+JyKZqiZmPKJiO9GqYC7OpIqIl3sXY60DJ9vVKqx6H5zFQLlOQGACghmZu67/nhwZgCfVvMahrpOitBp95KUAdQfNaWkIqfT7LitNCuihlii3FnFzDgi+jKwBU45plnmlFvTPWand4gxIvCUZJpOIoIcQkAAjLFreDcFQ6bzOIbQiYGpYRbNgrN1nFX1/nACVM3iaeim5g11v9/7Kur7TcrzeDc6P46qCiLl7I0KNpvN+XzOYu5beOM8RDQEyaX0aJY8z7NICYgx82YbPUILAKVnTt/nXOiTXL7nnJ0IKed886QTovM0ASLGoRs6UTUwQ+J+mKZpf/vEC4E2VxER5+kYzIjo01ef7DZbEGZGyT4dYKZETMTTdM615+vrVy+bPwQ1Td4gC9RaLTEzYckcns8eyD3e3fu7T7VKuPkuVOD3mubpdDxadZiSU4dCyYwc7g9+RzB6OY7zPDpuyGo0NWfFQh5pqjrPzo4JvozX8rRJgAvPSUtYYu0g+plu6/hOub+/dwsDak2gyFIagNVRa1gzL20gIgRW0bYHK5NX6daMBDFGr86C4gQ45nF5Wl5Af9isgbX+aAcANEo4MAMzAV2f7+CGFs/Y7Xaq6Xp/1Q9dzrms4aoOzSznUgbms2mrlGqbTf/E35cr7WiDdACQJ5u//e1ve+7ARVN7KShykM3Ap7IqFDQzzbmNbbtjE+MtjLwED+pDNlXtt6BaD0arvPJ6MZTRVg9rLdBuQ6+uLjQB9ZGLxiEF97YKHsDU8dRgZlqCGc1YgWLnwep3C7ZyaqHFjUFttQIMxGPfRGSaAcDJS40W/6kucTO7yDW2d9MV3XQ1EpagNIAAoHvD6y8CAKI6o+UDO6s9cFkT9SnK63kwGOSX7hn8JU7wL6l6Hx8IQMQxdMPv/KN/cjodnzx5cnd313EAQlBIKSGFPM2+yWOM52lUBbUM4Iah5JxiDEPfd12Y5/nu7jBNs6+rpoCp8UvXhG6snW2GMCyrDRCdw5PCGkTQpKHvCscKtSyvmbWKQKjl8HPKZgJqBpzmnObs/E1e2cK1E4PfJaWRSw1Dao0K1ldDKDWXxZsHFCFmRcTWLJaZPeqrqqpTi9F58szvKCJiKIbmta3g7arZ42hAdJ4mJ6YDUM96TqnQhPWRVTUQb7dD3/cRCREt1JR2M/NhARUCaNdtAzEzu5IrccJmsqgSECCHGAHJgJzPNpX+DqSq45wcZdPFYbfbSbbNsHPaHeefAqMY+pzzOKdpmosByiGEYEj3xyMzx74HgHEcs0KMvWsOIgrdkHOes3oy2Mx6yNvdrt9uNpvNZrd1plgIkcPCko9Q4vkAQGBV2Gat8sOkaFNYYQV85UznuSkDADCzLOLtRpoE0JpABQAMpKrTNJWWU7Er8tSJZyhM55N7MA5yNkRVHbrOXXZVNWytbMqOYGbHQznTMj0iNn9siJMBGWgFYXnc2y1aRBaZ+76/u7vzJT3Pcx+7UNmeYYV+aHdxKyqGHqvr1u5e7eDSTXLJATWALlyUqrRjPbAAYLBk5VYOyQX1BwM6B0rza5tqdPdxu93e3t6aGVeG7ar10RU6V7AnrhJeD+6LjQMOkWr/NLcVPE/xN3/zN97dy8wQaJ5K3bO3EEdkosV/a9cEAMSAaIy0wN8egrCa93UxZg80XxN0sFLn7S5QZWn7ipnVlvYKAIAMte2pqzlVRbBCWFF7sqEqVEX0QP2tJm5Rxqoamo1weXt/b2p7TCH7jVTdOjCCgAp22Wx5/UpSMdrr52jvsOyE+lBUKmgfoMv8u4ZVveOqlpwqxBeKDm7TsFLhqGa0GrsvOd6og3817duA2QgM4A2L+t1u1wV45713X9+9/Ktv/4fj8bjZ7LAWesYYz/NZK7I3pZE5AgMzb7fbbT90XefxUisxA1yDZYiWdVkMlMt+9esXb5KCVujo5uB6ajCXBmTu+fm+NTOP+XtHAW0pZAOv0BAHYykoInIMjiVqYS6qXU2IFlHYpE8MAXHJcjUzi5l3cOVh4foKiqpowLEIESJCXYxfhVq573wOxf8pLcnO5ynnmVtG2YyIfTC7UISjY4lTSgEesqMzcz9coLVptdJatYbWIK2Zidr5fPaG58AB1JAs+ggEBgCkoAIqCzZ1t9ttt9vzNHIMDMCxQ8T99c3hcPBpTWLIkUJEhZySqniYfZqSiOWs85wRcbPZAFDOaoaqKeczM+f5/Pr+LnIQkWfPnjnGLRBnmckgAyZNRIAclVnMUJSZpVJ8w0pEttxHGXxRRorctRyBVRysk2yIad/3jYYJEed5BjAKMdY2R8ycVeYphRCQAwDst4NYKWIWkeN59Di2T800pikn9LgRAAA5Ta2ITDmllFyTL9uzPnnbMhcR1GoYtUyNt2UTkePxaGZOx9Fm2e0kWOmhZo6oKlP0obBaK0g1hudz7e7g+tkeiL4LwYIPM4BkC+v4stnrXriQSCtWcK6gPN/su92T6+trM2smu4sUXTEhNm+bkbJe1Km2G7V4SXNSRcRDX5999tkPfvAD3/7zlNpOAQA0QHS2riUV/GAQEC9oy+iix5TCkmRFANc21c4zayHhRTxePvkiN6qFxCtWHDND9Vy+IWItuUVw7iv/+qoWB8ndzyUOvzbL1tNkFU4RWj5m/VhmyfVde9s28S0IbF4SLOo9VYia264ApG094UMzbVkrK7uj/V7Y2B6CtqXUQa/cvjoBGWoLCFgG4+J2NSnwyxx///rgNdCNEIFi2O73R0gffPDB3euXL1589v3v/UBEYugCkRXSKGTm4+ngwTPHAQGAC6z2IiEEk0JZ1cI4VqNhubXrEm2Uqg+Wmq4OP5+rbPVeN75tfCiqimocWF5uMeuSFOCUHaCETDGGGMMSiAvMiNYAHQAaAnEohpcrciQIgUMMaUoV8F/SKkSESEZoyO7Ucu0kY2ZUF7oDqRDRU8KzZIVUVldtfGkIOWcC9M5uWFhXycwUAgCgiYh1XccInroL1LAc4OwfiMhMeU7MPKfZZZazO1E9fKe4giksBwnmeTbiNXLVvPIqBCLqOuj73rtaubRzGmQcYdMP3dAzc856Pp/P5/OcCwAEER1Z6oLVp9tlnIt7qRW3nvH159xsNia83W6Z6NWrF69evt4MPaJJyojI2L4YqLKFeySt4epDJaZtm9pNFgKE4JE9aAvGKjdICIGQDaEFM33iQgge5AwInmhkZkPIqSw8Z9Jg5vE8I+KY5v31zTr6egojn8/AlJJDw03BSMFDysxRatkbvEn+tLdoMtGL6HPOP/3pT/u+97RIAzE0VRroomrAr9y2Us4ZgZvk9HrugpG25e4tU46uGfw6LS5lAADZLhS8rexsAEBTW9VzWq1RffBqIIbhgsauKkhsKLkQKOfZaY6IyJdrqAcagJphIQZo0ltrGwOoPe2tJDSDixER+fTTT92o9SIxvcgILCp8edpLh61ENS7lN1ZHtnpw68ldaKcMgFYJ/vUCaFco31klm6kU3FbZ0cafbE050NYMIgIqgacTce2xWQuDE9bm5WX8yobygW6ZjBYkEUlkQcPDuW/j0oYJRD13fXFmI+5Y1cC0IXgQ07j4fekK8HCrlIFbrfs2Cg5h8IjL4+LgMmy/7PH3rw+2UkANYAiBO+oyXl+pPb/56e2HH354uDt++unngaNVzu6AwcsMmPVwPIXQjafzOJ5C6CwLAExcvEDNs6/7sm2XPEeNMyN6Ez3z5rcc27xhsWE8AmY5exSXiEqyNmdtxePNkm1WoRU7FBE5xrJgZpmZo6iims2ZmVWzqvZ9zyHkNOWc3RUsBPRZPfboOewGqEYiDkFVc9X6xPz/6+1aeuNGjnC9mkONNJLsxIcksI9JgGwA//+bk/wKIzk4wMpY2CvJK82L7KrKobqbPWMBCfYQniQOh9PdbNbr+6oKqk0KAIjs6AYgJGZ5fzgQ0SDBfO7mTgSFTEYRb49qaSjkYGNpgpuFaBgkEER3n+ecmIRWIkJghFGwoiBMYVMDkKrqPGFXDwgRLy4uIuYWaamFZIQQ2O0IzIBB/vTOTqUojOmRqueSKOu03e1/e7vR+fjLtN/v9xBJLD4d52m/PwaEjJzGcVyv19FxITyPSJW5urqKYWAtSQ01th/G1vF4REnzrC44DGPO+fkpsxC6hcrVki+rOWdwYmbTSPUp7YSLjqx2Rgv5hgoJgeWVat6eMhLFbgqHbxgGp9JCICSymSFWIUgcSivnPGt5sof9VECK0oDBEXGeCivneJhVS0HKbKrZs+Yi94gaqAlVHDVp1ivm2O0shXj88PBwfX399u1bItrtdtEsKPq2BTY/jqO7U1poO3Dqny33XEq/AdakgNBb85TjCVrWCgHH67oQJjqx8oJURDAEdFgUSX9N+0qbePsj53xzczMMMk2Hy8tLZg4oOkYbbBKOvAAkwIqqVoHbbts4JcU0kSEy6OL84/3Dz1++Xl6sY0DUFSd2XxbKqoWHTP002yyIFo5V0yNYHN/vj24RTj/wU2e0rLa71GdkqtBpOq8XAACV4Z9HUt0dgRwRIo+pwB+d2iIEAKvNU+uTQgAUzRnqb7ewTLsvg2khKlvtbc7dCNRtKVvYvtiZcWAdcNu2ftO4vQdcttR3Criq9gVEASgJ19ZRtc0M0YlkCQgAtXS683X/78evdoVLVKQExBwQHTmRytXV1Zs3b3bbp9/94fc//fQFulK3h8NORLLO7969+/L15/v7x/1hGyGjDIiIprVxJixThu4Nd/eUBijNbhdbL3rz9YtstbrbmT3YbK92JRHVrpzY2irExe0dU3Uib4ywlBJ5QX+bFk8pEUfakrnmCC2iAwEyEpjPOpsW5dRC1mY2z5oSA6i7VWNrQkRXrSV0HDueIRFlc0eOrHmL0ElfWI6qTUoUP5eYEHGVhJmj35SZo3sU6Y58vrLrHBFxGMdpmrCABSWeFoBfkaTgh+motUXgPAU9G9Bdc/Y8MxETJWEuLRGBmdc0bi7Xqnp5kQCADYery3jXZlOikWApasg1WhglhYl4GEpTxShdFOJsnudxHEWG/X4fYPnz8/PFxWqz2Vyt10/fHi1PLLIa0nQ8lMpcJUYS0EOk4gzuTmbC4DY7kkE4AohM7tmyWml4HDSVKF2HxyD2E3HFGpxw0uzuTtVNLOQpsyp8wlAAqF3Qkc2MUMxsHEcR2c/WrsFWrTPP7qBVDzphFGzRDmrxLoOlOQC9LikKpuV2E93d3YXzejgcEP3m5iYaT03TJMRBFEcpnIkWTHZ3hJIX19jj7c3SyvYnommaorQZAOCptGHgcKWYXqaw9DITEQnBcSm72F9TRmUOvGyhCD9cXl5KaTqeWkgMggx4cVEEwmmFpap/l+BHbC2sTKgIxYUxqqqfP3/ebreRq5JSivOECIa2aPPl0PD4TxUtALhjvIFtJPXz8+HVT8Pjr+5ovRGC42lvRKjvtnshPkWKVPx4BMBjAIbQkGDQEzpwfN2yL9EZWryjVs8STkEcABBTgPhAQuZiKPm2ynFlpzWhrT40yNP7mRcPuPzrEYw9mbPXBMTvQs0vKOB6Tz2Dh7H+yjJPxGjFUzQ9LCoKwLDUevvf1fCvD0djhQYRIYo5TdOUBrn9zev7h6+vX7++uro6TBMDM/NutyOC6+vru88/3t/f//mPf/rbP/7+/PwsIikNiZiITOcwWiNTrT2CNvEAxgDArBSqtdLwbikisyxyhAtOc9KhSrT4u4E6TX6Fw2oGLTxjZsSCxKbuDuYmtUdzxFTdslk2k+gjEz3FqmfpsblVNZtS7dxQ9T3EXNw1R9KRFBpX7JxBavkhpN6YUKec8/F4PE7zAlIyDZLafFNKq0FExLImLm0kqFatAUBH0zxHRg74AhMKi2kJsjEzuGvXqh0RgZCrPcTM4zhqPoZ/HLHiVqCfKCqBgEN0NWZGkMTRAztMn5BHaK6WVZURgGie5xUtMOQgAGYNtkL3QeR4PK5SSoWLh+ggjAD4nCfV4du3p+3TkxCv12tGByCRJEgi7O6as2aL9LCW5sEslBJVbldY1UmkiVrBItmneQ+EjiWYm1JS8NnUEAhxHEer60OlTUjRhVjCehrRqmnK7i4ipsDMk+ZwmFYIl+t1EJJZpHDgwc0q+uYGZqoaVTlSbRzrnb3eZxaFW992vqSheMxIz8/PHz9+jIG9f//+1aubKMC52Wx0Lo+JZQHg2ssYhKZ4Jb2ifaGh1S06HGMX/3O1YJHiidgrbBt4SR6eCRx3B1fAcw9quRcRtDxss4hRjeOoqkE3i+4jgWXEeSKKSHuTCW0bn42njSo2beAOAPD09HR3dxcudQTAYlNN05SEEMCtFEe10lWdorUBIvJ306x7/OWlaLZI+xcRAbiLY73ghp05If3f1WAq3CNwr/3SEAAUAap6pgofNOnq7mjgrQnjEq44P6SZHlAKcbgZRopIUeTmVlUylooafYWs8ymF8l+QjKKnl1BAvwrnahugrxXcL1y790vnF2+42SNNtTdLAk6B4f/jgWZGSdxnEXn16tW3h19ub2///enHzWajpZ6RzHnabDYfPnz44S9/vb6+/ufHfxFKe0WJKN4KxpISE0oXamoK1raXEQ5smUgtPtZvUFxA1s5M6/YoFlQeAgmGDiOp10SlN1ytmIgOTAyVzMWYnPtoilpmS4CFb9x+sd1TCJlK89d5ngGKZS0iYcOqKqCDRX6UunviMRL2Aw32BWspbDLmal8jIYC6CUq0T+iTtdBLLDSKArCQlHZjORLoAMDNIKhtCIpLqepoHTPXjC+v9jvXRM9QISHdgtjFgmqac2ZZ58ofBIC4mJkZTESC7WJmhKyg0/4QrRGGpryhZUl6GCU5z09Pk5Z8MyCiAIkb8dXdh2GY5ywi06x72+ec0RTBmECQVqsV1uqhka5aPFd3SgUpsFKCzil4q3U/ZLAIIzbaESIYQq6FsokYK5ZhlQXNnB4fH0ttMl7abanq9fW43W7N7JhnYFrJKhof+UkHqqJF9tNxCn1rnnM2yG0DNOPSOu5IYOfx7jTmRFyWD4dwBw+Hw+3tbXjDZrbb7S4uVsGLVFXLGujpbBN2mQje4+Jdxktg8KqaVkNU1gxuV3w35yUhcJEaiACQ8wydoOsDVO1YziBxpSzF9b3AbHo3Tq7X63Ec53m32WxivmNEdxCJaLvdrtdrGla9wHT3XKGNs2FIaZ9VhFWQxj99+pSzpkQAHoVIm4eNZ/ks7oiVyxMBAzyfKRG2JS3SrIqyM3XQi7uTk2aR6wwdJHomA5dVNUciL1BygVcAnDr1HFdqjRPAaR+2ZUitFCVCo23G8R9WkirDTZpHzwAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import urllib\n",
+ "\n",
+ "from PIL import Image\n",
+ "\n",
+ "\n",
+ "def load_image_from_url(url: str) -> Image:\n",
+ " with urllib.request.urlopen(url) as f:\n",
+ " return Image.open(f).convert(\"RGB\")\n",
+ "\n",
+ "\n",
+ "EXAMPLE_IMAGE_URL = \"https://dl.fbaipublicfiles.com/dinov2/images/example.jpg\"\n",
+ "\n",
+ "\n",
+ "image = load_image_from_url(EXAMPLE_IMAGE_URL)\n",
+ "display(image)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e3240cb-54d0-438d-99e8-8c1af534f830",
+ "metadata": {},
+ "source": [
+ "## Semantic segmentation on sample image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "49226d5b-83fc-4cfb-ba06-407bb2c0d96f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "import dinov2.eval.segmentation.utils.colormaps as colormaps\n",
+ "\n",
+ "\n",
+ "DATASET_COLORMAPS = {\n",
+ " \"ade20k\": colormaps.ADE20K_COLORMAP,\n",
+ " \"voc2012\": colormaps.VOC2012_COLORMAP,\n",
+ "}\n",
+ "\n",
+ "\n",
+ "def render_segmentation(segmentation_logits, dataset):\n",
+ " colormap = DATASET_COLORMAPS[dataset]\n",
+ " colormap_array = np.array(colormap, dtype=np.uint8)\n",
+ " segmentation_values = colormap_array[segmentation_logits + 1]\n",
+ " return Image.fromarray(segmentation_values)\n",
+ "\n",
+ "\n",
+ "array = np.array(image)[:, :, ::-1] # BGR\n",
+ "segmentation_logits = inference_segmentor(model, array)[0]\n",
+ "segmented_image = render_segmentation(segmentation_logits, HEAD_DATASET)\n",
+ "display(segmented_image)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "de40012e-a01e-4e73-bb71-3048f16d41c8",
+ "metadata": {},
+ "source": [
+ "## Load pretrained segmentation model (Mask2Former)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ff2cbbbe-c53c-4e5b-977f-c2a7d93f4b8c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/private/home/plabatut/github/patricklabatut/dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py:222: UserWarning: Default ``avg_non_ignore`` is False, if you would like to ignore the certain label and average loss over non-ignore labels, which is the same with PyTorch official cross_entropy, set ``avg_non_ignore=True``.\n",
+ " warnings.warn(\n",
+ "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/mmcv/ops/multi_scale_deform_attn.py:209: UserWarning: You'd better set embed_dims in MultiScaleDeformAttention to make the dimension of each attention head a power of 2 which is more efficient in our CUDA implementation.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "load checkpoint from http path: https://dl.fbaipublicfiles.com/dinov2/dinov2_vitg14/dinov2_vitg14_ade20k_m2f.pth\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "EncoderDecoderMask2Former(\n",
+ " (backbone): ViTAdapter(\n",
+ " (patch_embed): PatchEmbed(\n",
+ " (proj): Conv2d(3, 1536, kernel_size=(14, 14), stride=(14, 14))\n",
+ " (norm): Identity()\n",
+ " )\n",
+ " (pos_drop): Dropout(p=0.0, inplace=False)\n",
+ " (blocks): Sequential(\n",
+ " (0): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): Identity()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (1): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (2): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (3): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (4): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (5): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (6): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (7): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (8): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (9): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (10): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (11): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (12): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (13): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (14): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (15): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (16): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (17): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (18): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (19): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (20): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (21): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (22): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (23): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (24): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (25): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (26): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (27): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (28): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (29): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (30): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (31): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (32): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (33): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (34): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (35): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (36): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (37): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (38): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (39): Block(\n",
+ " (norm1): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): Attention(\n",
+ " (qkv): Linear(in_features=1536, out_features=4608, bias=True)\n",
+ " (attn_drop): Dropout(p=0.0, inplace=False)\n",
+ " (proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (drop_path): DropPath()\n",
+ " (norm2): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (mlp): SwiGLUFFN(\n",
+ " (w1): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w2): Linear(in_features=1536, out_features=4096, bias=True)\n",
+ " (w3): Linear(in_features=4096, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (norm_pre): Identity()\n",
+ " (spm): SpatialPriorModule(\n",
+ " (stem): Sequential(\n",
+ " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+ " (1): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (2): ReLU(inplace=True)\n",
+ " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (4): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (5): ReLU(inplace=True)\n",
+ " (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (7): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (8): ReLU(inplace=True)\n",
+ " (9): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " )\n",
+ " (conv2): Sequential(\n",
+ " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+ " (1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (2): ReLU(inplace=True)\n",
+ " )\n",
+ " (conv3): Sequential(\n",
+ " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+ " (1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (2): ReLU(inplace=True)\n",
+ " )\n",
+ " (conv4): Sequential(\n",
+ " (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+ " (1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (2): ReLU(inplace=True)\n",
+ " )\n",
+ " (fc1): Conv2d(64, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " (fc2): Conv2d(128, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " (fc3): Conv2d(256, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " (fc4): Conv2d(256, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (interactions): Sequential(\n",
+ " (0): InteractionBlockWithCls(\n",
+ " (injector): Injector(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (extractor): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " )\n",
+ " (1): InteractionBlockWithCls(\n",
+ " (injector): Injector(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (extractor): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " )\n",
+ " (2): InteractionBlockWithCls(\n",
+ " (injector): Injector(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (extractor): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " )\n",
+ " (3): InteractionBlockWithCls(\n",
+ " (injector): Injector(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=576, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=288, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (extractor): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " (extra_extractors): Sequential(\n",
+ " (0): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " (1): Extractor(\n",
+ " (query_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (feat_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (attn): MSDeformAttn(\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=192, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=96, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (output_proj): Linear(in_features=768, out_features=1536, bias=True)\n",
+ " )\n",
+ " (ffn): ConvFFN(\n",
+ " (fc1): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (dwconv): DWConv(\n",
+ " (dwconv): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384)\n",
+ " )\n",
+ " (act): GELU(approximate='none')\n",
+ " (fc2): Linear(in_features=384, out_features=1536, bias=True)\n",
+ " (drop): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (ffn_norm): LayerNorm((1536,), eps=1e-06, elementwise_affine=True)\n",
+ " (drop_path): DropPath()\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (up): ConvTranspose2d(1536, 1536, kernel_size=(2, 2), stride=(2, 2))\n",
+ " (norm1): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (norm2): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (norm3): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (norm4): SyncBatchNorm(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " (decode_head): Mask2FormerHead(\n",
+ " input_transform=multiple_select, ignore_index=255, align_corners=False\n",
+ " (loss_decode): CrossEntropyLoss(avg_non_ignore=False)\n",
+ " (conv_seg): None\n",
+ " (dropout): Dropout2d(p=0.1, inplace=False)\n",
+ " (pixel_decoder): MSDeformAttnPixelDecoder(\n",
+ " (input_convs): ModuleList(\n",
+ " (0-2): 3 x ConvModule(\n",
+ " (conv): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n",
+ " )\n",
+ " )\n",
+ " (encoder): DetrTransformerEncoder(\n",
+ " (layers): ModuleList(\n",
+ " (0-5): 6 x BaseTransformerLayer(\n",
+ " (attentions): ModuleList(\n",
+ " (0): MultiScaleDeformableAttention(\n",
+ " (dropout): Dropout(p=0.0, inplace=False)\n",
+ " (sampling_offsets): Linear(in_features=1536, out_features=768, bias=True)\n",
+ " (attention_weights): Linear(in_features=1536, out_features=384, bias=True)\n",
+ " (value_proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (output_proj): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " )\n",
+ " )\n",
+ " (ffns): ModuleList(\n",
+ " (0): FFN(\n",
+ " (activate): ReLU(inplace=True)\n",
+ " (layers): Sequential(\n",
+ " (0): Sequential(\n",
+ " (0): Linear(in_features=1536, out_features=6144, bias=True)\n",
+ " (1): ReLU(inplace=True)\n",
+ " (2): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (1): Linear(in_features=6144, out_features=1536, bias=True)\n",
+ " (2): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (dropout_layer): Identity()\n",
+ " )\n",
+ " )\n",
+ " (norms): ModuleList(\n",
+ " (0-1): 2 x LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (postional_encoding): SinePositionalEncoding(num_feats=768, temperature=10000, normalize=True, scale=6.283185307179586, eps=1e-06)\n",
+ " (level_encoding): Embedding(3, 1536)\n",
+ " (lateral_convs): ModuleList(\n",
+ " (0): ConvModule(\n",
+ " (conv): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n",
+ " )\n",
+ " )\n",
+ " (output_convs): ModuleList(\n",
+ " (0): ConvModule(\n",
+ " (conv): Conv2d(1536, 1536, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " (gn): GroupNorm(32, 1536, eps=1e-05, affine=True)\n",
+ " (activate): ReLU(inplace=True)\n",
+ " )\n",
+ " )\n",
+ " (mask_feature): Conv2d(1536, 1536, kernel_size=(1, 1), stride=(1, 1))\n",
+ " )\n",
+ " (transformer_decoder): DetrTransformerDecoder(\n",
+ " (layers): ModuleList(\n",
+ " (0-8): 9 x DetrTransformerDecoderLayer(\n",
+ " (attentions): ModuleList(\n",
+ " (0-1): 2 x MultiheadAttention(\n",
+ " (attn): MultiheadAttention(\n",
+ " (out_proj): NonDynamicallyQuantizableLinear(in_features=1536, out_features=1536, bias=True)\n",
+ " )\n",
+ " (proj_drop): Dropout(p=0.0, inplace=False)\n",
+ " (dropout_layer): Identity()\n",
+ " )\n",
+ " )\n",
+ " (ffns): ModuleList(\n",
+ " (0): FFN(\n",
+ " (activate): ReLU(inplace=True)\n",
+ " (layers): Sequential(\n",
+ " (0): Sequential(\n",
+ " (0): Linear(in_features=1536, out_features=6144, bias=True)\n",
+ " (1): ReLU(inplace=True)\n",
+ " (2): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (1): Linear(in_features=6144, out_features=1536, bias=True)\n",
+ " (2): Dropout(p=0.0, inplace=False)\n",
+ " )\n",
+ " (dropout_layer): Identity()\n",
+ " )\n",
+ " )\n",
+ " (norms): ModuleList(\n",
+ " (0-2): 3 x LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n",
+ " )\n",
+ " )\n",
+ " )\n",
+ " (post_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n",
+ " )\n",
+ " (decoder_input_projs): ModuleList(\n",
+ " (0-2): 3 x Identity()\n",
+ " )\n",
+ " (decoder_positional_encoding): SinePositionalEncoding(num_feats=768, temperature=10000, normalize=True, scale=6.283185307179586, eps=1e-06)\n",
+ " (query_embed): Embedding(100, 1536)\n",
+ " (query_feat): Embedding(100, 1536)\n",
+ " (level_embed): Embedding(3, 1536)\n",
+ " (cls_embed): Linear(in_features=1536, out_features=151, bias=True)\n",
+ " (mask_embed): Sequential(\n",
+ " (0): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (1): ReLU(inplace=True)\n",
+ " (2): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " (3): ReLU(inplace=True)\n",
+ " (4): Linear(in_features=1536, out_features=1536, bias=True)\n",
+ " )\n",
+ " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n",
+ " (loss_mask): CrossEntropyLoss(avg_non_ignore=False)\n",
+ " (loss_dice): DiceLoss()\n",
+ " )\n",
+ ")"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import dinov2.eval.segmentation_m2f.models.segmentors\n",
+ "\n",
+ "CONFIG_URL = f\"{DINOV2_BASE_URL}/dinov2_vitg14/dinov2_vitg14_ade20k_m2f_config.py\"\n",
+ "CHECKPOINT_URL = f\"{DINOV2_BASE_URL}/dinov2_vitg14/dinov2_vitg14_ade20k_m2f.pth\"\n",
+ "\n",
+ "cfg_str = load_config_from_url(CONFIG_URL)\n",
+ "cfg = mmcv.Config.fromstring(cfg_str, file_format=\".py\")\n",
+ "\n",
+ "model = init_segmentor(cfg)\n",
+ "load_checkpoint(model, CHECKPOINT_URL, map_location=\"cpu\")\n",
+ "model.cuda()\n",
+ "model.eval()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "53c0309f-df2b-4912-bca5-e57d8b3875b3",
+ "metadata": {},
+ "source": [
+ "## Semantic segmentation on sample image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "f4abb13b-0e5a-4a40-8d44-21da4286ba7d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/private/home/plabatut/.conda/envs/dinov2-extras-conda/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1678402374358/work/aten/src/ATen/native/TensorShape.cpp:3483.)\n",
+ " return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAIAAAC6s0uzAAAfKElEQVR4nO3dO4xlR3rY8WqBomFvSueKjA7W4KJ7Q2Kzuduhm1Lq1JMZAwECpgWGlIeAAGPgbJQ6lcy0tydbKNwZgLCCgSMqNlM5GCy2FZz15eXt+zjv+qrq9wMDPoY9px9z//erOo+LXz+mLN58OuY3fv7x4v7iv8xyAP/8p29m+Tgs5JcfL3IfQnl+SP+u+5t/uPiX7m+ePw74Mr65ePzy0z8/8Qv+18d/6Pmh/ufVdfc33/7Tn/U/gD7u/vI/nP4F/+ObV/P+jozz280nuQ9hJX9/9Vfj/sc/mfc4AIA+sr1Def7xYtwQDGQxYvyd3e3Pv08P3+/9y8vNZvcf/+vLO0Mwa/qL9387bggubIngzaePKT3PfRQQ1Gfp/21XoUd4/njx5b/5cuIx7NX39uffz7UKffvz7w/++w8PD7v/uNdjCKuwAM/FBjAs4eDsu23wtqBDk3wsvQd9eHhIyQTMqoYOwa/++/9JzQYYmN2Jlee9gp4O6m6eB6UXitDVNzUSYPMuLG3GfV/RpUQjdoJrDrDu0pqeG8BvLv54/uPeRUpvLh7TycuQjlnurKsRHt6/y30INGpog3NehvR8+IWePf+Xf/7TN+oLB23rO5dQ9YW8/uL93579Ndtr2cu7Dvjm8e9O/wLphRFmD3MWxl8KUuQS9M3j3z29H5buwvqMv7Cnz0J0NwQXNgFv792xOwdbcIb+jt2cctBNK2My/sbRzn0op8gc4BHbwHukF4Z6/njR/TXx4xh/4aA+O8Gp0CXojvRCRtHqa/ylOPmXoIcOwW8+fez+Wuh4oAJ//vizY//pzcXj9q/RH1994bQ+Q3D+AAOrqeNU5z3qS6EEGNo1rsehxl/1DcgZWD0JMADM7+wqdIgATz8Xmvr8zjb/cP/p+nL718E5de/M591/7DkNG3+hv9MNDhFgYDVTLkBSXxjqRIOt1BPX7z59/KXVkQlO9PLAYxgmfDRgBAGGSnxxfXX6F1R5CjTROAOrP0vQUL+JV/0CUxxbhfZWhdCsQk/0xfXVf+69V/rlqIcBl2VzfCHdpjIrizIBOxEaIrv9+fe5D+EnlojliTbDEkzAULn+J099+U9/tuSB5Hc2sZura3MwqwkU4OcfL9zhGaKJNvuO03+63f5KJWZpgQIMjHb2FOhxWqvvwf9LiVlIlD1gILu93Eau75r7tfaGWYgAAwdErm9/m6vrWfKpwSxBgIF9RdT3dBTnSu9yHxDsAQM/KiK9W+sX0WnSzCjWBOxqYCA4czBziRVggPgsRx/jRtCDCDDAGDJMT39/9VcH/70AA4ynwYwmwACTaDDjhAuw87DY8zs3KCU8DWYEG+YAM/CgQw46tgGcBBhgaW4rzUHhlqCTVWigUnWvVLsG6akT42+KGWDY9UtvyM5Z6FFILKHuBrPrdH2TJWiAle022KJ0y0zAANkYiFsmwFA268+lq6PBNoD3nF1/TpagoWjqWwenSbcpaICff7x44/YL5XjxH+d8C//6f3sNolF707Ae1y1ogIlj3rjG/B0LZfytXtdjGS5On/XnlNLFr0POmcbfeVWQtH989z73IUShu22KnGEbwHsEOKUqwgPQCdtgAd7Vs76p4iVo6QUqs7m6Dthg9R0t4hdu4vgrvQDEV9t1wOoLQBFqCzAA5NJ/AzgFXIKesv5s/AUYqs+tuB7e/fsf/+HifsGjaUm4AI+mvgCDjLwL5uPNtsHOwJoi1tdu3PgrvQCDDE3v5vr/pr05mMliBXgo6QUYZMqzH37M8M4QzGiBTsJy9yuARc3y5KUuw+nxZvqHqsygM7BSnACPqK/xF2hKnLtw/LHBTBMlwACcEKe+HQ3eM3T8TQIMABONqG8KEmC7vwBLm2UDmBmFCPAINoCBdkRbf+64CHii/AE2/gJQrnHrzyl7gN15A2AFS6w/f/3D57N/zKbkn4ABoFCjx99U4p2wjL8A/Tn3KiwTMEC11HdRU8bflH0Cfv7xYtA2sPEXoA/pja+kCVh9AfpQ3yLkD/DzjxfPP16c/WXqC0AcE9efU/Yl6K2uwXvL0aILMJTxtxRRAtx5/vHi315f5T4KAFhcoADfX/z10395e+WZzw359v3+E0b9AEDM+1Ay3YIB3g3qzeN/O9jXs56+IicvyjU6+I3u/r1vN4T19Q+ff/XZd7mPolQXv558J+ZxZV2CV+qyHIvuQb65tGnE+LvyHnCbAZ5+BlYaMQHHye1TFjDDGtTaYx/BdxOoSa8AR47uad3rvhfuvKbXF+jJKdArmGX8TWcDXG56d+0GQIyXs3RovZ2iNU6/Cmiu+qaUPqkjsf05q+ugvQXeyDPr9th814CiBboMKaPGX9O7Tz9ydA8yEANFy38rylC+fX9TXIcmau3zBRhtxvXnZAI+qNaBuMrWOjsaKJQAn7JXrFAv9FXWdBxr0UCJLEEPEGeBOshhAMtxCnT1BHiw7BlW34N8WcBFwIuadwM4WYIeLcvqtMacZi2aahh/o5m9vkmA5zIljT2Dob49OS2L0qlvIyxB59dnTVt9B/HlAuIzAUdxbPlUS4A+bAAvZ4n15yTA0cjtXOwHA8FZgqZm3tAAYQkwAGQgwFTOEAzEJMDUL/u9U6A/1yC1Q4BphQYDIyx0CnQSYADIwmVINMRNsthd4K3pwtmaPpd2mIBpi4Xolu1trz68f2fDlYwEmOZocJuOtVaDOWG5DeAkwLRJg9llFOagReubBJhmaXBT+vS13AbbAC6UANMuDWZPuQ1mdkuPv0mAaZwGUzrjb7lchgTwo+0QLGwszQQMcEARZ2Z5l1A0AaZ1VqE5IX6D83p4/+5XD7/PfRTzW2EDOAkwJA2u3cSIrtngQntfZYNXIMCQkgZz0jrL0YXWtz5f/OYX6/xGAgzUbMaqCWQLVqtvEmDYMgTXZ/ZkLtfgEute4jH38eLu2Tq/0Sd3L//w6hsZBiqxdBUe3r9r6tzjnl/PXz38/rebGq5rXa2+qbsO+O7lH1JKMgyUbp2ZrPprhWsdbaP5MbpdhgEKtX42irhWeKjRn5FzoYf6ydSrwTTONjAj1NHg7s1EHZ/LaOtc/rtVw5I9QF7BN4Ybz2pY+/u+hmCAEcKOjzGPinTwMiQNBkoUYQZds3Z9Pl/17W/l9ed0bAnatUlA9Z4GTK5Y09E9YA2mNbdX97kPgcy2SZ5S4jgXKXk/0d8Xv/nFi7u1f1OJhZTUtz2n6zhLOxfdFc5e98qsef+NLQEGOGCuwuUaQ42//a2/+9sRYDD+NqdnXAttcNjzsdnjOmCgHpur62PtGVfT7v+a3rPuIyy6biy6xTk1AbseCajA5up6YvkCjsJ7H0p9R8u1/pxMwEBlFpoy5xqFDxr3YYPffouzzgTYxUgAW9OvU5q3mhkH393Potz5O8vVR1viCjDY9GXtTqEnTO197kUP4q9fvc31W58PsJ1ggBl1xS00vanw3O764je/yHsAJmCAkUbPwYWmNx2v7+bq+rcbJxUNI8DgMcBMUs1EeNpcq+7RZLkHVscbFkgppW/f37gdB6OduP64LFUmNiwTMPyROZhmddPtxPp+/cPncx3PCrJvAKeeE7CLkQDqYMbdlXH9OfVfgtZggGPCrj/L7Ql565ssQcMuq9CMELO+Wc6ZKmsVOrsBAXZBMC3QYPoLey2vwbcIzoIGOCVmYk/LeJvor3/4/KvPvsvyWxdnWIDtBNMClyQVpMQ6kl2EU6CTCRgoke4yWpD6JgEGCqK7/XVfqywL0VahexJgOMAqdByiO8XeV8/JWXHG3zQiwLaBgf7kM5Sn346Fkvyrh997NsNZvkDAIqS3CAutVG+uroM3OPtdONK4G3G4IJgWuCCYdni3lEXctycArOZgg6dMxgH3m0NtAKfRt6I0BNMCQ/BoJqo6dLf6Gn3Dr7B3poyw/pzcCxqAPsLed3OoIPVNlqAB6G+186hn160/x6lvmhJg1yMBHNMnS3UMlEUkOdrub8cEDDCbQe3Z/uI6SryV8SZcZZkUYEMw0DiZOabL8ENKca4GDrX+nKZPwBpM3dyTsm5l5bPQiflXD79PWTMcc/05zbIErcHArnXyUFY7T9tcXZ/+ou19sgc/9+BVDn5jrCx8OYDZrNCAmrrbU89PuftlwTOcUbT15+Q6YGAuS7/0b66u1Xf2X7+mbi06i4D1TXNNwFahoWWj0xu5FuXa+6qGmoktRO/yhQAmGff6Lr2r2f1SR4jxyg0OewZWsgQN0I4g73syrkWHMluAPZ4BGhRhomKQprbSI4+/yRI0QIMKvaS4MgIM0K5cJV5hJzj4+Jvm3QO2Cg300c4SaEGaWpoOwklYwHhesivTZbiyb2vMi4DT7EvQLggGqMCJBs+1WL3oKnT89edkAgZgkBnn4xWuRwo7/iYBBmCoUhocub5pibOgrUIDx1S2ubi0yF+uaDfY2lXE+nNa6DIkDYY2RQ4Gy3n6fc+Y5FLqm5ZbgnZJErRGfUeLNkFOF+FU6uDrz8keMDBR9zqb/dWWgCJkODJ3wgKm8iI70ebqur4heOv0j8dXn3034+9V0PpzMgEDkNHXP3y+xIeNv/6cFg2wbWAAzlqowfGZgAGoShHjbxJgALKbcQgupb5JgAGowxe/+UVB9U1LB9g2MBX49v1N7kMAKrT4BKzBAJw2/WKksi5A6liCBiCnGev7+tXbqUezIjfiACCPee/CUZw1JmCr0JTONjDMbq76lrj43LEEDb1oMMxoodm3rLOgLUEDsJ7lbv5cVn3TagH2hGAAztb34B05jv1f2/oWl96OCRggs4ofhbRr9Ox7sMr37y6mHU5+602lTsUCaFaf+o67IWWh429a+SQsDQZoUOOXGx1jXxaABfWsb4MPJVw7wIZgAEgmYACWY/H5BGdBAzC/QeltcP05mYAB8qryGqSl61vBNUgpS4BtAwOQUvr6h8/bnH07eSZgDQZINY6/X332ndOee7IEDcAM+qc35ajvwUcF531+cLYAG4IBTthcXec+hAHin3IV8IZZJmAAJsl4rdHErOatsgAD5FHHBvDQ+k4ff+s4BTrlDbBVaICirV/fmrgRB/Rye3Wf+xAglsinXBUh8xK0IZgiqC/syVXfatafU/YAJw0GKI3Zdxb5AwzBGX9ZQh1nYJ02e31rGn9TkAAbgoGmnK1v5IuAPeBoLk7CAljQw/t325pWMPVafJ6RAMMp1p+Zoivu0O6GHX/Vd14hlqAB6lPBvDuO+vYUJcC2gQnI+Mto9dU3+zOOKjsDK1mChmPUl9HarO/6g2/A5ysMIsAAc6qsvs55Xk6UJehkFRog8BlYpy09/j5dfy59/E2hApw0mDCsP0MKsO97TAX1TdECnLzwAcTQc993hfrujb911DcFDHDSYKBY1WwAh936raa+KeBJWJebzYeHh1k+1NOQf/v+ZpaPTN28BaRxYVeeKxNxAp7FwdfQ26t7r62c5icE+litvvVd/rtVbYBP8ArLMX42IOYlv1WKGODLzWbp06GNwsASCr2IaCvs1m+Vwu0Bz6JnXLe/zN4wyfhLAEX02/g7l4gTcGfNa4K98gLZZa9v/PG3plOgU8wAv3719vWrt2ndLmpw4/wAkNHm6jpvfb/67DtnPq8vYoBf3D3bvs3RYKBuBQ2+69d39xToysbfVOse8Gi7DbYx3A7vvchCehsXOsCjb8rx7fub6S+pt1f3GgwMtbm6Png/rOy53RO/vhVfAdyJuAQdh8EImIX6DlV9fVPwCbiTdxK1KA0M1eV2OwerLwdFD3C3Ct1VMHv/Dg7E2Y8KiCladzvqG4cl6KncVAsoRSn1fbr+XN8p0KmIAF9uNt3fRO5c5GMDSOXUtx3Rl6ALstdgS9NAHAXVt5HxNxUxAaedIbi/7P2zNA0E0f8uV9nr25QyArw1KGnZGwyQXVn3mNwbf3dvjFifwgI8VPYGG4KBjOI/X+GEitPbKSbAl5tNtxBdXNKsRQNZFLTv22nh5hu7ignwrhKTVtwBA+Xq/3SjFKa+e6off1OhAR4k+yr0lgYDKxi07Byzvo0oLMC7p0P375kGA42oo74tjL+puACPpsFA9Yqub2sbwKn0ABd6VZIGA7MbtOkbrb67Ghl/U+kBTsU2GGBGRV9ulJocf1MFAU7DGxwhw4ZgIIvIs29qafxNdQQ4De9ZkAbLcAS+C5Su9DtNtjn+pmoCnMpscPLqD0xT1p0m2VXe05AuN5sPDw8H/9Pt1f2grA5t8EKxHHrYAIOUUt+m1p9TTRNwZ9GBcrlMmoOBEfqMv8Hr2+z6cyo0wCOeThifBgODVFDfxpW3BN2ZcSE6jr0GF/pZACuor76trT+nQifgs5abJteMopkYOKi++rbp4uXLl7mPYbxjQ/DW7L3MFUXT8EK8y6E4NdV3uwHc4Pibap2At6q51raaTyQUX1KKU1N9KXUPuHP/7uLm+jH3UVAk9aUs9V3v2/j4myqYgPucwj7XS232l2xzMLSpvvqSSg9w//dNE9MVqnxxjqRcvoZUJuxtJjmh7CXolNKLu2cf0plTsba6l90gN8CaotxLrbIL+N2EE2rd9G35/htbZU/AnaH35ajjJbiOzwKYooLBt9kN4FTBBDzOiVteFBQ2c/AgBX1noVP6U345rdEA7yn3pVmDzyr3m0vjzta39NmXGpagGycwJ/jiUCj1bUElE7ALgnlKfSnU6fpKbzVMwDVQmqd8TahSZfVt+QysVFOAGz+pXW+gDsfG3wpOeN7qXq4br2+qJsC+kezydoTKVJPe1PywtKuSAANUwHVHTRHgehj7oGgH61vTynPyAIafqifAL+6eDb0lFkBkNaWXp+oJMEC5no6/6lu9Sq4DBqhGrel1+tWe2gJ8udl8eOj7cKT6RLsz5elt6VCHCnl9/cPnX332Xa3p3WMDuFNbgFPzDQ6izxlh8gy71Lc1Fe4Bv371tuWFjmrOhb69uq/mcwHu3128uHumvrsqnIBf3D17/ept7qPIKftC9Izh7D6UaZjs9n4IvTtkugon4OSSpOpeHUzDZPTt+5unbwG9KRyk5VXJEyqcgKlV9sme1pz+edv+V+8OGUeAq1Vlrnp+Ut++v/GayCBT/rAo8WnG32PqXILu+K5buYWzDq4wj/5Qs3wcGlFzgJMGAyfNnkwNpr/KA5w0uNVlMa+DnDbj4LvaRy6aC5Ceqj/ApLoa3P9z8SLIU10dV/jZkOGOEegEAW5FTfvBGsw46/88+AnsGH8PqjnA22+5t2BbDTYYOrlaaBTmmMovQ3JXLFyS1Lgg8WvzUiXDz2k1T8Cdbg72c7C1wp//dV7yBi1EB3kVZjWr7fUOFfCQFuJV96z6A7zlp2GrqffgNCh45IIf3uxsAB/TRIB9+59ausEBX2ICHhJLKOIbHXM6n5GBp4/K94D33L+7uLl+zH0Ucc376KGAm69PP7VoR8hEZVXt4NH6mWxHKwHuhmAnZO06dl/lKm8ifYxnzFWjmh/ayk7XsgB5QhNL0BxT+p/w2Y+/mhdxKlDuT+N2/Vl9T2srwC/untmZ2HOwYaWHeYrqN+eqVOu3rOifRvU9q60Ac1CX273oztLgFV47FnqvEPYiFhpU1o9iN+Sobx8tBtgQ/JQ5+JiCXvioWxEZ9uo6SIsBTn5KeqvpDtIAoTQaYAaZ0uByV6EpRfy5cEZNfbLVE2B6mTIKl/6SUfrxU5mwa9FOfh6quQB7RNIUYRtsCG5WzBStoNlPvCbNBZiJwu4KxzwqgGNaDLAhuFYLNVjaw2p8Coy5Fm39ub8WA8x0YZsU9sBgIaEarL6DNBpgQ3DFukXyuUqs6MQXocFeS0doNMBMF79M048w/ufYsgjVoaO+4wiwH52VFPdyqb4UJOZ+MKe18jhCljDv84OX8DSinsBKxbI8hNvlv6O1G+AXd888HrhBWluHyG/78srSYMZpegna+7VZ9P/T7kWTWfhBOs3XpxRNBzj9/wbbBl6NlwYm8iPUx/Z5mqt9ucwzI7S7BA3Qgm2Dl1iavtxsLu9m/6itaH0C3jIEr8YEA1n4oxeNAAO0wtVKoQiwu2JBMcRjFnNl+HKzmf5BWibAzGDo3pKXUUbwYzMvX8/sBBgogFpEc//uwq0UJhLgn7AKPZohGIrjj2FeAkw2/vBDduP+GJpVZiHAKbmEfCZugMdCvFdblC9vLgK8zzu7NfmTDzRLgMlMg6FQ1g4nEuA/2v1JMgSvzM0BgAYJ8I+8m5vONjC04MXdMy+Y0wnwYYbg9RmCgaYI8E94T5eXtWjIYtCfO/PJXAQYCM17snX4Oq9PgAFIqV+Djb8zEuCj/JwBsBwB3mcbGOKwLrqy019wY8m8BPgADQY4xivkXD7JfQCh3b+7uLl+zH0Uhbm9uje1QH0uN5vLu9wHURcT8GHe4k3hdhxQroNXA15uNlkOpm4CfIY9j3Fur+5lGMrlovwVCDALkmGAYwT4PEPwRIMaLNhsmcCCsP68EAFmDT2zqr5sqW8El5uN+i7HWdCsRFwBdpmAj/KEYMjF+EsLTMB9uSYYlqO4Mb365k/uXv4h91FUS4BPeXH37PWrt9t/1GBq0rN5y+0diC6NswR9hjty0LjuetB5Y+ka04K8+kYmluIrC/QyVzKlFzqWoIexCk0dxlVw+3+NWJfWXdgjwOft7QQDagrTWYIGgAwEuBfXBAMwLwHuy+nQQJucCL0QX9YxDMGUzp1BITsBHsAQDDTIzbAWIsAjGYIBmEKAASADAYZG3V7d2wmGjNyIA5p2sMFP77Nxe3Xf/ctjzV7i1hx7v5e7f1CZi5cvX+Y+hsLs3hXLbSnhhCnJfFp6Ac7FSVgLMQEP5s6U0FPP8brn/wiVEWBgVaPjul0Ghzo4CWuM7QXBLkaC1agvlRHgqTQYgBEEeCR3xQJgCgEGgAwEeDw7wQCMJsAAkIEAT2InGKibu3AsR4Cn6hpsFRoW5Rok6iPAs9FgoDLG30UJMABkIMBzMgQD0JMAz8CpWAAMJcAAkIEAA0AGAjwz28AA9CHA87ANDMAgAjwbt4YGauIi4KUJ8JzMwbAEt8GiSgK8CEMwAKcJ8MwMwQD0IcBLMQTDLKw/U6tPch8AwGHSS90EeH4v7p69fvU291FAUHtZvb26P/troEoCDCzrdE21lmYJ8CK6Ifj+3cXN9WPuY4H1qCn0J8BLsRBNO3QXRnAWNDCJ+sI4ArwsFyNRN/WF0SxBL85OMFWSXpjIBAwAGQgwAPs8CmkFArwgDygE4BgBBuAnjL/rcBLWslwNDKc9vRWl07vyUt/VmIAX1y1EW4WGXbdX991fx/7T+ocEKxPgNXhIMGz17KsGUz1L0OtxQTDNUtNSWH9ekwCvSoNphOLCWQIMzEx9S2T2XZ894JXYBgZglwkYGMOYWxPjbxYm4PW4HgmALQFelYVoIBrjby4CDNAu9c1IgDOwCg1EoL55CXAeGgzQOAFem21gAJIAZ2QIBjKy/pydAANABgKcgVVoOMtTgameAOfhphwAjRNgIBzjLy0Q4GwMwXCQ+tIIAQaADAQ4J0MwkMurb7z+Z+YbAAAZCHBmLkkCaJMA5/fi7tnlZpP7KABYlQADgTgFmnYIMABkIMBROBcaoCkCHIgGA7RDgIFAbq/ucx8CrESAYzEEAzRCgKNwQTBAUwQYADIQ4EAMwZBsA9MMAY7lxd0z28AALRDgiDSYxhmCaYEAA0AGAhyOhwRDSun26r77K/eBwFI+yX0AAKcMbbDHOVAKE3BEhmAYzdxMKS5evnyZ+xg46sPDQ+5DgLIZiI+5e/mH3IfQOkvQQM0OTsOqTAQCHNrlZmMIhtntVlmMycUeMNA0G8bkIsDRORULlua8LbKwBA2Q0hyjsNVsBjEBF8AQDEUwSTOIAAPMSYPpSYCj84xCKI4G04cAF0CDAeojwGW43GxyHwIwQPAh2G2wIhBggLaobxACDAAZCDAAZCDAAA2x/hyHAANABgJcBs9EAqiMAAPML+Z9oa0/hyLAADOLWV+iEWCAJhh/oxHgArx+9Tb3IQB9xRx/1TcgAY5OfYGJ1DcmAS7AzfVj7kMAeok5/hLTJ7kPAKASQeq79xwIj3IJS4ABZpClvmefuaS+kQkwwFTr1zf44w7pQ4ABxos5+FIEAQYYaeX66m5lBDg6p0BDTGvWd3R6Pzw82AYOy2VIAIMVUd+OR7mEZQIGGKCg9BKcAIfmrSvEsVx6lw6theiYBBjgvIXqu9qMq8EB2QMGOKP0+hKTAAOcUk19Pzw8eLhLKAIclw1gyC7I7Z3n4rLGUAQYoCHe2cchwACQgbOgAdrS7QS/uHuW+0Bq1melQYAB1vaz9DeblO0U6Jvrx/t3F7l+9/qMXtUXYIBV/Sz9Te5DSDfXj6/fvTUEH7TaNrkAA5DZweadvnNIBWeTCTBAi26uH1PWW2OdLWgFiT3NWdAAjcpVuA8PD9XHtQ8TMAAr0d1dJmCAdq1ZRPXdI8AAR81+x+YIp0AThADH5dlhEIFnFs3C+PuUAAM0bYVHJKnvQQIMcEb1Q/CiDVbfYwQ4Lj+1EEfFDV70GYVex05wGRJAL12Dd58QfLDKhT5C+PWree5MuTdM3+jvcQIMMMDZUXj3F5QS4+7xDBOfkrTCXnJlLEEDLOX26r77K/eBDDCuowf/r0UXtysgwACQwb8Cfzi08Mu2voAAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "array = np.array(image)[:, :, ::-1] # BGR\n",
+ "segmentation_logits = inference_segmentor(model, array)[0]\n",
+ "segmented_image = render_segmentation(segmentation_logits, \"ade20k\")\n",
+ "display(segmented_image)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.17"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/facebookresearch/dinov2/pyproject.toml b/facebookresearch/dinov2/pyproject.toml
new file mode 100644
index 0000000..da67abd
--- /dev/null
+++ b/facebookresearch/dinov2/pyproject.toml
@@ -0,0 +1,29 @@
+[tool.black]
+line-length = 120
+
+[tool.pylint.master]
+persistent = false
+score = false
+
+[tool.pylint.messages_control]
+disable = "all"
+enable = [
+ "miscellaneous",
+ "similarities",
+]
+
+[tool.pylint.similarities]
+ignore-comments = true
+ignore-docstrings = true
+ignore-imports = true
+min-similarity-lines = 8
+
+[tool.pylint.reports]
+reports = false
+
+[tool.pylint.miscellaneous]
+notes = [
+ "FIXME",
+ "XXX",
+ "TODO",
+]
diff --git a/facebookresearch/dinov2/requirements-dev.txt b/facebookresearch/dinov2/requirements-dev.txt
new file mode 100644
index 0000000..5cad34c
--- /dev/null
+++ b/facebookresearch/dinov2/requirements-dev.txt
@@ -0,0 +1,3 @@
+black==22.6.0
+flake8==5.0.4
+pylint==2.15.0
diff --git a/facebookresearch/dinov2/requirements-extras.txt b/facebookresearch/dinov2/requirements-extras.txt
new file mode 100644
index 0000000..ac75fb3
--- /dev/null
+++ b/facebookresearch/dinov2/requirements-extras.txt
@@ -0,0 +1,2 @@
+mmcv-full==1.5.0
+mmsegmentation==0.27.0
diff --git a/facebookresearch/dinov2/requirements.txt b/facebookresearch/dinov2/requirements.txt
new file mode 100644
index 0000000..04c159c
--- /dev/null
+++ b/facebookresearch/dinov2/requirements.txt
@@ -0,0 +1,11 @@
+--extra-index-url https://download.pytorch.org/whl/cu117
+torch==2.0.0
+torchvision==0.15.0
+omegaconf
+torchmetrics==0.10.3
+fvcore
+iopath
+xformers==0.0.18
+submitit
+--extra-index-url https://pypi.nvidia.com
+cuml-cu11
diff --git a/facebookresearch/dinov2/scripts/lint.sh b/facebookresearch/dinov2/scripts/lint.sh
new file mode 100644
index 0000000..b91acaf
--- /dev/null
+++ b/facebookresearch/dinov2/scripts/lint.sh
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+if [ -n "$1" ]; then
+ echo "linting \"$1\""
+fi
+
+echo "running black"
+if [ -n "$1" ]; then
+ black "$1"
+else
+ black dinov2
+fi
+
+echo "running flake8"
+if [ -n "$1" ]; then
+ flake8 "$1"
+else
+ flake8
+fi
+
+echo "running pylint"
+if [ -n "$1" ]; then
+ pylint "$1"
+else
+ pylint dinov2
+fi
+
+exit 0
diff --git a/facebookresearch/dinov2/setup.cfg b/facebookresearch/dinov2/setup.cfg
new file mode 100644
index 0000000..a2b19d6
--- /dev/null
+++ b/facebookresearch/dinov2/setup.cfg
@@ -0,0 +1,8 @@
+[flake8]
+max-line-length = 120
+ignore = E203,E501,W503
+per-file-ignores =
+ __init__.py:F401
+ hubconf.py:F401
+exclude =
+ venv
diff --git a/facebookresearch/dinov2/setup.py b/facebookresearch/dinov2/setup.py
new file mode 100644
index 0000000..daa9d63
--- /dev/null
+++ b/facebookresearch/dinov2/setup.py
@@ -0,0 +1,88 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the Apache License, Version 2.0
+# found in the LICENSE file in the root directory of this source tree.
+
+from pathlib import Path
+import re
+from typing import List, Tuple
+
+from setuptools import setup, find_packages
+
+
+NAME = "dinov2"
+DESCRIPTION = "PyTorch code and models for the DINOv2 self-supervised learning method."
+
+URL = "https://github.com/facebookresearch/dinov2"
+AUTHOR = "FAIR"
+REQUIRES_PYTHON = ">=3.9.0"
+HERE = Path(__file__).parent
+
+
+try:
+ with open(HERE / "README.md", encoding="utf-8") as f:
+ long_description = "\n" + f.read()
+except FileNotFoundError:
+ long_description = DESCRIPTION
+
+
+def get_requirements(path: str = HERE / "requirements.txt") -> Tuple[List[str], List[str]]:
+ requirements = []
+ extra_indices = []
+ with open(path) as f:
+ for line in f.readlines():
+ line = line.rstrip("\r\n")
+ if line.startswith("--extra-index-url "):
+ extra_indices.append(line[18:])
+ continue
+ requirements.append(line)
+ return requirements, extra_indices
+
+
+def get_package_version() -> str:
+ with open(HERE / "dinov2/__init__.py") as f:
+ result = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", f.read(), re.M)
+ if result:
+ return result.group(1)
+ raise RuntimeError("Can't get package version")
+
+
+requirements, extra_indices = get_requirements()
+version = get_package_version()
+dev_requirements, _ = get_requirements(HERE / "requirements-dev.txt")
+extras_requirements, _ = get_requirements(HERE / "requirements-extras.txt")
+
+
+setup(
+ name=NAME,
+ version=version,
+ description=DESCRIPTION,
+ long_description=long_description,
+ long_description_content_type="text/markdown",
+ author=AUTHOR,
+ python_requires=REQUIRES_PYTHON,
+ url=URL,
+ packages=find_packages(),
+ package_data={
+ "": ["*.yaml"],
+ },
+ install_requires=requirements,
+ extras_require={
+ "dev": dev_requirements,
+ "extras": extras_requirements,
+ },
+ dependency_links=extra_indices,
+ install_package_data=True,
+ license="Apache",
+ license_files=("LICENSE",),
+ classifiers=[
+ # Trove classifiers: https://github.com/pypa/trove-classifiers/blob/main/src/trove_classifiers/__init__.py
+ "Development Status :: 3 - Alpha",
+ "Intended Audience :: Developers",
+ "Intended Audience :: Science/Research",
+ "License :: OSI Approved :: Apache Software License",
+ "Programming Language :: Python :: 3.9",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+ "Topic :: Software Development :: Libraries :: Python Modules",
+ ],
+)
diff --git a/model_loader_utils.py b/model_loader_utils.py
new file mode 100644
index 0000000..ab891e4
--- /dev/null
+++ b/model_loader_utils.py
@@ -0,0 +1,94 @@
+# !/usr/bin/env python
+# -*- coding: UTF-8 -*-
+import os
+import torch
+import gc
+from PIL import Image
+import numpy as np
+import cv2
+from comfy.utils import common_upscale
+
+
+cur_path = os.path.dirname(os.path.abspath(__file__))
+
+def gc_cleanup():
+ gc.collect()
+ torch.cuda.empty_cache()
+
+def tensor2cv(tensor_image):
+ if len(tensor_image.shape)==4:# b hwc to hwc
+ tensor_image=tensor_image.squeeze(0)
+ if tensor_image.is_cuda:
+ tensor_image = tensor_image.cpu()
+ tensor_image=tensor_image.numpy()
+ #反归一化
+ maxValue=tensor_image.max()
+ tensor_image=tensor_image*255/maxValue
+ img_cv2=np.uint8(tensor_image)#32 to uint8
+ img_cv2=cv2.cvtColor(img_cv2,cv2.COLOR_RGB2BGR)
+ return img_cv2
+
+def phi2narry(img):
+ img = torch.from_numpy(np.array(img).astype(np.float32) / 255.0).unsqueeze(0)
+ return img
+
+def tensor2image(tensor):
+ tensor = tensor.cpu()
+ image_np = tensor.squeeze().mul(255).clamp(0, 255).byte().numpy()
+ image = Image.fromarray(image_np, mode='RGB')
+ return image
+
+def tensor2pillist(tensor_in):
+ d1, _, _, _ = tensor_in.size()
+ if d1 == 1:
+ img_list = [tensor2image(tensor_in)]
+ else:
+ tensor_list = torch.chunk(tensor_in, chunks=d1)
+ img_list=[tensor2image(i) for i in tensor_list]
+ return img_list
+
+def tensor2pillist_upscale(tensor_in,width,height):
+ d1, _, _, _ = tensor_in.size()
+ if d1 == 1:
+ img_list = [nomarl_upscale(tensor_in,width,height)]
+ else:
+ tensor_list = torch.chunk(tensor_in, chunks=d1)
+ img_list=[nomarl_upscale(i,width,height) for i in tensor_list]
+ return img_list
+
+def tensor2list(tensor_in,width,height):
+ if tensor_in is None:
+ return None
+ d1, _, _, _ = tensor_in.size()
+ if d1 == 1:
+ tensor_list = [tensor_upscale(tensor_in,width,height)]
+ else:
+ tensor_list_ = torch.chunk(tensor_in, chunks=d1)
+ tensor_list=[tensor_upscale(i,width,height) for i in tensor_list_]
+ return tensor_list
+
+
+def tensor_upscale(tensor, width, height):
+ samples = tensor.movedim(-1, 1)
+ samples = common_upscale(samples, width, height, "nearest-exact", "center")
+ samples = samples.movedim(1, -1)
+ return samples
+
+def nomarl_upscale(img, width, height):
+ samples = img.movedim(-1, 1)
+ img = common_upscale(samples, width, height, "nearest-exact", "center")
+ samples = img.movedim(1, -1)
+ img = tensor2image(samples)
+ return img
+
+
+
+def cv2tensor(img,bgr2rgb=True):
+ assert type(img) == np.ndarray, 'the img type is {}, but ndarry expected'.format(type(img))
+ if bgr2rgb:
+ img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+ img = torch.from_numpy(img.transpose((2, 0, 1)))
+ return img.float().div(255).permute(1, 2, 0).unsqueeze(0)
+
+
+
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..fcb3481
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,16 @@
+[project]
+name = "omnipart"
+description = "OmniPart: Part-Aware 3D Generation with Semantic Decoupling and Structural Cohesion,this node ,you can use it in comfyUI"
+version = "1.0.0"
+license = {file = "LICENSE"}
+dependencies = ["torch", "torchvision", "pillow", "imageio", "imageio-ffmpeg", "tqdm", "easydict", "opencv-python-headless", "scipy", "rembg", "onnxruntime", "trimesh", "xatlas", "pyvista", "pymeshfix", "igraph", "git+https://github.com/EasternJournalist/utils3d.git@9a4eb15e4021b67b12c460c7057d642626897ec8", "xformers", "spconv-cu120", "transformers", "pydantic", "diffusers", "lightning", "mesh2sdf", "loguru", "tetgen", "pymeshfix", "igraph", "omegaconf", "pycocotools", "kornia", "timm", "h5py", "boto3", "torch-scatter", "git+https://github.com/facebookresearch/segment-anything.git", "git+https://github.com/facebookresearch/detectron2.git", "#https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.0.post2/flash_attn-2.7.0.post2+cu12torch2.4cxx11abiFALSE-cp310-cp310-linux_x86_64.whl", "#https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/diff_gaussian_rasterization-0.0.0-cp310-cp310-linux_x86_64.whl?download=true", "#https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/nvdiffrast-0.3.3-cp310-cp310-linux_x86_64.whl?download=true"]
+
+[project.urls]
+Repository = "https://github.com/smthemex/ComfyUI_OmniPart"
+# Used by Comfy Registry https://registry.comfy.org
+
+[tool.comfy]
+PublisherId = "smthemex"
+DisplayName = "ComfyUI_OmniPart"
+Icon = ""
+includes = []
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..23a3582
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,42 @@
+torch
+torchvision
+pillow
+imageio
+imageio-ffmpeg
+tqdm
+easydict
+opencv-python-headless
+scipy
+rembg
+onnxruntime
+trimesh
+xatlas
+pyvista
+pymeshfix
+igraph
+git+https://github.com/EasternJournalist/utils3d.git@9a4eb15e4021b67b12c460c7057d642626897ec8
+xformers
+spconv-cu120
+transformers
+pydantic
+diffusers
+lightning
+mesh2sdf
+loguru
+tetgen
+pymeshfix
+igraph
+omegaconf
+pycocotools
+kornia
+timm
+h5py
+boto3
+torch-scatter
+git+https://github.com/facebookresearch/segment-anything.git
+git+https://github.com/facebookresearch/detectron2.git
+
+
+#https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.0.post2/flash_attn-2.7.0.post2+cu12torch2.4cxx11abiFALSE-cp310-cp310-linux_x86_64.whl
+#https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/diff_gaussian_rasterization-0.0.0-cp310-cp310-linux_x86_64.whl?download=true
+#https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/nvdiffrast-0.3.3-cp310-cp310-linux_x86_64.whl?download=true
\ No newline at end of file