From bcc151b9fe5487c1d6dd7dff1a7fee6674b4fa01 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Thu, 4 Apr 2024 10:14:52 -0400 Subject: [PATCH 01/50] added updated frontier code --- .../._multinode_deepspeed_launcher.sh | Bin 0 -> 206 bytes .../deepspeed/multinode_deepspeed_launcher.sh | 62 ++++ .../frontier_satvision_giant_runner.sh | 104 +++++++ ...v2_satvision_giant_192_window12_200ep.yaml | 30 ++ ...se_landcover5class_192_window12_100ep.yaml | Bin 0 -> 206 bytes ...se_landcover9class_192_window12_100ep.yaml | Bin 0 -> 206 bytes ...nv2_satvision_base_192_window12_800ep.yaml | Bin 0 -> 206 bytes .../._run_satvision_finetune_lc_fiveclass.sh | Bin 0 -> 206 bytes .../._run_satvision_finetune_lc_nineclass.sh | Bin 0 -> 206 bytes .../._run_satvision_pretrain.sh | Bin 0 -> 206 bytes ...se_landcover5class_192_window12_100ep.yaml | 0 ...se_landcover9class_192_window12_100ep.yaml | 0 ...nv2_satvision_base_192_window12_800ep.yaml | 0 .../run_satvision_finetune_lc_fiveclass.sh | 0 .../run_satvision_finetune_lc_nineclass.sh | 0 .../run_satvision_pretrain.sh | 0 examples/satvision-giant/._README.md | Bin 0 -> 206 bytes ...v2_satvision_giant_192_window12_200ep.yaml | Bin 0 -> 206 bytes .../._run_satvision_pretrain.sh | Bin 0 -> 206 bytes examples/satvision-huge/._README.md | Bin 0 -> 206 bytes ...nv2_satvision_huge_192_window12_200ep.yaml | Bin 0 -> 206 bytes .../._run_satvision_pretrain.sh | Bin 0 -> 206 bytes examples/satvision/README.md | 35 --- pytorch_caney/data/benchmark.py | 142 +++++++++ pytorch_caney/data/datamodules/test_wds.py | 82 +++++ .../datasets/mim_modis_22m_4band_dataset.py | 83 +++++ .../data/datasets/mim_modis_22m_dataset.py | 10 +- pytorch_caney/data/transforms.py | 3 + .../pipelines/finetuning/finetune.py | 2 - .../pipelines/pretraining/mim_deepspeed.py | 286 +++++++++++------- requirements/._Dockerfile | Bin 0 -> 206 bytes requirements/._Dockerfile.dev | Bin 0 -> 206 bytes requirements/._README.md | Bin 0 -> 206 bytes requirements/._environment_gpu.yml | Bin 0 -> 206 bytes requirements/._requirements-test.txt | Bin 0 -> 206 bytes requirements/._requirements.txt | Bin 0 -> 206 bytes requirements/Dockerfile | 2 +- requirements/Dockerfile.dev | 3 +- 38 files changed, 697 insertions(+), 147 deletions(-) create mode 100644 examples/deepspeed/._multinode_deepspeed_launcher.sh create mode 100644 examples/deepspeed/multinode_deepspeed_launcher.sh create mode 100644 examples/frontier/frontier_satvision_giant_runner.sh create mode 100644 examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml create mode 100644 examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml create mode 100644 examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml create mode 100644 examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml create mode 100755 examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh create mode 100755 examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh create mode 100755 examples/satvision-base/._run_satvision_pretrain.sh rename examples/{satvision => satvision-base}/finetune_satvision_base_landcover5class_192_window12_100ep.yaml (100%) rename examples/{satvision => satvision-base}/finetune_satvision_base_landcover9class_192_window12_100ep.yaml (100%) rename examples/{satvision => satvision-base}/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml (100%) rename examples/{satvision => satvision-base}/run_satvision_finetune_lc_fiveclass.sh (100%) rename examples/{satvision => satvision-base}/run_satvision_finetune_lc_nineclass.sh (100%) rename examples/{satvision => satvision-base}/run_satvision_pretrain.sh (100%) create mode 100644 examples/satvision-giant/._README.md create mode 100644 examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml create mode 100755 examples/satvision-giant/._run_satvision_pretrain.sh create mode 100644 examples/satvision-huge/._README.md create mode 100644 examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml create mode 100755 examples/satvision-huge/._run_satvision_pretrain.sh delete mode 100644 examples/satvision/README.md create mode 100644 pytorch_caney/data/benchmark.py create mode 100644 pytorch_caney/data/datamodules/test_wds.py create mode 100644 pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py create mode 100644 requirements/._Dockerfile create mode 100644 requirements/._Dockerfile.dev create mode 100644 requirements/._README.md create mode 100644 requirements/._environment_gpu.yml create mode 100644 requirements/._requirements-test.txt create mode 100644 requirements/._requirements.txt diff --git a/examples/deepspeed/._multinode_deepspeed_launcher.sh b/examples/deepspeed/._multinode_deepspeed_launcher.sh new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/deepspeed/multinode_deepspeed_launcher.sh b/examples/deepspeed/multinode_deepspeed_launcher.sh new file mode 100644 index 0000000..9d47225 --- /dev/null +++ b/examples/deepspeed/multinode_deepspeed_launcher.sh @@ -0,0 +1,62 @@ +#!/bin/bash +#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --nodes=5 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) +#SBATCH --mem=300G # total memory per node (4 GB per cpu-core is default) +#SBATCH --gres=gpu:4 # number of allocated gpus per node +#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --partition=gpu_a100 +#SBATCH --reservation=jcv +#SBATCH --constraint=rome +#SBATCH --qos=8n_a100 +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES + +launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 40" +echo $cmd + +srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +echo "END TIME: $(date)" diff --git a/examples/frontier/frontier_satvision_giant_runner.sh b/examples/frontier/frontier_satvision_giant_runner.sh new file mode 100644 index 0000000..dd37dcd --- /dev/null +++ b/examples/frontier/frontier_satvision_giant_runner.sh @@ -0,0 +1,104 @@ +#!/bin/bash +#SBATCH -A geo160 +#SBATCH --job-name=satvision-giant-pretraining-100-epoch-test # create a short name for your job +#SBATCH --nodes=46 # node count +#SBATCH --qos=debug +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --gres=gpu:8 # number of allocated gpus per node +#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) +#SBATCH --cpus-per-task=56 +#SBATCH -C nvme +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + +##### Setup modules +module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 +module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 +module load PrgEnv-gnu/8.4.0 +export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich +module load amd-mixed/5.7.1 +module load craype-accel-amd-gfx90a +module load miniforge3/23.11.0 +export MPICH_GPU_SUPPORT_ENABLED=1 +export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" +export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} +rm -rf ${MIOPEN_USER_DB_PATH} +mkdir -p ${MIOPEN_USER_DB_PATH} + +##### sbcast env to local nvme +echo "copying torch_env to each node in the job" +conda_env_name='rocm-torch-test-full-0.1.0' + +sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz +echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz +echo /mnt/bb/${USER}/${conda_env_name}.tar.gz +ls -l /mnt/bb/${USER} +ls -l $MEMBERWORK/geo160 + +if [ ! "$?" == "0" ]; then + # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, + # your application may pick up partially complete shared library files, which would give you confusing errors. + echo "SBCAST failed!" + exit 1 +fi + +srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} +echo "untaring torchenv" +srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} +echo "Done untarring torchenv" + +source activate /mnt/bb/${USER}/${conda_env_name} +echo "Activated ${conda_env_name}" + +srun --ntasks-per-node 1 conda-unpack + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +# export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/02m +batchsize=416 +nprocpernode=8 + +launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize}" +echo $cmd + +srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +echo "END TIME: $(date)" + diff --git a/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml b/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml new file mode 100644 index 0000000..5ed2538 --- /dev/null +++ b/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml @@ -0,0 +1,30 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 12 + NORM_PERIOD: 6 + +DATA: + IMG_SIZE: 192 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 100 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + WARMUP_LR: 5e-7 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 1 +SAVE_FREQ: 1 +TAG: mim_pretrain_swinv2_g_satvision_192_window12__100ep diff --git a/examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml b/examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml b/examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml b/examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh b/examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh new file mode 100755 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh b/examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh new file mode 100755 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-base/._run_satvision_pretrain.sh b/examples/satvision-base/._run_satvision_pretrain.sh new file mode 100755 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision/finetune_satvision_base_landcover5class_192_window12_100ep.yaml b/examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml similarity index 100% rename from examples/satvision/finetune_satvision_base_landcover5class_192_window12_100ep.yaml rename to examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml diff --git a/examples/satvision/finetune_satvision_base_landcover9class_192_window12_100ep.yaml b/examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml similarity index 100% rename from examples/satvision/finetune_satvision_base_landcover9class_192_window12_100ep.yaml rename to examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml diff --git a/examples/satvision/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml b/examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml similarity index 100% rename from examples/satvision/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml rename to examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml diff --git a/examples/satvision/run_satvision_finetune_lc_fiveclass.sh b/examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh similarity index 100% rename from examples/satvision/run_satvision_finetune_lc_fiveclass.sh rename to examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh diff --git a/examples/satvision/run_satvision_finetune_lc_nineclass.sh b/examples/satvision-base/run_satvision_finetune_lc_nineclass.sh similarity index 100% rename from examples/satvision/run_satvision_finetune_lc_nineclass.sh rename to examples/satvision-base/run_satvision_finetune_lc_nineclass.sh diff --git a/examples/satvision/run_satvision_pretrain.sh b/examples/satvision-base/run_satvision_pretrain.sh similarity index 100% rename from examples/satvision/run_satvision_pretrain.sh rename to examples/satvision-base/run_satvision_pretrain.sh diff --git a/examples/satvision-giant/._README.md b/examples/satvision-giant/._README.md new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml b/examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-giant/._run_satvision_pretrain.sh b/examples/satvision-giant/._run_satvision_pretrain.sh new file mode 100755 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-huge/._README.md b/examples/satvision-huge/._README.md new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml b/examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision-huge/._run_satvision_pretrain.sh b/examples/satvision-huge/._run_satvision_pretrain.sh new file mode 100755 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/examples/satvision/README.md b/examples/satvision/README.md deleted file mode 100644 index 136a140..0000000 --- a/examples/satvision/README.md +++ /dev/null @@ -1,35 +0,0 @@ -# SatVision Examples - -The following is an example on how to run SatVision finetune. This is only an example and does not limit other decoder possibilities, or other ways of dealing with the encoder. - -## SatVision Finetune Land Cover Five Class - -The script run_satvision_finetune_lc_fiveclass.sh has an example on how to run the finetuning of a 5 class land cover model using a simple UNet architecture. The dependencies of this model are as follow: - -- finetune.py script (pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py): this script has the basics for training the finetuning model. Below you will find an example of this script: - -```bash -export PYTHONPATH=$PWD:pytorch-caney -export NGPUS=8 - -torchrun --nproc_per_node $NGPUS \ - pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py \ - --cfg finetune_satvision_base_landcover5class_192_window12_100ep.yaml \ - --pretrained /explore/nobackup/people/cssprad1/projects/satnet/code/development/masked_image_modeling/development/models/simmim_satnet_pretrain_pretrain/simmim_pretrain__satnet_swinv2_base__img192_window12__800ep_v3_no_norm/ckpt_epoch_800.pth \ - --dataset MODISLC9 \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/finetuning/h18v04/labels_9classes_224 \ - --batch-size 4 \ - --output /explore/nobackup/people/cssprad1/projects/satnet/code/development/cleanup/finetune/models \ - --enable-amp -``` - -From these parameters note that: - -- the pretrained model path is given by --pretrained -- the data paths is given by --data-paths and is expecting a directory whose internal structure is one for images and one from labels, but this can be modified if both input and target files are stored in the same file -- the dataloader is simply called from the script using the --dataset option, which is simply calling build_finetune_dataloaders -from pytorch-caney - -These is simply a guide script on how to run a finetuning pipeline. If you want to get additional insights on how to build other -types of decoders, the build_model function from pytorch_caney/models/build.py has additional details on how to combine the different -encoder and decoders. \ No newline at end of file diff --git a/pytorch_caney/data/benchmark.py b/pytorch_caney/data/benchmark.py new file mode 100644 index 0000000..8966ea8 --- /dev/null +++ b/pytorch_caney/data/benchmark.py @@ -0,0 +1,142 @@ +from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset +from pytorch_caney.data.transforms import SimmimTransform +from pytorch_caney.config import get_config + +import argparse +import os +import sys +import time + +import torch +from torch.utils.data import DataLoader + + +NUM_SAMPLES: int = 2000180 + + +def parse_args(): + """ + Parse command-line arguments + """ + parser = argparse.ArgumentParser( + 'pytorch-caney implementation of MiM pre-training script', + add_help=False) + + parser.add_argument( + '--cfg', + type=str, + required=True, + metavar="FILE", + help='path to config file') + + parser.add_argument( + "--data-paths", + nargs='+', + required=True, + help="paths where dataset is stored") + + parser.add_argument( + '--batch-size', + type=int, + help="batch size for single GPU") + + parser.add_argument( + '--gpu', + action='store_true', + default=False, + help="Copy batches to gpu") + + parser.add_argument( + '--dtype', + type=str, + default='bf16', + help='target dtype') + + args = parser.parse_args() + + config = get_config(args) + + return args, config + + +def benchmark(dataLoader: DataLoader, target_dtype, gpu: bool) -> None: + """ + Benchmark the speed of iterating through a PyTorch dataset using DataLoader. + + Args: + - dataLoader: PyTorch DataLoader object + """ + + start_time = time.time() + num_batches = 0 + + for _, img_mask in enumerate(dataLoader): + + img_mask = img_mask[0] + + img = torch.stack([pair[0] for pair in img_mask]) + mask = torch.stack([pair[1] for pair in img_mask]) + + if gpu: + img = img.to('cuda:0', non_blocking=True) + mask = mask.to('cuda:0', non_blocking=True) + + if target_dtype: + img = img.to(target_dtype) + + num_batches += 1 + + end_time = time.time() + total_time = end_time - start_time + + samples_processed = NUM_SAMPLES + samples_per_second = samples_processed / total_time + + print(f"Processed {samples_processed} samples in {total_time:.2f} seconds.") + print(f"Avg time per batch: {total_time / num_batches:.4f} seconds") + print(f"Samples per second: {samples_per_second:.2f}") + + +def main(config, args): + pin_memory = True + + if args.dtype == 'bf16': + dtype = torch.bfloat16 + elif args.dtype == 'f16': + dtype = torch.half + else: + dtype = None + + gpu = args.gpu + + transform = SimmimTransform(config) + + dataset = MODIS22MDataset(config, + config.DATA.DATA_PATHS, + split="train", + img_size=config.DATA.IMG_SIZE, + transform=transform, + batch_size=config.DATA.BATCH_SIZE).dataset() + + dataloader = torch.utils.data.DataLoader( + dataset, + batch_size=None, + num_workers=int(os.environ["SLURM_CPUS_PER_TASK"]), + shuffle=False, + pin_memory=pin_memory,) + + print(f'Batch size: {config.DATA.BATCH_SIZE}') + print(f'Img size: {config.DATA.IMG_SIZE}') + print(f'Num workers: {int(os.environ["SLURM_CPUS_PER_TASK"])}') + print(f'PIN MEMORY {pin_memory}') + print(f'GPU: {gpu}') + print(f'Datatype: {dtype}') + + benchmark(dataloader, dtype, gpu) + + +if __name__ == '__main__': + + args, config = parse_args() + + sys.exit(main(config=config, args=args)) diff --git a/pytorch_caney/data/datamodules/test_wds.py b/pytorch_caney/data/datamodules/test_wds.py new file mode 100644 index 0000000..7c6f2f7 --- /dev/null +++ b/pytorch_caney/data/datamodules/test_wds.py @@ -0,0 +1,82 @@ +import sys + +sys.path.append('pytorch-caney') + +from pytorch_caney.config import get_config +from pytorch_caney.loss.build import build_loss +from pytorch_caney.lr_scheduler import build_scheduler, setup_scaled_lr +from pytorch_caney.ptc_logging import create_logger +from pytorch_caney.training.mim_utils import get_grad_norm + +import argparse +import datetime +import joblib +import numpy as np +import os +import time + +import torch +import torch.cuda.amp as amp +import torch.backends.cudnn as cudnn +import torch.distributed as dist + +from timm.utils import AverageMeter + + +from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset + +from pytorch_caney.data.transforms import SimmimTransform, SimmimMaskGenerator + +from torch.utils.data import DataLoader, DistributedSampler +from torch.utils.data._utils.collate import default_collate + +import torch.distributed as dist + +def collate_fn(batch): + if not isinstance(batch[0][0], tuple): + return default_collate(batch) + else: + batch_num = len(batch) + ret = [] + for item_idx in range(len(batch[0][0])): + if batch[0][0][item_idx] is None: + ret.append(None) + else: + ret.append(default_collate( + [batch[i][0][item_idx] for i in range(batch_num)])) + ret.append(default_collate([batch[i][1] for i in range(batch_num)])) + return ret + + + +def build_mim_dataloader(config, logger): + + transform = SimmimTransform(config) + + logger.info(f'Pre-train data transform:\n{transform}') + + dataset_to_use = MODIS22MDataset + + dataset = dataset_to_use(config, + config.DATA.DATA_PATHS, + split="train", + img_size=config.DATA.IMG_SIZE, + transform=transform) + + logger.info(f'Build dataset: train images = {len(dataset)}') + + sampler = DistributedSampler( + dataset, + num_replicas=dist.get_world_size(), + rank=dist.get_rank(), + shuffle=True) + + dataloader = DataLoader(dataset, + config.DATA.BATCH_SIZE, + sampler=sampler, + num_workers=config.DATA.NUM_WORKERS, + pin_memory=True, + drop_last=True, + collate_fn=collate_fn) + + return dataloader diff --git a/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py b/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py new file mode 100644 index 0000000..f5d446c --- /dev/null +++ b/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py @@ -0,0 +1,83 @@ +import os +import numpy as np +import pathlib +import logging + +from io import BytesIO +import webdataset as wds +import torch.distributed as dist + + +def nodesplitter(src, group=None): + if dist.is_initialized(): + if group is None: + group = dist.group.WORLD + rank = dist.get_rank(group=group) + size = dist.get_world_size(group=group) + logging.info(f"nodesplitter: rank={rank} size={size}") + count = 0 + for i, item in enumerate(src): + if i % size == rank: + yield item + count += 1 + logging.info(f"nodesplitter: rank={rank} size={size} " + \ + f"count={count} DONE") + else: + yield from src + + +class MODIS22MDataset(object): + """ + MODIS MOD09GA 22-million pre-training dataset + """ + SHARD_PATH = os.path.join("shard") + + INPUT_KEY = 'input.npy' + + OUTPUT_KEY = 'output.npy' + + def __init__( + self, + config, + data_paths: list, + split: str, + img_size: tuple = (192, 192), + transform=None, + batch_size=64, + ): + + self.random_state = 42 + + self.config = config + + self.img_size = img_size + + self.transform = transform + + self.split = split + + self.shard_path = pathlib.Path(os.path.join(data_paths[0], + self.SHARD_PATH)) + + shards = self.shard_path.glob('*.tar') + + self.shards = list(map(str, shards)) + + self.batch_size = batch_size + + def dataset(self): + + dataset = ( + wds.WebDataset(self.shards, + shardshuffle=True, + handler=wds.ignore_and_continue, + nodesplitter=nodesplitter) + .shuffle(self.random_state) + .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) # , self.OUTPUT_KEY) + .map_tuple(BytesIO) + .map_tuple(np.load) + .map_tuple(self.transform) + .batched(self.batch_size, partial=False) + ) + + return dataset diff --git a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py b/pytorch_caney/data/datasets/mim_modis_22m_dataset.py index 0407907..8234288 100644 --- a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py +++ b/pytorch_caney/data/datasets/mim_modis_22m_dataset.py @@ -20,7 +20,7 @@ def nodesplitter(src, group=None): if i % size == rank: yield item count += 1 - logging.info(f"nodesplitter: rank={rank} size={size} " + + logging.info(f"nodesplitter: rank={rank} size={size} " + \ f"count={count} DONE") else: yield from src @@ -46,7 +46,7 @@ def __init__( batch_size=64, ): - self.random_state = 42 + self.random_state = 1000 self.config = config @@ -70,14 +70,18 @@ def dataset(self): dataset = ( wds.WebDataset(self.shards, shardshuffle=True, + # resampled=True, + repeat=True, handler=wds.ignore_and_continue, nodesplitter=nodesplitter) .shuffle(self.random_state) - .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) + .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) # , self.OUTPUT_KEY) .map_tuple(BytesIO) .map_tuple(np.load) .map_tuple(self.transform) .batched(self.batch_size, partial=False) + .repeat(2) + .with_length(1962000) ) return dataset diff --git a/pytorch_caney/data/transforms.py b/pytorch_caney/data/transforms.py index e0a71b5..2252cd8 100644 --- a/pytorch_caney/data/transforms.py +++ b/pytorch_caney/data/transforms.py @@ -17,6 +17,9 @@ def __init__(self, config): RandomResizedCropNP(scale=(0.67, 1.), ratio=(3. / 4., 4. / 3.)), T.ToTensor(), + #lambda x: x / 500.0, + #T.ConvertImageDtype(dtype=torch.float32), + #torchvision.ops.Permute(dims=[1, 2, 0]), T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), ]) diff --git a/pytorch_caney/pipelines/finetuning/finetune.py b/pytorch_caney/pipelines/finetuning/finetune.py index e111523..4b3b05b 100644 --- a/pytorch_caney/pipelines/finetuning/finetune.py +++ b/pytorch_caney/pipelines/finetuning/finetune.py @@ -367,8 +367,6 @@ def build_finetune_model(config, logger): logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") - # You can replace this section by simply calling your model class - # For example: model = UNet(parameters) model = build_model(config, pretrain=False, pretrain_method='mim', diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 4d7d33c..0c3ddb6 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -1,34 +1,30 @@ -from pytorch_caney.data.datamodules.mim_datamodule \ - import build_mim_dataloader - -from pytorch_caney.models.mim.mim \ - import build_mim_model - -from pytorch_caney.training.mim_utils \ - import build_optimizer, save_checkpoint - -# from pytorch_caney.training.mim_utils import get_grad_norm -from pytorch_caney.lr_scheduler import build_scheduler, setup_scaled_lr +from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset +from pytorch_caney.data.transforms import SimmimTransform +from pytorch_caney.models.mim.mim import build_mim_model from pytorch_caney.ptc_logging import create_logger from pytorch_caney.config import get_config import deepspeed +from deepspeed.accelerator import get_accelerator +from socket import gethostname import argparse import datetime import joblib import numpy as np import os +import sys import time import torch -import torch.cuda.amp as amp -import torch.backends.cudnn as cudnn import torch.distributed as dist from timm.utils import AverageMeter +NUM_SAMPLES: int = 1962000 + + def parse_args(): """ Parse command-line arguments @@ -50,11 +46,10 @@ def parse_args(): required=True, help="paths where dataset is stored") - parser.add_argument( - '--dataset', - type=str, - required=True, - help='Dataset to use') + parser.add_argument('--dataset', + type=str, + required=True, + help='Dataset to use') parser.add_argument( '--batch-size', @@ -65,27 +60,11 @@ def parse_args(): '--resume', help='resume from checkpoint') - parser.add_argument( - '--accumulation-steps', - type=int, - help="gradient accumulation steps") - parser.add_argument( '--use-checkpoint', action='store_true', help="whether to use gradient checkpointing to save memory") - parser.add_argument( - '--enable-amp', - action='store_true') - - parser.add_argument( - '--disable-amp', - action='store_false', - dest='enable_amp') - - parser.set_defaults(enable_amp=True) - parser.add_argument( '--output', default='output', @@ -98,12 +77,6 @@ def parse_args(): '--tag', help='tag of experiment') - # distributed training (deepspeed) - parser.add_argument("--local_rank", - type=int, - required=True, - help='local rank for DistributedDataParallel') - args = parser.parse_args() config = get_config(args) @@ -115,8 +88,7 @@ def train(config, dataloader, model_engine, optimizer, - lr_scheduler, - scaler): + device): """ Start pre-training a specific model and dataset. @@ -127,26 +99,37 @@ def train(config, model_wo_ddp: model to pre-train that is not the DDP version optimizer: pytorch optimizer lr_scheduler: learning-rate scheduler - scaler: loss scaler """ logger.info("Start training") + target_dtype = None + if model_engine.bfloat16_enabled(): + target_dtype = torch.bfloat16 + elif model_engine.fp16_enabled(): + target_dtype = torch.half + logger.info(f'Target dtype: {target_dtype}') + + torch.cuda.empty_cache() + start_time = time.time() for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): - dataloader.sampler.set_epoch(epoch) + start = time.time() execute_one_epoch(config, model_engine, dataloader, - optimizer, epoch, lr_scheduler, scaler) + optimizer, epoch, target_dtype, device) - if dist.get_rank() == 0 and \ - (epoch % config.SAVE_FREQ == 0 or - epoch == (config.TRAIN.EPOCHS - 1)): + tag = f'ckpt_epoch_{epoch}' + model_engine.save_checkpoint(save_dir=config.OUTPUT, + tag=tag,) + + epoch_time = time.time() - start + logger.info( + f"EPOCH {epoch} training takes " + + f"{datetime.timedelta(seconds=int(epoch_time))}") - save_checkpoint(config, epoch, model_engine, 0., - optimizer, lr_scheduler, scaler, logger) total_time = time.time() - start_time @@ -160,8 +143,8 @@ def execute_one_epoch(config, dataloader, optimizer, epoch, - lr_scheduler, - scaler): + target_dtype, + device): """ Execute training iterations on a single epoch. @@ -171,31 +154,36 @@ def execute_one_epoch(config, dataloader: dataloader to use optimizer: pytorch optimizer epoch: int epoch number - lr_scheduler: learning-rate scheduler - scaler: loss scaler + target_dtype: torch dtype, should match model dtype + device: device to move inputs to """ - model.train() - - optimizer.zero_grad() - - num_steps = len(dataloader) + ntrain = 1962000 + num_steps = max(1, + ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) # Set up logging meters batch_time = AverageMeter() data_time = AverageMeter() loss_meter = AverageMeter() - norm_meter = AverageMeter() - loss_scale_meter = AverageMeter() start = time.time() end = time.time() - for idx, (img, mask, _) in enumerate(dataloader): + + for idx, img_mask in enumerate(dataloader): + + img_mask = img_mask[0] + + img = torch.stack([pair[0] for pair in img_mask]) + mask = torch.stack([pair[1] for pair in img_mask]) data_time.update(time.time() - start) - img = img.cuda(non_blocking=True) - mask = mask.cuda(non_blocking=True) + img = img.to(device, non_blocking=True) + mask = mask.to(device, non_blocking=True) + + if target_dtype: + img = img.to(target_dtype) loss = model(img, mask) @@ -203,6 +191,8 @@ def execute_one_epoch(config, model.step() + torch.cuda.synchronize() + loss_meter.update(loss.item(), img.size(0)) batch_time.update(time.time() - end) end = time.time() @@ -217,15 +207,13 @@ def execute_one_epoch(config, f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'grad_norm {norm_meter.val:.4f} ({norm_meter.avg:.4f})\t' - # f'loss_scale {loss_scale_meter.val:.4f}' + - f' ({loss_scale_meter.avg:.4f})\t' f'mem {memory_used:.0f}MB') - epoch_time = time.time() - start - logger.info( - f"EPOCH {epoch} training takes " + - f"{datetime.timedelta(seconds=int(epoch_time))}") + if idx == num_steps: + logger.info(f'Ending step loop for epoch {idx}') + break + + torch.distributed.barrier() def main(config): @@ -238,53 +226,140 @@ def main(config): logger.info('In main') - pretrain_data_loader = build_mim_dataloader(config, logger) + transform = SimmimTransform(config) + + dataset = MODIS22MDataset(config, + config.DATA.DATA_PATHS, + split="train", + img_size=config.DATA.IMG_SIZE, + transform=transform, + batch_size=config.DATA.BATCH_SIZE).dataset() + + dataloader = torch.utils.data.DataLoader( + dataset, + batch_size=None, + num_workers=8, + shuffle=False, + pin_memory=True,) + + logger.info(f'MODEL CHECKPOINTING: {config.TRAIN.USE_CHECKPOINT}') simmim_model = build_model(config, logger) - simmim_optimizer = build_optimizer(config, - simmim_model, - is_pretrain=True, - logger=logger) + # Count the total number of parameters + total_params = sum(p.numel() for p in simmim_model.parameters()) + logger.info(f"Total number of parameters: {total_params}") - n_iter_per_epoch = len(pretrain_data_loader) + # Count the total number of trainable parameters + trainable_params = sum(p.numel() for p in simmim_model.parameters() + if p.requires_grad) + logger.info(f"Total number of trainable parameters: {trainable_params}") - lr_scheduler = build_scheduler(config, simmim_optimizer, n_iter_per_epoch) + ntrain = 1962000 + num_steps = max( + 1, + ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) deepspeed_config = { + "zero_allow_untested_optimizer": True, + "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, + "steps_per_print": config.PRINT_FREQ, + "memory_breakdown": False, + "zero_optimization": { - "stage": 2, - "allgather_partitions": True, - "allgather_bucket_size": 2e8, - "overlap_comm": True, - "reduce_scatter": True, - "reduce_bucket_size": "auto", + "stage": 0, + # "offload_optimizer": {"device": "cpu"}, + #"offload_param": {"device": "cpu"}, "contiguous_gradients": True, - } + "overlap_comm": True, + "reduce_bucket_size": 5e8, + "allgather_bucket_size": 5e8, + #"offload_optimizer": { + # "device": "cpu" + #}, + }, + + "activation_checkpointing": { + "partition_activations": True, + # "cpu_checkpointing": True, + "profile": False, + }, + + "fp16": { + "enabled": False, + }, + + "bf16": { + "enabled": True, + }, + + "scheduler": { + "type": "WarmupLR", + "params": { + "warmup_min_lr": config.TRAIN.WARMUP_LR, + "warmup_max_lr": config.TRAIN.BASE_LR, + "last_batch_iteration": num_steps - 1, + }, + }, + + + "flops_profiler": { + "enabled": False, + #"profile_step": 1, + "module_depth": -1, + #"top_modules": 1, + "detailed": True, + "output_file": f'profile_{time.time()}', + }, + } logger.info('Initializing deepspeed') - model_engine, _, _, _ = deepspeed.initialize( + optimizer = torch.optim.AdamW(simmim_model.parameters(), lr=config.TRAIN.BASE_LR) + + model_engine, optimizer, _, _ = deepspeed.initialize( model=simmim_model, - optimizer=simmim_optimizer, - lr_scheduler=lr_scheduler, model_parameters=simmim_model.parameters(), + optimizer=optimizer, + dist_init_required=True, config=deepspeed_config ) - scaler = amp.GradScaler() + if config.MODEL.RESUME: + + load_dir = os.path.dirname(config.MODEL.RESUME) + logger.info(f'Ckpt load dir: {load_dir}') + + tag = os.path.basename(config.MODEL.RESUME) + logger.info(f'Ckpt tag: {tag}') + + epoch = tag.split('_')[2] + logger.info(f'Ckpt epoch: {epoch}') + + load_path, _ = model_engine.load_checkpoint(load_dir=load_dir, + tag=tag) + config.defrost() + config.TRAIN.START_EPOCH = int(epoch) + 1 + config.freeze() + + logger.info(f'Loaded from checkpoint: {load_path}') + logger.info(f'Resuming from epoch {config.TRAIN.START_EPOCH}') + + local_rank = model_engine.local_rank + local_device = get_accelerator().device_name(local_rank) logger.info('Starting training block') + torch.distributed.barrier() + train(config, - pretrain_data_loader, + dataloader, model_engine, - simmim_optimizer, - lr_scheduler, - scaler) + optimizer, + local_device) def build_model(config, logger): @@ -293,8 +368,6 @@ def build_model(config, logger): model = build_mim_model(config) - logger.info(str(model)) - return model @@ -307,20 +380,23 @@ def setup_seeding(config): if __name__ == '__main__': _, config = parse_args() + world_size = int(os.environ["WORLD_SIZE"]) + rank = int(os.environ["RANK"]) + gpus_per_node = torch.cuda.device_count() + print(f" {gpus_per_node} allocated GPUs per node.", flush=True) + deepspeed.init_distributed() - setup_seeding(config) + torch.distributed.barrier() - cudnn.benchmark = True + print(f"Hello from rank {rank} of {world_size} on" + f" {gethostname()} where there are" + f" {gpus_per_node} allocated GPUs per node.", flush=True) - linear_scaled_lr, linear_scaled_min_lr, linear_scaled_warmup_lr = \ - setup_scaled_lr(config) + if rank == 0: + print(f"Group initialized? {dist.is_initialized()}", flush=True) - config.defrost() - config.TRAIN.BASE_LR = linear_scaled_lr - config.TRAIN.WARMUP_LR = linear_scaled_warmup_lr - config.TRAIN.MIN_LR = linear_scaled_min_lr - config.freeze() + setup_seeding(config) os.makedirs(config.OUTPUT, exist_ok=True) logger = create_logger(output_dir=config.OUTPUT, @@ -337,4 +413,4 @@ def setup_seeding(config): config_file_path = os.path.join(config.OUTPUT, config_file_name) joblib.dump(config, config_file_path) - main(config) + sys.exit(main(config)) diff --git a/requirements/._Dockerfile b/requirements/._Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/._Dockerfile.dev b/requirements/._Dockerfile.dev new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/._README.md b/requirements/._README.md new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/._environment_gpu.yml b/requirements/._environment_gpu.yml new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/._requirements-test.txt b/requirements/._requirements-test.txt new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/._requirements.txt b/requirements/._requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..b852360644df5435f0aeee5e1bc894d3018b38c7 GIT binary patch literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz literal 0 HcmV?d00001 diff --git a/requirements/Dockerfile b/requirements/Dockerfile index a9995b2..608e0fd 100644 --- a/requirements/Dockerfile +++ b/requirements/Dockerfile @@ -1,5 +1,5 @@ # Arguments to pass to the image -ARG VERSION_DATE=23.01 +ARG VERSION_DATE=24.01 ARG FROM_IMAGE=nvcr.io/nvidia/pytorch # Import RAPIDS container as the BASE Image (cuda base image) diff --git a/requirements/Dockerfile.dev b/requirements/Dockerfile.dev index b7fc5d6..2445b91 100644 --- a/requirements/Dockerfile.dev +++ b/requirements/Dockerfile.dev @@ -1,5 +1,6 @@ # Arguments to pass to the image -ARG VERSION_DATE=23.01 +ARG VERSION_DATE=24.01 + ARG FROM_IMAGE=nvcr.io/nvidia/pytorch # Import RAPIDS container as the BASE Image (cuda base image) From 8ccdd902249536ca78a1f5b0d3d54106f21a131c Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Thu, 4 Apr 2024 10:16:05 -0400 Subject: [PATCH 02/50] rmd tar pieces --- .../deepspeed/._multinode_deepspeed_launcher.sh | Bin 206 -> 0 bytes ...n_base_landcover5class_192_window12_100ep.yaml | Bin 206 -> 0 bytes ...n_base_landcover9class_192_window12_100ep.yaml | Bin 206 -> 0 bytes ..._swinv2_satvision_base_192_window12_800ep.yaml | Bin 206 -> 0 bytes .../._run_satvision_finetune_lc_fiveclass.sh | Bin 206 -> 0 bytes .../._run_satvision_finetune_lc_nineclass.sh | Bin 206 -> 0 bytes .../satvision-base/._run_satvision_pretrain.sh | Bin 206 -> 0 bytes examples/satvision-giant/._README.md | Bin 206 -> 0 bytes ...swinv2_satvision_giant_192_window12_200ep.yaml | Bin 206 -> 0 bytes .../satvision-giant/._run_satvision_pretrain.sh | Bin 206 -> 0 bytes examples/satvision-huge/._README.md | Bin 206 -> 0 bytes ..._swinv2_satvision_huge_192_window12_200ep.yaml | Bin 206 -> 0 bytes .../satvision-huge/._run_satvision_pretrain.sh | Bin 206 -> 0 bytes requirements/._Dockerfile | Bin 206 -> 0 bytes requirements/._Dockerfile.dev | Bin 206 -> 0 bytes requirements/._README.md | Bin 206 -> 0 bytes requirements/._environment_gpu.yml | Bin 206 -> 0 bytes requirements/._requirements-test.txt | Bin 206 -> 0 bytes requirements/._requirements.txt | Bin 206 -> 0 bytes 19 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 examples/deepspeed/._multinode_deepspeed_launcher.sh delete mode 100644 examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml delete mode 100644 examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml delete mode 100644 examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml delete mode 100755 examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh delete mode 100755 examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh delete mode 100755 examples/satvision-base/._run_satvision_pretrain.sh delete mode 100644 examples/satvision-giant/._README.md delete mode 100644 examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml delete mode 100755 examples/satvision-giant/._run_satvision_pretrain.sh delete mode 100644 examples/satvision-huge/._README.md delete mode 100644 examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml delete mode 100755 examples/satvision-huge/._run_satvision_pretrain.sh delete mode 100644 requirements/._Dockerfile delete mode 100644 requirements/._Dockerfile.dev delete mode 100644 requirements/._README.md delete mode 100644 requirements/._environment_gpu.yml delete mode 100644 requirements/._requirements-test.txt delete mode 100644 requirements/._requirements.txt diff --git a/examples/deepspeed/._multinode_deepspeed_launcher.sh b/examples/deepspeed/._multinode_deepspeed_launcher.sh deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml b/examples/satvision-base/._finetune_satvision_base_landcover5class_192_window12_100ep.yaml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml b/examples/satvision-base/._finetune_satvision_base_landcover9class_192_window12_100ep.yaml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml b/examples/satvision-base/._mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh b/examples/satvision-base/._run_satvision_finetune_lc_fiveclass.sh deleted file mode 100755 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh b/examples/satvision-base/._run_satvision_finetune_lc_nineclass.sh deleted file mode 100755 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-base/._run_satvision_pretrain.sh b/examples/satvision-base/._run_satvision_pretrain.sh deleted file mode 100755 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-giant/._README.md b/examples/satvision-giant/._README.md deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml b/examples/satvision-giant/._mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-giant/._run_satvision_pretrain.sh b/examples/satvision-giant/._run_satvision_pretrain.sh deleted file mode 100755 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-huge/._README.md b/examples/satvision-huge/._README.md deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml b/examples/satvision-huge/._mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/examples/satvision-huge/._run_satvision_pretrain.sh b/examples/satvision-huge/._run_satvision_pretrain.sh deleted file mode 100755 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._Dockerfile b/requirements/._Dockerfile deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._Dockerfile.dev b/requirements/._Dockerfile.dev deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._README.md b/requirements/._README.md deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._environment_gpu.yml b/requirements/._environment_gpu.yml deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._requirements-test.txt b/requirements/._requirements-test.txt deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz diff --git a/requirements/._requirements.txt b/requirements/._requirements.txt deleted file mode 100644 index b852360644df5435f0aeee5e1bc894d3018b38c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206 zcmZQz6=P>$Vqox1Ojhs@R)|o50+1L3ClDI}@f;uq@y`J<5x_AdBnYYuq+J^qI7A5ADWagzZ6zUroSr}TInWkB$Stc1+Tbr7?IU5-mSm+uW dSvcvMI6J%PT9}&y31dTN6IVw^R|7Xk1^}609UuSz From 7221ae06b0d16036b1f3f4df7564ed97ba868082 Mon Sep 17 00:00:00 2001 From: "Caleb S. Spradlin" Date: Fri, 7 Jun 2024 10:26:58 -0400 Subject: [PATCH 03/50] updated pre-training code --- notebooks/satvision-toa-reconstruction.ipynb | 394 -------------- pytorch_caney/config.py | 7 + pytorch_caney/data/transforms.py | 43 ++ pytorch_caney/data/utils.py | 189 ++++++- pytorch_caney/models/swinv2_model.py | 2 +- .../pipelines/pretraining/mim_deepspeed.py | 116 +++- .../pretraining/mim_deepspeed_scaling.py | 515 ++++++++++++++++++ ...nt_128_window08_patch8_onecycle_100ep.yaml | 31 ++ ..._128_window08_patch8_onecycle_scaling.yaml | 31 ++ ...uge_128_window8_patch8_onecycle_100ep.yaml | 33 ++ .../discover_svtoa_pretraining_runner.sh | 66 +++ ...iscover_svtoa_pretraining_runner_resume.sh | 66 +++ ...scover_svtoa_pretraining_runner_scaling.sh | 66 +++ ...svtoa_pretraining_runner_scaling_resume.sh | 66 +++ 14 files changed, 1219 insertions(+), 406 deletions(-) delete mode 100644 notebooks/satvision-toa-reconstruction.ipynb create mode 100644 pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py create mode 100644 runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml create mode 100644 runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml create mode 100644 runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml create mode 100644 runs/runners/discover_svtoa_pretraining_runner.sh create mode 100644 runs/runners/discover_svtoa_pretraining_runner_resume.sh create mode 100644 runs/runners/discover_svtoa_pretraining_runner_scaling.sh create mode 100644 runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh diff --git a/notebooks/satvision-toa-reconstruction.ipynb b/notebooks/satvision-toa-reconstruction.ipynb deleted file mode 100644 index b4b8f1e..0000000 --- a/notebooks/satvision-toa-reconstruction.ipynb +++ /dev/null @@ -1,394 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c8ab2075-c488-46b9-8cd2-0cdaf399acfc", - "metadata": {}, - "source": [ - "# Satvision-TOA Reconstruction Notebook\n", - "\n", - "Version: 02.20.24\n", - "\n", - "Env: `Python [conda env:ilab-pytorch]`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6e88ea70-7dbf-4b67-a12d-db36e2bc9914", - "metadata": {}, - "outputs": [], - "source": [ - "!pip install yacs timm segmentation-models-pytorch termcolor webdataset==0.2.86" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d046c3e5-c458-4e03-9c96-e9eb95a04963", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import sys\n", - "import time\n", - "import random\n", - "import datetime\n", - "import numpy as np\n", - "import logging\n", - "\n", - "import torch\n", - "import torch.cuda.amp as amp\n", - "\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.backends.backend_pdf import PdfPages\n", - "\n", - "import warnings\n", - "\n", - "warnings.filterwarnings('ignore') " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7c7db1bc-09ee-47e3-9015-e6b148d497e7", - "metadata": {}, - "outputs": [], - "source": [ - "sys.path.append('../../pytorch-caney')\n", - "\n", - "from pytorch_caney.config import get_config\n", - "\n", - "from pytorch_caney.training.mim_utils import load_checkpoint, load_pretrained\n", - "\n", - "from pytorch_caney.models.build import build_model\n", - "\n", - "from pytorch_caney.ptc_logging import create_logger\n", - "\n", - "from pytorch_caney.data.datamodules import mim_webdataset_datamodule\n", - "\n", - "from pytorch_caney.data.transforms import SimmimTransform, SimmimMaskGenerator\n", - "\n", - "from pytorch_caney.config import _C, _update_config_from_file" - ] - }, - { - "cell_type": "markdown", - "id": "d841e464-f880-4e53-bf31-f9f225713918", - "metadata": {}, - "source": [ - "## Configuration" - ] - }, - { - "cell_type": "markdown", - "id": "6274e323-bc04-41d4-bc49-baed65d027e6", - "metadata": {}, - "source": [ - "### Clone model ckpt from huggingface\n", - "\n", - "```bash\n", - "# On prism/explore\n", - "module load git-lfs\n", - "\n", - "git lfs install\n", - "\n", - "git clone git@hf.co:nasa-cisto-data-science-group/satvision-toa-base\n", - "```\n", - "\n", - "Note: If using git w/ ssh, make sure you have ssh keys enabled to clone using ssh auth. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "af699ba3-2d98-4daf-9437-c322d7b59a98", - "metadata": {}, - "outputs": [], - "source": [ - "MODEL_PATH: str = '../../satvision-toa-base/satvision-toa_84M_2M_100.pth'\n", - "CONFIG_PATH: str = '../../satvision-toa-base/mim_pretrain_swinv2_satvision-toa_base_192_window12_800ep.yaml'\n", - "\n", - "BATCH_SIZE: int = 64 # Want to report loss on every image? Change to 1.\n", - "OUTPUT: str = '.'\n", - "TAG: str = 'satvision-base-toa-reconstruction'\n", - "DATA_PATH: str = '/explore/nobackup/projects/ilab/projects/3DClouds/data/mosaic-v3/webdatasets'\n", - "DATA_PATHS: list = [DATA_PATH]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c4593e8c-6e94-4d01-b86e-5b78b621fc59", - "metadata": {}, - "outputs": [], - "source": [ - "# Update config given configurations\n", - "\n", - "config = _C.clone()\n", - "_update_config_from_file(config, CONFIG_PATH)\n", - "\n", - "config.defrost()\n", - "config.MODEL.RESUME = MODEL_PATH\n", - "config.DATA.DATA_PATHS = DATA_PATHS\n", - "config.DATA.BATCH_SIZE = BATCH_SIZE\n", - "config.OUTPUT = OUTPUT\n", - "config.TAG = TAG\n", - "config.freeze()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "202a4474-88e4-44d5-b899-7aaf6cbed6f4", - "metadata": {}, - "outputs": [], - "source": [ - "# Configure logging\n", - "logging.basicConfig(\n", - " filename='app.log', # Specify the log file name\n", - " level=logging.INFO, # Set logging level to DEBUG\n", - " format='%(asctime)s [%(levelname)s] %(message)s', # Specify log message format\n", - " datefmt='%Y-%m-%d %H:%M:%S' # Specify date format\n", - ")\n", - "\n", - "# Add logging to standard output\n", - "console = logging.StreamHandler() # Create a handler for standard output\n", - "console.setLevel(logging.INFO) # Set logging level for standard output\n", - "console.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')) # Set log message format for standard output\n", - "logger = logging.getLogger('')\n", - "logger.addHandler(console)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "68abf348-c6bf-43a3-b00a-cc5f8d80545f", - "metadata": {}, - "outputs": [], - "source": [ - "checkpoint = torch.load(MODEL_PATH)\n", - "model = build_model(config, pretrain=True)\n", - "model.load_state_dict(checkpoint['model'])\n", - "n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", - "logger.info(f\"number of params: {n_parameters}\")\n", - "model.cuda()\n", - "model.eval()" - ] - }, - { - "cell_type": "markdown", - "id": "bd9ba52e-62ca-4800-b2aa-deaaea64be9f", - "metadata": {}, - "source": [ - "## Dataloader" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "75c52c66-f322-413c-be76-6c7abfd159bc", - "metadata": {}, - "outputs": [], - "source": [ - "dataloader = mim_webdataset_datamodule.build_mim_dataloader(config, logger)" - ] - }, - { - "cell_type": "markdown", - "id": "55acf5e9-eb2a-496c-baa6-3b74503a2978", - "metadata": {}, - "source": [ - "## Prediction helper functions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "595336f8-71b4-418b-b153-2461583ed613", - "metadata": {}, - "outputs": [], - "source": [ - "def predict(model, dataloader, num_batches=5):\n", - "\n", - " inputs = []\n", - " outputs = []\n", - " masks = []\n", - " losses = []\n", - "\n", - " for idx, img_mask in enumerate(dataloader):\n", - " \n", - " if idx > num_batches:\n", - " return inputs, outputs, masks, losses\n", - "\n", - " img_mask = img_mask[0]\n", - "\n", - " img = torch.stack([pair[0] for pair in img_mask])\n", - " mask = torch.stack([pair[1] for pair in img_mask])\n", - "\n", - " img = img.cuda(non_blocking=True)\n", - " mask = mask.cuda(non_blocking=True)\n", - "\n", - " with torch.no_grad():\n", - " with amp.autocast(enabled=config.ENABLE_AMP):\n", - " z = model.encoder(img, mask)\n", - " img_recon = model.decoder(z)\n", - " loss = model(img, mask)\n", - "\n", - " inputs.extend(img.cpu())\n", - " masks.extend(mask.cpu())\n", - " outputs.extend(img_recon.cpu())\n", - " losses.append(losses)\n", - " \n", - " return inputs, outputs, masks, losses\n", - "\n", - "\n", - "def minmax_norm(img_arr):\n", - " arr_min = img_arr.min()\n", - " arr_max = img_arr.max()\n", - " img_arr_scaled = (img_arr - arr_min) / (arr_max - arr_min)\n", - " img_arr_scaled = img_arr_scaled * 255\n", - " img_arr_scaled = img_arr_scaled.astype(np.uint8)\n", - " return img_arr_scaled\n", - "\n", - "\n", - "def process_mask(mask):\n", - " mask = mask.unsqueeze(0)\n", - " mask = mask.repeat_interleave(4, 1).repeat_interleave(4, 2).unsqueeze(1).contiguous()\n", - " mask = mask[0, 0, :, :]\n", - " mask = np.stack([mask, mask, mask], axis=-1)\n", - " return mask\n", - "\n", - "\n", - "def process_prediction(image, img_recon, mask, rgb_index):\n", - " img_normed = minmax_norm(image.numpy())\n", - "\n", - " mask = process_mask(mask)\n", - " \n", - " red_idx = rgb_index[0]\n", - " blue_idx = rgb_index[1]\n", - " green_idx = rgb_index[2]\n", - "\n", - " rgb_image = np.stack((img_normed[red_idx, :, :],\n", - " img_normed[blue_idx, :, :],\n", - " img_normed[green_idx, :, :]),\n", - " axis=-1)\n", - "\n", - " img_recon = minmax_norm(img_recon.numpy())\n", - " rgb_image_recon = np.stack((img_recon[red_idx, :, :],\n", - " img_recon[blue_idx, :, :],\n", - " img_recon[green_idx, :, :]),\n", - " axis=-1)\n", - "\n", - " rgb_masked = np.where(mask == 0, rgb_image, rgb_image_recon)\n", - " rgb_image_masked = np.where(mask == 1, 0, rgb_image)\n", - " rgb_recon_masked = rgb_masked\n", - " \n", - " return rgb_image, rgb_image_masked, rgb_recon_masked, mask\n", - "\n", - "\n", - "def plot_export_pdf(path, num_sample, inputs, outputs, masks, rgb_index):\n", - " random_subsample = random.sample(range(len(inputs)), num_sample)\n", - " pdf_plot_obj = PdfPages(path)\n", - "\n", - " for idx in random_subsample:\n", - " # prediction processing\n", - " image = inputs[idx]\n", - " img_recon = outputs[idx]\n", - " mask = masks[idx]\n", - " rgb_image, rgb_image_masked, rgb_recon_masked, mask = \\\n", - " process_prediction(image, img_recon, mask, rgb_index)\n", - "\n", - " # matplotlib code\n", - " fig, (ax01, ax23) = plt.subplots(2, 2, figsize=(40, 30))\n", - " ax0, ax1 = ax01\n", - " ax2, ax3 = ax23\n", - " ax2.imshow(rgb_image)\n", - " ax2.set_title(f\"Idx: {idx} MOD021KM v6.1 Bands: {rgb_index}\")\n", - "\n", - " ax0.imshow(rgb_recon_masked)\n", - " ax0.set_title(f\"Idx: {idx} Model reconstruction\")\n", - "\n", - " ax1.imshow(rgb_image_masked)\n", - " ax1.set_title(f\"Idx: {idx} MOD021KM Bands: {rgb_index}, masked\")\n", - " \n", - " ax3.matshow(mask[:, :, 0])\n", - " ax3.set_title(f\"Idx: {idx} Reconstruction Mask\")\n", - " pdf_plot_obj.savefig()\n", - "\n", - " pdf_plot_obj.close()" - ] - }, - { - "cell_type": "markdown", - "id": "551c44b5-6d88-45c4-b397-c38de8064544", - "metadata": {}, - "source": [ - "## Predict" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa43bfaf-6379-43d5-9be3-bd0e55f5ca12", - "metadata": {}, - "outputs": [], - "source": [ - "%%time\n", - "\n", - "inputs, outputs, masks, losses = predict(model, dataloader, num_batches=5)" - ] - }, - { - "cell_type": "markdown", - "id": "dc3f102c-94df-4d9e-8040-52197a7e71db", - "metadata": {}, - "source": [ - "## Plot and write to PDF" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5ebdcd1d-09db-4ccf-8cc1-58d6f47e3a55", - "metadata": {}, - "outputs": [], - "source": [ - "pdf_path = '../../satvision-toa-reconstruction-pdf-02.20.pdf'\n", - "num_samples = 10 # Number of random samples from the predictions\n", - "rgb_index = [0, 3, 2] # Indices of [Red band, Blue band, Green band]\n", - "\n", - "plot_export_pdf(pdf_path, num_samples, inputs, outputs, masks, rgb_index)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e7a57f4d-5df0-47a3-bfb6-d7f29a95e276", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:ilab-pytorch]", - "language": "python", - "name": "conda-env-ilab-pytorch-py" - }, - "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.15" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/pytorch_caney/config.py b/pytorch_caney/config.py index 139c81b..13bf26b 100644 --- a/pytorch_caney/config.py +++ b/pytorch_caney/config.py @@ -15,6 +15,8 @@ _C.DATA.BATCH_SIZE = 128 # Path(s) to dataset, could be overwritten by command line argument _C.DATA.DATA_PATHS = [''] +# Path to validation numpy dataset +_C.DATA.VALIDATION_PATH = '' # Dataset name _C.DATA.DATASET = 'MODIS' # Input image size @@ -91,6 +93,7 @@ _C.TRAIN.START_EPOCH = 0 _C.TRAIN.EPOCHS = 300 _C.TRAIN.WARMUP_EPOCHS = 20 +_C.TRAIN.WARMUP_STEPS = 200 _C.TRAIN.WEIGHT_DECAY = 0.05 _C.TRAIN.BASE_LR = 5e-4 _C.TRAIN.WARMUP_LR = 5e-7 @@ -153,6 +156,8 @@ _C.SAVE_FREQ = 1 # Frequency to logging info _C.PRINT_FREQ = 10 +# Frequency for running validation step +_C.VALIDATION_FREQ = 1 # Fixed random seed _C.SEED = 42 # Perform evaluation only, overwritten by command line argument @@ -189,6 +194,8 @@ def _check_args(name): config.DATA.BATCH_SIZE = args.batch_size if _check_args('data_paths'): config.DATA.DATA_PATHS = args.data_paths + if _check_args('validation_path'): + config.DATA.VALIDATION_PATH = args.validation_path if _check_args('dataset'): config.DATA.DATASET = args.dataset if _check_args('resume'): diff --git a/pytorch_caney/data/transforms.py b/pytorch_caney/data/transforms.py index 2252cd8..4c8dd00 100644 --- a/pytorch_caney/data/transforms.py +++ b/pytorch_caney/data/transforms.py @@ -1,4 +1,5 @@ from .utils import RandomResizedCropNP +from .utils import TransformBrightnessAndReflectance from .utils import SimmimMaskGenerator import torchvision.transforms as T @@ -45,6 +46,48 @@ def __call__(self, img): return img, mask +class SimmimTransformScale: + """ + torchvision transform which transforms the input imagery into + addition to generating a MiM mask + """ + + def __init__(self, config): + + self.transform_img = \ + T.Compose([ + TransformBrightnessAndReflectance(), + RandomResizedCropNP(scale=(0.67, 1.), + ratio=(3. / 4., 4. / 3.)), + T.ToTensor(), + #lambda x: x / 500.0, + #T.ConvertImageDtype(dtype=torch.float32), + #torchvision.ops.Permute(dims=[1, 2, 0]), + T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), + ]) + + if config.MODEL.TYPE in ['swin', 'swinv2']: + + model_patch_size = config.MODEL.SWINV2.PATCH_SIZE + + else: + + raise NotImplementedError + + self.mask_generator = SimmimMaskGenerator( + input_size=config.DATA.IMG_SIZE, + mask_patch_size=config.DATA.MASK_PATCH_SIZE, + model_patch_size=model_patch_size, + mask_ratio=config.DATA.MASK_RATIO, + ) + + def __call__(self, img): + + img = self.transform_img(img) + mask = self.mask_generator() + + return img, mask + class TensorResizeTransform: """ diff --git a/pytorch_caney/data/utils.py b/pytorch_caney/data/utils.py index 86d9555..305fb17 100644 --- a/pytorch_caney/data/utils.py +++ b/pytorch_caney/data/utils.py @@ -63,7 +63,6 @@ def __call__(self, img): cropped_squeezed_numpy = np.moveaxis(cropped_squeezed_numpy, 0, -1) return cropped_squeezed_numpy - # MASKING class SimmimMaskGenerator: @@ -114,3 +113,191 @@ def make_simmim_mask(token_count, mask_count, rand_size, scale): mask[mask_idx] = 1 mask = mask.reshape((rand_size, rand_size)) return mask + + +class ModisScalesAndOffsets(object): + + reflectance_indices = [0, 1, 2, 3, 4, 6] + emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + @staticmethod + def rsb_radiance_scales() -> torch.tensor: + + radiance_scales_array = np.array([0.02995670214, 0.01111282408, 0.04215827957, + 0.002742749639, 0.0009269224829, 0.003434347222], dtype=np.float32) + + return torch.tensor(radiance_scales_array).view(6, 1, 1) + + @staticmethod + def rsb_radiance_offsets() -> torch.tensor: + + radiance_offsets_array = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], dtype=np.float32) + + return torch.tensor(radiance_offsets_array).view(6, 1, 1) + + @staticmethod + def rsb_reflectance_scales() -> torch.tensor: + + reflectance_scales_array = np.array([5.665329445e-05, 3.402091534e-05, 6.13320808e-05, + 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], dtype=np.float32) + + return torch.tensor(reflectance_scales_array).view(6, 1, 1) + + @staticmethod + def rsb_reflectance_offsets() -> torch.tensor: + + reflectance_offsets_array = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], dtype=np.float32) + + return torch.tensor(reflectance_offsets_array).view(6, 1, 1) + + @staticmethod + def emi_radiance_scales() -> torch.tensor: + + radiance_scales_array = np.array([ + 0.003149510128, 0.0001175572979, 0.0001924497337, + 0.0005324869417, 0.0004063234373, 0.0008400219958, + 0.0007296975818, 0.0002622638713], + dtype=np.float32) + + return torch.tensor(radiance_scales_array).view(8, 1, 1) + + @staticmethod + def emi_radiance_offsets() -> torch.tensor: + + # Radiance offsets + radiance_offsets_array = np.array([ + 2730.583496, 2730.583252, 2317.488281, 2730.583496, + 1560.333252, 1577.339722, 1658.221313, 2501.297607], + dtype=np.float32) + + return torch.tensor(radiance_offsets_array).view(8, 1, 1) + + @staticmethod + def derived_constants() -> torch.tensor: + + # Planck constant (Joule second) + h__ = np.float32(6.6260755e-34) + + # Speed of light in vacuum (meters per second) + c__ = np.float32(2.9979246e+8) + + # Boltzmann constant (Joules per Kelvin) + k__ = np.float32(1.380658e-23) + + # Derived constants + c_1 = 2 * h__ * c__ * c__ + c_2 = (h__ * c__) / k__ + + return torch.tensor(c_1), torch.tensor(c_2) + + # ev1km_band_names = [20,21,22,23,24,25,27,28,29,30,31,32,33,34,35,36] + # ev1km_band_names = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15] + + @staticmethod + def cwn() -> torch.tensor: + cwn_array = np.array([ + 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, + 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], + dtype=np.float32) + cwn_array = 1. / (cwn_array * 100) + return torch.tensor(cwn_array).view(8, 1, 1) + + @staticmethod + def tcs() -> torch.tensor: + # Temperature correction slope (no units) + tcs_array = np.array([ + 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, + 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], + dtype=np.float32) + return torch.tensor(tcs_array).view(8, 1, 1) + + @staticmethod + def tci() -> torch.tensor: + # Temperature correction intercept (Kelvin) + tci_array = np.array([ + 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, + 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], + dtype=np.float32) + return torch.tensor(tci_array).view(8, 1, 1) + + + +class TransformBrightnessAndReflectance(object): + + # Planck constant (Joule second) + h__ = np.float32(6.6260755e-34) + + # Speed of light in vacuum (meters per second) + c__ = np.float32(2.9979246e+8) + + # Boltzmann constant (Joules per Kelvin) + k__ = np.float32(1.380658e-23) + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emi_radiance_offsets = np.array([ + 2730.583496, 2730.583252, 2317.488281, 2730.583496, + 1560.333252, 1577.339722, 1658.221313, 2501.297607], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.emi_radiance_scales = np.array([ + 0.003149510128, 0.0001175572979, 0.0001924497337, + 0.0005324869417, 0.0004063234373, 0.0008400219958, + 0.0007296975818, 0.0002622638713], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_reflectance_offsets = np.array([ + 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_reflectance_scales = np.array([ + 5.665329445e-05, 3.402091534e-05, 6.13320808e-05, + 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_radiance_offsets = np.array([ + 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_radiance_scales = np.array([ + 0.02995670214, 0.01111282408, 0.04215827957, + 0.002742749639, 0.0009269224829, 0.003434347222], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + # Derived constants + self.c_1 = 2 * self.h__ * self.c__ * self.c__ + self.c_2 = (self.h__ * self.c__) / self.k__ + + self.cwn = np.array([ + 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, + 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], + dtype=np.float32)[np.newaxis, np.newaxis, :] + self.cwn = 1. / (self.cwn * 100) + + self.tcs = np.array([ + 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, + 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.tci = np.array([ + 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, + 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + def __call__(self, img): + + # Reflectance to radiance units + reflectance_bands = img[:, :, self.reflectance_indices] + img[:, :, self.reflectance_indices] = self.rsb_radiance_scales * ((((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) + img[:, :, self.reflectance_indices] = img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp to radiance units: + emissive_bands = img[:, :, self.emissive_indices] + intermediate = emissive_bands * self.tcs + self.tci + exponent = self.c_2 / (intermediate * self.cwn) + img[:, :, self.emissive_indices] = self.c_1 / (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) + + return img diff --git a/pytorch_caney/models/swinv2_model.py b/pytorch_caney/models/swinv2_model.py index f784af0..2ec866c 100644 --- a/pytorch_caney/models/swinv2_model.py +++ b/pytorch_caney/models/swinv2_model.py @@ -318,7 +318,7 @@ def _extra_norm(index): def forward(self, x): for blk in self.blocks: if self.use_checkpoint: - x = checkpoint.checkpoint(blk, x) + x = checkpoint.checkpoint(blk, x, use_reentrant=False) else: x = blk(x) if self.downsample is not None: diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 0c3ddb6..df46be1 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -22,7 +22,7 @@ from timm.utils import AverageMeter -NUM_SAMPLES: int = 1962000 +NUM_SAMPLES: int = 1962000 def parse_args(): @@ -46,6 +46,11 @@ def parse_args(): required=True, help="paths where dataset is stored") + parser.add_argument('--validation-path', + type=str, + required=True, + help='validation dataset path') + parser.add_argument('--dataset', type=str, required=True, @@ -157,6 +162,7 @@ def execute_one_epoch(config, target_dtype: torch dtype, should match model dtype device: device to move inputs to """ + validationDataset = validation_setup(config) ntrain = 1962000 num_steps = max(1, @@ -197,6 +203,10 @@ def execute_one_epoch(config, batch_time.update(time.time() - end) end = time.time() + if idx % config.VALIDATION_FREQ == 0: + lr = optimizer.param_groups[0]['lr'] + validate(model, validationDataset, lr, idx, epoch, target_dtype, device) + if idx % config.PRINT_FREQ == 0: lr = optimizer.param_groups[0]['lr'] memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) @@ -255,21 +265,36 @@ def main(config): if p.requires_grad) logger.info(f"Total number of trainable parameters: {trainable_params}") + # Total number of samples in current 2m dataset ntrain = 1962000 + + # Number of batches (or steps) to process per epoch num_steps = max( 1, ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) - deepspeed_config = { - "zero_allow_untested_optimizer": True, + # Calculate LR steps + # total steps (or batches) for the entire training iteration + total_steps = num_steps * config.TRAIN.EPOCHS + logger.info(f'Total steps for {config.TRAIN.EPOCHS} epochs: {total_steps}') + cycle_one_percentage = 0.3 + cycle_stage_one = int(total_steps * cycle_one_percentage) + cycle_stage_two = (total_steps - cycle_stage_one) - 1 + + logger.info(f'OneCycle: stage-1 step size = {cycle_stage_one}') + logger.info(f'OneCycle: stage-2 step size = {cycle_stage_two}') + logger.info(f'OneCycle: min LR = {config.TRAIN.MIN_LR}') + logger.info(f'OneCycle: max LR = {config.TRAIN.BASE_LR}') + + deepspeed_config = { "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, "steps_per_print": config.PRINT_FREQ, "memory_breakdown": False, "zero_optimization": { - "stage": 0, + "stage": 2, # "offload_optimizer": {"device": "cpu"}, #"offload_param": {"device": "cpu"}, "contiguous_gradients": True, @@ -296,15 +321,25 @@ def main(config): }, "scheduler": { - "type": "WarmupLR", + "type": "OneCycle", + # "type": "WarmupLR", "params": { - "warmup_min_lr": config.TRAIN.WARMUP_LR, - "warmup_max_lr": config.TRAIN.BASE_LR, - "last_batch_iteration": num_steps - 1, + # "lr_range_test_step_size": 10, + # "lr_range_test_step_rate": 4, + # "lr_range_test_min_lr": config.TRAIN.BASE_LR, + # "lr_range_test_staircase": False, + # "warmup_min_lr": config.TRAIN.WARMUP_LR, + # "warmup_max_lr": config.TRAIN.BASE_LR, + # "warmup_num_steps": num_steps, + "cycle_min_lr": config.TRAIN.MIN_LR, + "cycle_max_lr": config.TRAIN.BASE_LR, + "cycle_first_step_size": cycle_stage_one, + "cycle_second_step_size": cycle_stage_two, + # "warmup_min_ratio": 0, + # "warmup_num_steps": config.TRAIN.WARMUP_STEPS, }, }, - "flops_profiler": { "enabled": False, #"profile_step": 1, @@ -318,7 +353,18 @@ def main(config): logger.info('Initializing deepspeed') - optimizer = torch.optim.AdamW(simmim_model.parameters(), lr=config.TRAIN.BASE_LR) + + optimizer = torch.optim.AdamW(simmim_model.parameters(), + lr=config.TRAIN.BASE_LR,) + # weight_decay=config.TRAIN.WEIGHT_DECAY) + + """ + scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, + max_lr=config.TRAIN.BASE_LR, + total_steps=num_steps, + last_epoch=num_steps-1, + pct_start=0.4) + """ model_engine, optimizer, _, _ = deepspeed.initialize( model=simmim_model, @@ -362,6 +408,45 @@ def main(config): local_device) +@torch.no_grad() +def validation_setup(config): + transform = SimmimTransform(config) + validation_dataset_path = config.DATA.VALIDATION_PATH + validation_dataset = np.load(validation_dataset_path) + len_batch = range(validation_dataset.shape[0]) + imgMasks = [transform(validation_dataset[idx]) for idx \ + in len_batch] + img = torch.stack([imgMask[0] for imgMask in imgMasks]) + mask = torch.stack([torch.from_numpy(imgMask[1]) for \ + imgMask in imgMasks]) + return img, mask + + +@torch.no_grad() +def validate(model, img_masks, lr, step, epoch, target_dtype, device): + start_time = time.time() + + img, mask = img_masks + + img = img.to(device, non_blocking=True) + mask = mask.cuda(device, non_blocking=True) + + if target_dtype: + img = img.to(target_dtype) + + loss = model(img, mask) + + validation_time = time.time() - start_time + + logger.info( + f"Validation: [{step}/{epoch}]\t" + f"lr {lr}\t" + f"val_loss {loss:.4f}\t" + f"time {validation_time:.4f}s") + + del img, mask, loss + + def build_model(config, logger): logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") @@ -398,6 +483,13 @@ def setup_seeding(config): setup_seeding(config) + config.defrost() + base_batch_size = 2048 + config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.freeze() + os.makedirs(config.OUTPUT, exist_ok=True) logger = create_logger(output_dir=config.OUTPUT, dist_rank=dist.get_rank(), @@ -413,4 +505,8 @@ def setup_seeding(config): config_file_path = os.path.join(config.OUTPUT, config_file_name) joblib.dump(config, config_file_path) + logger.info(f'Base LR (scaled): {config.TRAIN.BASE_LR}') + logger.info(f'Warmup LR (scaled): {config.TRAIN.WARMUP_LR}') + logger.info(f'Min LR (scaled): {config.TRAIN.MIN_LR}') + sys.exit(main(config)) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py new file mode 100644 index 0000000..e338400 --- /dev/null +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py @@ -0,0 +1,515 @@ +from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset +from pytorch_caney.data.transforms import SimmimTransform, SimmimTransformScale +from pytorch_caney.data.utils import ModisScalesAndOffsets +from pytorch_caney.models.mim.mim import build_mim_model +from pytorch_caney.ptc_logging import create_logger +from pytorch_caney.config import get_config + +import deepspeed +from deepspeed.accelerator import get_accelerator + +from socket import gethostname +import argparse +import datetime +import joblib +import numpy as np +import os +import sys +import time + +import torch +import torch.distributed as dist + +from timm.utils import AverageMeter + + +NUM_SAMPLES: int = 1962000 + + +def parse_args(): + """ + Parse command-line arguments + """ + parser = argparse.ArgumentParser( + 'pytorch-caney implementation of MiM pre-training script', + add_help=False) + + parser.add_argument( + '--cfg', + type=str, + required=True, + metavar="FILE", + help='path to config file') + + parser.add_argument( + "--data-paths", + nargs='+', + required=True, + help="paths where dataset is stored") + + parser.add_argument('--validation-path', + type=str, + required=True, + help='validation dataset path') + + parser.add_argument('--dataset', + type=str, + required=True, + help='Dataset to use') + + parser.add_argument( + '--batch-size', + type=int, + help="batch size for single GPU") + + parser.add_argument( + '--resume', + help='resume from checkpoint') + + parser.add_argument( + '--use-checkpoint', + action='store_true', + help="whether to use gradient checkpointing to save memory") + + parser.add_argument( + '--output', + default='output', + type=str, + metavar='PATH', + help='root of output folder, the full path is ' + + '// (default: output)') + + parser.add_argument( + '--tag', + help='tag of experiment') + + args = parser.parse_args() + + config = get_config(args) + + return args, config + + +def train(config, + dataloader, + model_engine, + optimizer, + device): + """ + Start pre-training a specific model and dataset. + + Args: + config: config object + dataloader: dataloader to use + model: model to pre-train + model_wo_ddp: model to pre-train that is not the DDP version + optimizer: pytorch optimizer + lr_scheduler: learning-rate scheduler + """ + + logger.info("Start training") + + target_dtype = None + if model_engine.bfloat16_enabled(): + target_dtype = torch.bfloat16 + elif model_engine.fp16_enabled(): + target_dtype = torch.half + logger.info(f'Target dtype: {target_dtype}') + + torch.cuda.empty_cache() + + start_time = time.time() + + for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): + + start = time.time() + + execute_one_epoch(config, model_engine, dataloader, + optimizer, epoch, target_dtype, device) + + tag = f'ckpt_epoch_{epoch}' + model_engine.save_checkpoint(save_dir=config.OUTPUT, + tag=tag,) + + epoch_time = time.time() - start + logger.info( + f"EPOCH {epoch} training takes " + + f"{datetime.timedelta(seconds=int(epoch_time))}") + + + total_time = time.time() - start_time + + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + + logger.info('Training time {}'.format(total_time_str)) + + +def execute_one_epoch(config, + model, + dataloader, + optimizer, + epoch, + target_dtype, + device): + """ + Execute training iterations on a single epoch. + + Args: + config: config object + model: model to pre-train + dataloader: dataloader to use + optimizer: pytorch optimizer + epoch: int epoch number + target_dtype: torch dtype, should match model dtype + device: device to move inputs to + """ + validationDataset = validation_setup(config) + + ntrain = 1962000 + num_steps = max(1, + ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) + + + # Set up logging meters + batch_time = AverageMeter() + data_time = AverageMeter() + loss_meter = AverageMeter() + + start = time.time() + end = time.time() + + for idx, img_mask in enumerate(dataloader): + + img_mask = img_mask[0] + + img = torch.stack([pair[0] for pair in img_mask]) + mask = torch.stack([pair[1] for pair in img_mask]) + + data_time.update(time.time() - start) + + img = img.to(device, non_blocking=True) + mask = mask.to(device, non_blocking=True) + + if target_dtype: + img = img.to(target_dtype) + + loss = model(img, mask) + + model.backward(loss) + + model.step() + + torch.cuda.synchronize() + + loss_meter.update(loss.item(), img.size(0)) + batch_time.update(time.time() - end) + end = time.time() + + if idx % config.VALIDATION_FREQ == 0: + lr = optimizer.param_groups[0]['lr'] + validate(model, validationDataset, lr, idx, epoch, target_dtype, device) + + if idx % config.PRINT_FREQ == 0: + lr = optimizer.param_groups[0]['lr'] + memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) + etas = batch_time.avg * (num_steps - idx) + logger.info( + f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' + f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' + f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' + f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' + f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' + f'mem {memory_used:.0f}MB') + + if idx == num_steps: + logger.info(f'Ending step loop for epoch {idx}') + break + + torch.distributed.barrier() + + +def main(config): + """ + Starts training process after building the proper model, optimizer, etc. + + Args: + config: config object + """ + + logger.info('In main') + + transform = SimmimTransformScale(config) + + dataset = MODIS22MDataset(config, + config.DATA.DATA_PATHS, + split="train", + img_size=config.DATA.IMG_SIZE, + transform=transform, + batch_size=config.DATA.BATCH_SIZE).dataset() + + dataloader = torch.utils.data.DataLoader( + dataset, + batch_size=None, + num_workers=8, + shuffle=False, + pin_memory=True,) + + logger.info(f'MODEL CHECKPOINTING: {config.TRAIN.USE_CHECKPOINT}') + + simmim_model = build_model(config, logger) + + # Count the total number of parameters + total_params = sum(p.numel() for p in simmim_model.parameters()) + logger.info(f"Total number of parameters: {total_params}") + + # Count the total number of trainable parameters + trainable_params = sum(p.numel() for p in simmim_model.parameters() + if p.requires_grad) + logger.info(f"Total number of trainable parameters: {trainable_params}") + + # Total number of samples in current 2m dataset + ntrain = 1962000 + + # Number of batches (or steps) to process per epoch + num_steps = max( + 1, + ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) + + # Calculate LR steps + # total steps (or batches) for the entire training iteration + total_steps = num_steps * config.TRAIN.EPOCHS + logger.info(f'Total steps for {config.TRAIN.EPOCHS} epochs: {total_steps}') + + cycle_one_percentage = 0.3 + cycle_stage_one = int(total_steps * cycle_one_percentage) + cycle_stage_two = (total_steps - cycle_stage_one) - 1 + + logger.info(f'OneCycle: stage-1 step size = {cycle_stage_one}') + logger.info(f'OneCycle: stage-2 step size = {cycle_stage_two}') + logger.info(f'OneCycle: min LR = {config.TRAIN.MIN_LR}') + logger.info(f'OneCycle: max LR = {config.TRAIN.BASE_LR}') + + deepspeed_config = { + "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, + + "steps_per_print": config.PRINT_FREQ, + "memory_breakdown": False, + + "zero_optimization": { + "stage": 2, + # "offload_optimizer": {"device": "cpu"}, + #"offload_param": {"device": "cpu"}, + "contiguous_gradients": True, + "overlap_comm": True, + "reduce_bucket_size": 5e8, + "allgather_bucket_size": 5e8, + #"offload_optimizer": { + # "device": "cpu" + #}, + }, + + "activation_checkpointing": { + "partition_activations": True, + # "cpu_checkpointing": True, + "profile": False, + }, + + "fp16": { + "enabled": False, + }, + + "bf16": { + "enabled": True, + }, + + "scheduler": { + "type": "OneCycle", + # "type": "WarmupLR", + "params": { + # "lr_range_test_step_size": 10, + # "lr_range_test_step_rate": 4, + # "lr_range_test_min_lr": config.TRAIN.BASE_LR, + # "lr_range_test_staircase": False, + # "warmup_min_lr": config.TRAIN.WARMUP_LR, + # "warmup_max_lr": config.TRAIN.BASE_LR, + # "warmup_num_steps": num_steps, + "cycle_min_lr": config.TRAIN.MIN_LR, + "cycle_max_lr": config.TRAIN.BASE_LR, + "cycle_first_step_size": cycle_stage_one, + "cycle_second_step_size": cycle_stage_two, + # "warmup_min_ratio": 0, + # "warmup_num_steps": config.TRAIN.WARMUP_STEPS, + }, + }, + + "flops_profiler": { + "enabled": False, + #"profile_step": 1, + "module_depth": -1, + #"top_modules": 1, + "detailed": True, + "output_file": f'profile_{time.time()}', + }, + + } + + logger.info('Initializing deepspeed') + + + optimizer = torch.optim.AdamW(simmim_model.parameters(), + lr=config.TRAIN.BASE_LR,) + # weight_decay=config.TRAIN.WEIGHT_DECAY) + + """ + scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, + max_lr=config.TRAIN.BASE_LR, + total_steps=num_steps, + last_epoch=num_steps-1, + pct_start=0.4) + """ + + model_engine, optimizer, _, _ = deepspeed.initialize( + model=simmim_model, + model_parameters=simmim_model.parameters(), + optimizer=optimizer, + dist_init_required=True, + config=deepspeed_config + ) + + if config.MODEL.RESUME: + + load_dir = os.path.dirname(config.MODEL.RESUME) + logger.info(f'Ckpt load dir: {load_dir}') + + tag = os.path.basename(config.MODEL.RESUME) + logger.info(f'Ckpt tag: {tag}') + + epoch = tag.split('_')[2] + logger.info(f'Ckpt epoch: {epoch}') + + load_path, _ = model_engine.load_checkpoint(load_dir=load_dir, + tag=tag) + config.defrost() + config.TRAIN.START_EPOCH = int(epoch) + 1 + config.freeze() + + logger.info(f'Loaded from checkpoint: {load_path}') + logger.info(f'Resuming from epoch {config.TRAIN.START_EPOCH}') + + local_rank = model_engine.local_rank + local_device = get_accelerator().device_name(local_rank) + + logger.info('Starting training block') + + torch.distributed.barrier() + + train(config, + dataloader, + model_engine, + optimizer, + local_device) + + +@torch.no_grad() +def validation_setup(config): + + transform = SimmimTransformScale(config) + validation_dataset_path = config.DATA.VALIDATION_PATH + validation_dataset = np.load(validation_dataset_path) + len_batch = range(validation_dataset.shape[0]) + imgMasks = [transform(validation_dataset[idx]) for idx \ + in len_batch] + img = torch.stack([imgMask[0] for imgMask in imgMasks]) + mask = torch.stack([torch.from_numpy(imgMask[1]) for \ + imgMask in imgMasks]) + return img, mask + + +@torch.no_grad() +def validate(model, img_masks, lr, step, epoch, target_dtype, device): + start_time = time.time() + + img, mask = img_masks + + img = img.to(device, non_blocking=True) + mask = mask.cuda(device, non_blocking=True) + + if target_dtype: + img = img.to(target_dtype) + + loss = model(img, mask) + + validation_time = time.time() - start_time + + logger.info( + f"Validation: [{step}/{epoch}]\t" + f"lr {lr}\t" + f"val_loss {loss:.4f}\t" + f"time {validation_time:.4f}s") + + del img, mask, loss + + +def build_model(config, logger): + + logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") + + model = build_mim_model(config) + + return model + + +def setup_seeding(config): + seed = config.SEED + dist.get_rank() + torch.manual_seed(seed) + np.random.seed(seed) + + +if __name__ == '__main__': + _, config = parse_args() + + world_size = int(os.environ["WORLD_SIZE"]) + rank = int(os.environ["RANK"]) + gpus_per_node = torch.cuda.device_count() + print(f" {gpus_per_node} allocated GPUs per node.", flush=True) + + deepspeed.init_distributed() + + torch.distributed.barrier() + + print(f"Hello from rank {rank} of {world_size} on" + f" {gethostname()} where there are" + f" {gpus_per_node} allocated GPUs per node.", flush=True) + + if rank == 0: + print(f"Group initialized? {dist.is_initialized()}", flush=True) + + setup_seeding(config) + + config.defrost() + base_batch_size = 2048 + config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size + config.freeze() + + os.makedirs(config.OUTPUT, exist_ok=True) + logger = create_logger(output_dir=config.OUTPUT, + dist_rank=dist.get_rank(), + name=f"{config.MODEL.NAME}") + + if dist.get_rank() == 0: + path = os.path.join(config.OUTPUT, "config.json") + with open(path, "w") as f: + f.write(config.dump()) + logger.info(f"Full config saved to {path}") + logger.info(config.dump()) + config_file_name = f'{config.TAG}.config.sav' + config_file_path = os.path.join(config.OUTPUT, config_file_name) + joblib.dump(config, config_file_path) + + logger.info(f'Base LR (scaled): {config.TRAIN.BASE_LR}') + logger.info(f'Warmup LR (scaled): {config.TRAIN.WARMUP_LR}') + logger.info(f'Min LR (scaled): {config.TRAIN.MIN_LR}') + + sys.exit(main(config)) diff --git a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml new file mode 100644 index 0000000..14ccf1b --- /dev/null +++ b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml @@ -0,0 +1,31 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 100 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + WARMUP_LR: 1e-4 + MIN_LR: 2e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 10 +SAVE_FREQ: 1 +VALIDATION_FREQ: 10 +TAG: mim_pretrain_swinv2_g_satvision_128_window08__128heads_100ep diff --git a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml new file mode 100644 index 0000000..f5fd639 --- /dev/null +++ b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml @@ -0,0 +1,31 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 100 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + WARMUP_LR: 1e-4 + MIN_LR: 2e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 10 +SAVE_FREQ: 1 +VALIDATION_FREQ: 10 +TAG: scaled_mim_pretrain_swinv2_g_satvision_128_window08__128heads_100ep diff --git a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml new file mode 100644 index 0000000..4d5ced7 --- /dev/null +++ b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml @@ -0,0 +1,33 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-huge + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + PATCH_SIZE: 4 + EMBED_DIM: 352 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 + +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 100 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 10 +SAVE_FREQ: 1 +VALIDATION_FREQ: 20 +TAG: mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_rsb_scaled_100ep diff --git a/runs/runners/discover_svtoa_pretraining_runner.sh b/runs/runners/discover_svtoa_pretraining_runner.sh new file mode 100644 index 0000000..5fcc4ec --- /dev/null +++ b/runs/runners/discover_svtoa_pretraining_runner.sh @@ -0,0 +1,66 @@ +#!/bin/bash +#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --nodes=6 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) +#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) +#SBATCH --gres=gpu:4 # number of allocated gpus per node +#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --partition=gpu_a100 +#SBATCH --reservation=warpsles15 +#SBATCH --constraint=rome +#SBATCH --qos=8n_a100 +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +export NCCL_NET_GDR_LEVEL=PHB +export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" + +launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_lr_finding.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" +echo $cmd + +srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +pkill -9 python + +echo "END TIME: $(date)" diff --git a/runs/runners/discover_svtoa_pretraining_runner_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_resume.sh new file mode 100644 index 0000000..0bcf791 --- /dev/null +++ b/runs/runners/discover_svtoa_pretraining_runner_resume.sh @@ -0,0 +1,66 @@ +#!/bin/bash +#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --nodes=7 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) +#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) +#SBATCH --gres=gpu:4 # number of allocated gpus per node +#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --partition=gpu_a100 +#SBATCH --reservation=warpsles15 +#SBATCH --constraint=rome +#SBATCH --qos=8n_a100 +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +export NCCL_NET_GDR_LEVEL=PHB +export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" + +launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_lr_finding.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2" +echo $cmd + +srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +pkill -9 python + +echo "END TIME: $(date)" diff --git a/runs/runners/discover_svtoa_pretraining_runner_scaling.sh b/runs/runners/discover_svtoa_pretraining_runner_scaling.sh new file mode 100644 index 0000000..f562306 --- /dev/null +++ b/runs/runners/discover_svtoa_pretraining_runner_scaling.sh @@ -0,0 +1,66 @@ +#!/bin/bash +#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --nodes=7 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) +#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) +#SBATCH --gres=gpu:4 # number of allocated gpus per node +#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --partition=gpu_a100 +#SBATCH --reservation=warpsles15 +#SBATCH --constraint=rome +#SBATCH --qos=8n_a100 +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +export NCCL_NET_GDR_LEVEL=PHB +export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" + +launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" +echo $cmd + +srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +pkill -9 python + +echo "END TIME: $(date)" diff --git a/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh new file mode 100644 index 0000000..58ba10c --- /dev/null +++ b/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh @@ -0,0 +1,66 @@ +#!/bin/bash +#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --nodes=7 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) +#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) +#SBATCH --gres=gpu:4 # number of allocated gpus per node +#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --partition=gpu_a100 +#SBATCH --reservation=warpsles15 +#SBATCH --constraint=rome +#SBATCH --qos=8n_a100 +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +export NCCL_NET_GDR_LEVEL=PHB +export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" + +launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2 " +echo $cmd + +srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +pkill -9 python + +echo "END TIME: $(date)" From b84c587e1fa7e0dc92108e83eec91736e5be2a0e Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Fri, 7 Jun 2024 10:58:41 -0400 Subject: [PATCH 04/50] added frontier code --- ...ision_giant_128_window08_50ep_32nodes.yaml | 31 +++++ .../frontier_svtoa_pretraining_runner.sh | 106 ++++++++++++++++++ ...rontier_svtoa_pretraining_runner_resume.sh | 105 +++++++++++++++++ 3 files changed, 242 insertions(+) create mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml create mode 100644 runs/runners/frontier_svtoa_pretraining_runner.sh create mode 100644 runs/runners/frontier_svtoa_pretraining_runner_resume.sh diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml new file mode 100644 index 0000000..de13574 --- /dev/null +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml @@ -0,0 +1,31 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 10 +SAVE_FREQ: 1 +VALIDATION_FREQ: 20 +TAG: mim_pretrain_3b_26m_32nodes_128_window8_onecycle_50ep diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh new file mode 100644 index 0000000..14e3759 --- /dev/null +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -0,0 +1,106 @@ +#!/bin/bash +#SBATCH -A geo160 +#SBATCH --job-name=sv-3b-26m-pt-15-epoch-test # create a short name for your job +#SBATCH --nodes=32 # node count +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --gres=gpu:8 # number of allocated gpus per node +#SBATCH --qos=debug +#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) +#SBATCH --cpus-per-task=56 +#SBATCH -C nvme +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + +##### Setup modules +module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 +module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 +module load PrgEnv-gnu/8.4.0 +export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich +export LD_LIBRARY_PATH=/lustre/orion/geo160/proj-shared/testing/aws-olf-rccl-plugin/aws-ofi-rccl/lib:$LD_LIBRARY_PATH +module load amd-mixed/5.7.1 +module load craype-accel-amd-gfx90a +module load miniforge3/23.11.0 +export MPICH_GPU_SUPPORT_ENABLED=1 +export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" +export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} +rm -rf ${MIOPEN_USER_DB_PATH} +mkdir -p ${MIOPEN_USER_DB_PATH} + +##### sbcast env to local nvme +echo "copying torch_env to each node in the job" +conda_env_name='rocm-torch-test-full-0.1.0' + +sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz +echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz +echo /mnt/bb/${USER}/${conda_env_name}.tar.gz +ls -l /mnt/bb/${USER} +ls -l $MEMBERWORK/geo160 + +if [ ! "$?" == "0" ]; then + # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, + # your application may pick up partially complete shared library files, which would give you confusing errors. + echo "SBCAST failed!" + exit 1 +fi + +srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} +echo "untaring torchenv" +srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} +echo "Done untarring torchenv" + +source activate /mnt/bb/${USER}/${conda_env_name} +echo "Activated ${conda_env_name}" + +srun --ntasks-per-node 1 conda-unpack + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +# export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/26m +validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy +batchsize=128 +nprocpernode=8 + +launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --validation-path ${validationpath}" +echo $cmd + +srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +echo "END TIME: $(date)" + diff --git a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh new file mode 100644 index 0000000..e728d31 --- /dev/null +++ b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh @@ -0,0 +1,105 @@ +#!/bin/bash +#SBATCH -A geo160 +#SBATCH --job-name=satvision-giant-pretraining-15-epoch-test # create a short name for your job +#SBATCH --nodes=32 # node count +#SBATCH --qos=debug +#SBATCH --ntasks-per-node=1 # total number of tasks per node +#SBATCH --gres=gpu:8 # number of allocated gpus per node +#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) +#SBATCH --cpus-per-task=56 +#SBATCH -C nvme +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov + +##### Setup modules +module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 +module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 +module load PrgEnv-gnu/8.4.0 +export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich +module load amd-mixed/5.7.1 +module load craype-accel-amd-gfx90a +module load miniforge3/23.11.0 +export MPICH_GPU_SUPPORT_ENABLED=1 +export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" +export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} +rm -rf ${MIOPEN_USER_DB_PATH} +mkdir -p ${MIOPEN_USER_DB_PATH} + +##### sbcast env to local nvme +echo "copying torch_env to each node in the job" +conda_env_name='rocm-torch-test-full-0.1.0' + +sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz +echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz +echo /mnt/bb/${USER}/${conda_env_name}.tar.gz +ls -l /mnt/bb/${USER} +ls -l $MEMBERWORK/geo160 + +if [ ! "$?" == "0" ]; then + # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, + # your application may pick up partially complete shared library files, which would give you confusing errors. + echo "SBCAST failed!" + exit 1 +fi + +srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} +echo "untaring torchenv" +srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} +echo "Done untarring torchenv" + +source activate /mnt/bb/${USER}/${conda_env_name} +echo "Activated ${conda_env_name}" + +srun --ntasks-per-node 1 conda-unpack + +# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) +export MASTER_PORT=6000 +export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) +echo "WORLD_SIZE="$WORLD_SIZE + +# export NCCL_SOCKET_IFNAME=ib + +export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) +echo "MASTER_ADDR="$MASTER_ADDR + + +echo "$MASTER_ADDR:$MASTER_PORT" + +export PYTHONPATH=$PWD:pytorch-caney +export NCCL_DEBUG=INFO + +# do not remove or the training will hang and nodes will be lost w/o this workaround +#export CUDA_LAUNCH_BLOCKING=1 + +# hide duplicated errors using this hack - will be properly fixed in pt-1.12 +#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json + +# force crashing on nccl issues like hanging broadcast +#export NCCL_ASYNC_ERROR_HANDLING=1 + +#export NCCL_P2P_DISABLE=1 + +# cublas bug solve? +# export DISABLE_ADDMM_CUDA_LT=1 + +echo $SLURM_JOB_NUM_NODES +echo $SLURM_PROCID +echo $MASTER_ADDR +echo $MASTER_PORT + +nnodes=$SLURM_JOB_NUM_NODES +datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/02m +validationpath= +batchsize=128 +nprocpernode=8 + +launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" +echo $launcher + +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --resume $2 --validation-path ${validationpath}" +echo $cmd + +srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" + +echo "END TIME: $(date)" + From 4f1f2d2c3acd562e03a1120b7277e9a4bf18483e Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Mon, 10 Jun 2024 15:13:39 -0400 Subject: [PATCH 05/50] added latest code, runners, and notebooks --- ...struction-comparison-plotting-scaled.ipynb | 512 ++++++ ...toa-reconstruction-generation-scaled.ipynb | 1500 +++++++++++++++++ pytorch_caney/data/transforms.py | 158 +- pytorch_caney/data/utils.py | 137 +- .../pipelines/pretraining/mim_deepspeed.py | 32 +- .../pretraining/mim_deepspeed_scaling.py | 515 ------ ...ision_giant_128_window08_50ep_32nodes.yaml | 2 +- ...nt_128_window08_patch8_onecycle_100ep.yaml | 4 +- ..._128_window08_patch8_onecycle_scaling.yaml | 31 - ...uge_128_window8_patch8_onecycle_100ep.yaml | 2 +- runs/runners/README.md | 26 + .../discover_svtoa_pretraining_runner.sh | 6 +- ...iscover_svtoa_pretraining_runner_resume.sh | 4 +- ...scover_svtoa_pretraining_runner_scaling.sh | 66 - ...svtoa_pretraining_runner_scaling_resume.sh | 66 - .../frontier_svtoa_pretraining_runner.sh | 2 +- ...rontier_svtoa_pretraining_runner_resume.sh | 4 +- 17 files changed, 2219 insertions(+), 848 deletions(-) create mode 100644 notebooks/satvision-toa-reconstruction-comparison-plotting-scaled.ipynb create mode 100644 notebooks/satvision-toa-reconstruction-generation-scaled.ipynb delete mode 100644 pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py delete mode 100644 runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml create mode 100644 runs/runners/README.md delete mode 100644 runs/runners/discover_svtoa_pretraining_runner_scaling.sh delete mode 100644 runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh diff --git a/notebooks/satvision-toa-reconstruction-comparison-plotting-scaled.ipynb b/notebooks/satvision-toa-reconstruction-comparison-plotting-scaled.ipynb new file mode 100644 index 0000000..3f2a8b4 --- /dev/null +++ b/notebooks/satvision-toa-reconstruction-comparison-plotting-scaled.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c8ab2075-c488-46b9-8cd2-0cdaf399acfc", + "metadata": {}, + "source": [ + "# Satvision-TOA Reconstruction Plotting Notebook\n", + "\n", + "# Pt 2/2\n", + "\n", + "Version: 06.07.24\n", + "\n", + "Env: `Python [conda env:ilab-pytorch]`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d046c3e5-c458-4e03-9c96-e9eb95a04963", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import time\n", + "import joblib\n", + "import random\n", + "import datetime\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import logging\n", + "\n", + "import torch\n", + "import torch.cuda.amp as amp\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.backends.backend_pdf import PdfPages\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore') " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c7db1bc-09ee-47e3-9015-e6b148d497e7", + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append('../../pytorch-caney')\n", + "\n", + "from pytorch_caney.config import get_config\n", + "\n", + "from pytorch_caney.models.build import build_model\n", + "\n", + "from pytorch_caney.ptc_logging import create_logger\n", + "\n", + "from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset\n", + "\n", + "from pytorch_caney.data.transforms import SimmimTransform, SimmimMaskGenerator\n", + "\n", + "from pytorch_caney.config import _C, _update_config_from_file" + ] + }, + { + "cell_type": "markdown", + "id": "d841e464-f880-4e53-bf31-f9f225713918", + "metadata": {}, + "source": [ + "## 1. Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7e753bc3-bd7a-4944-9250-3f7055fd05bd", + "metadata": {}, + "outputs": [], + "source": [ + "# version strings used when generating data from satvision-toa-reconstruction-generation-scaled.ipynb\n", + "\n", + "versionA = 'hugeDiscover-ep88-scaledDLscaledRSB1e-2' # Your new model version\n", + "versionB = 'giantDiscover26m-ep97' # Latest best of the un-scaled reflectance and k models\n", + "\n", + "# Output version string\n", + "version = 'huge.88.huge.2m.scaled.radiance'\n", + "\n", + "# Which bands\n", + "bands = range(0, 14)\n", + "band = 'All'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5a0701ee-3234-4af9-b394-50a7bfa87d4a", + "metadata": {}, + "outputs": [], + "source": [ + "recon_path_a = f'recons128.v{versionA}.cAll.sav'\n", + "diff_path_a = f'diffs128.v{versionA}.cAll.sav'\n", + "\n", + "recon_path_b = f'recons128.v{versionB}.cAll.sav'\n", + "diff_path_b = f'diffs128.v{versionB}.cAll.sav'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "27470b7a-779a-4d21-885a-2886420a633d", + "metadata": {}, + "outputs": [], + "source": [ + "diff_as = np.array(joblib.load(diff_path_a)[:])\n", + "recon_as = np.array(joblib.load(recon_path_a)[:])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9fe5fa18-aa5a-4ed3-b1e6-400310008c5e", + "metadata": {}, + "outputs": [], + "source": [ + "diff_bs = np.array(joblib.load(diff_path_b)[:])\n", + "recon_bs = np.array(joblib.load(recon_path_b)[:])" + ] + }, + { + "cell_type": "markdown", + "id": "dc3f102c-94df-4d9e-8040-52197a7e71db", + "metadata": {}, + "source": [ + "## 6. Plot and write to PDF\n", + "\n", + "Writes out all of the predictions to a PDF file" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5ebdcd1d-09db-4ccf-8cc1-58d6f47e3a55", + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams.update({'font.size': 22})\n", + "\n", + "idx_to_band = {\n", + " 0: 1, # Ref 250m\n", + " 1: 2, # Ref 250m\n", + " 2: 3, # Ref 500m\n", + " 3: 6, # Ref 500m\n", + " 4: 7, # Ref 500m\n", + " 5: 21, # Emi 1km\n", + " 6: 26, # Ref 1km\n", + " 7: 27, # Emi 1km\n", + " 8: 28, # Emi 1km\n", + " 9: 29, # Emi 1km\n", + " 10: 30, # Emi 1km\n", + " 11: 31, # Emi 1km\n", + " 12: 32, # Emi 1km\n", + " 13: 33 # Emi 1km\n", + "}\n", + "\n", + "idx_to_wavelength = {\n", + " 0: '0.659 um', # ABI 2\n", + " 1: '0.865 um', # ABI 3\n", + " 2: '0.47 um', # ABI 1\n", + " 3: '1.64 um', # ABI 5\n", + " 4: '2.13 um', # ABI 6\n", + " 5: '3.96 um', # ABI 7\n", + " 6: '1.375 um', # ABI 4\n", + " 7: '6.72 um', # ABI 9 (or 8)\n", + " 8: '7.33 um', # ABI 10\n", + " 9: '8.55 um', # ABI 11\n", + " 10: '9.73 um', # ABI 12\n", + " 11: '11.03 um', # ABI 14\n", + " 12: '12.20 um', # ABI 15\n", + " 13: '13.34 um', # ABI 16\n", + "}\n", + "\n", + "reflectance_bands = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,26]\n", + "emissive_bands = [20,21,22,23,24,25,27,28,29,30,31,32,33,34,35,36]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7e7f3b71-6d63-4795-9fea-8680d153d011", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_show(path, diffs_a, recons_a, diffs_b, recons_b, band, crop=0):\n", + " pdf_plot_obj = PdfPages(path)\n", + " resize_to_128_crop = 0\n", + " aC = crop // 2 # Additional crop, total crop for 128s\n", + " cN = resize_to_128_crop + aC # Total crop for 192s\n", + " print(f'Cropping each size by {cN} pixels')\n", + "\n", + " # ---\n", + " # Ranges, calculated globally\n", + " # diff range\n", + " # ---\n", + " if cN > 0:\n", + " diffs_a_perBand = diffs_a[:, band, aC:-aC, aC:-aC]\n", + " diffs_b_perBand = diffs_b[:, band, cN:-cN, cN:-cN] # Clip to size\n", + " recons_a_perBand = recons_a[:, band, aC:-aC, aC:-aC]\n", + " recons_b_perBand = recons_b[:, band, cN:-cN, cN:-cN] # Clip to size\n", + " else:\n", + " diffs_a_perBand = diffs_a[:, band]\n", + " diffs_b_perBand = diffs_b[:, band] # Clip to size\n", + " recons_a_perBand = recons_a[:, band]\n", + " recons_b_perBand = recons_b[:, band] # Clip to size\n", + "\n", + " assert len(diffs_a_perBand.shape) == 3\n", + " assert len(diffs_b_perBand.shape) == 3\n", + " diff_vmax_a = np.nanmax(diffs_a_perBand)\n", + " diff_vmin_a = -diff_vmax_a # We want an even range for the diff map. 0 should be white\n", + " diff_vmax_b = np.nanmax(diffs_b_perBand)\n", + " diff_vmin_b = -diff_vmax_b\n", + "\n", + " print(f'Diff Range A: ({diff_vmin_a}, {diff_vmax_a})')\n", + " print(f'Diff Range B: ({diff_vmin_b}, {diff_vmax_b})')\n", + "\n", + " # reconstruction range\n", + " assert len(recons_a_perBand.shape) == 3\n", + " assert len(recons_b_perBand.shape) == 3\n", + " assert recons_a_perBand.shape == diffs_a_perBand.shape\n", + " assert recons_b_perBand.shape == diffs_b_perBand.shape\n", + " # recon_vmin_a = np.nanmin(recons_a_perBand) # min(np.nanmin(recons_a_perBand), np.nanmin(recons_b_perBand))\n", + " # recon_vmax_a = np.nanmax(recons_a_perBand) # max(np.nanmax(recons_a_perBand), np.nanmax(recons_b_perBand))\n", + " # print(f'Recon Range A: ({recon_vmin_a}, {recon_vmax_a})')\n", + " # print(f'Recon Range B: ({recon_vmin_b}, {recon_vmax_b})')\n", + " \n", + " channel = idx_to_band[band]\n", + " channel_wl = idx_to_wavelength[band]\n", + " processed_type = 'Reflectance' if channel in reflectance_bands else 'Brightness Temp (K)'\n", + " radiance_units = 'W/m^2/μm/sr'\n", + " print(f'Visualizing reconstruction for band {channel} ({channel_wl})')\n", + "\n", + "\n", + " for idx in range(recons_a_perBand.shape[0]):\n", + " \n", + " # prediction processing\n", + " diff_a = diffs_a_perBand[idx]\n", + " diff_b = diffs_b_perBand[idx]\n", + " recon_a = recons_a_perBand[idx]\n", + " recon_b = recons_b_perBand[idx]\n", + "\n", + " fig, axs = plt.subplots(3, 2, figsize=(30, 30))\n", + "\n", + " # ---\n", + " # First row: imshow plots\n", + " # Reconstruction images\n", + " # vmin and vmax are ranged per-image not per-batch if these lines are uncommented\n", + " recon_vmin_a = np.nanmin(recon_a)\n", + " recon_vmax_a = np.nanmax(recon_a)\n", + " recon_vmin_b = np.nanmin(recon_b)\n", + " recon_vmax_b = np.nanmax(recon_b)\n", + " # ---\n", + " \n", + " recon_plot_a = axs[0, 0].matshow(recon_a, vmin=recon_vmin_a, vmax=recon_vmax_a, ) # cmap='Greys_r')\n", + " axs[0, 0].set_title(f\"Idx: {idx} Model A reconstruction, Band: {channel} ({channel_wl}) {radiance_units}\")\n", + " recon_plot_b = axs[0, 1].matshow(recon_b, vmin=recon_vmin_b, vmax=recon_vmax_b, ) # cmap='Greys_r')\n", + " axs[0, 1].set_title(f\"Idx: {idx} Model B reconstruction, Band: {channel} ({channel_wl}) {processed_type}\")\n", + " cbar_ax = fig.add_axes([0.45, 0.7, 0.02, 0.2]) # [left, bottom, width, height]\n", + " fig.colorbar(recon_plot_a, cax=cbar_ax, orientation='vertical', fraction=1)\n", + " cbar_ax = fig.add_axes([0.95, 0.7, 0.02, 0.2]) # [left, bottom, width, height]\n", + " fig.colorbar(recon_plot_b, cax=cbar_ax, orientation='vertical', fraction=1)\n", + "\n", + " # ---\n", + " # Second row: matshow plots with shared colorbar\n", + " # Diff per-channel\n", + " # norm = plt.Normalize(-100, 100)\n", + " # vmin = min(np.nanmin(diff_128), np.nanmin(diff_192))\n", + " # vmax = max(np.nanmax(diff_128), np.nanmax(diff_192))\n", + " # ---\n", + " diff_plot_a = axs[1, 0].matshow(diff_a, cmap='seismic', vmin=diff_vmin_a, vmax=diff_vmax_a)\n", + " axs[1, 0].set_title(f\"Diff Heatmap, + reconstruction, - ground truth image\")\n", + " diff_plot_b = axs[1, 1].matshow(diff_b, cmap='seismic', vmin=diff_vmin_b, vmax=diff_vmax_b)\n", + " axs[1, 1].set_title(f\"+ reconstruction / - ground truth image\")\n", + "\n", + " # Create a colorbar for matshow plots\n", + " cbar_ax = fig.add_axes([0.45, 0.4, 0.02, 0.2]) # [left, bottom, width, height]\n", + " fig.colorbar(diff_plot_a, cax=cbar_ax, orientation='vertical', fraction=1)\n", + " cbar_ax = fig.add_axes([0.95, 0.4, 0.02, 0.2]) # [left, bottom, width, height]\n", + " fig.colorbar(diff_plot_b, cax=cbar_ax, orientation='vertical', fraction=1)\n", + "\n", + " # ---\n", + " # Third row: histograms with shared y-axis\n", + " # Left histogram\n", + " # N bins == 64, optimal?\n", + " # ---\n", + " nbins = 64\n", + " hist_range_a = (diff_vmin_a, diff_vmax_a)\n", + " hist_range_b = (diff_vmin_b, diff_vmax_b)\n", + " mean_a = np.nanmean(diff_a)\n", + " std_a = np.nanstd(diff_a)\n", + " mean_b = np.nanmean(diff_b)\n", + " std_b = np.nanstd(diff_b)\n", + " \n", + " # Model A histogram\n", + " axs[2, 0].hist(diff_a.flatten(), bins=nbins, alpha=0.7, color='blue', range=hist_range_a)\n", + "\n", + " axs[2, 0].text(0.95, 0.95, f'Mean: {mean_a:.2f}',\n", + " horizontalalignment='right', verticalalignment='top',\n", + " transform=axs[2, 0].transAxes, color='blue', fontsize=16)\n", + "\n", + " axs[2, 0].text(0.95, 0.90, f'Std: {std_a:.2f}',\n", + " horizontalalignment='right', verticalalignment='top',\n", + " transform=axs[2, 0].transAxes, color='blue', fontsize=16)\n", + "\n", + " axs[2, 0].set_title(f\"Diff Histogram\")\n", + "\n", + " # Model B histogram\n", + " axs[2, 1].hist(diff_b.flatten(), bins=nbins, alpha=0.7, color='green', range=hist_range_b)\n", + "\n", + " axs[2, 1].text(0.95, 0.95, f'Mean: {mean_b:.2f}',\n", + " horizontalalignment='right', verticalalignment='top',\n", + " transform=axs[2, 1].transAxes, color='green', fontsize=16)\n", + "\n", + " axs[2, 1].text(0.95, 0.90, f'Std: {std_b:.2f}',\n", + " horizontalalignment='right', verticalalignment='top',\n", + " transform=axs[2, 1].transAxes, color='green', fontsize=16)\n", + "\n", + " axs[2, 1].set_title(f\"+ reconstruction / - ground truth image\")\n", + "\n", + " # Shared axis, does this do anything?\n", + " # axs[2, 0].get_shared_y_axes().join(axs[2, 0], axs[2, 1])\n", + " axs[2, 0].set_ylabel('Frequency')\n", + "\n", + " # Adjust layout for better spacing\n", + " plt.tight_layout()\n", + " pdf_plot_obj.savefig()\n", + " \n", + " pdf_plot_obj.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9925565a-4ac7-466b-b4ee-9213bfa274ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cropping each size by 0 pixels\n", + "Diff Range A: (-2.831550121307373, 2.831550121307373)\n", + "Diff Range B: (-67.75938415527344, 67.75938415527344)\n", + "Visualizing reconstruction for band 32 (12.20 um)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Test with a small subset on band\n", + "band = 12\n", + "pdf_path = f'satvision-toa-reconstruction-pdf-scale-patch-8-compare-06.06.full.v{version}.channel0.pdf'\n", + "plot_show(pdf_path, diff_as[:5], recon_as[:5], diff_bs, recon_bs, band)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82b106d3-f96f-42b7-a221-3560e17789c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cropping each size by 0 pixels\n", + "Diff Range A: (-2.384681224822998, 2.384681224822998)\n", + "Diff Range B: (-47.9204216003418, 47.9204216003418)\n", + "Visualizing reconstruction for band 1 (0.659 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-1.5874985456466675, 1.5874985456466675)\n", + "Diff Range B: (-49.93202590942383, 49.93202590942383)\n", + "Visualizing reconstruction for band 2 (0.865 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-3.0454976558685303, 3.0454976558685303)\n", + "Diff Range B: (-46.732398986816406, 46.732398986816406)\n", + "Visualizing reconstruction for band 3 (0.47 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-0.31507667899131775, 0.31507667899131775)\n", + "Diff Range B: (-35.87236785888672, 35.87236785888672)\n", + "Visualizing reconstruction for band 6 (1.64 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-0.1067577600479126, 0.1067577600479126)\n", + "Diff Range B: (-27.826475143432617, 27.826475143432617)\n", + "Visualizing reconstruction for band 7 (2.13 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-1.3098115921020508, 1.3098115921020508)\n", + "Diff Range B: (-54.6114501953125, 54.6114501953125)\n", + "Visualizing reconstruction for band 21 (3.96 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-0.2543014883995056, 0.2543014883995056)\n", + "Diff Range B: (-20.713294982910156, 20.713294982910156)\n", + "Visualizing reconstruction for band 26 (1.375 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-0.7877901792526245, 0.7877901792526245)\n", + "Diff Range B: (-48.941680908203125, 48.941680908203125)\n", + "Visualizing reconstruction for band 27 (6.72 um)\n", + "Cropping each size by 0 pixels\n", + "Diff Range A: (-1.9258666038513184, 1.9258666038513184)\n", + "Diff Range B: (-33.78221130371094, 33.78221130371094)\n", + "Visualizing reconstruction for band 28 (7.33 um)\n" + ] + } + ], + "source": [ + "# Plot all the bands in individual PDFs\n", + "\n", + "for band in bands:\n", + " pdf_path = f'satvision-toa-reconstruction-pdf-scale-rsb-scale-1e-2-patch-8-compare-06.06.full.v{version}.channel{band}.pdf'\n", + " plot_show(pdf_path, diff_as, recon_as, diff_bs, recon_bs, band)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc7e6a42-c2a7-402b-b3d5-ee859bc94465", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:ilab]", + "language": "python", + "name": "conda-env-ilab-py" + }, + "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.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/satvision-toa-reconstruction-generation-scaled.ipynb b/notebooks/satvision-toa-reconstruction-generation-scaled.ipynb new file mode 100644 index 0000000..8cf3fde --- /dev/null +++ b/notebooks/satvision-toa-reconstruction-generation-scaled.ipynb @@ -0,0 +1,1500 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c8ab2075-c488-46b9-8cd2-0cdaf399acfc", + "metadata": {}, + "source": [ + "# Satvision-TOA Reconstruction Comaprison Plotting Notebook\n", + "\n", + "# Pt 1/2\n", + "\n", + "Version: 06.06.24\n", + "\n", + "Env: `Python [conda env:ilab-pytorch]`\n", + "Env (discover): `Python [conda env:ilab]`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6e88ea70-7dbf-4b67-a12d-db36e2bc9914", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: yacs in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (0.1.8)\n", + "Requirement already satisfied: timm in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (0.9.2)\n", + "Requirement already satisfied: segmentation-models-pytorch in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (0.3.3)\n", + "Requirement already satisfied: termcolor in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (1.1.0)\n", + "Requirement already satisfied: webdataset==0.2.86 in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (0.2.86)\n", + "Requirement already satisfied: numpy in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from webdataset==0.2.86) (1.21.3)\n", + "Requirement already satisfied: pyyaml in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from webdataset==0.2.86) (6.0)\n", + "Requirement already satisfied: braceexpand in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from webdataset==0.2.86) (0.1.7)\n", + "Requirement already satisfied: safetensors in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (from timm) (0.4.3)\n", + "Requirement already satisfied: huggingface-hub in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (from timm) (0.16.4)\n", + "Requirement already satisfied: torchvision in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from timm) (0.11.2)\n", + "Requirement already satisfied: torch>=1.7 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from timm) (1.10.1)\n", + "Requirement already satisfied: tqdm in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from segmentation-models-pytorch) (4.62.3)\n", + "Requirement already satisfied: pretrainedmodels==0.7.4 in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (from segmentation-models-pytorch) (0.7.4)\n", + "Requirement already satisfied: pillow in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from segmentation-models-pytorch) (8.4.0)\n", + "Requirement already satisfied: efficientnet-pytorch==0.7.1 in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (from segmentation-models-pytorch) (0.7.1)\n", + "Requirement already satisfied: munch in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from pretrainedmodels==0.7.4->segmentation-models-pytorch) (2.5.0)\n", + "Requirement already satisfied: typing-extensions in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from torch>=1.7->timm) (3.10.0.0)\n", + "Requirement already satisfied: importlib-metadata in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from huggingface-hub->timm) (4.10.1)\n", + "Requirement already satisfied: packaging>=20.9 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from huggingface-hub->timm) (21.3)\n", + "Requirement already satisfied: filelock in /gpfsm/dnb33/cssprad1/.local/lib/python3.7/site-packages (from huggingface-hub->timm) (3.12.2)\n", + "Requirement already satisfied: fsspec in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from huggingface-hub->timm) (2022.1.0)\n", + "Requirement already satisfied: requests in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from huggingface-hub->timm) (2.27.1)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from packaging>=20.9->huggingface-hub->timm) (3.0.6)\n", + "Requirement already satisfied: zipp>=0.5 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from importlib-metadata->huggingface-hub->timm) (3.7.0)\n", + "Requirement already satisfied: six in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from munch->pretrainedmodels==0.7.4->segmentation-models-pytorch) (1.15.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from requests->huggingface-hub->timm) (2021.10.8)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from requests->huggingface-hub->timm) (1.26.8)\n", + "Requirement already satisfied: idna<4,>=2.5 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from requests->huggingface-hub->timm) (3.3)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /gpfsm/dulocal/sles12/other/python/JH.1/GEOSpyD/4.11.0_py3.9/2022-05-25/envs/ilab/lib/python3.7/site-packages (from requests->huggingface-hub->timm) (2.0.10)\n" + ] + } + ], + "source": [ + "!pip install yacs timm segmentation-models-pytorch termcolor webdataset==0.2.86" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d046c3e5-c458-4e03-9c96-e9eb95a04963", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import time\n", + "import joblib\n", + "import random\n", + "import datetime\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import logging\n", + "\n", + "import torch\n", + "import torch.cuda.amp as amp\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.backends.backend_pdf import PdfPages\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore') " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c7db1bc-09ee-47e3-9015-e6b148d497e7", + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append('../../pytorch-caney')\n", + "\n", + "from pytorch_caney.config import get_config\n", + "\n", + "from pytorch_caney.models.build import build_model\n", + "\n", + "from pytorch_caney.ptc_logging import create_logger\n", + "\n", + "from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset\n", + "\n", + "from pytorch_caney.data.transforms import SimmimTransform, SimmimMaskGenerator\n", + "\n", + "from pytorch_caney.config import _C, _update_config_from_file" + ] + }, + { + "cell_type": "markdown", + "id": "d841e464-f880-4e53-bf31-f9f225713918", + "metadata": {}, + "source": [ + "## 1. Configuration" + ] + }, + { + "cell_type": "markdown", + "id": "6274e323-bc04-41d4-bc49-baed65d027e6", + "metadata": {}, + "source": [ + "### Clone model ckpt from huggingface\n", + "\n", + "```bash\n", + "# On prism/explore\n", + "module load git-lfs\n", + "\n", + "git lfs install\n", + "\n", + "git clone git clone git@hf.co:nasa-cisto-data-science-group/satvision-toa-huge-patch8-window12-192\n", + "```\n", + "\n", + "Note: If using git w/ ssh, make sure you have ssh keys enabled to clone using ssh auth.\n", + "https://huggingface.co/docs/hub/security-git-ssh\n", + "\n", + "```bash\n", + "eval $(ssh-agent)\n", + "\n", + "# If this outputs as anon, follow the next steps.\n", + "ssh -T git@hf.co\n", + "\n", + "# Check if ssh-agent is using the proper key\n", + "ssh-add -l\n", + "\n", + "# If not\n", + "ssh-add ~/.ssh/your-key\n", + "\n", + "# Or if you want to use the default id_* key, just do\n", + "ssh-add\n", + "\n", + "```\n", + "\n", + "### if performing reconstruction tests on discover, softlink the model weights and associated yaml config file" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "af699ba3-2d98-4daf-9437-c322d7b59a98", + "metadata": {}, + "outputs": [], + "source": [ + "# MODEL_PATH: str = '../../mim_pretrain_swinv2_h_satvision_128_window8_patch8_3e4_100ep/ckpt_epoch_99/mp_rank_00_model_states.pt'\n", + "# CONFIG_PATH: str = '../../mim_pretrain_swinv2_satvision_huge_128_window8_patch8_100ep.yaml'\n", + "# MODEL_PATH: str = '../../mim_satvision_pretrain-huge/mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_100ep/ckpt_epoch_88/mp_rank_00_model_states.pt'\n", + "# CONFIG_PATH: str = '../../mim_pretrain_swinv2_satvision_huge_128_window8_mpatch8_onecycle_100ep.yaml'\n", + "# MODEL_PATH: str = '../../satvision-toa-huge-patch8-window12-192/mp_rank_00_model_states.pt'\n", + "# CONFIG_PATH: str = '../../satvision-toa-huge-patch8-window12-192/mim_pretrain_swinv2_satvision_huge_192_window12_100ep.yaml'\n", + "# MODEL_PATH: str = '../../3b_26m_8p/mp_rank_00_model_states.pt'\n", + "# CONFIG_PATH: str = '../../3b_26m_8p/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml'\n", + "# MODEL_PATH: str = '../../3b.2m.discover.nodecay.6nodes/mp_rank_00_model_states.pt'\n", + "# CONFIG_PATH: str = '../../3b.2m.discover.nodecay.6nodes/mim_pretrain_swinv2_satvision_giant_128_window08_100ep.yaml'\n", + "MODEL_PATH: str = '../../mim_satvision_pretrain-huge/mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_rsb_scaled_100ep/ckpt_epoch_99/mp_rank_00_model_states.pt'\n", + "CONFIG_PATH: str = '../../mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml'\n", + "\n", + "\n", + "OUTPUT: str = '.'\n", + "TAG: str = 'satvision-huge-toa-reconstruction'\n", + "DATA_PATH: str = '/discover/nobackup/cssprad1/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy'\n", + "DATA_PATHS: list = [DATA_PATH]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c4593e8c-6e94-4d01-b86e-5b78b621fc59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=> merge config from ../../mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml\n" + ] + } + ], + "source": [ + "# Update config given configurations\n", + "\n", + "config = _C.clone()\n", + "_update_config_from_file(config, CONFIG_PATH)\n", + "\n", + "config.defrost()\n", + "config.MODEL.RESUME = MODEL_PATH\n", + "config.DATA.DATA_PATHS = DATA_PATHS\n", + "config.OUTPUT = OUTPUT\n", + "config.TAG = TAG\n", + "config.freeze()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "202a4474-88e4-44d5-b899-7aaf6cbed6f4", + "metadata": {}, + "outputs": [], + "source": [ + "# Configure logging\n", + "logging.basicConfig(\n", + " filename='app.log', # Specify the log file name\n", + " level=logging.INFO, # Set logging level to DEBUG\n", + " format='%(asctime)s [%(levelname)s] %(message)s', # Specify log message format\n", + " datefmt='%Y-%m-%d %H:%M:%S' # Specify date format\n", + ")\n", + "\n", + "# Add logging to standard output\n", + "console = logging.StreamHandler() # Create a handler for standard output\n", + "console.setLevel(logging.INFO) # Set logging level for standard output\n", + "console.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')) # Set log message format for standard output\n", + "logger = logging.getLogger('')\n", + "logger.addHandler(console)" + ] + }, + { + "cell_type": "markdown", + "id": "11ebd497-7741-41a7-af9d-0ee49a6313a4", + "metadata": {}, + "source": [ + "## 2. Load model weights from checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "68abf348-c6bf-43a3-b00a-cc5f8d80545f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-06-10 10:17:27,888 [INFO] number of params: 695328632\n" + ] + }, + { + "data": { + "text/plain": [ + "MiMModel(\n", + " (encoder): SwinTransformerV2ForSimMIM(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(14, 352, kernel_size=(4, 4), stride=(4, 4))\n", + " (norm): LayerNorm((352,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (pos_drop): Dropout(p=0.0, inplace=False)\n", + " (layers): ModuleList(\n", + " (0): BasicLayer(\n", + " dim=352, input_resolution=(32, 32), depth=2\n", + " (blocks): ModuleList(\n", + " (0): SwinTransformerBlock(\n", + " dim=352, input_resolution=(32, 32),num_heads=4, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((352,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=352, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=4\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=4, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=352, out_features=1056, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=352, out_features=352, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm((352,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=352, out_features=1408, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=1408, out_features=352, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SwinTransformerBlock(\n", + " dim=352, input_resolution=(32, 32),num_heads=4, window_size=8, shift_size=4, mlp_ratio=4.0\n", + " (norm1): LayerNorm((352,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=352, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=4\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=4, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=352, out_features=1056, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=352, out_features=352, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.004)\n", + " (norm2): LayerNorm((352,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=352, out_features=1408, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=1408, out_features=352, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (downsample): PatchMerging(\n", + " input_resolution=(32, 32), dim=352\n", + " (reduction): Linear(in_features=1408, out_features=704, bias=False)\n", + " (norm): LayerNorm((704,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " (1): BasicLayer(\n", + " dim=704, input_resolution=(16, 16), depth=2\n", + " (blocks): ModuleList(\n", + " (0): SwinTransformerBlock(\n", + " dim=704, input_resolution=(16, 16),num_heads=8, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((704,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=704, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=8\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=8, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=704, out_features=2112, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=704, out_features=704, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.009)\n", + " (norm2): LayerNorm((704,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=704, out_features=2816, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=2816, out_features=704, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SwinTransformerBlock(\n", + " dim=704, input_resolution=(16, 16),num_heads=8, window_size=8, shift_size=4, mlp_ratio=4.0\n", + " (norm1): LayerNorm((704,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=704, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=8\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=8, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=704, out_features=2112, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=704, out_features=704, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.013)\n", + " (norm2): LayerNorm((704,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=704, out_features=2816, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=2816, out_features=704, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (downsample): PatchMerging(\n", + " input_resolution=(16, 16), dim=704\n", + " (reduction): Linear(in_features=2816, out_features=1408, bias=False)\n", + " (norm): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " (2): BasicLayer(\n", + " dim=1408, input_resolution=(8, 8), depth=18\n", + " (blocks): ModuleList(\n", + " (0): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.017)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.022)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (2): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.026)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (3): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.030)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (4): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.035)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (5): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.039)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (6): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.043)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (7): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.048)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (8): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.052)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (9): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.057)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (10): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.061)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (11): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.065)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (12): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.070)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (13): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.074)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (14): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.078)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (15): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.083)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (16): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.087)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (17): SwinTransformerBlock(\n", + " dim=1408, input_resolution=(8, 8),num_heads=16, window_size=8, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=1408, window_size=(8, 8), pretrained_window_size=(0, 0), num_heads=16\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=16, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=1408, out_features=4224, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=1408, out_features=1408, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.091)\n", + " (norm2): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=1408, out_features=5632, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=5632, out_features=1408, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " (downsample): PatchMerging(\n", + " input_resolution=(8, 8), dim=1408\n", + " (reduction): Linear(in_features=5632, out_features=2816, bias=False)\n", + " (norm): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " )\n", + " (3): BasicLayer(\n", + " dim=2816, input_resolution=(4, 4), depth=2\n", + " (blocks): ModuleList(\n", + " (0): SwinTransformerBlock(\n", + " dim=2816, input_resolution=(4, 4),num_heads=32, window_size=4, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=2816, window_size=(4, 4), pretrained_window_size=(0, 0), num_heads=32\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=32, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=2816, out_features=8448, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=2816, out_features=2816, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.096)\n", + " (norm2): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=2816, out_features=11264, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=11264, out_features=2816, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (1): SwinTransformerBlock(\n", + " dim=2816, input_resolution=(4, 4),num_heads=32, window_size=4, shift_size=0, mlp_ratio=4.0\n", + " (norm1): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " (attn): WindowAttention(\n", + " dim=2816, window_size=(4, 4), pretrained_window_size=(0, 0), num_heads=32\n", + " (cpb_mlp): Sequential(\n", + " (0): Linear(in_features=2, out_features=512, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=512, out_features=32, bias=False)\n", + " )\n", + " (qkv): Linear(in_features=2816, out_features=8448, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=2816, out_features=2816, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (softmax): Softmax(dim=-1)\n", + " )\n", + " (drop_path): DropPath(drop_prob=0.100)\n", + " (norm2): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " (norm3): Identity()\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=2816, out_features=11264, bias=True)\n", + " (act): GELU()\n", + " (fc2): Linear(in_features=11264, out_features=2816, bias=True)\n", + " (drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (norm): LayerNorm((2816,), eps=1e-05, elementwise_affine=True)\n", + " (avgpool): AdaptiveAvgPool1d(output_size=1)\n", + " (head): Identity()\n", + " )\n", + " (decoder): Sequential(\n", + " (0): Conv2d(2816, 14336, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): PixelShuffle(upscale_factor=32)\n", + " )\n", + ")" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "checkpoint = torch.load(MODEL_PATH)\n", + "model = build_model(config, pretrain=True)\n", + "model.load_state_dict(checkpoint['module']) # If 'module' not working, try 'model'\n", + "n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + "logger.info(f\"number of params: {n_parameters}\")\n", + "# model.cuda() # For some reason cuda not working on JH discover ilab kernel. I think due to not sles15\n", + "model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e684b1fe-21ad-48ff-b440-ba45f032f6e5", + "metadata": {}, + "outputs": [], + "source": [ + "import torchvision.transforms as T\n", + "from pytorch_caney.data.utils import RandomResizedCropNP, SimmimMaskGenerator\n", + "\n", + "class MinMaxEmissiveScaleReflectance(object):\n", + " \"\"\"\n", + " Performs scaling of MODIS TOA data\n", + " - Scales reflectance percentages to reflectance units (% -> (0,1))\n", + " - Performs per-channel minmax scaling for emissive bands (k -> (0,1))\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " \n", + " self.reflectance_indices = [0, 1, 2, 3, 4, 6]\n", + " self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13]\n", + "\n", + " self.emissive_mins = np.array(\n", + " [223.1222, 178.9174, 204.3739, 204.7677,\n", + " 194.8686, 202.1759, 201.3823, 203.3537],\n", + " dtype=np.float32)\n", + "\n", + " self.emissive_maxs = np.array(\n", + " [352.7182, 261.2920, 282.5529, 319.0373,\n", + " 295.0209, 324.0677, 321.5254, 285.9848],\n", + " dtype=np.float32)\n", + "\n", + " def __call__(self, img):\n", + " \n", + " # Reflectance % to reflectance units\n", + " img[:, :, self.reflectance_indices] = \\\n", + " img[:, :, self.reflectance_indices] * 0.01\n", + " \n", + " # Brightness temp scaled to (0,1) range\n", + " img[:, :, self.emissive_indices] = \\\n", + " (img[:, :, self.emissive_indices] - self.emissive_mins) / \\\n", + " (self.emissive_maxs - self.emissive_mins)\n", + " \n", + " return img\n", + "\n", + "\n", + "class SimmimTransform:\n", + " \"\"\"\n", + " torchvision transform which transforms the input imagery into\n", + " addition to generating a MiM mask\n", + " \"\"\"\n", + "\n", + " def __init__(self, config):\n", + "\n", + " self.transform_img = \\\n", + " T.Compose([\n", + " MinMaxEmissiveScaleReflectance(), # New transform for MinMax\n", + " RandomResizedCropNP(scale=(0.67, 1.),\n", + " ratio=(3. / 4., 4. / 3.)),\n", + " T.ToTensor(),\n", + " #lambda x: x / 500.0,\n", + " #T.ConvertImageDtype(dtype=torch.float32),\n", + " #torchvision.ops.Permute(dims=[1, 2, 0]),\n", + " T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)),\n", + " ])\n", + "\n", + " if config.MODEL.TYPE in ['swin', 'swinv2']:\n", + "\n", + " model_patch_size = config.MODEL.SWINV2.PATCH_SIZE\n", + "\n", + " else:\n", + "\n", + " raise NotImplementedError\n", + "\n", + " self.mask_generator = SimmimMaskGenerator(\n", + " input_size=config.DATA.IMG_SIZE,\n", + " mask_patch_size=config.DATA.MASK_PATCH_SIZE,\n", + " model_patch_size=model_patch_size,\n", + " mask_ratio=config.DATA.MASK_RATIO,\n", + " )\n", + "\n", + " def __call__(self, img):\n", + "\n", + " img = self.transform_img(img)\n", + " mask = self.mask_generator()\n", + "\n", + " return img, mask" + ] + }, + { + "cell_type": "markdown", + "id": "b500d13b-89d7-4cd8-a36a-ab6f10f6a397", + "metadata": {}, + "source": [ + "## 3. Load evaluation set (from numpy file)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "73a8d307-de9b-4617-abdd-dae1e7c2521a", + "metadata": {}, + "outputs": [], + "source": [ + "# Use the Masked-Image-Modeling transform\n", + "transform = SimmimTransform(config)\n", + "\n", + "# The reconstruction evaluation set is a single numpy file\n", + "validation_dataset_path = DATA_PATH\n", + "validation_dataset = np.load(validation_dataset_path)\n", + "len_batch = range(validation_dataset.shape[0])\n", + "\n", + "# Apply transform to each image in the batch\n", + "# A mask is auto-generated in the transform\n", + "imgMasks = [transform(validation_dataset[idx]) for idx \\\n", + " in len_batch]\n", + "\n", + "# Seperate img and masks, cast masks to torch tensor\n", + "img = torch.stack([imgMask[0] for imgMask in imgMasks])\n", + "\n", + "mask = torch.load('mask_192.pt')\n", + "\n", + "if config.DATA.IMG_SIZE == 128:\n", + " mask = mask[:, 8:-8, 8:-8]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "85453997-9da8-4e18-9a53-bd96dc9dab8d", + "metadata": {}, + "outputs": [], + "source": [ + "idx_to_band = {\n", + " 0: 1,\n", + " 1: 2,\n", + " 2: 3,\n", + " 3: 6,\n", + " 4: 7,\n", + " 5: 21,\n", + " 6: 26,\n", + " 7: 27,\n", + " 8: 28,\n", + " 9: 29,\n", + " 10: 30,\n", + " 11: 31,\n", + " 12: 32,\n", + " 13: 33\n", + "}\n", + "\n", + "\n", + "def get_batch_info(img):\n", + " \n", + " channels = img.shape[1]\n", + " \n", + " for channelIdx in range(channels):\n", + " channel = idx_to_band[channelIdx]\n", + " img_band_array = img[:, channelIdx, :, :]\n", + " min_ = img_band_array.min()\n", + " mean_ = img_band_array.mean()\n", + " max_ = img_band_array.max()\n", + " print(f'Channel {channel}, min {min_}, mean {mean_}, max {max_}') " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0bbe3d8a-90f5-4b20-9768-a3e3c1b0c4aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel 1, min 0.00787659827619791, mean 0.2306605875492096, max 0.9887060523033142\n", + "Channel 2, min -0.00038768138620071113, mean 0.2931264340877533, max 0.9125235676765442\n", + "Channel 3, min 0.039573196321725845, mean 0.2628457546234131, max 1.032042145729065\n", + "Channel 6, min -0.026754550635814667, mean 0.22612576186656952, max 0.6638308763504028\n", + "Channel 7, min -0.02489299885928631, mean 0.15096446871757507, max 0.6149790287017822\n", + "Channel 21, min 0.013017232529819012, mean 0.5206390619277954, max 0.9244224429130554\n", + "Channel 26, min -0.021210160106420517, mean 0.030266068875789642, max 0.5291910171508789\n", + "Channel 27, min 0.03513594716787338, mean 0.7143411636352539, max 0.999663233757019\n", + "Channel 28, min 0.015452031046152115, mean 0.583636462688446, max 0.993326723575592\n", + "Channel 29, min 0.023415686562657356, mean 0.6118876338005066, max 1.0035899877548218\n", + "Channel 30, min 0.004206456709653139, mean 0.6180419921875, max 1.0000258684158325\n", + "Channel 31, min 0.012684257701039314, mean 0.6036472916603088, max 0.9999096393585205\n", + "Channel 32, min 0.008829907514154911, mean 0.6057718396186829, max 0.999901294708252\n", + "Channel 33, min 0.005273506045341492, mean 0.6280515789985657, max 0.9978172779083252\n" + ] + } + ], + "source": [ + "get_batch_info(img)" + ] + }, + { + "cell_type": "markdown", + "id": "55acf5e9-eb2a-496c-baa6-3b74503a2978", + "metadata": {}, + "source": [ + "## 4. Prediction helper functions" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "595336f8-71b4-418b-b153-2461583ed613", + "metadata": {}, + "outputs": [], + "source": [ + "def minmax_norm(img_arr, minmax=None):\n", + " if minmax:\n", + " arr_min, arr_max = minmax\n", + " else:\n", + " arr_min = img_arr.min()\n", + " arr_max = img_arr.max()\n", + " img_arr_scaled = (img_arr - arr_min) / (arr_max - arr_min)\n", + " img_arr_scaled = img_arr_scaled * 255\n", + " img_arr_scaled = img_arr_scaled.astype(np.uint8)\n", + " return img_arr_scaled\n", + "\n", + "\n", + "def process_mask(mask, repeat=3, axis=-1):\n", + " mask_img = mask.unsqueeze(0)\n", + " mask_img = mask_img.repeat_interleave(4, 1).repeat_interleave(4, 2).unsqueeze(1).contiguous()\n", + " mask_img = mask_img[0, 0, :, :]\n", + " mask_img = mask_img[:, :, None].repeat_interleave(repeat, -1).numpy()\n", + " if not axis == -1:\n", + " mask_img = np.moveaxis(mask_img, -1, axis) \n", + " return mask_img\n", + "\n", + "\n", + "def process_prediction(image, img_recon, mask, rgb_index, minmax, rgb=False, norm=False):\n", + "\n", + " mask_14c = process_mask(mask, repeat=14, axis=0)\n", + " image = image.numpy()\n", + " img_recon = img_recon.numpy()\n", + "\n", + " diff = np.where(mask_14c == 1, (img_recon - image), np.nan)\n", + " image_recon_masked = np.where(mask_14c == 0, image, img_recon)\n", + "\n", + " if rgb:\n", + "\n", + " # ---\n", + " # Process RGB version\n", + " # ---\n", + " mask_3c = process_mask(mask)\n", + " \n", + " red_idx = rgb_index[0]\n", + " blue_idx = rgb_index[1]\n", + " green_idx = rgb_index[2]\n", + "\n", + "\n", + " rgb_image = np.stack((image[red_idx, :, :],\n", + " image[blue_idx, :, :],\n", + " image[green_idx, :, :]),\n", + " axis=-1)\n", + " rgb_image = minmax_norm(rgb_image, None) if norm else rgb_image\n", + "\n", + "\n", + "\n", + " \n", + " rgb_image_recon = np.stack((img_recon[red_idx, :, :],\n", + " img_recon[blue_idx, :, :],\n", + " img_recon[green_idx, :, :]),\n", + " axis=-1)\n", + "\n", + " rgb_image_recon = minmax_norm(rgb_image_recon) if norm else rgb_image_recon\n", + "\n", + " diff = np.where(mask_3c == 1, (rgb_image_recon - rgb_image), np.nan) # \n", + "\n", + " rgb_masked = np.where(mask_3c == 0, rgb_image, rgb_image_recon)\n", + " rgb_image_masked = np.where(mask_3c == 1, rgb_image, 0)\n", + "\n", + " rgb_recon_masked = rgb_masked\n", + " \n", + " return rgb_image, rgb_image_masked, rgb_recon_masked, mask_3c, diff\n", + " \n", + " else:\n", + "\n", + " return image, image_recon_masked, diff\n", + "\n", + "def save_diff_and_recons(inputs, outputs, masks, minmaxes,\n", + " rgb_index, size, version, rgb=False, norm=False):\n", + "\n", + " recons = []\n", + " diffs = []\n", + "\n", + " for idx in range(len(inputs)):\n", + "\n", + " # prediction processing\n", + " image = inputs[idx]\n", + " img_recon = outputs[idx]\n", + " mask = masks[idx]\n", + " img_minmax = minmaxes[idx]\n", + "\n", + "\n", + "\n", + " if rgb:\n", + " image, image_masked, img_recon_masked, mask, diff = \\\n", + " process_prediction(image, img_recon, mask, rgb_index, img_minmax, rgb=True, norm=norm)\n", + " else:\n", + " image, img_recon_masked, diff = process_prediction(image, img_recon, mask, rgb_index,\n", + " img_minmax, rgb=False, norm=norm)\n", + "\n", + " recons.append(img_recon_masked)\n", + " diffs.append(diff)\n", + "\n", + " recon_filepath = f'recons{size}.v{version}.cAll.sav'\n", + " diff_filepath = f'diffs{size}.v{version}.cAll.sav'\n", + " joblib.dump(recons, recon_filepath)\n", + " joblib.dump(diffs, diff_filepath)\n", + " print(f'Saved reconstructions to {recon_filepath}')\n", + " print(f'Saved channel diff to {diff_filepath}')\n", + "\n", + "\n", + "def plot_validate(inputs, outputs, masks, minmaxes, rgb_index):\n", + "\n", + " for idx in range(len(inputs)):\n", + " # prediction processing\n", + " image = inputs[idx]\n", + " img_recon = outputs[idx]\n", + " mask = masks[idx]\n", + " minmax = minmaxes[idx]\n", + " rgb_image, rgb_image_masked, rgb_recon_masked, mask, diff = \\\n", + " process_prediction(image, img_recon, mask, rgb_index, minmax, rgb=True, norm=True)\n", + "\n", + " # matplotlib code\n", + " fig, (ax01, ax23) = plt.subplots(2, 2, figsize=(40, 30))\n", + " ax0, ax1 = ax01\n", + " ax2, ax3 = ax23\n", + " ax2.imshow(rgb_image)\n", + " ax2.set_title(f\"Idx: {idx} MOD021KM v6.1 Bands: {rgb_index}\")\n", + "\n", + " ax0.imshow(rgb_recon_masked)\n", + " ax0.set_title(f\"Idx: {idx} Model reconstruction\")\n", + "\n", + " ax3.imshow(rgb_image_masked)\n", + " ax3.set_title(f\"Idx: {idx} MOD021KM Bands: {rgb_index}, masked\")\n", + " \n", + " ax1.imshow(np.where(mask == 1, rgb_recon_masked, 0))\n", + " ax1.set_title(f\"Idx: {idx} Reconstruction Masked\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "551c44b5-6d88-45c4-b397-c38de8064544", + "metadata": {}, + "source": [ + "## 5. Predict" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4e695cc3-b869-4fc2-b360-b45f3b81affd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 128/128 [01:49<00:00, 1.17it/s]\n" + ] + } + ], + "source": [ + "inputs = []\n", + "outputs = []\n", + "masks = []\n", + "losses = []\n", + "minmaxes = joblib.load('mms_128.sav')\n", + "\n", + "# We could do this in a single batch however we\n", + "# want to report the loss per-image, in place of\n", + "# loss per-batch.\n", + "for i in tqdm(range(img.shape[0])):\n", + " single_img = img[i].unsqueeze(0)\n", + " single_mask = mask[i].unsqueeze(0)# [:, 8:-8, 8:-8]\n", + " # single_img = single_img.cuda(non_blocking=True)\n", + " # single_mask = single_mask.cuda(non_blocking=True)\n", + "\n", + " with torch.no_grad():\n", + " z = model.encoder(single_img, single_mask)\n", + " img_recon = model.decoder(z)\n", + " loss = model(single_img, single_mask)\n", + "\n", + " inputs.extend(single_img.cpu())\n", + " masks.extend(single_mask.cpu())\n", + " outputs.extend(img_recon.cpu())\n", + " losses.append(loss.cpu()) \n", + " \n", + "# This takes <1.5 mins for huge models, <3 mins for giant" + ] + }, + { + "cell_type": "markdown", + "id": "d9561768-1ce2-4fb8-9e13-d069d92512d6", + "metadata": {}, + "source": [ + "## 6. Save reconstruction images and diffs" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bac11a7b-0eee-4607-b364-d5a96af1b84f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved reconstructions to recons128.vhugeDiscover-ep88-scaledDLscaledRSB1e-2.cAll.sav\n", + "Saved channel diff to diffs128.vhugeDiscover-ep88-scaledDLscaledRSB1e-2.cAll.sav\n" + ] + } + ], + "source": [ + "# Saves out 14-band reconstruction and diffs per-band.\n", + "version = 'hugeDiscover-ep88-scaledDLscaledRSB1e-2'\n", + "rgb_index = [0, 2, 1] # Indices of [Red band, Blue band, Green band]\n", + "rgb = False\n", + "norm = False\n", + "save_diff_and_recons(inputs, outputs, masks, minmaxes, rgb_index, config.DATA.IMG_SIZE, version, rgb=rgb, norm=norm)" + ] + }, + { + "cell_type": "markdown", + "id": "c1da241d-cea3-48e4-b9d5-1f048a811f03", + "metadata": {}, + "source": [ + "## 7. Visualize reconstruction and diffs per-band." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9df29526-75fd-4f01-9628-9a10ebc2d497", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB88AAAaOCAYAAADcbnwvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9e5it2XkQdr5rV51zulvdrZYsS5ZsyzY2ARwCBEQg4GATY2wC2DzzxIZAgiEkzlyAkBsYyIQwgYmTIQkwZEjMJbHBITiEAAEHbESMIWQAA4YJNsY3ybpZ11a3+nIuVXvNH1UtH/d+3+r9nvrqVNX5fr/n0SNpfWu/676+Xevb++wx5wwAAAAAAAAAWLPNZVcAAAAAAAAAAC6bh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAK9hjPHZY4w5xji87LosYYzxH44x/vieeb99jPGvXXSdHhVjjBfGGD/ususBAAAAUHnUzroeFWOM/2WM8dWXXY+uzlnja8T5ojHGe5eoE8B5eHgOEBFjjHeNMX7BQyjnq8YYf2OM8dIY49tfI+8Xnf4h86dflf5TT9PPfP3ajTH+2zHG77rA+DsfLJhzPjnn/MGLKhMAAABgH1f4rGt7+uWDT4wxvneM8Wsvuo4PYozxa8YYf/0C4+88cJ5z/qI55zdcQFn/7elZ4pe/Kv33nqb/mqXLBLjOPDwHeLg+FhG/NyK+bs/8H46InzPG+JT70r46Iv7xwvU6t+v2aeXrVl8AAACAK6h71vX+OeeTEfF0RPxbEfGHxhg/4YLqdqHGGAeXXYeGfxwnZ4oR8clzsa+MiB+4tBoBXFEengO8yhjjYIzxe8YYHxlj/GBE/OL7rr1xjPHeMcYvPf3/T44xvn+M8av3iT3n/Mtzzm+OiPfvWZ27EfFnIuJXvFK3iPiqiPimV9X554wx/vYY47nT//459137nDHGXz39RO+3RcSbXvXan336CeGPjzH+/hjji/ap2OknZP/UGOOPjzGej4hfM8Z4/Rjjj4wxPjDGeN8Y43fd/4fEGONfH2N8z2ldvnuM8dNP03/S6Te5Pz7G+If3fxL29NOx/+UY4y+cvu5vjjE+9/TaGGP8F2OMD522/R+MMX7yGONrIuJXRcRvPv008/98mv9dY4zfMsb4BxHx4hjj8PQTtp/3qvJ+133//yvGGN81xnh+jPEDY4wvG2P87oj45yLiD5zG/wOneT8Z67QvvnGM8eExxrvHGP/+GGNzeu3XjDH++uk8e3aM8UNjjF+0T78DAAAAdFyxs65XXjfnnN8SJw/ff8pp2Zsxxteenr98dIzxzWOMN95X1y+47wzrPa98Y/o8ZzCn13/w9Mzph8YYv2qM8ZMi4r+KiH/29Nzn46d5/9sxxh8cY3zLGOPFiPj541X/MuF41TfWxxj/5Bjj28YYHxtjfHCM8dvGGF8WEb8tIn75afy/f5r3k7FO++LfP23Ph07b9/rTa6/8s/tfPcb44dNx/e2v0eX/c0T83DHGG07//5dFxD+IiB+5r66fO8b4K6d9/5ExxjeNMZ657/pvGSfnfa/8qwFf/OpCxhg3xhh/YozxP44xbo4x3nb6vz982r+/8b68j5/26bNjjO+OiJ/5Gm0AeCg8PAfY9a9HxC+JiH86It4REf/iKxfmnB+LiH81Tj4V++aI+C8i4rvmnN8YETHG+JXj5MHskr4xIl75g+VLI+Ifxn1/kJz+EfEXIuL3R8SnRMR/HhF/Yfzot9X/u4j4O3Hy0Pw/ih/7KdNPP33t74qIN0bEvxsR/+MY41P3rNtXRMSfiohn4uSB/jdExFFEfF6c9N8vjIhX3vR/ZUT8h6dteToivjwiPjrGuBEnb+C/NSLeHBG/ISK+afzYTx3/SxHxOyPiDRHx/RHxu0/Tf2FE/LyI+CdO6/DLI+Kjc86vP63Pf3r6T6n/0lfF+sUR8cyc8+isxo0x/pk46f9/7zT+z4uId805f3tE/LWI+PWn8X998vL/d0S8PiJ+XER84Wm77/+nyH5WRHxvnIzLfxoRf2SMMc6qDwAAAMADuGpnXa88HP7yODkX+f7T5N8YEb8sTs5R3hYRz0bEf3ma/+0R8b/EyXnLp0bET4uI7zp93QOdwYwxXhcn52m/aM75VET8nDhp+/dExP85Iv7303OfZ+6L9Svj5FzqqYg48591H2M8FRF/OSL+4ml7Pi8i3jnn/IsR8f+MiD95Gv+nJi//Naf/+fmn7XoyIv7Aq/J8QUT8hIj44oj4D04f+lduR8Sfi9Mv6MRJH33jq6scEf/xaV1/UkR8Zpyc5cXpOd2vj4ifedpXXxoR73pVex+Pky8B3YmTL/8cxcmZ39+PiE8/redvGmN86elLfkdEfO7pf7407juzBLhMHp4D7PqqiPi9c873nP4B8R/ff3HO+a0R8T9ExDvj5CHsv3Hftf9uzvlTlqzMnPNvRMQbT9+kZm9sf3FEfN+c84/NOY/mnH8iIv5RRPzS0z8sfmZE/N/nnHfmnN8RJ29aX/EvR8S3zDm/Zc65nXN+W0R8Z0T8C3tW73+fc/6ZOec2Th6I/6KI+E1zzhfnnB+Kkz+4XnlT/q/FycPsv3366eLvn3O+OyJ+dpz8AfB1c867c86/EhF/Pk4ecr/iT885/9bpw+5vipM/kCIi7sXJHys/MSLGnPN75pwfeI06//7TsX15j/b9uoj4o3PObzvtn/fNOf/Ra71onHzb/pdHxG+dc35izvmuiPjPIuJfuS/bu+ecf2jOeRwnHzp4a0S8ZY86AQAAAHRcpbOut51+k/vliPifIuLfnnP+vdNr/0ZE/PY553vnnHfi5MHtvzhO/onxXxURf3nO+SfmnPfmnB+dc37XAmcw24j4yWOMx+ecH5hz/sPXqP+fnXP+b6fnRLdfI+8viYgfmXP+Z3PO26f1+5uv2UMnflVE/Odzzh+cc74QEb81In7F+LE/Q/g755wvzzn/fpw8oM4ewt/vGyPiV59+g/0L4+RB9yedntV92+kZ4ofj5As6X3h6+TgibkXE548xbsw53zXnvP+ffH86Tj4k8AMR8WtP+/pnRsSnzjn/H6dnfj8YEX8ofvSs8Ksi4nfPOT8253xPnHyQAeDSeXgOsOttEfGe+/7/u5M8Xx8RPzki/ps550cfQp3+WJx8uvPnx8kfFvd7W+zW8d1x8onOt0XEs3POF1917RWfFRFfefrPXX389I+XL4iTPyL2cX8/fVZE3IiID9wX67+Ok2+TR5x8WjX7HaW3RcR7Th/Av7r+r/iR+/73S3HysD1OH7T/gTj5FPIHxxhfP8Z4ulHn11LV+bW8KSJuxo/t67JNc86XTv/nkw9QFgAAAMBZrtJZ1/tPv8n9dJw8LP3n77v2WRHxP913rvQ9cfLQ9i1Rn9E88BnM6XnZL4+Tb5l/YJz8ZOBPfI36P4xzpYjd8753R8Rh/NgvXqTnZZU551+Pk2/t//sR8edf/cWSMcabxxj//ek/zf58RPzxOP35xznn90fEb4qTDzR86DTf2+57+c+Ok39+/+vmnPM07bPi9MMS943pb7uvDfvMS4CHzsNzgF0fiJM3t694+/0XTz/R+l/Hyac1/y/jvt/LvkB/LCL+r3HyLfGXXnXt/XHyZvR+b4+I98VJW95w+s9Q3X/tFe+JiD8253zmvv+8bs75dXvWa973v98TJ/8s05vui/X0nPOfvO/65yYx3h8RnzlOf4vqVfV/7QrM+fvnnD8jIv7JOPnn2/+9pG5VnSNO/rh44r7//2n3/e+qzmfFj4j4SJx8K/7+cdm7TQAAAAALunJnXaffLP8tEfFPjTF+2Wnye+Lkn1C//5zqsTnn+6I+oznXGcyc8y/NOb8kTr5I8o/i5JvREfufK70Yy58rReye9709Tv4Z9A++xuteyx+PiH8ndv9ly4iTf5FgRsRPmXM+HSf/YuUnf2Lw9F8h+ILTes2I+E/ue+23nr7+nWOMVx6OvycifuhV4/nUnPOVf/HyzHkJcFk8PAfY9c0R8RvHGJ8xxnhDRHztq67/ttP//lcj4vdExDee/pHxmsYYB2OMx+Lkk6KbMcZjp7/5faY55w/FyT+T9NuTy98SEf/E6W9QHY4xfnlEfH6cfIL03XHyz7D/zjHGzTHGF0TE/b///cfj5J93/9JX6jbG+KIxxmfs055X1fEDcfJG+T8bYzx9+ttVnzvGeOWfd/rDEfHvjjF+xunvSn3eGOOzIuJvxskfGr95jHFjjPFFp3X871+rzDHGzxxj/KzTPnwxTn6/6fj08gfj5DehXst3RcSvPG3/l8WP/nNUERF/JCJ+7Rjji0/b8+n3fQK5jH/6T1N9c0T87jHGU6ft/LfjpL8BAAAAHqYrd9YVETHnvBsn/8T6f3Ca9F/FyVnKZ53G/tQxxlecXvumiPgFY4yvOj3/+pQxxk87zxnMGOMtY4wvP/3SyZ2IeCF+7LnSZ4wxbr5GmO+KiP/TGOOJ0w8d/Lr7rv35iPi0McZvGmPcOq3fz7ov/me/6ssk9/sTEfFvjTE+Z4zxZPzob6QfvVa7XsPvj4gviYjvSK49FSd98PExxqfHj35BJcYYP2GM8c+PMW7Fyfnby/GjfRUREXPO/zQi/rs4eYD+poj4WxHx/Bjjt4wxHj+dKz95jPEzT1/yzRHxW8cYbzg9i/wN52wbwCI8PAfY9Yci4i/FyW8F/d2I+NOvXBhj/Iw4eQP+q0/fnP8ncfJJy689vf6rxhhn/TbSvxInby7/YET8c6f/+w+dkf+T5px/fc75/iT9o3HyG0r/TkR8NCJ+c0T8kjnnR06z/MqI+FkR8bGI+B1x3ydLT39P6Cvi5I+kD8fJJ0L/vXjw+8OvjpN/Kuu7I+LZiPhTcfpPwM85/4eI+N1x8ib6E3Hyu0pvPP1D6cvj5PfSPxIR/5846d/X/G3xOPknvv7QaVnvjpP2/57Ta38kTn6H6eNjjD9zRox/M04e1n88Tn5P6pN555x/KyJ+bZz8dvtzEfFX40c/9fv74uR3t54dY2S/yfQb4uSB/g9GxF8/bfcf3aNNAAAAAEu6kmddp/5oRLx9jPFL4+Ss5c9FxLeOMT4REf/fODnTijnnD0fEvxAn518fi5OH1q/8xveDnsFsTuO9/zTmF8bJv/wYEfFXIuIfRsSPjDE+kr88Ik7OjO7GycPwb4iTh/xxWudPxMmD6l8aJ//E+vfFyU8yRpz8xnxExEfHGH83iftH4+RfovyOiPihOHlgfe6Hy6e/L/7O+/5p9fv9zoj46XFyBvYX4r55Eie/d/51cXJ29yNx8jONv+3VAeac/1GcnK395Yh4fZy0/aedtuEjcfLlmtffV967T699a5y0F+DSjXyPBAAAAAAAAID18M1zAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbvwh6ejzG+bIzxvWOM7x9jfO1FlQMAAAAAl8UZGAAAPDrGnHP5oGMcRMQ/jogviYj3RsTfjoh/ac753Vn+zY0xNzcXr8aDGUV60k1ze6E1uVCj+thE1f6HrF+N4hVXpD3zeKFAjWaWK7u4MNp9df7O7Zd5gYp+yZIvut6bw6SAhbbqOkza0lbsevusSu3E73VAHXn3yvZ4+fvgw7LMLXyZ9nfqsjloxu5lb1liOS9Vv4vcWjr3oSVW7FlxOrHHQnPlMm43V/59YtFZRy/Pj8w5P/XhVgYArq/uGVjE9T0HO37pQmtyoQ6eKC5ckXOJR+0c7OiF6/t3Ng/frdcnf/g5B1ukLtmVO88vdVDNvm482ZtbzsHO7941vQ8tNVcu4+3Ade3zOWfaXYcXVN4/ExHfP+f8wYiIMcZ/HxFfERH5w/ObEU/95P2Hc4nD2DJ244+Ge59olrnI+9plpv3hk3kvjsZTwTprfqHMn1zo92Gvc9O6NLu2ak9WlzvP5f1dHaxvDqo+LNKz2HnoiG0x9pv8ExUH2YPciDMWSxK76qtNr51Zo7pzpXrAN4t+yd7wbor6dW9WVZ8/8cbdPxrKejfvSeUb+DRQc3cq+/wS/mhoTIyXn+390VC2p7s/NWJX7dkW8zYPXsQoyqzq0llDVYxbz/T+4ZvePF9orqR7XLVPdFV73/7rsPshnrvFfShTTvFmodW+mjWpin3j6V7vLvNHQ6/PN0X+O89f3B8N1f0z64FynyiSP/L37rz7wWoFAKvVOgOLuL7nYM/9ret5KBpR97dzsP11zsF+5K/e7QVn1d7+BU/tpDkHu7hzsB/4X55rxeb83vQzbrXyOwfL8vZKfP+33+694Ip408/ofbryKp2DvffbX26VetVd1D/b/ukR8Z77/v97T9MAAAAA4FHhDAwAAB4hF/XN89f8mMoY42si4msiIsZV+aeqAAAAAGB/e31VyzkYAABcDxf1zfP3RsRn3vf/PyMi3n9/hjnn18853zHnfMfmoh7hAwAAAMDFec0zsAjnYAAAcF1c1Nv1vx0RP36M8TkR8b6I+BUR8SvPesF5fzWp+9tAVYHpzywUcbq/s9D53dulVL/dVP1UZvbTFt16t38DqhO8+VvDneh1iN5vPmR9XvZJ8fGV6ndiR/Fb6On8LIqMg7zQMn9nTVRZy99q3/+3zbvK34bpzqEke/+3RIrfSN/mP3o/ZzZG1dhXv93UW28zG6P270hVmhtxQz1vG2ul2BDL32tuyn5vuHv/6P5mcfU75mmI5m+b1zfQRozuj5SVzn9fXawqDaMx9/stbP/K5W6E8k1CsybV2ko6vZqH3d9ZX+KdVn2bKNrTiLPA25WT2MeN35Nv/h4mANDWPgOLuJ7nYNfZpnhf6Rwsu3D+czDoyP8edA7Widw5B+MSOAdr5O1Hf5Rc53OwR82FPDyfcx6NMX59RPyliDiIiD865/yHF1EWAAAAAFwGZ2AAAPBoubB/KGrO+S0R8S0XFR8AAAAALpszMAAAeHRc1G+eAwAAAAAAAMC14eE5AAAAAAAAAKvn4TkAAAAAAAAAq3dhv3m+hHGVgs8kxCiCJHkvT16Zquoj6ZiqOVWMunPzSHMm+cv6VZGLdvYrv7dy/BuhN8XHV9I+iYi5Ldp5sJu/ql9dvQXmc7Nb58yDbzb7B+q2c7utLlRrpdOoYtyKTqzamY3zLCbzKOZKNfmrPu+oQlzonl0oW9PYhrbH+aSo+qo3JyIOkvVZ9WFVZj//xd2IZrGG8nme16NYbqXs3nRyYf8yy3lbjOdMGtod+yWUt7HuCxqRuvfa6p7au98U660MUY1bWejeRrV/Vu0v9uG0it25X7WznOeNAq7U+1UAIOLqn4NdZ87BrsY5GGScg+1viXMwHr5tcx46B9vVPwe7nq7zOdijxjfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFi9w8uuwCsu7Cfmi9+0j9H7sfuZBapil5qtzLIXZY4idFXF2alLM3YduVFmNTz7R3iN+EmkohPLWpcdsPuKObdV5jx1U5S6zQvNmlNVcBTt3FSTqNDMnjrY9D6/02hmOXBV+0dRlW3eub0yiwtV6G02zmWHL7YqktBVg5oLtDNXlogREbPq3E53devSKHJWa3mh8UzneTXfir4q+7DR/mq9Ve1vz/Ml3jyUXX7+4O0IWV2K9Tar9Vncb+qZdf73N9WWUO/DSZHl+6/mm5BFNO+HnSsL7WXV2spjlFd6lQEAFnUtz8GuMedgD/ccDDqcg50zRix0DsaFcQ5WuMBzsOvqep+DPVp88xwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDVO7zsCrxinvP1o4wwigKL9EZNZrPSoyqyLKCZPyuzCl3ETvux6qsqeJm90bdFkHYfdvIv0N8ncbJAzYqXA7R/v1QhttWFTZ6+2eRllnESVeurGGVvJQ0d1aSoln5z4abxy/VTlFnGri5keZt73CVoj2fDKPahWfTu+Xf4M+ZWc684Pt4mIYog3WFurPNq7rfbeaFTrru4kj2hF7mW7qu9PlykC8uKN+dQFaVxz6rnba9fWvfyBd6vdXVLvLia1PfyOXf3lYgz1nMW40EqBAAs5jqeg11nzsHSQpfRPSCFV3MOthvjEs7BuAzOwfYOstA52JXXbf8CrtI52FXim+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACs3uFlVyAiIkbEGEn6zLNnybPIGyO/MCIrMIqKRJ67CFErK7l3clVk2f6yKvkLZlpm0YdFX1XtLFufxNmUfdvu9CLKbpxyThTKLk86serDKrns28b8HNVHY6qqNOfQyAapHuSiKs01kVRy2+zbbvZOx8xsAUXEppjQVfs3SX/V9SvS22toN1Dd8irGNo9c9EsaprmXV7pbYse2mhPVvtqIPcvYzfx55k5yOT+roUj3rTJvnl6p6pjHWebe1Bm4ahyq+0q59yUNat/1qv125uszq2O9N1dFNtt5gQu0M1eayy1Gcx9a5j1L9z1YlneBagAAy7qu52AX+pfWBXMOtlfaWTrnYNDhHCzLe3XOwTi/zt/wEc7BWlZ+6HG1zsEeLb55DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOodXnYFXrE52H2OP7fbPPN27uYdReDdrCdGeWHv9M3I885ZxC7Sx0ERp9HOoiq1Kk4jb9XMTbMuefYqNS+0Gs0qTpZ//5E/+8pI0kezU6r2VJ926cZPYzTHuTPnquWW9dXphXOXWQYpOrGq40xGYxZbUzVyyVI+KbPTnnqS59nL/J1AVafsv64i6nXbqcosN/nyFUXybpxyz+6qBjSbAOdfsmeXmbapd88a5QQt9uFqondidOd52qaLG89sP4iIGEXFy3v2A1fqwZX7bbInjvZ6K1R7ZTa3qqlc9XkVukjP5nn3rWO9leWRtsmaKJdVmd58r5mG2P/9CgDw8FzHc7DF3mtfBudge+Zc5hwMzs052P6Zzwq+1N/3nJNzMPZznc/BHjW+eQ4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqHV52BSIixog4PBg76UdzNy0iYpslb2ead+bJEXnoiCL/GLsXqtizCDJGXugs6l4Ez1XtqZT5swuN+sUD9HkepVdmEbwqcqRXitxVcpm+e6E7PA/yir0jbIor5dzfv4S6T6oYSyjGvrnGq3Wbxk/2g5OczboU+fO6VHlz5TosXpHm7y2JUrlXJoGqT3TV41O+YO845d5cd2IRvFpEaUXyrEVdtmUnFuOZpnX38t69LCu1ilHO2z3q9WNsk7T2/bCcLI3QvfVZxkleULwVOkNjHhbJZZnNARrF/SadQ8311l2ead9WeYv212/X9u/zbogHWBVJiAViAACLuq7nYNeac7D9cy9wDgYdzsGSvBd4DsbD5xyscJHnYI+Ya3EO9ojxzXMAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVm/M9i/NL+/mUwfz037akzvpH3/uhTT/8dF2J22zKX7Vvvi1+6rdVZTMwW6VzzSqri4KTZNHJ3N9YcT+lamKbIQ4M04WZpQNqsatyF/Mi03azqKvio+YjPrCblq5zHrrr6zj3ol1jGqAypWV9O2mitGcRPV0Tq4Use98/DgvsTkWaf7m3F9CtWfV6b049RilUdLUx95w2IjRVTWolVyMZ9GHRYzRzN9Z5rM5ue48t/88L+/3S83nRpndtx6d+dl9X9OZ+jee7nVKuX+21lvPbL9NSPbyKnZZ6Nl12ssC8+3s/MkLmmWWU6uxJ5RFFu9XyvytfaWSR/+Rv3b778w537F/CQBA1xjlCdGV9vp/pvl+2DnY3mGcg1WhnYPtlRYRP/AtH6+icEE+6xc+dYHRnYNl3ve/vrR/cM7tzV9ws5XfOViDc7A0+WGfg33k792Je5/YpsX65jkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACrd3jZFYiIOD7axsee/cTe+W/e3K320b3jPPN40Fq9dqDNZqY5Z558Rl3yC1nqbMYoVYE6YbohijJHq+pVofv3YURENURpjKLec+RR8uSqfr1OrPtq98Ko+qQssrpQtLOqSqZYFFUdqzJbWcsQvQW6ST5itN0WMarFX7RzlpvF/so+rNrZKPL4eFuU+fDrskBXRURvXy3nVrOZWbfM5jwss1dlpvUo5mERpKxhEWc78/mSB+nFLrs8mRibTbXeqsq07gh5anuydIrsxag/Fbl/O7vLrapiK075BmepxZ8uxEXKnGUHJHGqOX7+bbJWL6AlogMAK5L9fRzhHMw52P41cQ52gedgPHTOwYrsF3kOxkPmHCzjHGwd52C+eQ4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqHV52BV4xkrSDw4M079HRdidtZgEi4mCTX9ge5/lnzDT98Sdu7saIu2neUdQlj9wz0p56kEBFbdLKV2V2YpxRlVaMvMy6yPxClr+uddHOKjmNvdC4FRO91+XduixQ93aI6gW76dW6mjO/UiTHqNZEVpcqRrHfdBd/J3vVzu22W2iSv2jO4Y18b66XbbEPZy1doNptjaE/yV9cKPNnBTz8udJW7XFlp2dtKvbsssxi3VYlJpOuuo9neU/yV2PR6N3unOjcV7vzs1TcP/arxWneqp1Fn5e3z4XuiefVfXuzSKHVHN9/fNrRq3V1RYYBALg+qveDzsGcg+3Gdg62zAv2Pwfj4XMOVuW/uHMwrgjnYJ1k52Bp6tU/B/PNcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbv8LIrEBExRsTB4cFO+mYz0vxHMXdjRJ53u93N+yBuv3R3J+3G03mZRVUiqfaZ2S9Wp9RuH1b5lyiziFFmP39d6ghVXZL5WRVXTqHm3Fqgb9vtLBuVxJ4LzfJkPOsu6S3EZNhO07evWa1P5t1227n/HJpFBav0g03vs1H3jo520g6TffmsMqsu76zCKm81PrVOqc250iwyvw0tE7vb55281Ti3LHaDywO1qrjALXs0B6KOXayhIn8VJU9t1iWre3Po6z2+3Fj3j92rSt2H6YD2otfrc/+xGGXbixiNe22tiLHQe2QAYD2q95rOwZyD7eR1DrZ33jN1zsF46JyD5ckXeQ7Gw+UcrIjhHKzI/2idg/nmOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKt3eNkViIiYM+L4aLt74TB/tn+w2U2fc6Z5xxhp+vY4z39wkJe53e7mL8tMUyNGeaV8wa68yLrQKn91YSaBith1a7rtbOQvs7Yr2QjRbE87/xIhyoFOslYNzdPLKZfN/3Isiyhl9v07oJ7ijT6JiFF9lKixJspl1axLlr/ay/ryuhweHuxVj4iIW7dupOl1HfffuMp9tQix7exlRV3K0Un2/bOUubPKJ7e8s2Pn0TtTqzsPH+DGsn+MakC796xGkd33CXl6bx12ezx7wSz6ajT2yZM4efrI5nnVh60S6xekyfXNpkju3vfTzi1yNltazaFGammx930L1AUAWD3nYBXnYOfmHKy4sHdkLoFzsMIFnoPxsDkH6xXaSHYOlrtC52C+eQ4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6h1edgVekf0o/Xab/9r7PN4mqc0fuy9+G/44jR1xeHiwG2Lkeeu6tKrSzFxc6CWXdczz5lHq9nRaWsXujWevLs0gZfbWiOZm1c5GHavBrD4yM/IX1HMludKsdjnfyrrsBqq6qr3eOnGq4HWDqgupzSZrZ2d1Rmxnb3+qxihT7ZM3R35LKWveaNOs6lc1s7ObNfu2zr1Ae5pzqzNu5VrpNT96d5DmAm3Oz5GslW0xPyvlXpGU2d7Lmn2bzouqC5t7dllmYy+vLPGeoo7de39X34P379zufby+3+xeWaJPXome1qWYF3nmhaoCAKxG/feHc7BeqfvndQ7mHGwnhvfxV8YoBto5WJJzoXMwHi7nYDnnYFWJj9Y5mG+eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHqHl12BiIgxRty8uVuVzWak+e/cnruJM0k7Cd6uS2Zud+NXeStFDeuqVy84d+a6Mp0mNZtf5u+VWQUpX7F3ars9VaHNOEvEyOZQd352C03bX4SoZmd72qbx8yDt5heyOpbVrsosFnmz+XmR1Z7VDH50dLyTdnjjoFmZIrmoS6uK5SSqJl3V51n+JUYiol4AjfgLrP2T9P3LXGqt5H1blLlMkbFN7s31OiySi77K9/jqnlLdVKsy8/T8QndjbRa6wGAssoLKjaJ3r11iPNsaXd7ds8vhrKqS3bOWWnAAwOo5B+sV6RysFbzFORhXgnOwVl06IbgqnIN1qtLiHCwPfYXOwXzzHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKfNLMEkeadSTJs8jbtdlUZe6mZ/WIiJhpW6JoY30hSy1bWcbuWqYfc1UlkzKLalR93v0cSBqmrF6vT0Zj4OrI3XFICm22pyoxm/tnxcljN8b+LOXi2j9r1Z6qJrPRt7MotOyqTrdU+822V2ZVxxs3DnbStkXem7fyW8fcVmU20qu89YVcNW2zQovOam7ZZUPT+1P/RlEUuX+/1O3Jr1T3w4VWc09jD210yUmMco/L8haxm8PZ2MrKIKMYn/r+We7yjars/35lOc0B7UQpbxS92DF795U87wL3/arU1iYMAFCr3lM6B6s4B9sz+cwrOedgXD7nYA//HIyHyzmYc7A8+CN0DnZGv/rmOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKt3eNkViIiYMeP4eLuTvp0zzT82YzfGcZ63XZdtHmfGbvrd55rBx269u84f4TXiNwooszbbmeYuQtRl7s6fM8ts1bE3t7LQt15ffE5lVOmt5DOv7K0bIlmf7Sle5a/Wfpa1CFH1+TLztii1TK4u5GXeee54J63aD2eRXqnm/tjs9tem2A/v3LmXpt+6eZCm1zVMrpRzv5wsrTI7a7+6H9Rldsaiec9qjnN3XmS2ZfsLSdf29traLLf4/etY16ScLTspd54vKtKbnmW/bJPw9Z5V7JPFC249ne+J6VQpYtfrKk+v5mG6l/e21TN03sg0B66sTNFfSfyia+s+L7ehxj60zFtkAID46N84uuwqcE18+s9/PL/gHGzv2FX26u3953zp060ir9I52A996/ONulwd2+R5RoRzsE6MOrs/ZK+CD3zH7cuuwgN72xfm9yHnYI1SV34O5pvnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArN7hZVcgIiJmxHbO3fTjJK0wRhF6/xDtAmYRvKhKxAJ1qUJU7S+1X5DFKNKLfimbn9WlGriyzCp0Z2LkeRfpqipIlVz1YREnS+3Wu+zy0Zm4eaHlvG0u0EVyl3OiSt69MMp2li0t0osyGw0dm6IuzTW0Pd7uZi3ybjYHeYy5G+PMQpP+mrM3PqUi/zYJvynnSrHHl3Ol0c4iZ615k0sGb1MMaDVXqvlczf/ONC/n5xL3yebSL9dzEqd9qy3S57bo2+QF5f2jil1uIJ09obrXdMdt/3tCea/pbqudMN351rx/5Gu/GeMC3zsCAMBFcQ5W5HYO9khxDnYJ52CwN+dge8eurPwczDfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFi9w8uuwCd1fsW9+I35Vtbyx+6LiiTpo4rRVZS5SPyynVX+vZIeqMxlemuZ2HnzG51yhjR3Ob+LC+0+3L0yi9hljGIeznoRJSF6ZZbd0lif7XVStbMVYltcyevSnVnV2HWMTR59u81jb5L8Nx7LbxFH947T9INysjT6vOjbcmvu9lUSaFvVrywzV7Y+m7dV3iK9Uk3/bF1U67MuswqeJ1f9tUTsTvD+lrB/7Nm8BxXLLcpez5KLjzmO5r1p2xqgai+v9rjuOsyCV3OitxDr9bl7pd6ymu+dKvkm14vR3SzSup//ngIAAC3OwfLYZeh1n4NdW8157hxs/9hwXs7BnIOdl2+eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHqHl12BBzL3SjrTmN1X7FePM8sczQtZclVmI8TZFy4qSDP8MqFbRjEOSzR/FgNXhaimZ1XHotAiSH5hVrVprJXFpkpjbc3mWq5zF2OU1L0bo869f8c0l349bMWFg4ODvdIiIo7ubfPQRZHVlc7Qlc1pviCfL+07SFFktXDPX2T7/rFnNc6qSme7qeJ35213G8r2xGpP6I7yptsBiSpEtfbT1Hy5xaz28qr9RZxc9aZigfdOhe5efkakRmovRj/37pXRvSEuMJ+rErcXN5wAAKycc7C9Q7xSmf2zruQc7DpwDnYJ52Cwp9k69HAOtkzuR+sczDfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWL3DB33hGOMzI+IbI+LTImIbEV8/5/x9Y4w3RsSfjIjPjoh3RcRXzTmffbBSZlV6Up9ehEbo17qQxM6Dz5nHqOqe1XGUmS9Qu6+K7NUYZe1sxqjLXKC/GuNzWuj+Wbt9W8yt7li0QlRFdpZEWWZz4SbZyy5ZaKlU8ReKvnfOemsqrmy3rfzbpKHb4zxGvZar9hTpSXJ7zy41XtBch6N4wRJ17y79lmLgNhfZnsa+f+aFIlA+54p7bVHx1n2ieT/o7k/p/XCp+15rnlfvY8pSG6n5hYveyyN9D9a8py6wKMp9stxvmi6jbwFgJR7OORg8GpyDVWU6B3uUOAc7f1Uu9ByMdXMOliUWhVYxyuD7V+Man4Od55vnRxHx78w5f1JE/OyI+L+NMT4/Ir42It455/zxEfHO0/8PAAAAANeVczAAAFiBB354Puf8wJzz757+709ExPdExKdHxFdExDecZvuGiPhl56wjAAAAAFwa52AAALAOi/zm+RjjsyPin46IvxkRb5lzfiDi5A+LiHjzEmUAAAAAwGVzDgYAAI+uB/7N81eMMZ6MiP8xIn7TnPP5fX87dIzxNRHxNRER48Z5awEAAAAAF2uJczAAAODqOtc3z8cYN+LkD4ZvmnP+6dPkD44x3np6/a0R8aHstXPOr59zvmPO+Y5xcJ5aAAAAAMDFWuoc7OHUFgAAeBAP/M3zcfLR2j8SEd8z5/zP77v05yLiqyPi607/+88+ePX2+/RuRMTsRtg/9Bkl5EGqTx1XdWzVYuZR9v2k82vJwhRFxlioLln20RygJVrf7sLiBWly0YdztGdunjsJ021Plb01b4sgdTOrydWofJG1WitLtLSuXdUBxZ5wget5bPIYx9u8zM3Bbv7j422a99694zT9xq32BNhNao9boZpaadZemeVMaUznqplV7Iu8f3Tzt+ZnYxxOymwGauQt+7bRzmoq9/u28f6mvAkvtMkvoBzPJW4sRZAqdvXepFVouSVUN5xuoEZVuiFa43yBkwIAHkEP5xwMHhHOwXoXVn4Odl1tizM252BJ1ks4B2PlnIM1yizSV34Odp5/tv3nRsS/EhH/vzHGd52m/bY4+WPhm8cYvy4ifjgivvIcZQAAAADAZXMOBgAAK/DAD8/nnH896kf1X/ygcQEAAADgKnEOBgAA63Cu3zwHAAAAAAAAgEeBh+cAAAAAAAAArJ6H5wAAAAAAAACs3gP/5vllGtUvTPWinDv3vNASqyDNKAsU2i2y6pdRXujFz2OcfzzrvIuMXK6cRM3OSj4GM4usdXuqFzRmepG1qkuVfxRl5qnd8emu3EaEqq9mbzxnkn8UczzLe5Yq/43D3dvB0fFxHmNbtbNVlZjJC+rRPP+41SUstMaLML0h6i2i7vinqm1l5J+vW6LMbOzPtEjftkKnwdv3/UXWbdX4qsxG6LaiPeXuXN6Ikhjd+/gCc6h5zxpLTLjKMttqfhtq3oMBAODCOAfLi1z5Odi11T2Tcw6W5S6SH7G5wjXlHOzCXINzMN88BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1Di+7Ag+k8yPwTaMRZ6Eiz4iflND9sfsqvVX5pTq3SO50emHOvKFld2VlVn1VXyh0JlGz7UX2mdRxzKrDixij2YdFemqbRxlFmfV03o1T9uBia2X/DaeYhvUwN9ZnNcer9Mrc5vlv3tq9Hbz87J1e7GWmc6/Mbv60v4oo3QZ1xrNbZrdvk0lXlZneaxZStrNSLJZ6q9yN31wSvRp2F3m3MgvscfWesP84z+bcr+7j9fg32tlen/v3eX3b792buveElu58zqqyyHtBAABYgHOwVuzVnINdU87BivRLOAeD83AOtuJzsDOG3jfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWL3Dy67AAxlJ2qzyZpnPUMbZP0SdtVmXJHsVYRYX2nXpVHGBvqrCVCEOn+oVOsr0/ZVTqLgwkvR7z+f17k7bOj27sM3zVn1SBL/5+uaApsGb7e+kF5nvfryK3jNnFqdb817+rM/TapwRox61/DNTt7cv76TdeDrPm/dJxO1nj/O6FJXJwhwc9Obn9jivy3abz//NZrdNh08tMMcjWsPfnimtRRExk0jdVlbjXM3Fzu328Kmy0P2DRNQd1snc6NxqHlah27fJJbbboo7drs2DN/NXb07Ol/WkKv0JvXeM/jSsXrCbXq+fXoM62cvmLHObBADgAr35n7tRXLna52Dv//bdM4br4rO+5MnzB7mEc7B3/6UXXqNSV9fbv+R1O2ndv8vaf04nL9hWf9sXlXnfO1/qlnolvPWLHlsm0GWcg11Tn/oFxV7e/bv8oZ+D9UJfzjlYURfnYHvHWPU52Blt981zAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVu/wsitwprFE3tl7QafMZUosLdL8BZSxq49eVB2wgDGK2izQ6WXWqsxG8LJ6iw3c/p1e5pzFlW6fZyH2z/qQAnWKTApt1qPq2hj5hazM7rJqL8PkBbOoeHu5FS/YbJJ2FnmrupRbeTFvszh13jz2Mnr3oCXGs1rLVd9W/dLat8pm9lo0F1n73SBZHXs3vvq+UoXZvVD2VTWeVZkLbNr1uDX7doFJVO4JnTj1DbFVl/Y4dyzx5rF5DwIA4Oq4rudg11r599r5Q7StuMuvwznYdVVuK9f5HOyKa59IOQdLYjgHaxaaBKnyrvgc7IzyfPMcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1Tu87Aqcae6fPMaF1uRSzKShF93OVvhifLrRs9SqnWX9NsWVoo55/G7n5sFnEueix22JuTLLBZenj6Sd9ZRoDUQtXfxF1qLeldGoS5WzuySyPjytTJK3mG/tdVjN2/PH6C6hbIzqPmnGblwoy+z2VXssFojRyN9dE4usoSpEc5MfZZwkraj3XGrh7l2ROrkOs1uZhZZ4uyot7eD7b+blsFVzqDNvy6xFXXpvNVoxlrLIdAYA4Mq4rudg19o1PQe71q7rOdg1da3Pwa4r52BFfudg+4Z2Dpa7yC3EN88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYvcPLrsBZxrjI4BcYe6ngF1rHmafOpNCiHt3qdcZz5tWrSy3znz97exiSylfllbEXGPu6jfmVURS6zeZERMTYjZMknZbYa1A5V+qJsXfWKvZszIptM3atsQ7bc7z5gkS3PVX+7TZP32x2X1CXWczPIng5hfZMi4iY5WQ5f9+WLjJ2V3Pjmlndy859kAplYbJAFzhuZYylbthZnGU6q7MPj/5d69yqMsvWd+dWeoPqvcHpj0Snv5rt74Up8l6h/QYAgML1PAe7zq7rOdh1ljbzGpyDXVfOwS6Bc7BGHOdgrQvOwRp5G2fX4ZvnAAAAAAAAAODhOQAAAAAAAAB4eA4AAAAAAADA6nl4DgAAAAAAAMDqHV52BV6R/ZR89vvtVd7Wb9FH1D8E343TCbFA7OWqvf8r6vYs0KBLMpYYjFZ5TUsMdBWjyj6qFxTpWfJCc6Jc+0n4Tt6zC23m78Qo6lIXuXulW72q+XUVd18xi9yj6NwqfVN8TKs1RsVAV2WWHbBN+rY7iRaYXFWRVcXr/Puvz247y1Y2JmM1h9q7YhkmfffQLLOxx13KRw5749PZV8pIxZxovS9rFlnP8XOHrq8sdnPu6BV6kXv5Im9MAQC4Fh72Odj1dj3Pwa6363kOdl1d73OwlXAOtmeqczDnYBd3Duab5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKze4WVX4BXzIZc3qgtVRcoXnDPvYpqFXkodG6r6VeNTfAzkUpp5kZN55sGz1FG1vtu3DbOo3xgLjUQSvoxclFlVpah6WmjVt+2urQvdjV3Vu4xdxCkL2LsqZdaxya9sj7Z5/qRR2201h4oyu3OrkX8UnThndz5n+XsD1F5ByQvKvuqu/c5c6fZVt6Fp3S9w5y/fIyzx5qGn6tpyH2rUfVZ73FLNSepS1W9UfdtLzoeo3aBFJugi6imXdW4V5WG/+wYAoG3t52BX3JU6B3vEXIdzsEfNtT4Hu66cg+3NOVgr2TlYqlc/3zwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Q4vuwKLmUX6qLLnLxijeME58z6IXvReB1xkzduxkxeUMYqPe4wLbVFXNhbN+pXzdv8iqzleB2lVpch8seMwG+G7NamqPkY26ZqdWC7PYn1udtNnEWNs8wuz7IGqMvu3aRaVmds8/yZpz0mc3bTuvlr1Synbb5pldqd52s4qby/0IjtfZ12dGScdzzxvld5ufxan3Pq60dMSi/Sq0Grhnr/M0d1X6hfsW2St+R5skSDNxZ/N806XnHWhnBWN+VkuxLIujfYvteEAAPDwXdtzsOvrup6DXWfX9RzsurrO52DXlXOw85fpHMw52N4W2nB88xwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDVO7zsCnzSTNLGubOeof+KnXrMrCYPUOLYvy5ViedvTV+7zMYL6nbmQarQs1XLvNR+OxcYjd7UirFEmYVyLJYosjmhR5K/CtFen1WD0g2nylvMoWZfZXUZRextEbw7PDNpaH/P2uaxi6HI0uuurfo2f0E5+mmcZdZPOeUaUzGb42eF6Mzybh/WgRoXZhW7u5d3whTtLOuyf+yx6Q1Qt8h0dhbjNsu1X1SmtVecv69OdPqrWMtV+8vKNAajutcUkdt7eRqp2Z7m+4Esf1nvC3zvAADAMlZzDnaFXNdzsOvs+p6DrdtlnINdX87B9g3jHMw5WMt5z8HOaKNvngMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweoeXXYGIiHEQcePp8wbpZi9+eb74NfmRpnd/vb5y/jhj9jrg6MUiTiPGnHm9876Kspl59iJG9XGPosxN2aDkQpW3N1ViJIE2r6/q0Sqy1OnCKj2r91m1memc27bKLDux7IFs3PIYt57prOUidh2+CNGMXTRzJu2f1d7UnC11z+6/Jqp6j2rBFdMiDdSMXe1D9brdjXP3E70+rEZ5u13qnrCraudjz+z/GbiLq12tu8Kr4azmeZq/ugU1O6Ca53nmKrm8kNpka78stLgHF8HvPFctxL1Dn/EmoTfS9T68v3Lt16/YrUe/0Fb2W8n6rPfyqsxWcnohu6ecHQQAuGgHr4t4+p865/dZ2udg1YXLOAc7v/ocLE//yN+4d3GVuUjX9BzsM/75J6qKdIosOQfb9Vm/8HVFkRd5Dta78Kidg11X7/9fX77sKjywt33RY3vndQ5WFFp41M7BfuQ77pSRuBhv/Xm76/PKn4OdMe998xwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDVO7zsCnzSSNLm/nmzl3eLW0odO7/SaGa74t12ZnUZC3VW1c78Qp57bosom+bnQNKGljXMQzSyj2Ikqq5td3lnTbQm3BlFNiZou8hi0mWpVd/OhTaF1proTaHYVi/oTa5zhyhV1Wvm73TMLCpejXMVelRzqHGvKeftpohd1L0zFlX72/mX2rjTMosik7RtEWMUvVuNW7Wgs+zd/WZW95tGjOpKexiSF1Tzqrtpl32bmMX9sFyHdanN/Eldmu2/yPd33eBzJivgAtfmaal7JUUsdJ8AAB6cc7D9cl/wOdhVN7fFX1XOwfaP4RysVRnnYHsncwmcgyVZyzKL0Cs5B+Phe9TOwXzzHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKfNI8Z97RLK7IX4ZplDmrtoz8wigCpamjV/Eqdq/DK3nssvmdyFV7qgtVqdVAZ/mLgZvtybXdSRqb6nMqzdidalQXqj4sXlBmz/qryFy1smx9p47NtVzNoda8bS6fWbyg2itGkr/K21/JjVc011s6J+KMPbFhbsvO6sXJln7Rnmr/rOrSaX935dd7XyEptL2XNXXGuc7aG4v0vtq8CZWxGw0axf19kT2+Pfbd+ElSce/sVqVu//57XD32zZo0Kl+t5fben+ZvzvFmoVnuWczPJfZmAOAcnIPtF36xc7DryTlYoxrVBedge4cu4zgHa5fKQ+YcLAvSi72WczAuzKN2Duab5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKze4WVX4BVzzp20MUYjQJFehSjyV2EitntnLqs9iwutjzDkMaoiO134IPnzIN3s+7+gmhP1uFWBslf0+racQ1kdy7z5hU6ftCVr7UGyp0PRynzGuFVh0iKLPizWVbP5+bJtT7gqeB4o2W3OiFGkF3OrlIxROQubG8XYFPmT9lfjM6uGVp1VbopFeiPv9jgvdFtUfrPIxpprjXJzfS42zztVqfKXe2WStv90O8lftTObt+2KL5J9GUWhaX/Vb2Rayb03Z9VevlRvNe773fYvMKLlHreAUb3/7N4nAIBFOQfb18Weg111zsEW4BysxTnYfnm5HM7BkjTnYFxD1+EczDfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWL3Dy65ARETMiDmT9JFnL5KXq8w5887iMwllvdPGV68o8hbB57zI3srrMpojNJM4Y+QxtsfbPEiRv55DuxeqWs8idtnK5EI1xGWZZejOXOnFmA9Qm711Q5Qdtn+Zs5gq9bxdQFHtzq7SDt6ueOcF3U24t1aOk3Gu1ng1Jar0TfXRsKQym4Niv9kWdalCF/Oz3OLTINWFYt6OvKGzU2irgmVVctUUqtrZnc+NutTTtpi3jb28u8iz+97JhU4HLLA3N2P3279/x5RzonkDrdZhVpX2rakR+6Qu+5fZtkigi31HDQCcwTlYceGqn4M9fM7BnIPtXaRzsMJFnoPxsNVnb87B9g7tHIwL8qidg/nmOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACrd3jZFYiIiJH/mHzM4lfgk8zV78X3fgL+LI1IjXqfZC9ijyTOtiiyCDGrurSS8+BVj1RlVlXZbNLBT/MeH+cdkMeImCP/fMgmSR7F+JQjXw1bFqc5DunYn5U9vVLVvGpn0YdFqVmTii5s1vvkyv51KSd/Hrlah+Xs33/tV62pxrN6QWcmVlOrnJ9F9ixMc3q25kqZ3l2HZS3z9E22+Mstu9NbZ7Vz90IVujPfTl/QiFPO0FR3bqVZF7oJ92reG7dW5N52U2strt5e3m1+p8S+/etYdkmzMuX7njR2b1+tYnfWbf3eae8Qi1lqfQIAD8A5WJH/As/BrinnYFVVnIPtZnYO1khe5ByMS+AcLCt1kShp5Ot8DsaVcOXPwc6YP755DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOodXnYFPmnslXRqni/wA8iizCL0aJdZtCdLHnneuc3LrHpqu82vbI9300fRnFkEPz7apuk3bhyk6ZubeXqa92CZvs3qnte6nkFjND57Ula7GqFmO7PJuMzUL+OkU7FsTmOOn5m/0c5mn49ioqfLsKp4EaPcExp1rNZbe6q0L+yftTvlsu4am2Icig7YFOuwipOVWcWu+ryaK51pUe3BrdtbEbubuWp/GbvRL925UtalUZVyfS6hXMq9OVQvlgU27uLNyaj21cYkKnNWt8Oq/WXHZIXuv5a7yjVetqdYQ4313J2ddf7G5KrfyDRrAwAsyjnYfskLnYNdV87BqjDOwfZOdw7WvHCurFww52BZXudgXBGP2DmYb54DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweoeXXYFXjEbemb1+5BFmljkiiux1mVn+InaaN85oY7MuqeJjEJsi+OYgTz+8kaRX7Sk68fBmUZmqv5JBOrx5kMd+YpumH93Lg2+Pi0LTML3JMqv829385XwrJkt3DmV1qfPWVzqVKXJfrP2n54UuuG7bu/nTGhaTqBzNstD8Qp6/mhOt5DOW1v5rZZsv/TJ/1S/HR7uByvvEpohSd+7eNlXspqomrej1BtXKn96bO/U48xV5XUa1WS5QZDbM5ZQob5St5CWmVr0mGuO2XOxiv0l6oPu+rCvt26LDq/2mXWbjvWMdpLrQfbN5rqwAwAVwDnZOzXOw6+rWE/nRrXMw52ALXNibc7AqNg+bczDnYDuxH63b/rX2qJ2D+eY5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq3d43gBjjIOI+M6IeN+c85eMMd4YEX8yIj47It4VEV8153z2teLMGLuxqzL3TDv7whJ6wccClSz7pLgwNvmFW8/sX0K3zM3hTNMPDvMXjIOD3RhF8O1xnl40s/x4SFbDer4VV/JmxmxFr8rMg1d1WaLMojlllCz/Up/GKfs8z7yIsv0zuVIv5lbsyp3n9o8ys/pFtPtle7wbZ3OQBzk+3qbpjz+T31KqOubztlDGqLIX+9DcnaVlH5bOP+nKdVXt5c05l8/RvJ2bqvnlxppLu7Hs2t4eV625RjPPmG9VmbtJd54vQjRVXduZivXS762VNEZn448HWONJcvY+MGK593dZm5rTs3dDjIijF5Ks3T7Mt9vSyG7E5YA2gwMAi52BRTgHO2+J3XOwt3zhzb1L6J+D5Rfqc7DdN231OVj+ns05mHOw87pK52Dv+ksvNl9xNbz9S55M06/SOViW3D8HOz/nYNfzHOz9336niAG7PvjX7l52FRa1xD3+34yI77nv/39tRLxzzvnjI+Kdp/8fAAAAAK4zZ2AAAPCIO9fD8zHGZ0TEL46IP3xf8ldExDec/u9viIhfdp4yAAAAAOAyOQMDAIB1OO83z39vRPzm+LH/7uNb5pwfiIg4/e83n7MMAAAAALhMvzecgQEAwCPvgR+ejzF+SUR8aM75dx7w9V8zxvjOMcZ3bu89aC0AAAAA4OKc9wzsNIZzMAAAuAYOz/HanxsRXz7G+Bci4rGIeHqM8ccj4oNjjLfOOT8wxnhrRHwoe/Gc8+sj4usjIg6fHPMc9QAAAACAi3KuM7AI52AAAHBdPPDD8znnb42I3xoRMcb4ooj4d+ec//IY4/8VEV8dEV93+t9/dp94Y4y9y94/Zz9IHTu5Uv2tUwbJL1RtT1Or2FWMql/n/nUv/6IrLmyP8gtzmyZHjOOqhN0YVb2rSs79Z0u3nWXoJH85vat52FgPJ2E6+RvzLSKqDmjNz3Lut7LnqqlcDVCzzJlVcpmlX5pJAdUYj02evt1W6zBfiJuD3X+IZLPp/uMk1Th3FlFR784+2Vat/mWid9ZKvfSb7c9uWf2J2JMulWbfNpdtdksY5bRt7qtJ7E1zb67uWWWvNOKX98PGvakdu70mGpUp21NtznnytoiT7jbNOd7t2nR+dm8Um+b7nv0jn1UZAOBVlj4DO42zd/nOwdIgrdjOwfYP4RzMOdjeZRahFzpOuQacg+0dxTnYEskP/RwM1uy8v3me+bqI+JIxxvdFxJec/n8AAAAAeJQ4AwMAgEfMef7Z9k+ac357RHz76f/+aER88RJxAQAAAOCqcAYGAACPtov45jkAAAAAAAAAXCsengMAAAAAAACweov8s+1LGDGS1HlxBRah58jqEWntKnlbHkAnzEJdNeduoFH1VRWjqve2fEVSjyJrYVTjVtQlG6MqRjUOo6hk3v7evKraX86tdJAWmoeFvLt649CvYvKC1jicEbl8wf59W07bckJX8yKbn0XoKnKRf3NwUMTZjXRwmH++ant3WxRabqx5eqNv6027yF7Oxf3LrPaE3mguozvOS9xA6vYX+dOubY5npZhDWfh+l5Qb7t4xsnvn2WVWNUnuwUWQzaYYn25dkvxViCp2VZfa/u/5ZvneYf/IZfTuNOxlz2Ms9P6mWod5mcWaveD3CQDA2ZyDnbNQ52BFepHfOdi5OQfbL+fJhcs4ObkEzsEujHOwK3IOBivmm+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACs3uFlV+AVY8ydtN2U17rQKbBKroJnLyiD9AotzO25Q0TVWXMW7RyNArohyq7dfUEVo6p2papKGr8azlaQSCtZdklVZnfyZ8lFkPbwtOd5Q9UB5eRK0rsNKquyf99m+9XZepXcbncX/6azNs8osbqwPdot83gc53mPs80pYhSfxyr7Nsu70CKv9vIs/Kj6tkiv7xOFRvZ66RftKTtg/32oulKN2yjWbZY8uvea9rrdP2+9Jor2dOdiQ72vNtbKdpn6pWuiylze9np1ydZcGaKcQt09cf+GduvScZHz6iT+blqzqwCAh8Q52C7nYEkI52D7JzsHa1bl6pyDXVf1PHcOdu6szsH2LrNylc7B4DryzXMAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABW7/CyK/CKOR92gVXySNNHnpzH2ObpY+SFVk1Py5xFRYrY26IuValpmKLxdZ9UdSySk/TNJs88q3pXwcv0PStywYphu1CzOYfKPk+SR7cPqw5o9Eudtar3AuNcVbs39VtzbltskvXcz81iU8jG7ujecZr3xq381lE2p9zk9s9b3iOqedsajKpvi0LLdhb7VlbH5tqvu7C4st2tS9kl5Tqs9uGqLoliL+9K+zDy4W/V76wXJK+YxQ1+bpsD2pie1R5cKXNX0zl/s9EL3p3PyYIu7x/lGu8VOrK5uNCbzzpMo51l7Kr9ef50NMt9tXyTCAA8BM7B9izTOVgR2jnYvpyDXc9zsOvAOZhzsB2P2DkYrJlvngMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6h5ddgQczG3lHL/SoYmdxOnkjZi97Eb4IMnvtHFWhWXK3C8sL+ZUseRZRurHL7EmkanjK2VYNRZZeVG+RKVG8oJ7K+YVmF6aFdtvTCF1fKAot+7Ax9UtljG7wap535mc1EVtFxkgmwNzmQW7czG8dY3OcV2Vb1CVbLFVfNQe0nM/ZWqlCL7T5lfNiAVU7O3fJeqpUi6vRnmrfL+ty/nvcYr2dzM+yftVHEbub4mb3Qtme6k1FeW/aP3/73lTNw6LMbL8p75OdyRxnrIluoAVipHt5sa8u1f78reMCaxkAuGTOwXaTnYN1OAdLkp2D7e+Cz8Guq5H8DR/hHMw5WBa7qsvVPgeDNfPNcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbv8LIr8EmjkXcmmecCcdtxiuDdMvsvuDCtmoxl2p91+dxuFylyFC+YWanZvDrNvX/qWRd2tUe+EbsfOq/NqAptVL6MPZsLdyT5e8NWqqqSTaElqh1RzMNe6DMKXSJ7nnr7pbtp+uOPH/Tq0hmj7h5fxk5eUPZJs28b7ZnFpKjmSrWXlfMiu7DU/rHE/bZq/1ILuhGi2vrT5CpGNW6b89/fq/vetqxL756V7UPVOHRiRNR1z4P0xrh1fz+5kMTYO+vZZS7x3rHqw1bu/EpZvWafAwALcw52JTgHy3Pvn3rWhV3OwZyDPVKaZ2/OwZLQzsGahTYscQ4GK+ab5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACs3uFlV+AVI8ZO2pyzEyBVxcjKi4gYjY8TjKLMqjJVa0Z5Yf+6LGUmhW66FSnbs82zzyR+Y+jPzF5cyFo0i8xV6zvD32xOf+iTeV4OQzFxy3aWEz1Zs3vnfO0rqaSAMkK306swnTKLQmfVh0vUcaF9IqtKVe3NQbHHVe0pLmRrropRrc/It5Xyo2FpzYt21mu8+4Ik60Lzc4mpVd0nq7EY5caa76x58Neu16tLPW+Rsan2vsbOVdzHqhjVOG+r9ybpQsxjxHaZG2X6fqia4uXUr8an2CuSunfe8kWcsSdUsnvzUuuwupDGL8a+6quqz8t1u/uC3poFAB4W52B7h7lQzsH2y3tWunOw/WM7B3uQGl1dzsGqFyRZnYM1XZFzMFgx3zwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Q4vuwKvmDH3zzzSAHnWkWWOKJKL4Hmcu8/nhY6yMkWRVdPLOp4ra0RE3Hhq/8qU1Zt5jCI5RtW3eydGOXDN4YzZmG4xegOUVrEssNeHnYaW87Bt/9nVnYe1/ete5bz98eM0vV/H5BXlHC/Si3lb73vZePbKLBV1OTra7a+Dg/33w4iI2Zzn6VIp1lu5fxQfARubKv9u+p2P5XNlbvO6PPa6m2n63TtHafqNGwc7abdv30vzHh72PtN24+minZ1NrtpXixizs5c3Z2g9h4r8WYnlfb9oT1Fktj435Vru6cQpe7CY45XqfU+2tqpx6K7xTvbyXUn5/q6Xf996nASpkov9qbEnVntZqWhQVWZnFm2b6w0AWNZ1PAf7yP+W/x1zHXzqz71RXHEOthvDOdjyOV/L+c/B3vOXX1ymKuztup6DvftbXsiDXAOf9YueTNOdg2Xp5z8HgzXzzXMAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABW7/CyK/BJM0kbVd4sc/U5gCxv3yJRqiBlOxt56wstaZSi3rMoclT5q0BjN9Co2pOOfcRMYpxVlz2r8cnadMw0f16RssyindULOqnleBZVGcWVdHoW9Vsi9kn+/dJO0rvjVoxRYyHW060a/yJOZ+1Xc6LIvy3m1uZg9wU3b91I8965fS9NP9jm+3DZL1ldiopvivZsigubg7wuBzd20w+fytv54idup+mPP34zTf+UNz+Vpn/wfc/upN16LL/9zmrtFxNgs2nsFcWmXZZZbfKNvfyMwU9Tt9vmvSype7WW57YKUeTff3pG+z5R9nkjb3UPbt0nIkayVOr9M0/fbqs+b9xwynr37hNLKFdhZ8+OiJHsT+USbyrfU2V5q7myTFUAgAe1hnOwa8A5WHpl/yDhHOyiYp/k3y+Ny1H9zXvVz8Gus03VHOdgu+kLnIPBmj1auycAAAAAAAAAPAAPzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYvcPLrsCZ5iwujCxzI2/ELPLnufO6lHkr1QuqqjdC9F/Q6K9mjLI51YUsfXQyn1HF6sJILjTG4czY2Vxpd0oRvFgTMx23qq96E3Fb5M6ibIv6VWVW6zAdn5MX7FeRs9LL7Pu/YBT1q6pdNbPa4jZZnDJ4L3b9gt2kO7fvpVkPDnufuxrVXpG0qYpc9nnxgs1Bnv8g6dw7947TvK976rE0/egoz//8sy+l6Y+97uZO2ssv3k3zHh4epOmzGNCqnVmXzyLrKC5UZVaj1JtyRXuK8ayqMpO6l8twW+03xQuOd/NvqxiFzi2oUpfYfkewdwHVvCr3rGLcqu7K+7HZt83mp9GrKVFtRM0plPdXNZmLIK3YAMC1d8XPwa4352B7hq45B9vNe5XOwbgyrvo52HXmHOzhnoPBmvnmOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKt3eNkVuDSzSi4uZHmLrGOMVpnLqBqU16WsYxqjbOj+Mc6M0ymy187adjdEVpEHkdWlCF2X2JwsaaA8ehm56vNiMGYy/u32dPslnXN57CrGEstwVhO00N0TsvxViVVdltiHWvvEGaoi0+jVR7qqqjTruN3u1ma73d0PIiJefOFemv70M0+k6S+9eGfvMm89diPNe3T3KE0/Pi7W4dz/M3D9rbyaQ+UNdL+0M0KXNVlgKo6D5lxJCz1uFtrb5DbJcM58esa2nBNFXTb7tz+bsyfB8+Ryryju2dl7rer2Xs39w8Ni7jc2/1GEKPuwO2/T2M2+6t0+i3tC8/0AAPBoWuAc7DpzDuYcbN8L1/UcjKvjqp+DXWedI1nnYEucg8F6+eY5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKt3eNkVeMWMuZM2zsi9m1TkroNcSzNpekTEaLZzFC9IwxdllunVhU4ly6xVvcvK5FGy7GniGZXpFFkOXPWC5oA26lINQ3eYl1lazcpk2cu1n6ePYizK9m+TvamKXaUX7eyMxSzq3V/7VZm7F7ZJ20/y5jbbXplZt5RZqwtFZbJxi4jIqlj17eYg/3zZiy/cKQot+itJv/3y3TxGoZpb26LPc1X9qknR21fzEqsBql7Q2yvTfmnMt5PkfJzHQZJWTfJmV1XzOd0rqrzFxx+Pj4o6FmvioJjnmWpNVOttU83bLL2o9sGmt98e3TtO0w8Pdwe0vtU07xPl/pzetIoYRV2ay3Mk/VXmPf8SBwDOwTnYw+UcbN/EMyrjHGwBF3gOxkNXnZtd9XOw68w52MM9B4M1881zAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVu/wsivwSXMkSXPvl4/YP+8rrygqUuTezT+KEHP26jKqQFUVF9Cs4oUq25/qVjzPP7PxbHf4/uO2VH/XNdwtoNevy0y3qplV7N4qjBhpR+ZR5nZbRKnkcbJ+LOvdXfubahPZM61OriddXfmdpM1Bnnm7LdbVAtvwSO4FJ8GLEAtM3Ht3j9P0w8ODNH1bzK3HHr+Rpt9N4ld9OKqPtBXt3x537pPVhSpGc9IlgzGL8azu2eUcqjeFJPb+a/n0Qpq8SeJUY7w9zudEe+tPXnBcxK6myjjMrxwdFXXM1n4RfVPsWcfFwFVjkcU5KOq9LWJXfV7tq1n6rZvVmr2Xph8d5XtFNW+zvj04KNpZ3bOaW3lr0i2xgQIAD+4anoNdZ87BnIPtH3t/V+kcjIevew54Vc7BrjPnYA/3HAzWzDfPAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWL3Dy67Aj5p7JZWvLvKO0SgvIkaUL9gzQl2X7fE2L7Oo5MGN3c82VLWryozR6MSImEkJZY+Ulamj751cDVyzzM68KLuwSK8u5HOo0faIetxmUehmN32253ieXsfpKGI3F25nNlfrqlLVJYtT1WNTlLndFrGr5hfxO8q+LZKPt7v70+E4aMZu9vmeaRHLbTeRbMOPPX4zzXrn9r00/eAw/9xZ0oUREXF0dLyTVs2VuS1aWvR5ufcvoRs7q0w5VfIL1VqpZOtzFLHL9VZ8jDDLflzdx5M9OKK/ljdJnMOb1Xwr5kSRns/yiJk1qbq/Nd6vRNTz83Ame0uxfm7fvtuKfeMwf2v71NOP7xZZBDk63l2zERGjGP9N+VHU5P5R3Wua9+COJe4pAMBFuH7nYNdb8f7ZOdjeRToH63j452BcguYAXZVzsOusXEOLBO/mf/TPwWDNfPMcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1Tu87Ar8qJGkzTTnTJJH9vKImFnmM14wG2Vuj4vYZZF5mZuDPH1sdtOrvMf3tnmMvCox8+zFC6oGFTGqMh/gygVVJZ9D9cC16tKqTD1x8+Qy9m7+cuzLyjTGoRmiqvdo1nIm+asI26IPN1WfF5GyMJtkbVZ5I+q1X+pO6E6MRh3Lalcxin4pJXGquVLt5VWfl2soSb5z+7iI0atLjDw965cqxGOP5bfll1+8m6Zvis/A5fHLzmrEOKPPO7rj2YpTrM9ifKIY/jRrca+t3jtUqntwOrfK9VYEb95XsrV/cCMPvt0WlTnaf+5HRBwcHOyk3bt3lObdFA09vLUbIyJis8nzHxzuph8UffXYNh+g7XEx/kW/ZO0/rt47Vpa4H/SWPgDw0Fy/c7DrzDlYFsM52LldoXMwHr7reg52nW0a57fOwc5/DgZr5pvnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArN7hZVfgFWMkiTNLjIgkOX39A5izKDKJvykKnZEHGUX+zWb/9LntxZ5FgxpdWySWyb3YTUfPF7GL4MVwxkiuVH1YRhn7j8WNp7oVzPP35nmzx4v23P14VcmsD4uc5bpq9nmjTaPI261Lp8+7+1C5PpNFVO0TVYyqCzs9uz2u5ngRY4GNuB2hamfVt8kLbr6+uzfnnzvbHOR1ufHUjfxCYlvs8U/cymPc/vhRHqeaF5lG1oh6nPO658FvPFVUZVsVWqRnN5xiL6vXRHEhqcthUe/YVu8HKvuv/WpOlJvZJk+/V90/k7ocHxUD0dzkq/ZvNsd7h75xI3+reniYL7jXPfl4mn737r2dtKOj3Xqc5M3XVWVzkO8Jx8dJ/O5tr1Dd4zqbaDn3AYCH4jqeg11n1/Uc7EPfcXeBKA/f235+/r78OpyDve+dL/fisFrX9RzsM7/0iTRv/xysWrf7t6o685j5n+vxQ99SHG5ccZ/+Cx5L06/6Odinf3Gxlxf17p+DJaHb52B58gf/6vW8f3J1+OY5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKt3eNkV+KQxksSZZ537543I8kaMKnZaj4iZ5c+zxmZTXKheUJQZMylzW4TulVi2M02t6tcss/eCqq+Kce60JyKdLr0ZVL9gm41b9TmVoj3tPmysiXKOpzGKuX/ygix6nrcw0xh1mHzd9sa+Gueyv5JIZYxmodVYZLbb5uKvFH2epbbLLNvTmOdll/TGeRT78GzM0Worb26JaZ9Xc6hK31Z7X5F88+bu7f3enaM8RHPzK9dtY33Wt8PeHt+JXV6opnlal+a9qd5w9s5fv6Uo7itV8qZa+40bYlmV5j6crYliHO5s7xWF5skvv3wnTX/88Zu7se8UsYv237hxkKbfOzpO09N+qaZKMYc25fvSIs5290p2H4uoxw0AeEiu4znYNXZtz8Gurd7fTlfpHAz25hwsd5HnYNdVdQ9yDrZjqXMwOC9TCwAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKfNLcTRox8rxZ8ijylnr507qMpNIPEHvOPM72uBWmpd1daZAifXb7NgnRrUvRh1UlW+0v8xaxW6GXGIiq0Dx2t2+r+bnpdGKzmeXUyvaJIvO2qPcoXlBNoePkQqvtC6nr3RvRKk7WAVXkxx6/WcTY9srMttWizLLLq9DFC7LkfpnNtd/Y5EZxobrdbA7yUo+Pdseiv68Wyc21leatLmyW2Cya96BqSTQiz3JO5H01q/vHJluH3cmfJ2+3+fpsKca+vAM3+rYuM09++eW7afrh4UGafu9o903VcdEnm4P8s6VV7M0mz3+UlHl0XLy5KydXkV7I1mE5DgtMCQDgHK7jOdg19sidg11T1+EcDPbWPR9xDpZk7Z2DXVfOwR7+ORicl2+eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHqHl12Bs8wifYyHWo1XSt1NmnkNZ1XzouKjyJ4mN9s+ijJnUffRLaBVmTw5q0k1xnXtir5dojnlRKzyZy+o5kpR79es1AWo+nyJTiyXRC92lr1cb2VVmnO/U2azndU6bITuz5VGd22Ket+5fS9Nv3XroAjU6PMLnvytOVeuiVb21h5XTYlR3Ci222JvSZK787AzP6v8nXV1lrpvG4GqZVvehNNOTLN2702te0I5DkWM42oSNcJUeav0bRG67Nr959Z2mwc/OMj3mxdfvJOm3072rceeuJnmPbp3nKbfu3eUps9iHWZrbrPJP7d6tM3LHNXHXBvD3FzKAMAluvLnYNfYdT0Hu76u7zkY7GsWfws7B9s/Rvcc7NpyDlakXuA5GJyTb54DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweofnefEY45mI+MMR8ZMjYkbEvxoR3xsRfzIiPjsi3hURXzXnfPY1Y8XcSZsxzlO9T0bO7ZZ3Vu4llLGLCyNJn3m1+/Uu4szkwsgq8iDBW2OxzEhU/dUJX2Ytgvf6qxrQi5uJ5SjM/MqmqEs2V8oyq/bsH+I0UJbU7KsFurasdvdCZ5yL+dbtwqr95VpJ81aZq42l2uT2L7M7cHXXNhpaBSmnc34h3cu31f6Rx95WVdlUL0juqQtNlmr8s7rfOzpK894o3n7U41b0bZbYbGfVnix5VB85LKd+ebPdX+9tTDb0Z5e5wC1rkX21qPiNG/lcqfeh3PHxdift5ZfupHk3m3ygb926kabfu3ucpt+4cbCTdueFl6sq5opFUVQx5m4z6/tHf1MAgNVzDnaNreQc7Oq7+udgsD/nYPuGWeoc7FHjHCyx1DkYnNN5v3n++yLiL845f2JE/NSI+J6I+NqIeOec88dHxDtP/z8AAAAAXGfOwQAA4BH3wA/PxxhPR8TPi4g/EhEx57w75/x4RHxFRHzDabZviIhfdr4qAgAAAMDlcQ4GAADrcJ5vnv+4iPhwRPw3Y4y/N8b4w2OM10XEW+acH4iIOP3vN2cvHmN8zRjjO8cY3znvnaMWAAAAAHCxnIMBAMAKnOfh+WFE/PSI+INzzn86Il6Mxj9NNef8+jnnO+ac7xj5T0gCAAAAwFXgHAwAAFbgPA/P3xsR751z/s3T//+n4uSPiA+OMd4aEXH63x86XxUBAAAA4FI5BwMAgBU4fNAXzjl/ZIzxnjHGT5hzfm9EfHFEfPfpf746Ir7u9L//7IOWMcrCWzVtRZ9FoVnyGI3MdXJEFWfu1r0d4yJVXVt8JGNUL2jVvdfOMnSSnnT3axRZzKG9E8+I3a1Mo1tm0Sn1+BTJ6WIpYlTtKeuS2yZxNpt8ws2iLmWXF+kdY9Nch0W/ZKndqdLYVkqzk/ks1RxK0pvLrW5nEWaTBJqjyt1bh6OM02loFaHYb3oD2iu0WkPl3NrNf3h4kGeuxrNYQ53uqppZNr+68W+3WeY87wVuLOXYF2Vuii4vxzNJLqvdvY2X63b3wjio9vKiKt0Ljfv+TMc+4t69ozx/sfZfenn332Nt76t5VVrvnaoyF9rhAWA1nINxOedg19R1PgeD83IOtm+IUnUWcm05B9vbcudgcD4P/PD81G+IiG8aY9yMiB+MiF8bJ28Zv3mM8esi4ocj4ivPWQYAAAAAXDbnYAAA8Ig718PzOed3RcQ7kktffJ64AAAAAHCVOAcDAIBH33l+8xwAAAAAAAAAHgkengMAAAAAAACweuf9zfPFzDl2E8dM8yY5z1DkLmJHlTyyOGXmVlXmtmhnmj8P0uuTs/IXbcpy5hWM0R6hbOyrzNWcqF5QtWc3/6Yan/1DnKFbv8r+lSmG5wz5C+Z2u3+EZh9uqjlUxEnzF8HLHm+OZ68flwme7jZlxXs1ma05V8yJss9745mlj2IhluNQ5S+yt7ab5vysF8D+sctxLva+6v6Rx6jKzNd4VcfOdrYpxmdTfHSv3efZ3lf0Yb2E8gvbtKHNvbxZZh6+N8fbfZhVpape977S6ZZy3PL0TTWJqqokcar1c1xUvHvH7liiPRH5vCj31YtsEADwmq7nOdj1dW3Pwa6t63sOBvtyDvbwz8GuK+dgD/8cDM7LN88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYvcPLrsAnje1uUow061yiuCLIyItcIPNCYZYp8ow+3C2g6qtGiHb6KDpldEe/jLOrirzEMI92J5aBOpnPH6IOU0VvlTnn+ftlgRCngfZPrrqwrkt+YbMp9rhOoxbaE3K9zh3Fx7Gqdm42uy8YB60J194T0tztNVHN/k7dizlRLZYiOenCiIjYbnfjV9Oq2m+3x7v35YiIxx6/kaYfHe3mr8a+ambV/qqOeb8UeZM+OYmdd2JW9eNt3idV53a3pzxMUe/mxK3ybxu1rMah6pfyfVzS0KoW1Ryqb9pF9ix/te9X4znzdpZ1TJIPbxzkeQuzmLdVQ9O6N/sKAHhIruM52DV2Xc/BrqtrfQ4Ge3IO9vDPwa6r+uzJOdi+UbrnYHBevnkOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6o0552XXIQ6fHPP1P+Vg/xdkVR69MkeVv7gw0gKafVeVWYVJ8pdZiwujbGiVf8+KnJVcpu/ft2W9m+NcSudQ3on52Nd1yfLffS6PXa2/cpy7c2iB2FX7t9vtTtpmk38ep56G+YXOvlTlfeyZ4rNBzTWRVbGcE01VlNsfPz5/7KKd22rOJelzW83PKkZel8/5J96Spn/0w8/vpL380t00bzVsTz3zRJq+Ochf8OInbu+k3Xp983NkzT0uXRblWu6tiTl312FExPZ4N3819p17UMQZe3mSXt5qq72iyD+LfsnqXs7bsg+LQrdJmZv9+zsiYttcQ3Vl8ii5au3ndc/6q6xF1Yf1wBXp2caaBzl6bpn3IPkel+ct610HT5MPDnfneftddzlV9n//UA1PNT+f/fv3/s6c8x2vXTkA4EE5B9s/v3OwPLntIZ+DvfedL+1ZMZbymV+cn49ch3Owd3/bC4vEZz+f++VP917gHGzvdOdgzsH2fkExrz747fnZOBdnFgvON88BAAAAAAAAWD0PzwEAAAAAAABYPQ/PAQAAAAAAAFg9D88BAAAAAAAAWD0PzwEAAAAAAABYvcPLrsADGXslnXlh1K9oxVki9izrOHfTRpm5V5exG7sKVJaZ1O/s/PsrazeLK90JkOZs1ruoSjaes2xR0/7DVuatp1B+oar75mD/z95Uw1ZVcjbGuZxvm954dtuf561i9/IvoezDqtBOZZoxPvIjz6Xpx3O7k3bj5kGa91Pe9FSa/ta3vzFN/8Hv+5E0Pavipporzb2sXFvJUqn35jJ6mrqtN8skqVpvvapURW4aN+d6eeYXqr6d1Q00zVzEbizcWdavuB9W2+Tu1D+N31Au8d7Oku6hjftbxBn35nJf3TfxrMoUyZ30cl7l6fVcaa7P/atSqvatZFuNbdWgYh4CAFeQc7Asc68uzsGSnBd3DsYlWPk5GPtzDtarinOwJKtzsCp6HmfvRK4S3zwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Q4vuwKfNHeTxrjI4pICI2JEUWiWvcyax65eUDUzrUuVeRYXyuSiLkmn161p9NUZdUmzzypIld4qMr3Qixz1BJ3bvevR7Ko6f7p+lllAZZTOmq26qmjQZlN9rmf3Bd0+POtKnnv//KOoTTmdywW6/wQt95squahMll6viWr/yF9x7+5xmv6mT3tqJ+0Nn/Jkmvdzfvxb0vTv/Z73pem3X76Xpm/SSdqcE8VEr6Ztln8s9NG1MfNAm83uWGy33bnyoLW6z2L38cb9sxqHsvlFJXe38mx7P4m9KepX5C8rk92Dq4Eo70G9cc5jF++RmntZ9dYkfXvTnIdVn89qnu9XjbNjd9dEUpfu7aBUjX8y/0c5EADApXIOtl9dnIMV6a0iH/o5GA/ftT4H4yFzDpYmOwfbzescrHpBXuQC52BcHb55DgAAAAAAAMDqeXgOAAAAAAAAwOp5eA4AAAAAAADA6nl4DgAAAAAAAMDqHV52Bc4yi/QRo5G7WWYZJruQZx5Z9ersEZvqBUmImecty6wUL+j0Ym98znzB/mUuM8wxRhao14ljWwbfSZpV47tzpZF9FEGqPqzmUGfYWssnIkY1D4tKZvnL5dNdFEUdOzOlWp/9QpP0oj3leqtU2ZP5XI9DHqKaWzduHqTpn/b2N+6kPffsi2ne//2vfW+a/sY3PZmmv/nTXp+mf/D9z+6kHR/ni3lTTK5RT7oif5KWJcYZ0zbds+oyt9vd/PW49faK6kKa2t2zizqWzc/6tliH5d63LfIfJC9otqc7Vzqd2N7LO1OovL8104sLm6xryxh5xbfbvJL1nrjAfb/o3GoPOThIJmj7jUwxP5M1XoZf6L0TAHDxnIMlIZyDLeJhn4NxCa7zORgPlXMw52Bpfudg++U9K32RczCuCt88BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPUOL7sCr5gxd9JGjEbeZYwk9kmZ+yZGxGjWpoyzV9KZ6bO6UpWZXihilM0sgzey1y3Kc1d1LOrSaGa7/Vl6VY1ZtKeYQ51eKUKXquybTbEOm/HzMntB5twmab05XpVZTZV8PKvxaewfTdVc6SqneTLOm93uPrMum4P881if/9PenqZ/xo97007aX/ozfzfN+9N/9o9L0z/v89+apn/vd78/Tf/ohz+xkza3x2nerE8i4gG2hN0r1W2ivH2MvG/LOMmsm8Uk31ZTqxz//dPrWdvb+9r7c0fxMcLs/rk56O2Hs+jcbefevC3GvrnfVNO5cwvu7kOt0WlucdW9qX5PlfRje1/N8x8e5mO0LRfX+cuspGuovMEBAJfJOVhamX2Szkx3DnZFzsF4+B6xczAuTnVW4RwsT3YOluR1Dpa6yHMwHj7fPAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1Di+7AmeZc6bpY4zdvEWM3ZyvcaWRPItSi2rXdSnyz+QFVYyq/WWRVR2Tvq2ij6o2/cFI6rFAkIi8E4swo8g7i7rMoi5ZnGquRNrfi3RhHaM5ibbb/WuzqWJXU6U5cbPsVXvaa6JxoRzPfvQ8d5K9u/bLcW7YFAO6LfIfHOSfxzqe+Su+49v+j928x3ne5597OU2/fftemv7hDzyXpr/4/O2dtDd+xuNp3qoTq37J98+IkXRLNT7lfC7Sq7pk+YthaO9922219+3mr+81C312L91vC9VeXvVLEunw1kGad3ucxz4u0qOY5zPZb6s+rOZEPVmK9qd1aW4g1T27TG7MlWKqVOutmrfFHaTIWs39PH1T1TFLb95rq3ZWdcz7q+ir7k0YALhwzsH2j+EcrHBFzsF4+K7zORgP163HikdCzsHSdOdgu5yDXdw5GFeHb54DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweoeXXYGzjOrCnPtnnsWFkcQ4U/Y5gzxGWe9SESere1Xvsp1Fke32J0Vm4xARo+yA/EKWOsu8eZlFVWIU7Zytvs2TK+lQVBWs1J24RPYiyPmzl80s52GzzKRzq3lYDlw5FAusiSK93J6KdTtje+4yu83P5tC2qMbmIK/3mz/t9Wn6nZfupemPP3ZzJ+3lF+6keb//ez6Qpt9+6W6afnwvr/yTTz+2m/b63bSIiO1x3lvbbS89XRjNj66NYpGPTZGerZVyPyzqXYx/Z4+v5nhR7VJ1T8jqPot6N5sZWXtuPpYP3PG94zxCMQ+PiwmwTVZotR9U061qUL1X5nfhjvT9ShU6Ir1RVvOzClK3pygyzd5bE9V6W+K2Uq3xqg/rvXz3BWXoatwAgEvjHMw52G7ea3oOxiW4vudgPFzOwZyD5ZyD7etiz8G4KnzzHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKvGKMJHHmebPk7OVnhDgjf35ljN1IY+Z5+2VenKTapxeK9LRNvRqWuasy0yB5lNlsUFmXJTq9aE9WxaI5+byPaM39M6rSy1zWsWpop9Be7Fl2WJK2zbNuixjVuu3pjcS2HND9B7pb7bKGjT6fRZSnn3ldmv7Ek7fS9M/+vDen6d/3j9+/k/axj3wizXvv9lGa/txHX0zTbz5+I03/rM/91J20zevySXTnTl7m3aIu9+4dp+nb4yR+NZ7VcivGbbMpXpBMmGpdlenFfrtpLM+q3qNR74h6Ls6ky7dFBbfbYk8o8mfdcvNW/rbpqFpXkc+JUWxcR0n63BSfczwu6l311Xb/zX8W+2o5P4vxHEXVs/daoxifrE/OUm2rHeV9rxv7/G+pHiB/tpcXyjchAMDD4BzsYjgHq+I36lJpnIPx8F3rczAeqte/4Yk03TmYc7BXcw5WJF/gORhXh2+eAwAAAAAAALB6Hp4DAAAAAAAAsHoengMAAAAAAACweh6eAwAAAAAAALB6Y87L/2H6g8fHfPLzDnYvjP1jjE7ms+IsEaYIUoZepuotN54uCp276WMUc6SaOsVHMqpmLjEDy/Evk5MLVUW645OOf7MPiwujMUE7eU9fUFSlqGSSvy5xmdG/yN2qrHvW/mbXVl1Yb7/ZheYcT9ZyRMSmGOfNwW76wWG+mA9uJPt1RLz5bU+l6VU7t9vdC3O7zWPkIeLwRl7Hm7cO8/THbuykVVP/zu17RfpRmn737nGafny0m17de6t1m43PSf40OfKJkZc582rHbK64rO6bTT4+m83+96CT4EX2ZLpk8yrijPZURWad+2KeeVvM2xc/cTtN3xzk/fLccy/tpN28kc/l46O8zIODfH3euX03Tc/6q+rDSve9ZHYP7q6JbZG/mluz0aaqOVXsqr9uZu+18mFb7r1gEqfcJ4oLH/hfb/+dOec7FqoRAJAY5UELF+XNP+9mfsE52N4x6so4B0syF+nOwYorSZpzsIxzsDQ5nIMleRc4B/s7f/R9eWZIfNoX3tpNvOLnYB/5zjtx9/lt+grfPAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1Di+7Ag9ixMgSr4458+SRV3KJqqd9EhEz8rrEtig1Ta7yFrGL5DpOK0iryE4Vi+GpVS/oBC8qWI1nqy7NBlW5eyPR0563eeYidpF9iXFud8oClewsnzMuzGLOzeQF22IvG8fbNP3lF++16pLtld3tY7vNX1GlH93brfsoPkZ27yhv5/G947zMol8WmM4xi9BV3VvVKLen4p5V3cs2u+lV3s2mqHhVl6rMJH1z0Ctzc5jnP0jyv3Scz/HbL91N0+s+z8t84olbSdY87+OPH6Tpd+7kdTw4zPPPZD5X82pT1OW4WCuzej9UpKd5i16stpV6T9y9UtXioGh/Ve3yFp+lF/OzfO9YvsHZPznb3yMiRmMcAACuPedgu3mdg6WcgzkH2wntHCwv0znY3nmv6zkYdFzLc7Az9isrAgAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKnGXEqC48fGOJQmeeOjuxixhF7rLao3hFlr9VvyJGRMyilllVZlHxUba0J4tetbIscTb6sIhezvGmNEo5KfLk3jysW9RJLlV1T+vYWxPtMjNlHxZzvFuX1gtaI1HPuaTuc5tnPR75hZdeupumV5/Syoazqt8ogoxNnn9zt0jf7Aaq9slqz9puq728mERZcnNSzGLPrtbtEresbogs/6Yan2764UGafuNwdzxv3Czy3srf8lT5D5P02x/7eJr35uM30vS3f+pTafpB0Z4fef+zO2lPPH4rzVvN/Wc/8kKaXg3o0dHxTto8zufbcTHHqzVRj+fuuB0n9XgQ1TLM1mG59ps3kHLfaizEWcaoXrD/e5DyvdNlvJ8GALgszsH2SotwDtYq0zlYJ3s7fiezczDnYOflHCxPh31dy3OwM6rsm+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACs3uFlVyAiYoyIMcbDLfOhlrZcqRfeTzNJGkliRBTJpVG0Pw0z8+CzaH+7V5IXNJtTSwKNsrMWGs8LHLdSZy4WZVZVqau4f+VnkXfMxjyMYoSK+Vn1SFnrzliU3V0EKcanNfzVOjzO0+/evpdXZZPXZZPVsWhnufeV+fePU8Wu1lClHKK0zP3znpV/bov8SZ9X7SzrXYxbtZfn7azql3927+AwT79x8yBNf+zxG7tpT+ymRUQ8/rqbafoTRXoW+96z+Zx45o2vS9Of//jLafqdO/laecc/+7k7aTcey9+q/aN/8L40/eBG3of3XjhK07PhrNbsdrvNyzzIy7yV9GFExMsv3dlJK7abM241xbot4mT7TdWeru7+1Mt6/vcJ9T1osXc+AADXl3Ow83MOllSmlewcrBPcOViRf/84zsEKzsHSdNjbdTwHO2Pb881zAAAAAAAAAFbPw3MAAAAAAAAAVs/DcwAAAAAAAABWz8NzAAAAAAAAAFbPw3MAAAAAAAAAVu/wsivwIMZlV+BBNSt+se2c+5fayHrWhSpMGmFUwZuVucBOHGU7szou1J6OIvTs9lVVxe3uhXrcesbszKE8dXQmXMQZXb7/eOZj/yBlnjvzGVOrmhi78btduE3mxEmRxchl86W7lLtzbv8i67pUZVbJycfUNkWMKnaxJPI+jIjNdjd9bIq8zT7cbqpx3j/OpqjLwWH+mb6bt/K3K489cWMn7cmnH0vzPv36PP31b3giz//M4ztpb/mUN6V5P/qhT6TpP/Gnvi1Nf+LJvC7ZUvnQ+59L8773qY+m6dUovPzSnTT96N7x3kGq+XnjZj4+9+4eFbVZQnmTy5OztzdF3nKNFy+o1lYeZpl7cHkvz0L3ugoA4BHlHOy8nIM5B9vN6RwsL9I52Ks5B7ue52DQ8aidg/nmOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACrd3jZFThL/gPzl2QmPydfVLD8rfssRkSMS2loXmZWw027eudv5yzqV0ZojkURpJWctzIiZqfUZcY+rUtVweIjM3XfVoF2X1H2STUnyj4v8id9W82VctyKSlafJMriV31VtqeMXcXZvdLt23oNVWs/i1PEKCozt0VdqiFK0sttotqIqgFtTIC87Wf0YTU/iyI3SQdsq3VY9VWz/cdZjGp8NnllqnHelH2+zaKkOQ9v5BGq+8TmME+/cXP3bcxjj99M8z759GNp+uvf8ESa/sY3PbmTdu91eV/9uJ/0ljT9LZ/5+jT9xefvpOkvv3B3J+3GYwdp3nf9wIfT9E8893Ka/ua3PpOmf/gDz+2k3blzlOa9/dJu/SIi7t3N82+PszmRT9tN/81GS7Y/1e9Lijle5K/e32WbX7mWmzo1r/a47J4KAPDocg62d27nYNWFvYt0DlbFruI4B9vhHCy/4BxsJ+0iz8GgJXuEeo3PwXzzHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNU7vOwKnGUuEGMsFDuNM/Mosyh0lLW5OGWZRQeMJHvRzBhZ5jNUfZ7VsRm6LylgFBWs2l917VK90sreqUhZ5AKdXtYvjz3bK7GRv5q3zchZ/qqrZjd6K7k5VyrVvpVGrva4vMztNs8/Wh/TKtpTxu72+W7+qmdn0VfbIn+nKlXWam6NaiOqbjhJoVXsbZG+KRq03eR12Wx3B3oWnXV0mE+KzUFe5s2j/O1KNkabYr4dHh7ksW/lsW89vpt+98W8QcfF/Lxz+yhNf+zJm3ldkjKff+F2mvczP/dT0vRn3vRkmv433vk9afrmxm6H3X3+Xpq3Wm/b42KgG/fJ8n5QhS4XXMcS7zRrWR2rdVV1VrnCi37ZpheKe3D5BgcA4BHkHGw3yTlYI3gztnOwBZKdg+WxnYPtW6hzsPOfg0HHo3YO5pvnAAAAAAAAAKyeh+cAAAAAAAAArJ6H5wAAAAAAAACsnofnAAAAAAAAAKyeh+cAAAAAAAAArN7hZVfgTHOBECNPL5Jr6QuqKHnFq+aM4kKWPJoVn7Ms9eIKLUtsDGgxcP2q7N/O9nRbYH52Z2Jd5P4N2hSdWPdtfiGbWmX9ynnYlMSp11VxpWp/0c6x2U2v+qqa49uqkkUdZxKnql+lqmNnJMouLC5sq7pUczH7+Fbxka5sHCLOWkGNzb+o3/a4SK/GrarMwW7Spqrfpohd1jHv9c5WvinK3FR9XqRvjnfjbA+qG1wxh5IYERGjqPzNm7ud+/ITN9O8t2/fS9PvNNLv5Vljc5DX78VP3EnTD28kkyIiXnzp9m6Zd/OJ+Ka3Pp2mf/AD703TbxRlPv74bn8dPZ2X+dILeXs2I499714eJ+2var/JQ8e23Fj317xNxNzm620c5BvXQZK+STe+iNb7sqj3oTF3489Z7M4L3ZoBAK4152D7cw62b5HOwZyDpZyDJZyD5WVekXMw6HjUzsF88xwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1TvXw/Mxxr81xviHY4z/Y4zxJ8YYj40x3jjG+LYxxved/vcblqosAAAAAFwG52AAAPDoO3zQF44xPj0ifmNEfP6c8+UxxjdHxK+IiM+PiHfOOb9ujPG1EfG1EfFbzoy1ibjx9G76nNULGvXcP+tJ/pG/Ymx20+9+vKpgrzKdKFWfFNWuY3f6sNuJhTmrQLu1LNtTxeglNxW9WCUnhdb16NWwHovsQjVZWkW2xr/Kuq1eUE7Q/MJIPu5TlXn3uSpyHjtZ4mfWJc25zfNWZVZuPL3/JOqu/XoK7b6i2m+q2Hefz68cHOSf0xpZpLI9+Sw6PDxI04/uHaXpm2ygm+0sFS+4l7bzOM9cb35p8s1n9v8MXHV/i1ms0GK/HUV6Nv+rNVGtt3Erz39YvSCp+r2X76VZX/j4y2n6QdEvx0e7Y/TSs3n9nnz9rbx+ybqKiHj8yRtp+gvvv71bj20+V554Ki/zzW9L3lBFxFu/8iel6R96//M7aR9M0iIiPvyBPP3jH30pTX/phTtp+tHd3fVZ7ZPVvC3322o9l28qd22KZbU5yPebah+aLyfpxX54fJyvw22Rfud2Ps+z/fb4KI9R9SEAkFvyHOzwdRHP/LTdI7mrfg72oe+424x+hTgHa3AOtnfeIv0yzsHe91d2/568Lt76RY/tJl6Dc7D3/ZX8nIGL81lf9uTeeZ2Dnf8c7Dr77X/+y9J052C76nOw/EJ1Dvauv/jC3mVeB+f9Z9sPI+LxMcZhRDwREe+PiK+IiG84vf4NEfHLzlkGAAAAAFw252AAAPCIe+CH53PO90XE74mIH46ID0TEc3POb42It8w5P3Ca5wMR8eYlKgoAAAAAl8E5GAAArMMDPzw//Q2nr4iIz4mIt0XE68YY/3Lj9V8zxvjOMcZ3bvN/XRcAAAAALp1zMAAAWIfz/LPtvyAifmjO+eE5572I+NMR8XMi4oNjjLdGRJz+94eyF885v37O+Y455zs2D/zL6wAAAABw4ZyDAQDACpzn4fkPR8TPHmM8MU5+xf6LI+J7IuLPRcRXn+b56oj4s+erIgAAAABcKudgAACwAg/8Wdc5598cY/ypiPi7EXEUEX8vIr4+Ip6MiG8eY/y6OPnD4isftIwxGvWJKvMsYlf58/SZhSnr16j4QtL6RV2TTt+2FXVpVWYWmUcRvMxflFnVsaOInY1Fc7qVA1rN8yx1lBUskrt1afRhOd2Kj+9Udd8c7KZXa/nuKP4dvKr9jQZVeau6zG0RZ7tE3zbnfiEvc5EgsS3auUn6q56GRezjvHOz2KUib3eb7M2hIn1bTJbC0b3jNH1sdmtf9cnc5unbql+qdZtc2GyqOZ63s+rD4+M8/e6d3XV+++W7ad4XX7yTpj//8ZfS9I986OZO2o3tY2neN7/19Wn60e18fN7/A8+m6S8ldXz7570pzXtwmA/EM294Ik1/6lPy/Nm+tS36+/ioN27VMnz5xd0Lx8Vcrmwjr0u132Qrulrj1Vo52OR9uCnSb77u1k7ac8++mMc+KMYnue+dJVv7hzcO0rxHR70+B4C1cw52vTkHK9I7nIPt7TLOwa6zznnKlToH46FzDvZwz8Gus7d95jNpunOwXUudgz1qzvUPRc05f0dE/I5XJd+Jk0/fAgAAAMAjwTkYAAA8+tbxEQEAAAAAAAAAOIOH5wAAAAAAAACsnofnAAAAAAAAAKzeuX7zfFHZ79pXv2Cf/th9FqAOMov8ZZHZlV6Rnea0zaoumwWC16U28xd1mbvpZeTiwhjFheYYtWJUdekUWA5cK0oeunllbPP0ZHheI34Su6x5UZfGvN0Uecco1n7Vzr1LrGN3bYu6ZJWpy1xikudj1J1DZe5inm/TzGlqbDb5Z72qJVT1V6dXyvEpFXMrSa76pIzczJ917ra6N1X7Z7UPVYHiOIldrMNiY6nW53abz4ujo6OdtLt376V5X375bpr+wifyt0I3HzvYSfucz/iMNO8nPv5ymv6+j30sTf++7/5Amv6h9z+3k/bZP/7Nad6f+wt/Ypr+tre9IU1//FPyPrx3d3fcXn4p76sq/c7tPD2LHRGxPdqtSx4h4vg4j1HNw3qr3H8NVTmLaRjjOH/Fc8+/uJN2UOxlx8d58Dd9ytNp+ofv7s79iIi7d3bTb9zM5/hxMg4AwEN0Hc/BVs852P6hnYO16rLAOdi1lsyL63wOxkUqxsI52I4lzsGusze/7ak03TlYkrVI756DPWp88xwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDVO7zsCkREzNP/7GukuUez1Gb+mZVZ1bobuxGmyDuqItN6R8Tcv46zKLQqcxYXRlWXzniOZnta/dKdQ0XoNHJnhj+IxmQplLnLcdu3HmdEr+bQtgiTfNzn+DjPPLe9edsxiiDdulTpWcdUw9Bd+/VS2b1Qh86vlHtFGWc3/42bB2nebXs8i/Yntdlui3Er988iucifVr3IW82tyhjVZ+D2v2dV41nnr9L3DlEO3Pa46MNi/LfJmjs6Ok7z3r17lKbfvp3PuRs3dtN/+PaH07zPPftSmv7ed300Tf/g+59N0w8Pd8u8eSt/q3bvbt7Op9+Yt+fJp26l6a97crfuTzxxM8372OM30vRbj+XpN4v1fCfp22rcjo96+025bjtLq1rLzb3i3r1kfo68nc8887o0/bi4IW6P8vRsaR1XfVvcswCAi3d9z8GusUZznIP1OAdrRL/Ac7BHzXU4B+Phcw72cM/BrrMnn3o8TXcOlgZJk9tn5o8Y3zwHAAAAAAAAYPU8PAcAAAAAAABg9Tw8BwAAAAAAAGD1PDwHAAAAAAAAYPU8PAcAAAAAAABg9Q4vuwJnGXMWF0aSWOSNLG8/+7nzPkiRyQvKGGVXNSvZMfPYo6plWZcsf9XS/SOcdSWvyRKTIs9dTuUySPGCZaq4kN1COyMcETG2Vf78FTPpyFnF2BZjvylGvxikTTJvy7xF7KKKcXjzoLiy/5qot8nupMgCFTGq5Gq7Ler4xOtu7qTdvXuUZy5025/OoWq5VenF3KrmeTpfiuDV3Ortn0X43rZa70OV9J6Vx9ge55/dm+M4z1/0yzbZALbbfMUdH+exj47ydXjvxm760XPPpXnf866PpumfeP7lNL3aK27evLGT9tILd9O8Lz2fpz/9xrydt1/K++Xend38x0d5jFn0bXnbLzaLfDpXd+bePCz3vsb8nEWMchU2NpFZvHd68cU7afrRcy/loYu6bDa7a+v4OB+3W4/tzrfTUot0AOCiXflzsLVzDrZ3budgRYQLPAd79Fz9czAug3OwnbQLPAe7zm6/lJ+bOQdL0pc6B3vE+OY5AAAAAAAAAKvn4TkAAAAAAAAAq+fhOQAAAAAAAACr5+E5AAAAAAAAAKvn4TkAAAAAAAAAq3d42RU4y2zkHVXm0Uqu42evWKrMRmW69a7UfZuVUOXujNBZGp/hmNs8vZoAM++xNPfI81Z93urDmeeeRb1HUe/O+PfnW3GhqHtnqnTnbdm3290r22JKdAcuXeORN38WQarp2V8rS6z03pqo5n+RuQiRp282efrdO0d7l7g9zjv34MZBnj+ZKxFRDejeWU/Si/HPs6eqvqpUsY+PFlif5f5Z5S8qk+59eeZqfMrQ8zhPTuJX67Aqc5uHjuPj3fwvPvdCmvfll+8W9cvLPD7KK7nZ7N4P/4+/98Np3rd8+hvS9Kff+Lo0/dmPP5emf/TDL+6kfewju2kREZ947naafvule2n63Xt552Z9W/XVYm81kslV7futIGdJ6n5wmL/nuVfsh9X9ZjPyONvkpnjzVv52/5lPyefKh+LlNB0AuHhX/hzsGnMOlsVwDpa6rudg19r1PAfj4XMO9nDPwa6zH/7+j6TpzsHOGWRFfPMcAAAAAAAAgNXz8BwAAAAAAACA1fPwHAAAAAAAAIDV8/AcAAAAAAAAgNXz8BwAAAAAAACA1Tu87Ar8qLl/zpnlHWnePDVijry8Ub6iEbwqswqzf9PbynaOvPJZ35bNLDu3rE11Yf+szTJndSFrfzqvziiz6MO8yGIcqno325k2pyqzalDZh1Vd9l+HpW6fZ1mrcShq3l5uWR2LIquqbPuFZtH3zxoRs6hMa4Sqdlbtaa79tGurem+Kz3qVdanGfze9mob5veaMadsYoqW2/Tn//+z9ebj12V0Q+H7X3ue871tTqioTSSqBAAZkkMEOiAKKRCSOeLsVwQEUb6Pd2sp1YvB6HfrSAtq07XO7bVEQaBlEGQRakBCMSMtkwpQBQiQJValMlZrf6Zyz97p/nFPJm9rf76m93rPPe4bf5/M89VTV+q39XeNv/fZZa5+zl+sXOnh/1u0ZuefWf9bspw+ELvL3vkjzLns+h5bFDbpYrOZ/4pGdNO/29jyPUYxP1bePvu/yStodd11M8/67731dmv6Tr/nlNP0TPv2FafqVy6ttevyxq2neJx69lqY/+Xiefu3ybpq+u7O3krZcDM6JQWmfDz6DW7murG+5l8+J6pldtX9+IZ/PFy+uvrXfW+Rlvu9dj+fBAYBb5Azug51h5c839sHWL9M+WBp9yLHug51lZ3QfjFvOPliWdnz7YGfZG37uHWm6fbAk+Rj3wc6y83VHAAAAAAAAAMBNcHgOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5WyddgQ8ovpU+k3xRfW/Vt92PldaLC0WYPPZAU8blwcv2VDUvG5RFGml9rYrSsiuDnVjHXv8Fw8NWza30Iylj0avpXIXpyT1RdWGSdT+9aFA5t9LsVfBi3pbjXHXuav7Rdlaxh2pSxR68VUZmRdme4iNQ43MoSyxCDN6fy2UeaD5frXw2lw8rsxexqzhj8zZPns2KulR1z8OMFHlIjKouAzE29cxK44yNT/3MXn/8qz5cxLKIUaxPi9VIy2UeY3c3L7Ncn4oLafxyHuY3/7sfeDRNf8PPL4oyV9N2rud5d67tpem7Rf7d3Tz/Yi/r27E50fOhqCVdXr3nq5TvEQeeCZt6v7q3m/d59kxYJnM5IuKue25P098T14pSAYDNOj/7YGeCfbD18w4Wah8sS771+2DnzVneB+M42QdbM8RG9sHOsjf8/ANpun2w9Q3vg50zfvMcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYvNZ7P+k6xPz21u/8DfOV9BZt/SADWSMiomh3a+sH2r67yjtYmYEhaC3P3Isy6z4caf+tnyNliYNVKccziVOOWjnMVZ8nabP163FIclXkZlRVXG5i/Nfvq4i6nVlNqjne+3KoLmX+pNC6R8b6qg/MoTK16KvZ6DqUZi9iFIXOqo9j9SrO2qGH7/2Re2h0jlePzT5QyVbkrSJUZV57ZLF2mfVwbmKujE2hqj1t8CN96W072JxZdR8mddm+I69g/VaqeNauvuXZr8t8tS7zrbzMKn02+LzJOqy6J5bFdFsu8vWzjJOkV3149ZG9NL0at+o+3Npa7fTFXlHv6j1i0bfV42PrWUk7i7zVbVg946pxnidzqBWL86xIf+sPP/7a3vvL8xoBAJvQqs2dU+55n7ldXLEPdlT2wYaK3Az7YGsXah/MPlhe5q3fB3vw319du0yO7r7Pvj1Ntw92fPtgD7z6cn7hDHjBZ11cSTvt+2Dv+E9PxvXHFmlwv3kOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABM3tZJVyAiokVEi3Zry2zHWV4vkvMyWyvyp31S1Hu4OcULelKXDXVVFaYnV8oiq76qurAKM9Cmaq6URY70VzWcg+1JK1NOlao9eaF1+5P8Rb3b4ABl0zAioid1Ga73cnSyJEkbGfxD1r2sgKpvN7WUbSJQEaOOnF0ZWQ/r/GXu0XtrQPVptLEaFsolO4+ezfPqnmjzIv0YP15Xxh5d4tMpNDbI1ZKQ3Ybz+TyPsVwOlVnf+qsd04vQy7284svZYCdmy01RZj3fqvxFejYXiz7Z3sr7vMq/u7tI05eja3+ien5Ua3nazPK+qmKMve9L+7yo9zIG5y0AQMk+2ECJ9sGyZPtgebp9sNWs9sHGcp+zfTBuLftgt34f7Cw7b/tgfvMcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYvK2TrsBxa6NX6hcc3THGHg3dohcXskhF3qrUInsZZaTyVeYqxmDV0xCDsXtVZlqNqj0DQfYDra2PDlBxIaviYK3HpZ072IdlX43N5yFVmQN1aaMfdRq9J0byFn3bqptl7CYfrMxg7g2MZ9mcgWW1WifKniryz2bFxEjGqCqzLze03gysCb2oTH1LrL/2j97iQw+KctyO8QE/+KwpHx/FC7Lk4funXIbXf0E1xMui0L7I07e253n+5bKoS5K3SC+nftHOWdaoDb1f2cgSP3rvAwCMsg+2fpEV+2BVoLXZB6uC2wdbO699sKHYx7kPxi1mH6wotKrL0ffBzrKzuA922HsYv3kOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABM3tZJV+D92lpJh7x+KPdG9J6nl1UpXzBQaBm7yj5YZpF9LHMRvEjOopRdMlS/zWjFuPWhTszz9qJBbbBr165GnXyIjUyWzURIu3ZDDS3zJxdOYL0Zvd2q5aaSzfORLjks/0bm8+g8HEhuvVqzRifR+otc/Zgo1oSxEvM5OjxtR9f41fx1vceeExtZ+wdjZNn7cjkWZHjaJheKIsu3FFXs5cD7gaqvRpfb0fdDib2dRZq+tT3PQxftHFkTh5f4oRcMzv3CyHpbrSvjawIAMHX2weyD5eyDrcs+2AD7YBupzHnbB+PWsg82lLyRfbDz5+zug/nNcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAyXN4DgAAAAAAAMDkbZ10BZ4y+F3tq6ovgT965EPCFGX2osyWp5c1z7IPftd9GbuqevKKsgeL9ozXZfVKH4x9vEbbuXpltE+q9PrC+kbrcsjIJUl53vL23ECRm+iTQ2VzcbjMo69Po/fy6M2ShtlQ32brSkRe97o5Y+vnIZVZryIHpaapRd8O1aW4KVr1nBgc5+F7biBGK1q6iTKP/X5OVLdKNhTl+jn22B9a45fVOLRlmr7Mk2M5MOeO+1mbxa/qPd/KP+dZ3SvLRRFoqFFjA9eLvu3pxCjGYbQumxikE7jfAICzzj7YZupiH2zddPtgA3k3xT7YkdkHyzJvaB+MW8o+2GaM7IOdZXmXn919ML95DgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJg8h+cAAAAAAAAATN7WSVfgKX0gbzu2yIdEz8JUodtYmW2kzMJoK3td+YEgeYze8hitKnO2mr/ukyLG2KTYSIi6B7MrG6jg4YWur8hb9nlZ6Gp6NTzjlVk/UCvmW+/LjVQlH87Rvjr6+JdFloq69HICbCB2dX8WYzQSupoTg10+dKuU87BY4wamRS9i9KoPy1tipC7Fmj14347kr9pT3bfDNvHmoXpmJcnbF+Z5NcqxH+vzZXIhS4s4ZGVejt2f2b1Vzc9y1DYwnqOPj+WyWONH3saMXinnyvo3//Dcr6qygcfNhu5CAGBK7IPlyfbBNhB9uND12Qcbqop9sJHY9sFSx7oPxq1kH6xwAvtgZ8P52gfzm+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAyXN4DgAAAAAAAMDkbZ10BZ7SBlIj+lEDRy9CtIHYrVX1G6rKyejr922VtQ2OWn1lNb2MUX3co6pkMZx59mrs8/SR8azm29BcHlSNT9VXbbBvs5oP3hKH9EsuC9/LPhy7+Ueq0qr1o+qA0Y7JCijv2UEjYcpl4pgHOlXM27Iqo/lHqlLcE8d4ny+L4EPrUJFed2HVzvXbM5sd75MvrUlRvbIu5aNp9cKl27bzehSLQl/m6dV4Lhar6YvlMo+R5I2IWEaev2poNp7jM7aan+v3ebWuVpWp7uWR5Wb0/Ur5vCnn3MBnVIdv0NFASc7jewsCAJxT9sHsg63LPlgR2j7Y+gXYB8tTJ74Pxq1lH6xyjPtgZ9jZ3AerX+83zwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACT5/AcAAAAAAAAgMnbOukKPKUPpLajBx6LMaiVwfMLRRWjZReq2L2KsgG9KLRILtszlH6cIzRYZtW39UCvhojl2nn3XzDW52X+LEQ6scanUFbi6CzcxCiXXVKtKvUL1i/gWOf+4VfWLXPU0FiUmY9xBozOz6FOH1uFRse5j9wtZTtHnpKHX1kx2NCRudKq3INl1t2yfju3tudp+t7OIk2/7a4LK2mX7sjfNlXVWC7zC4tF/kzY3VtNb3t57EWxlrficdOLSi6z/FW3jt6HxUc089tw7IlQDv3ADbpc5JkvXMrH+eqVnTR9ayufW7N50gHFnBh4jO/nL9ufXBgNDgAwyD7YUHb7YOkL7IMdNYZ9sDH2wdZNPV37YNxa9sGK9MJx7oOdBWdzH6zO6zfPAQAAAAAAAJg8h+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJPXevlN67fO1u2t3/myrZX0ka91r1pRxmiD30g/UOho6OG6p2XmuXsRvcpfBNmIusjsQl7oxXvyz3sMT+Msf8uD1LHzBmWprfqYShH7OO/KsXEY7dvBmld1qcKk4zYWZLTIoXulyFpFGIpdGF/C15/nZf2KMnceX+YXyn5Zv/2bWleP8+YaGc/RZ+9ymeefzY6vzLoPj68TR0NnXV711d333J6mLxb5vN3d2VtJ+4zf9bHrVy4invXsO9L0y09eS9N/5j++eSVtPp+nea9czmMs9vL2XHjWBt5VVcnVUlG9T0rSNzXf+sCzuTS6ZhVVvPrw6hy6dNuFNO/u7iJN30vmYUTEbXdcTNOz+by7m8e4dHtelwd+4onX9t5fnl4EADaitWIDAp7mRb/zUppuH2x99sHGirQPtnaIeMe/vzJaGeAW+dDfne/J5eyD5clja+L9r748Uuqp0Xs+on7zHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmLytk67A+/W1kva1tZIOLhRXehl9/ThloVWMoeS0iq1qT1nkaP6kHiOZ6+RDr6xdZjFuVTuHRrmXIzGU3rM4YyHG59ZIiLKd5Qvy+OlcHBuH+r59pjodQXEPjRQ5vKwUL6iXocH1KQ0xeIOO3PybmULRkwvja/lgXQbU6+1ooevn79Uat4mPug1O3OGx2Iixvs36q+rDq1d30vRP+JSXpumf/GkfvpJ297NuT/Pe//aH0vS7770zTX/LLz+Ypu/tLFbS7rj3Upr3yceupOl9OTo/V8czfY4dpppD1b2fpo++SSqyD8zP0alcvqcaWFeX1fgUfTjfmqfpO9f3ikKzauQVvLeYnw/EE2vHBgDgmNkHW5t9sCq2fbC1049xfgK32vo3tH2wqirDB4Dnit88BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJm/rpCtwmNby9N6TtCrGIVeOqoxw9NBlmKpPjlVRZjvGhraex65Gs7xSxMny17HH9CRSG52GZb3Xj1MWOXBfFaEPzT9SZv2CwfxpiGriHt9N1MqBztPrPhyZjXl7qrr0stDVOL1qT5G8tZV/HmtvbzlQl+LeX+aFtnJC58l5jOrKWPuze39U1Z7R+zaNUReaxx5sT0+GefR2q9pfrk+z1fzFNIx7n3Nnmv6Ot78vTf/Ij/mQlbTnviSP8amveFma/j/9lX+dpj/x6NU0PevD977rsSLv6Hyr+nb9OMO3ysj4F/UYnbel7L1GuX4OBDksf9KkZTlu1fjk6+eIaozf+558bgEAcHrYB1s/jn0w+2B5mce3DwacZvbBVpOOeR/snPGb5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwORtnXQFntLaalovM6+V9AzK6Otnzyp9E6ErbaRTqg4o8ldVHwu9mYa2vn5l+rIKUr5iIH1wFlV9OxZlUFHoQHP6Bqb+M11ZuzKbCF0WebwjMWK0OT0bpKI9rYg+sn6WWavpVsTY3V2k6S96ybPT9Hc+8Mj6dSkqnvZVRMxmRf5kDSmX1YHb7fALA5mLcR69b0emfxV7tM+Hnitl3rGHWVaXZVG/h97zeJp+8bbtNP37vu1nVtK+4L/99DzG9sU0/Z7n3JWmX7qQ53/yiasraVev7KR5WzHHl8v1+2r/Qp6cZi2GJ32/cojTszpXivW2WoeLBn3ER79wJe3+t743zbu3yNfPapyr4dzbWY3zkg9/bpr3Pe96LA8CAMCpYR/MPtj6RZ6en7Smsg8GnF72wUZsZh/svPGb5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJe8bD89baN7XW3tNae/0Nac9urb2qtfarB/++94ZrX9lae0tr7Vdaa597XBUHAAAAgE2yDwYAANPWeu+HZ2jtt0fEkxHxrb33jz9I+7qIeLj3/jWtta+IiHt771/eWvvYiPiOiPjUiHhRRPxoRHxU731xWBlbt7d+58u21q/0QGpE1b4ifxVmwAZC1LHbYL2L5ldhRgz2bDzDVFsryIW7BgsdLWAkQs9jpMlV4zc0WTYTZjDKQPYy6+BETLt2sN6tnLkDhVaK0L2+sHb+Vn7UabT9I/nH1pvrjy7T9NnIOA8Oz/Dkz+Jv6HFQVn2oTaMr60D24UV7LH/6fmL0EVzMlWd6r7JW3qLM2Ty/udps9QX3POf2NO+H/4YXpOmPP3olTX/3g4+m6ZefuLaaWK0Tg/fK9l35C8r3FVne8kI1KdYOPXz/VOtqucYlyVV7Rt9rVWVeed/uSlo13/oyb8/okjhP4ld91Rd5+rv/89XX9t5fPlg0AJwbt2IfrLU2+phnol7w2y/kF+yD3foo9sGyyhTJ09gHe8er85/5gZP34lfclqbbB0vSN7QP9rYfeaIo4XTrPX+D84y/ed57//GIePhpyZ8XEd9y8N/fEhF/6Ib07+y9X++9vzUi3hL7P0AAAAAAwKlmHwwAAKbtZr/z/EN67++MiDj49/MP0u+LiPtvyPfAQRoAAAAAnEX2wQAAYCLW/1vp61n7D8W21r40Ir40IqJtb7gWAAAAAHC8bmofDAAAOL1u9jfP391ae2FExMG/33OQ/kBEvOSGfC+OiAezAL33b+i9v7z3/vLZpo/wAQAAAGAzNroPdqw1BQAAjuRmj62/PyK+OCK+5uDf/+aG9G9vrX19RLwoIl4WET9zs5WrvsA+qi+wz+Tf9X5I8A1kryt+fLHTzzXX+XuVPwsxWOZA6NpokLIuRZ8nya3I24vg1dTKwvSqw4vk0bqM3BNV7OGBHlCOw+jEHblZij4fbU1LXlCOw6gseBTNLCdcFfvoi9zoGjy49OWDsam1uVr7xsKPxRiczmmIck0Yk+YfDFK3cwOLfxmiuCeKObdcLtevx+hyk6Q/+di1NO+7HnwkTX/kvU+m6dev7abps9nqZxrL58eyWOMG51CWv1o+6rX8JIw9J/O1vIhRdGLdLwPP5iLrYpHM5YjY2p6n6csi/+23X1xNLD4q+/gjV/ILAEDmluyDwdrsgxWVWT+2fbCiSPtgR48NnDj7YFneY94HO2ee8fC8tfYdEfFZEfHc1toDEfG3Yv+Hhe9qrf2ZiPj1iPgjERG99ze01r4rIt4YEXsR8ed774tjqjsAAAAAbIx9MAAAmLZnPDzvvX9hcekVRf6vjoivPkqlAAAAAOBWsw8GAADTdrPfeQ4AAAAAAAAA54bDcwAAAAAAAAAmz+E5AAAAAAAAAJP3jN95fqu0gdRU73mENhBjsMjBzBGR17EfvfXjVRlQdG1dZpV/A8rQZR2LPu9Z5QcrXvb5yGBUc2LQwAt60SetqvfAOJcxCsNlJhdGb/Gqr6ou7MmVVo1bOq+ibE917+c33YZurKLIWfJZqjYr1qZZ8bmrthgpMr1QrjeF0eVpJO9wjx/91h9XlTlwY/Rl9fws8hfzPMuf3T8HF4rYeXp54RifN1ns7fk8zbrYWabpy8VgvZOxWC7z2NX7m3I+V8vTyHJTPD/K4CNrZTmXx6pSybJXa3kZo2xnLh2jIsTWdj635lv5etuLe+KJx69kFUnzPuue29P098a1NB0AgFvPPthQmDyrfbCRZPtgWYhqHww4teyDZaGPdx/svLHyAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk7d10hU4XC+SW5KYpZURitxjLyhjHD30yUnbWfRtz1s02s4iTJW7SM2jj4xzOq0OMRK7lY0fm7eVZdKJVZnVeNbJY/lHVH0+q2Injaq7tujbZdG7y2URKclaXWiDI1ctccmF6j4px6d6QdG5Pfko1azIOyv69tId22n6tcs7afrW1nwlbbEo7vFi3FrVnnJh2cTEHYy9/iOrHM+NPCfqSZRnr+KUUy5Zh8pnczGeg2Wm8Qc7q5orFy9dWEm7fm03zbvz3sfz2NViMXDvVwtOuX5WC2hZ5vpa+cwaW/vS3GPTc/C9Qx6/fO4PPvbKFSF7QTUORYN2dxZDhV64tLoO337nxTTvo++7nAcBAOAUsQ+WsQ+WxbYPljrGfTDgFNvA88Y+2NqhzyW/eQ4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEze1klX4Ck9SWtDuSt1lFuttaIuA82pWtOrGMULqqpkL+hVBYsYs+JCLypZ1yWJUaQPj3Lygs3NlNVa7jw2FmGkTw5esVqL5XLdrAcWaeqFC/kysUzit1kevJr7i0Vex+UyH+nt7dU4Fy7m9bt6+XqaXt0r430+ELvol160PwszK2LUdRm73+bz1fy7fS/NO5vnn7t62ce9KE1/x1sfyuNsr8Z57H1X8goOjk+9Vqxe6aPBq6W8mgBJcvk8GDUQp6xfEaMMXXbu+nW5cPfY83Ckv6q8VYjq/pwl90TsFPdysdz2Yi2r5tC9z71rJe3h9z4xFHu5yNMX1XMozT44V4rQ1VqerWfVtCrnyiae2tWcKLKX74cKW3emQXKzfF2dlfN5/Xm+E/nz8NK9p+bHAAAACmd1H+xd/2FnY9EBzrr7Pvu2/MKp2gdb3Zd46w89vnY9TpsHXl3sMZ9yL37F7cWV078P9uLPTupe7oMV83AD+2BVg7Ljsnf91OU8c/jNcwAAAAAAAABweA4AAAAAAAAADs8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACZv66Qr8JSWpPWBvNHS1LECB/WqhkVyqwotkntfDZQk7Yco2l83M7+Stams96CR8ayGc7QPq/xVXUaCD83PQdU41/mXRw5+5123penXru3kYZarcba35mnexd4iTX/Bi+5N09/1jofT9O3t1fh7u3ns8j4cHKBl0s6trfxzR4tFXmjWV4dVJk2tlpuiPXffe0eafvVqPp5ZP1b1brM8/U2/cH+aXo3znfdcWkm78mRRv518nLN1cv/C+smz6mNkxfhU41zOrSR7lbdqT68fFENxMm1Di1nepmL9HF3khlR9MtaHy71kXd1UtYsl++H3PLGaWK0Tszx9uciDL4t2ztL4Y+8pRt+bLJK+nRfraizHnvulLH8xDtVUGYpdpQ82Z/ReyXKXIY7zNgQAYCOmsg8GcJ4d6zbYce6DcevZBxuqylH3wQ4rzW+eAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACZv66QrcJjWRr+pfn3Vl8aXJSYX2ui33Q/XJS10LPbglV5VZgOqqmfDvKlqVGHyuox1bisq2QfC1FM8v1CNz2y2+jmYXrT+0qULafrly9fS9Ntuv5im7+3uraTN5/nncS7dlpe5tT1P06uOuf1Zl1bSHn7vE0WMPLmaFCNzf7EYm6DluBXtzPL3arIUsZ947GpeZjFGW0n69h35I2K5WKbpu5cXafrz77s7TX/00csraYu9PMbovVKPf9K3Veiib4cfTUn+xTLvw/q5Nzbnsntrr+jb+nmQ597Es7maQ7NZ+aQo6pLlLO6rKvKyWsuz9OqeLYJXymm7ft8uBwst15usZ8rQY8+mMko5zknsdBxi9JZIXzA8V8oHyNHfD469X6lfMTIU1fsEAADOrtO+DwYwRWd3H4xbzT7Y2CuOcx/Mb54DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACTt3XSFTh12vpZ++CVVgSvisyiDFTvsKqU0joWhZb1Lsrs1YW2GqkXFe+96MOyY6oOyF4w3FlrF9mKClZ90lqVPjADlnlyVeZsVtRxuX5dXnjfs9O877j/oTT9Pe/aTdMrjz98ebUexUAsq/m2Aa342FFfjJVZ3hNZ3nIchoqM5d4iTZ9fWH0c3HX3bWnevZ08xrJo/8s/8yPT9O/+5p9M0zNDcz8iqvs5XUOqNWtwTajquLe72l933ZP37XKR37g71/fS9EWRfy8Z51m1DqWph82t9dfh+nkwGrt6fqzejKPP5l4t5lkly+DVc38k96DBICPrzfj9dnTLYo2L4rlfP93LGzoJXYzb+E2xvsE5VJVZDudIFY/vMQkAwIYMbKU99Yoi/dbugwHwAWd2H4xbb/1trYiwD3ac+2B+8xwAAAAAAACAyXN4DgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJi8rZOuwKH6QN42FrrK3kYCFVl730xlBqOkqi5sI8GLIMPNnFUdNhCjLHOwE7MyhzqllkXpfZnnHW1Pzztr5FbZ210UdcnL3NvL8/ekLm9/67vTvPP5PE2/dGE7TV8s8v6abyVxZnnexTJPH74pknb2vEuq4SmNVKW6f8opvsyjl/dh4uH3PLF23oiIu++5PU1/1/2PpOm7O6sdWa3B2XyLqOdtcculfVvFrtK3snkYEcuizy9cWn3UVjF2inlb3RNVHWez1c/GLQfyRhzyDNrA8+P2Oy4MBDlsjFbTqnbGspgrZamr+XuRu6xfGXt9I20/rNTqXhmszQZijK2VVftL9Ru8JGkzb8DKdSjrr8281Rh7fzMcBACA0+Ks7oMB8AFndR+MW88+WFVokX6M+2B+8xwAAAAAAACAyXN4DgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJi8rZOuwL528M/T9fVD9Oz1RdjDwvSizCROK8psRZlV7FZUsqWBBvqkjFGH6cmFNisbVBQ6ln2kRVVflZ1eRS/zp4UOGcletb33ZZo+m+Wfd8lS59vzKvhIcsyK8d/bXa1jm+f1Wy7z9jzxxNU89t4ir8vtq3Wp+vvipe00fff6Xppe3vtZCYNzf1bMt2VZ5tGVkZf5le0Lq/NlUeS970OfnabPt/Lxv/zk9TT9Yz7xvpW0N7/+nWne65d30/RlUcdKNs7VMGzN83toPs/Hs5pDy8Xq/H/+C56V5l0U98qbX/9gmv7Sj3p+mv6Otz28kjYv7s/6uTe2+GVhdnfz++05z7s7Td8p7s+dnTx9d2e1v/aS/o6IWBbr6shDqLxnyxjFelvkHunysj1V7KHcm9GL+zObc614vg0r3w4mz4+yU8beU5bvTYaWp8HnwcAja1NFAgBw6523fTCAKXrO8+5M00/7PhhngH2wYyvSb54DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACTt3XSFdjXD/5ZU2vHVpNSVr1W1Lnn9StrXTZ9oE+q6IOFptl7nne42kNVHGxPmX1krlR5j96gVszZXsSez/PPtRRDEbOto38OplfjPND85WKZZp3N8/YvivzbF/Kl6TnPe9ZK2vVru2nea9d20vSdayP3VW507lfjXM7OgTVucHbGxdu20/RrV1f7cbHMx2exW6QX+d/wuvvXLvPe59ye5n3XlcfS9NF5myUve17v5yXzLSLi0Ycvp+nL5fqFVvf49Wt7afo9996Rpj/28JU0PYu/VawTe3t5+0tFMxe7i5W0j3/5h6Z5L9yZB7n85PU0vV2u1tDVOdSvF3OiaOZxPoKrMkdUc7ysSvm8KQsYqMxQcrn2t+R9Ut3OsfcD1XO/zVbT66V27H1cWfP0BdVk2dR729XajD4nAAA4Rc7oPhgAH3BPsd95ZvfBuPXsg61dm03tg/nNcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAyXN4DgAAAAAAAMDkbZ10Bfa1w76tfj2D3wI//KXxA19234vobbCNVR1HcrexIBtRNXOkz4fHp67NkcscLrWvRmrVx1SWeezlMq/N9nZ+y7bZapyda7tp3q0L8zS9J/WOiFgs1h+Nqp1Ve8r7s6jL5SevraS99GUfkuZ9+1vekxc52xkqMxvPSjYOhypip/dQVb2yMnnycrFM03d29lbSnveCu9O81Rx69LHLafojDz2Zx9lejfOu+x9L81Zms3zSLZd5O7fmq2XurTZ9P32xSNNvu/NCnv/R1fkZkT8TfvVN78wLrW6VYm4t9vI6ZlNrNl9/PaxiRNR9e9+HPXsl7Xe+8jeleX/yJ38pTa/GsxWLS/ZcHV3L2+DTNlWNW/FArNabch0aiF06+hIXs3lxvxXzsHp+zLL5PPg8aNULinslK3NW9WFZlzy9HP80xliZw5I2tWq+bWLuAwBwrM7qPhgAH1DtyZ3ZfTCOjX2wQUfcBzusGn7zHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmLytk65ARESbR2zflV4pXtBX05KkQ8ssQldlttlq+s5jyyJCHqMv80pmsStl7F50wPqhS2XXFhcGhyLN34so1x7N06v2b23N0/TFcnXsWjUpigbNinHL6rL9rGJeFWXOZvnnWlo29wtbd+RtrydFlT+XdGF9XxXpVTvnRVXa1mIl7f4H35lnvpQn37GVL3uLRd63y/S+Le7laskq+yVv/2x3tY6Xn7iW5u1Fvbcv5O3c28vXrUuXtlfSrl/dSfO+4L570vT5HXnsO+7J63Lt6u5qmddW0yIidnZWxz4iYplNxIiYF5NuPk/SH88n3B/+kt+apv/Sz/16mv5Tr3pzmp5ZluOW1yWfhxH3vfQ5ef691fyXbr+Q5r3r3tvS9De+Lm/nC+97dpq+SObWD37nf07zbj0rH7ed6/k47+7spelZP86KG65nYx8Ry7zI9Dl0WzGXl8UzqHo2Ve8Hsvz1+lE9P8aeZdXcykMU87Z8fqwfu7iVY++J4gXF83CxyNeQ7Hnz/Bfdnea9ejlf+65duZ7XpWjmxbuzNb7qk+p9QpG9kI3R6PsyAOD4bd3Z4t5Pyt5bnu59sHf/h+L9EMfmnWe0z1/wOy6m6fU+2Oj74ezC2HvtUSexDzbfWs1f9VX1M9ViL/+h9zTtg93/I5eLF5xun/5nPzRNv3Yl/7n0OPfBKvP5ap+//d89ORSDo3vskatp+mnfB/uwz0kP7Sa/D3bYK9ZV3crv/A/5GcBZ8GGfc2eSenb3wfzmOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHlbJ12Bp7R2tNf3IkAVtixuoCKtyts3k7+u5EDsMvhA7sH2LPtyKP9gFVOzef45kMVy/br0nlek7Nmi3ll61fS6S/LgveftnLX1O7Gsd1XHcgKsnThcmeWyiLNYzV9MtxidWOUYZV1e1W8weCv6a7G7WEm7eNt2mnd3ZzVvRMTtd15M0688eS2Pk5T5nOfflea9fCWPMZvl7ZnNi/YnfduqGEV6OZ+LebFYrr7gnnvvSPP++A+/KU1/+395T5petfP2O1bH4tqVnTTvbbdfSNN3inF+7zsfT9OXi9UOaLN8/Wi/ntd7ezt/i3D18vU0/dq13ZW060laRMTdL8jnZzWey2TcIiKWe6vtLLLGsngeVCtF/kwoYtRB8vRiTSimeWHsnqjW8rH3X4PvNaoHS6Jq+2Lg+RYRsbU1T9Pn26vz/6F35fdPvZYV7zWSeRhRzaHR5+RQ8ljeDbz/AgBu3lncB4N12Qcbq8zU98HOqrO6D8at98hDl9N0+2BFnDzIWJFndB/sLDuL+2CHxfWb5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwORtnXQF3q8naS1LjIhoa6Q8Q3HFC1pakUjr15d53lZWpix0bb2oXx1isMy+Gn82yzMvFsuh2FV/zebJZziK0MueX9iaz/P8RZl333P7Stpjj15J8/akTw6L3ZIJ0IZnaDlAeWo2P6u5XKmm/sB9WM7P8raqLuSf61kukvyzPG+rCx2SjV3dJ7lqrlSV2dtdTb9wKV+ut7by9l9+8lqaftttF9L05aXVMvcWizTvJ33GR6TpP/ljr0/Tq3so69tq/SzX1cH0bI1/9OHLad6H3/dkmn73vavrR0TEXXfelqZfumO1z9/564+kea9c3knTxyXztlrL9vJ1NR/9iL0ifxY/Ww8jIq5drdo5tlYWTRrMu/5zNV2D4rD5mV+oP7m4/rpaRyieE1Wc+k3LatbB9TOK9w9ZVepqjBVazfPd63srabPi+VFZFHO/rszaieX4jHZ5PnPHowAAt8AZ3AeDddkHq4q0D3aeVHvdp30fjFvPPljFPti5cs72wfzmOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHlbJ12Bp/S2ft4WPU2tcucFZjHG6lEWWVzoab0j2kChrY1UcL/UNHW5foRF0Vdl+6vsRd37MnlBOZz5hfnWPI+9u5emP/741dW8RTtbVZlyaiVxqo+pFH1Vzc+q/VXNN6KqY3ahmstVX5Wh129/ryZzUZfqPiwNdGM6l6NuTjXn5vPV+Xz3vXeked/9jkeGyrxwcTtNf/KJ1XviOc+/K837o9/9C2n6xbvyzlos8jFaJmNX9lUx98s1cVaN82r+ZVVo4cknrqXpW9v5jf7Qe59YoxZPpW/mvk37pbqtBu+VZTGemb3dRZq+tRz77N5Qr1TL0OgcSgItivWmFc2pQpfPwyxvuX6MpVfjn43z8Dys+nYof/EkG3nvEBGzWVGX2fpzbnTNHooz9EYzohcTYOgt6OD7NQDg1jiT+2CwLvtgg6GnvQ92Vu3t5WNx2vfBuPWWxb1SsQ+W5J3IPthZlq7xZ3gfzG+eAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACZv66Qr8H7Jl7UPfQl89mX0hwYZlIWvvmC++khCkb8XdW+z1cr3wW+1H+rD/QKStLzMqstnSb33868/Rq3nMba25mn67s5umr5cFn3b1p8Yw32exO7LKnNRv2qAqj4cmOgDTR+OXVa76MO6nUX8JL3skuI+7EOTv6pjNfnz2K3I34t5vliuTpg77ryY5r33eXem6Y8/cjVNf+LxK2l6dq+8+fUPpnmf94K70/S4kHf63u4iTV8sVtvZk7ZHRLRqoMvbsxqLo9vby+tYrX2z5KbL1veIiGURu1Td0El/VeteucaNLX35Wl7dE1VdBquShalij9YlG89Z/giqx75Ir98PrOZfFvdE9Xxb5rdb/QweUTSneJSNPXCq5/48X1cWvWpokZy1f3BBGHt65PO5fM9X9W1Vl3KeZ2l5H46/HwAANuos7oPBmuyD2QdLSyx+7jurrl/fS9PP2z4YR2cfrEi2D3aunMV9sMOGzG+eAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk7d10hU4TI9eXGlrx1g/5zPESQK1WR69L6t6V8GL9CRM1Sctq2AeYmOKIqP3otQif1r3IsRisUjTZ7P8cyBVHbP4s2I8q3Fe7C3z2En2ZdUn1XgWnVU1J52fg5O/nkNHn0Wtj7Vn6Mat6l30+fCq0lZfUc23IjnavMhf1P3qtdV5/tC7Hk/zvuQjn5umv+/db0/T733unWn6tas7K2lPPrab5n3isatpert0MU3f28vv28Vi9R5aFutnfQ/lRqZQVeZsXsytRZ5/vpWP8871vSTGmpU7UK1DVd1HOmBj90qi6pPyOVEp7pV87cvzVmt8eT8n9+1tF7fzehT3/qy4UL1PyMZzbzd/1uzt5pNor+f5k9utVL7XKNbyelIMzKIiRtXO8j3I+iVGPQ2LC2PJh8RfXzWfq3trvrWafz6f57GLNQ4AODmnfR8M1mUfzD5Ymr8cpHyf6bTL9nsiTv8+GLeefTD7YOvHOLuG53niVu+DVfdJhN88BwAAAAAAAACH5wAAAAAAAADg8BwAAAAAAACAyXN4DgAAAAAAAMDkOTwHAAAAAAAAYPK2TroCN6MnaW00SMuiRLQy0mr6crlcM+e+vMTD8levSPIWWUfrkl4pgvS8+dEGP5LR2moBi6Jvq4a2eZ59WXVMknzxtgtp1mtXd4Ziz5L29CpvXrtyfo7M9Gr+VHO86qqhm2swRpm9vA2z+TnYnkpR5my2emE+z0duaztP376QT9DtC/kSfP2RKytpFy7medsyr/hHfdyL0vT3vvvxNH33+mIlbWsrr/fuzmre/fS9NH25yO/nxXJ1kHqStn8hTx5e5Ho2nnmQZVGXaiyuXt5N07M1roqdzbeIQ9aQ8mbJguTJWf0OCh2qy3y+Ol+q52QVoxrQcpiTulfPoKpvZ1t5+ny2Gujue28bil2uT4u8/Xt7q/11/Vp+X12/Wtxvyzx9UdyH+TgPv6salNz7yb0ZUT8Phh9ZaaBqvanGs0gevFfSGEVDZ9Xz5kKefjFZn7aLNSu7ZwGA0+m07IPBuuyDDWaf+D5YxGNF+ul2VvfBuPXsg9kHW63G+bs3z+I+2Gz+RFVFv3kOAAAAAAAAAA7PAQAAAAAAAJg8h+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJO3ddIVeL+2dmK0vnbW6JFljqiSqzjZC8qsxYVWv6IoMqlkG4tRNbO6ktWx6sNWfPQiq3ZEXfXlcplfSFy4tJ2m7+7spenb2/kU31ssVtKuXL6e5p3P84a2dCLm7WltnuYdnhIjV6qpPzDHIyJaNaAjlS8KHZzO0ZMyqxB16KIuVfuT7LN5HmP7Yj7Ot91xIU2/486LafqdF+9aSbv65E6a96W/8flp+q+84cE0/eJt+T30+CNXV9JuL+q9LObE3l5+Ly+Xef6epQ8OaLmuVs+E7FYp16w8SLXezIr8Wfjt7XyubF/I06u+XRTpPW1UXr9lsh5GRLRZtfblcbK6VM+J4cWvkjRzVt3jRb1nRSXnW6vpd91zW5p3q3xOFH1eTLqda6tza76V3/vVo3NnpxrP6iGcJ+fG+jZ/w1a8vSlKLJ9A5fu+yvrv46oY+X1Vq9a+TPVcmRVz69LFfC2/7c7VdfvS7XneC0UMAOAWOYP7YLCu+meEsTj2waaxD3ZWndV9ME6CfbCMfbDz5Szug1VnfxF+8xwAAAAAAAAAHJ4DAAAAAAAAgMNzAAAAAAAAACbP4TkAAAAAAAAAk/eMh+ettW9qrb2ntfb6G9L+fmvtl1trv9ha+97W2j03XPvK1tpbWmu/0lr73GOqNwAAAABslH0wAACYttZ7PzxDa789Ip6MiG/tvX/8Qdrvjogf673vtda+NiKi9/7lrbWPjYjviIhPjYgXRcSPRsRH9d4Xh5Wxfdes3/vJ20nl8vy9JfU8tBUbkH3MoOy7ojaHd/VaqnZmfRIR0Vr5ijx/EqhXFS+TBxua1LGq98bGOaniM90La4SIiLzubTbWnl62f6SOY73Vqo/SjMzzssix9lfTdqRvx2pSX5gn8bcuzNO8l27bStNvv+timn7ns/L0CxdW41TDsLebL6871/L0a1d20vSrV3dX0q5f3yvKXKbpy0Veyb4s0pO0Td3jI+vQziN5exaLPH1WzLnZLL+JFnurce68+1Ka9+qV1XHYj5GP523Pyefica5x1WTMUkdj1A+zPHmWLFzzeZ55vpWPz9Z23odZ/g95zrPTvC//9I9O03/hZ38tTd8t7s+Pf/mHraR9/3f+dJq3uvd3d/L7thWdWN2feeb1sx4aJolTrfuD0/ZYVfdQ/V5r/RiVi5dW3x9HRLzwpflcfOlHPn8l7bkf8qw07zvvfzhN/76v/bnX9t5fvmYVAeDcsQ92wD7YuiHsg9kHW7su9sHsgz3dSeyDvf2Hn9xQqbfeS195Z37BPthq+gb2wd7wrx7KKwLnSO/5jfiMv3nee//xiHj4aWk/0nt/6mnyUxHx4oP//ryI+M7e+/Xe+1sj4i2x/wMEAAAAAJxq9sEAAGDaNvGd518SET908N/3RcT9N1x74CANAAAAAM46+2AAAHCO5X9bZU2ttb8REXsR8W1PJSXZ0r9J0Vr70oj40oiIWf4XWwAAAADgVLAPBgAA599NH5631r44In5/RLyif+ALJB6IiJfckO3FEfFg9vre+zdExDdE7H/X083WAwAAAACOk30wAACYhps6PG+tvTIivjwifkfv/coNl74/Ir69tfb1EfGiiHhZRPzMTdcu/Zr2MnkjWsujf+Dnos3XZChKlbmqdxlmLP9IXVof7JeR/C2vYa9ijIQe7sMy0HppERHpvBqMHUW3lF1StbNoaVVmnrvIOxi7Cj5LLmRpMf6dFK14wWy2emFWlFk1c7G7TNOvXdlL0/d2F6uh8xCxWOQXdneK9CR2RMRyuVr5YnqWWtEv5Xgm8csiBy9U83yZNKpqZ9WeCxe30/TdnXw8szjXruzm9SvGcz7PJ2i9bq02anTdb2XHrD//q/qVa3kyDw8tc71qREQ+9hH1PZR11y+99tfTrL/6hnel6fc8+440/aM/Lv9Lnj/5ml9eSXv8kStJzojt7XmaXsnfx4zZ3A7vaqRq6Cv1jBhYcKq8o8/mAdXzI1uDIyKuX8vXillxT2Rz6Ld89svSvK/8o5+cpn/f1/5cmg4AU2YfbLM1sQ9mH+xIscM+WJp1jXp9UJn2wVbLnMg+2FlmH2ytakTEZvbBYMqe8fC8tfYdEfFZEfHc1toDEfG3IuIrI+JiRLzqYEH4qd77n+u9v6G19l0R8cbY/zNWf773nj+hAAAAAOAUsQ8GAADT9oyH5733L0ySv/GQ/F8dEV99lEoBAAAAwK1mHwwAAKZt9C+6AAAAAAAAAMC54/AcAAAAAAAAgMlzeA4AAAAAAADA5D3jd57fKm0gNaIfV4GHRF59QRusR6+aU8YpX7Cas4/FaFX7s/S64rfcYDOjjeQfHYZy+JMLVR8WA3GMU+WQ4azqMjDPy4lVxNhAXVrRoFZ9NKjq86ouyYWqOYtFnr5zPb+wXBZFDnysqS/zyiwWefC9vTw9y1/F7sWcmFUVLzt3QNHpvZgrvcjfkubP5nm9Z/PB2EU7s/zLcjHLDWaP7B6qxm0kxqG5k+zDJc6qPqxesHqhylvdb73nF7Ix+o2/6b4079Uru2n6fCufW7/4c29L0x956MmVtFm9OOXJg51ezedjlbSpeh9T1m5wWcnDF2UO9kk1ROlbjXJ+5hee94JnpemPP3olj5Os8Vef2MljPJLHAABuDftg65VZsQ9WJNsHW7sq9sHWz28f7Hztg51P9sGebhP7YDBlfvMcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYvK2TrsDNaWslRUREr9KLC1WcgdCVOvRAoeMNzVP7Bhraygvrxx7OXmQeHIxq+NMSi7xliOxCGaRoT9UnZV9lF0Zn6EjsyNtUduzguFXZk/yt6Ntqjg/OzrTQvsyjLBbLPETR0Cp/avDWXy7zC2V6UpdejGdVldlsbOKms3b0XimUdZ+tpl+4mMf4kPvuTdPf/pb3pOmzeV7H5d5qmfOW5636sLq1qvHMg4xeGOzzodwDN/lhZabLUDH21WO/WkOS2/P69b0078d80n157Hn+GcXX/OAv5ZVJypxv5TGGHgcx3LVDiuk8VmYRZHTNrsY/i9SzQY6IVtyHe7uLNH1WfBY1Hbtqfs7T5Ni5npd5x7Pyheu/+oyPXEmr1rJXfd8v5oUCAKeQfbBV9sFG2AcbYR9sJck+WOqs7oOdZfbBsrTj2weDKfOb5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwORtnXQFDtcHsraNlNiKMntsIH4RohfNbOkLBvrkJgrNUuuWF1eqF1RVz+rSNjOelTR6WWR+oW2iD9vYfCuyHzZIa2etZ9ZAodV0G61L0bctmRfLZZ53VgUvPjKUxa70okVVXap7fDFQ5vC4FReqvq3qmNclr82s7PQq0Gr+Kvbg7VlKl5sLeeMfeOt70/TF3iKPvcwn13xrtZLb2/M89mKZppfjWcy5/PasOuv4np/1vZ+XWbR+rB7Vo2l0riRp9/+XfE703TzGE49fSdPvvPO2NH3n6t5KWr1OFhcq1bo6GCZX3LfVM26g7tU9UaVvbeX34TLJf+n2C3nsvTz2vHjXvFXez8laUd2yLa/3E0/mc+iVX/hJafqnfuZHraS98RceSPP+6A/8fF4ZAOAE2QfLanKchdoHW/+CfTD7YOvWxT5YFeh07IOdZfbBktjHuA8GU+Y3zwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACT5/AcAAAAAAAAgMnbOukKvF9P0tpRAxwmD15FyXKPltiLFww1s8xdBC+T129pL4psZYPKF6xd5mAryyKHlMHHBi5NHp0s1QuqhmZjUeQdmeOHSyId6wAV8csuGb0nivTl+mVWel3JNHlkvSmnVvmCo8+AVnzsqg3dFHl6FaOcQuV6s37y409eLoLntrbnafqsqEubraYv9hZ53iLG7s5eXpfqM3DJwt2Ltawc+eH7NlnLB9e+TSwVVR9m43BYmdl47hYNeuc7Hk7Td3fzcauX+GTcBm/+0TVhNl+dQ8tltvAdoqzk0WNU47m3k99Dt99xKU2/eDF5y1uM/dUr19P0ebH4Pf7IlTT9rntuW0m7kNUjIq5f303Tt7by9WaZZ49//2/fsJL2qu99XZq36kMA4BaxD7Ym+2AjRQ6xDzbIPti67IOtX+RJ7IOdbdWEtg+2kr6BfTCYMr95DgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJi8rZOuwGF6z9PbSJChzBGtKDOLMxj6sFIH8uYVrKpdXulVmXWk1Zx5jKoPW6vKXL/9rRygwsB4bnBA165GpRyd8qZYfUUrSm3V2I8l540qx3jM0FQZnMpD7Yn8VqmmYS/6tmpPOS+S/NXQ1xdGJXEG+7a+3QY6d7b+HD8keUib558j64u8LrN5Hmc2K+JkY1RUfGd3kaZvbeeFlu1PyqzW7HItL0LX02LkQVmsT9ULqsk1W82fJO2nz/MLs+IFWfqzn3t7mvfhh57IC62m/jJPn2+vzqHFXj4nqr6q189i/NM1ZDM3f7U89ZGnYhHk0u3bafoTj17O49yzOnbbF8beBi8X+cDd99Jnp+kf/ZvvW0n72df8apr3WXfnc+va9Z00/Xu/5SfT9Oy9VtXf5f0GAJwY+2AZ+2BD7IOtptsHG8pvH2y9rIckn/p9sLOsXFftg62mb2AfDKbMb54DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACTt3XSFXhKj76S1sq8q1eqvIdFGcqfZa8LHaxLYaDMVjSnauVhV1azVoUW+Qe6MCKiJflHxv7Q/ENdPtAnh8iK7MUAlfUuKp71Vans8LG5X4/bSGUG2zMw5dpI5qjrXcUZa2feW9W8rTo3TV4WsasYZbXXn4ujfdv7sip0fWM3bfSiA6ooyyT/rBjjnb1Fmj6b5fnnxcfR9vbWX1vm89E+ryIlLyjyDk3xQyqTxhlZ+CPKBvXyvk3SivGpxnlWDNw8Sd/eyt827e3lc7/q2lkxzsvl+vdQOfdb3p5erCFZt4zeV6XRt2CJ3d38PnzWvbel6S/+sOek6b/vj758Je222y+mef/R3/3BNP2FL743Ta9G7Wde/asraVXfPvHY1TS9GrdD3kCsJpVZN/O+BwC4OfbBjlamfbAiv32wJIh9sDy7fbDVtGnsg51l9sGStGPcB4Mpc0cAAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACT13rvJ12HaK29NyLefvC/z42Ih06wOmyW8TxfjOf5YjzPF+N5fhjL8+WsjeeH9d6fd9KVAIDzzD7YuWUszxfjeb4Yz/PFeJ4vxvN8OUvjWe6BnYrD8xu11v5z7/3lJ10PNsN4ni/G83wxnueL8Tw/jOX5YjwBgMN4r3B+GMvzxXieL8bzfDGe54vxPF/Oy3j6s+0AAAAAAAAATJ7DcwAAAAAAAAAm7zQenn/DSVeAjTKe54vxPF+M5/liPM8PY3m+GE8A4DDeK5wfxvJ8MZ7ni/E8X4zn+WI8z5dzMZ6n7jvPAQAAAAAAAOBWO42/eQ4AAAAAAAAAt9SpOjxvrb2ytfYrrbW3tNa+4qTrw/paay9prf371tqbWmtvaK39pYP0Z7fWXtVa+9WDf9970nVlfa21eWvt51prP3jw/8bzjGqt3dNa+9ettV8+uE9/q/E8u1pr/6+Dtfb1rbXvaK1dMp5nR2vtm1pr72mtvf6GtHL8WmtfefDe6Fdaa597MrWmUozn3z9Yb3+xtfa9rbV7brhmPAEAe2BnnH2w88ce2PliH+z8sAd2ttkDO1+mtAd2ag7PW2vziPjfIuL3RMTHRsQXttY+9mRrxYC9iPgrvfePiYhPi4g/fzB+XxERr+69vywiXn3w/5wdfyki3nTD/xvPs+t/jYgf7r3/xoj4xNgfV+N5BrXW7ouIvxgRL++9f3xEzCPiC8J4niXfHBGvfFpaOn4Hz9IviIiPO3jN/37wnonT45tjdTxfFREf33v/hIh4c0R8ZYTxBAD22QM7F+yDnT/2wM4X+2DngD2wc+Gbwx7YefLNMZE9sFNzeB4RnxoRb+m9/1rvfScivjMiPu+E68Saeu/v7L2/7uC/n4j9NyT3xf4YfstBtm+JiD90IhVkWGvtxRHx+yLin92QbDzPoNbasyLit0fEN0ZE9N53eu+PhvE8y7Yi4rbW2lZE3B4RD4bxPDN67z8eEQ8/Lbkav8+LiO/svV/vvb81It4S+++ZOCWy8ey9/0jvfe/gf38qIl588N/GEwCIsAd25tkHO1/sgZ0v9sHOHXtgZ5g9sPNlSntgp+nw/L6IuP+G/3/gII0zprX20oj45Ij46Yj4kN77OyP2f7CIiOefYNUY8w8j4q9HxPKGNON5Nn1ERLw3Iv75wZ8g+2ettTvCeJ5Jvfd3RMQ/iIhfj4h3RsRjvfcfCeN51lXj5/3R2fclEfFDB/9tPAGACO8JzhX7YOfCPwx7YOeJfbBzwh7YuWUP7Pw6N3tgp+nwvCVp/ZbXgiNprd0ZEd8dEV/We3/8pOvDzWmt/f6IeE/v/bUnXRc2YisifnNE/OPe+ydHxOXw54zOrIPvAfq8iPjwiHhRRNzRWvsTJ1srjpH3R2dYa+1vxP6f9Py2p5KSbMYTAKbHe4Jzwj7Y2WcP7FyyD3ZO2AObHO+PzrDztgd2mg7PH4iIl9zw/y+O/T/BwRnRWtuO/R8Yvq33/j0Hye9urb3w4PoLI+I9J1U/hnx6RPzB1trbYv/Px312a+1fhPE8qx6IiAd67z998P//OvZ/iDCeZ9Pvioi39t7f23vfjYjviYjfFsbzrKvGz/ujM6q19sUR8fsj4o/33p/64cB4AgAR3hOcC/bBzg17YOePfbDzwx7Y+WQP7Jw5j3tgp+nw/Gcj4mWttQ9vrV2I/S+S//4TrhNraq212P8emTf13r/+hkvfHxFffPDfXxwR/+ZW141xvfev7L2/uPf+0ti/F3+s9/4nwnieSb33d0XE/a21jz5IekVEvDGM51n16xHxaa212w/W3lfE/vfrGc+zrRq/74+IL2itXWytfXhEvCwifuYE6seA1torI+LLI+IP9t6v3HDJeAIAEfbAzjz7YOeHPbDzxz7YuWIP7HyyB3aOnNc9sPaBDwGcvNba743975iZR8Q39d6/+mRrxLpaa58REf8xIn4pPvD9QF8V+9/39F0R8aGx/7D7I733h0+kktyU1tpnRcRf7b3//tbac8J4nkmttU+KiH8WERci4tci4k/H/geojOcZ1Fr7OxHxR2P/T+H8XET8PyPizjCeZ0Jr7Tsi4rMi4rkR8e6I+FsR8X1RjN/Bnz36ktgf7y/rvf/QalROSjGeXxkRFyPifQfZfqr3/ucO8htPAMAe2BlnH+x8sgd2ftgHOz/sgZ1t9sDOlyntgZ2qw3MAAAAAAAAAOAmn6c+2AwAAAAAAAMCJcHgOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH58Cp1Fp7aWutt9a2TrouTNfBHPwNR4zxt1tru621J1trd2yqbsehtfZnDup55HYDAADAFNnT4kb2lk6Hgz78FxuI81mttQc2USfg9HJ4DpyY1trbWmu/6xaU8/mttf/UWrvSWnvNM+T9rIM3d9/ztPRPPEh/zQ1prbX211prv9pau9pa+/XW2te01i7ekOebW2s7rbUnDv55fWvt77XW7n5a/D/WWnt7a+1ya+37WmvPvuHaPzgo44nW2i+31r7oaa/9htbar7TWlq21P/W0ax/0xrC1dt9BjH90UP/XHLTrE5/2uu87SP+sw/rrkH78iNbaDx7U+aHW2tcdkresf5L3qf588iD2a1trv+Nm6niL/cve+52998sR7587X9tae9/BP1/XWmvrBGqt/b7W2k+01h5trb2rtfZPW2t3rVuRw/q79/6Nvfc7h1oGAAAAE2NP64Pin6k9LXtL9pYAnonDc2AKHo6IfxgRX7Nm/vdGxG9rrT3nhrQvjog3Py3fP4qIL42IL4qIuyLi90TEZ0fEdz0t39f13u+KiOdFxJ+OiE+LiP+7HXxStLX2cRHxTyLiT0bEh0TElYj43294/eWI+AMRcfdBPf7X1tpvu+H6L0TEfx8RrzusUa21D4uIH4+I7++9/8Xeez+49OaDNjyV7zkHdXzvYfEOKedCRLwqIn4sIl4QES+OiMM+2blW/W/wdQdvwu+OiH8cEd/TWpvfTF1P0JdGxB+KiE+MiE+IiN8fEX92zdfeHRH/34h4UUR8TOz3798fKHu0vwEAAICTYU8rjmVPy96SvSWAksNz4FRorc0PPo36UGvt1yLi991w7dmttQdaa3/g4P/vbK295emfVq303n+09/5dEfHgmtXZiYjvi4gveKpuEfH5EfFtN9TpZbH/JvGP995/sve+13t/Q0T8NxHxytbaZyf1uNZ7/9mI+IMR8ZzY/6EjIuKPR8QP9N5/vPf+ZET8zYj4r5/6xGfv/W/13n+5977svf90RPzHiPitN8T933rvr46Ia1WDWmsfGfs/ZHx77/2vP+3yt0XEH73hh4QvjIjvPeiHLNanHXwqdX5D2v+jtfaLB//7pyLiwd771/feLx+0+xezWOvWv3jdMiK+PSKeHfs/oEVr7SNbaz928Inbh1pr39Zau+eGer6ttfZXW2u/2Fp7rLX2L1trl264/tdaa+9srT3YWvuSp7X797bW3njwqeR3tNb+6kh9n+aLI+J/7r0/0Ht/R0T8z7Hfb+u0+9t77z/ce7/Se38kIv5pRHz6ugXfbH8DAAAAq+xpnZ09raRd9pZOeG+pfeBrDv50a+3+1tojrbU/11r7lIM+frS19v+7If8zjc+XH/TtEwe/Hf+KpMzt1tp3tNa+u7V2obX2ooP/fm9r7a2ttb94Q97b2v5fK3iktfbGiPiUo7YZOP0cngOnxX8b+5+Q/OSIeHlE/OGnLvTeH46IL4mIf9pae35E/C8R8fO992+NeP+fhyoPZ2/St8YHPrn6uRHxhvjgH1ReEREP9N5/5sYX9d7vj4ifiojPqQL33p+I/d/M/syDpI+L/U9sPnX9v8T+m/yPevprW2u3xf6btDcMtOUjYv+HjH/Se/+byfUHI+KNEfG7D/7/i2K//VX9fyr2Pzl84w9Tfyz2f9iI2P+E79taaz908Cb2Na213zRQ37Uc/GD0RRHx1oh491PJEfH34gOfnH1JRPztp7308yPilRHx4bH/ydw/dRDvlRHxV2N/7F4WEU//82vfGBF/9uAT1x8f+79Z/1RdHm2tfcZA9T9ozA/+++MGXn+j3x5j8wEAAADYHHtaH7h+qve0kjrZW9p3GvaWfkvs99kfjf2/tvA3Yr//Pi4iPr994E/rl+PTWvvoiPgLEfEpB338uRHxthsLOZiH3xcR12N/HPci4gdiv//ui/3748taa5978JK/FREfefDP58b+hxaAc87hOXBafH5E/MPe+/0HP1j8vRsv9t5/JCL+VUS8OvY/wftnb7j27b33T9hkZXrv/ykinn3wpit74/3ciHhn8fJ3Hlw/zIOx/6nWiIg7I+Kxp11/LPb/bNbT/R+x/2bu3z1D/Bt9fETcERH/8pA83xoRX3TQ3nt67z/5DDG/I/Y/zRsHnyb+vQdpEft/6ukLYv9PgL0oIv6viPg3bf/PuW/CX22tPRr7B/j/MCL+Zu99ERHRe39L7/1Vvffrvff3RsTXR8TTv7fqH/XeHzyYZz8QEZ90kP75EfHPe++vP/j+qL/9tNftRsTHttae1Xt/pPf+/j9N1Xu/p/f+EwNtePqYPxYRd7a23ndTPaW19jmx/6b9/zPyOgAAAGBj7Gl9sNO+pxVhb+n9TtHe0v948BcOfiT2x+U7eu/vOfit+v8Y+x9OeabxWUTExdjv4+3e+9sOPtDxlGdFxA9HxH+JiD99MOafEhHP673/3d77Tu/912L/N/G/4OA1nx8RX917f/jgAyb/6Dg7ATgdHJ4Dp8WLIuL+G/7/7Umeb4j9N83/vPf+vltQp/8z9j+t+Dtj/08+3eihiHhh8boXHlw/zH2x/71VERFPxv6btxs9KyKeuDGhtfb3Y7/9n9/7+7/baR3fHxHfFBE/1va/IyrzPbH/m+T/Q+y3+5l8e+z/Ga6LEfFfR8Treu9PjdnViPiJ3vsP9d53IuIfxP6f9PqYgTof5h/03u+JiNti/xPdf7+19nsiIlprz2+tfefBn2d6PPa/a/3pP/S964b/vhL7P2xEPPMc/G9i/0MCb2+t/YfW2m+Nm/f0MX9WRDw5Mq6ttU+L/XH4w733p393GQAAAHBr2NP6YKd9TyvC3lJEnLq9pXff8N9Xk/+/M+Lw8em9vyUiviz2P7TwnoN8L7ohzqfF/l8K+Job+unDIuJFB7/5/+jBhyq+Kg7+jH+sd38D54zDc+C0eGfs/5mdp3zojRcP/ozSP4n9T5P+d62133AL6vR/xv53QP3b3vuVp137sYh4SWvtU59Wz5fE/huxV1dBW2t3xv6fHfqPB0lviIhPvOH6R8T+pyTffEPa34mI3xMRv7v3/vhoQ3rvfzkifjD2f9i4L7l+JSJ+KCL+u1jjB43e+xtj/83i74kP/pPtERG/GBEjPwjdlL7v9RHxf8cHvk/s7x2U/Qm992dFxJ+I/T/ntI5D52Dv/Wd7758XEc+P/T/v9F03X/sPHvOD/177z2O11j459n+A/JKD75gCAAAAToY9rQ9cP/V7Wk97rb2ls7e3dOj4HPw1h8+I/UPxHhFfe8Nrf+Tg9a9urT11OH5/RLz14Df/n/rnrt777z24fuiYAueTw3PgtPiuiPiLrbUXt9bujYiveNr1rzr495fE/m8yf+vBDx/PqLU2b61dioitiJi11i611raf6XW997fG/p/9+RvJtTfH/p+b+rbW2qcdlPFxEfHdEfGjvfcfTepxsbX2X8X+m+NHIuKfH1z6toj4A621z2yt3RERfzcivufge6SitfaVsX9A/TnZp5NbaxcO2tciYvugfdn6/hdi/wekG98g3uirIuJ39N7fVvfKB/n2iPiLsf+9SP/qhvR/ERGf1lr7XQdj9GWx/6nlN2VBBuqfvfY3RsRnxAd+OLgr9j95++jBD1R/bc22ROzPwT/VWvvY1trtsf+dRjfW8Y+31u7uve9GxOOx/6egbta3RsRfbq3dd/AJ2L8SEd98Q3mvaa397eyFrbWPj/0/MfU/9N5/ILn+t1trr6kKPkp/AwAAACvsaZ29Pa0b62BvafX6RveWnineoHJ8Wmsf3Vr77Lb/lzKvxf5vrH9QH/fevy729zRf3Vp7bkT8TEQ83lr78tbabQf3w8e31j7l4CXfFRFf2Vq7t7X24tj/CwfAOWezHDgt/mnsf+fRL0TE62L/Ty5FRMTBm/O/HBFfdPBdNF8b+58c/IqD63+8tXbYJyv/ZOy/WfrHEfGZB//9T9epVO/9J3rvDxaX/0JE/LPYPyx+MvbfdL4m9v8E043+emvtidj/k1bfGhGvjYjfdvDdR9F7f0NE/LnY/4HjPbH/JvC/v+H1/1Psf6rxV1trTx7881U3XP+Rgzb9ttj/M2BXY/9A++lt6bH/vVo/ExE/evAG8cbrDw5+t9J3RMRnRcSP9d7f/ye9eu+/Evuf+vw/Yv8Hqs+LiD948Cfco7X2QzdT/xv89YM+uHzw2n8e+5/gjoj4OxHxm2P/e57+r7hhHj2T3vsPxf73XP1YRLzl4N83+pMR8ba2/yeh/txBG+OgTU+21j5z3bIO6vsDEfFLEfH6g7r+kxuuvyT2P/Wc+SsR8byI+MYb5sON8/+w10aM9zcAAABQs6d19va07C3d2r2lZ4o34rDxuRgRXxP7v8Tzrtj/Df+venqA3vv/GPsfBPnRiLg7Iv5A7H9v/VsPXvvPDtKfKu/tB9d+JAb/ugFwNrWxrxgBAEa01v7fEfGVEbEbEfc99QPmIflfHBH/qvd+U9971Vr7+Yh4xc18h1pr7U9HxP8SEZci4mN77792M3UAAAAAYDPO+t7SUeIBnASH5wAAAAAAAABMnj/bDgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAwecd2eN5ae2Vr7Vdaa29prX3FcZUDAAAAACfFHhgAAJwfrfe++aCtzSPizRHxORHxQET8bER8Ye/9jWn+eettO7swUOZ4NSetDXTYMUyRD5LV5bjLHFH3VXEhS95UezZRZHFhZE4cWpmRCKfpxi36JUs+VfUuVHXcxL1VPTfaYMdkcaoYVbXPwFAcq82slZtZoE7Tus2qkXtlU/fbyJQYfdSeKmd1gSrqvXe1P9R7f96trQwAnF2je2ARZ3cfbHntBArdkPlt6+e1D1ZeWTt5ceUUNYhTb/uOo/9+n32w9e1eXm4gCiPmt532DYLzZ3H1bD6Htm4/A3Ol3k+6tfXYkN572ulbx1Tep0bEW3rvvxYR0Vr7zoj4vIjID8+3Iy69NLuwfoGjD6tRI4eTmzhrHavJuPnW+m9KlsuBU8UYf7MyS6pSvrEZ7PRe1T15QVXv2VZ+YZZVvKhLVY9evFeZzfMyq3k+dHhe1KUV7ZkX7Y98TcljV3N/NtbOrFGj91s1t8oxSgqdbeiNbdXnafix2zDmxRyq3vBnqYtFPkGXyzx9a2u+duyIiMXuYiVtNs/7ZPQHlZE5NKr80Fm5xq9/r9TtzPOX63MavIhRzYkyvQif1OU4PqD3jDZ1wjtwH5bzrarLRk6Vxwwdno+2s4pTzc8kzGgfHue7vtFh29RGyojq+ZnVcvR93EM/d/3tN1crAJisoT2wiLO7D3b5TWdzUzQi4s6Xrb8Fah/s6PtgD79up6gHrPqQT7xjNdE+WJq+iX2wB3/qyTwvx+buj8o+Mbch9sFS7/u565sJdIvd8xsvpulnYR/soTPa55Xj+rPt90XE/Tf8/wMHae/XWvvS1tp/bq3951h9bgAAAADAafeMe2AR9sEAAOCsOK7D82f8nErv/Rt67y/vvb888g9pAQAAAMBpttbvatkHAwCAs+G4Ds8fiIiX3PD/L46IB4+pLAAAAAA4CfbAAADgHDmu7zz/2Yh4WWvtwyPiHRHxBRHxx8rcLY7+R/sHv4N2E98SMPr1UiPfe7sp1fdPLIvvcMl6cfhrMwa/CyPLX39PbvG9LoNlZullmYPfkZ0VWX4PSPHxlTJ28f096ffH5jkjiu/SKfMPDEX53d7ld7Uf5/dSD14Y+HKP0e82r6704juT+sD8rPp2Zyf/O4Bj39depBbzs/qepuo7o2bVfM7KLL8rrppbhfJ7gpMyR75P/BDZ9+WNPj9Gv3Ov+h7zNMTgd5vXX3i0gRiDN9exfqd0klb3atWeDXxh92iflIHWX+TK79MevCWqONmcK9e4wXchVZkj92HZ5aPf+Z4E2tTb0r4Y+D75k/jieACYlrE9sIgzuw92ltkHu7X7YDAi+3nNPliefpz7YByfbh9sfRvbBzujNrT3dhL7YOfNsRye9973Wmt/ISL+XUTMI+Kbeu9vOI6yAAAAAOAk2AMDAIDz5bh+8zx67/82Iv7tccUHAAAAgJNmDwwAAM6P4/rOcwAAAAAAAAA4MxyeAwAAAAAAADB5Ds8BAAAAAAAAmLxj+87zEe3gn3X1LMasiJBlfqrQEUmc1gbLPBFjlRntljxIHqUXVcmyV31bpfcq+IByPMcDrZ11Vnx8pfeincu8nW2+mr/sw7I2G5jPg11Yjdusup+zIgfbuVxWF4q+HZoXxbgVnTjSztEp3sq6DAVJXbiwnV8ogl+6lOe/dnV3JW25yAdoVoxDlX+5yCuzdWG+klbdV9X8HF0r5sn9WY1nVeZ4/uN7EPXiHsrn+ehDeCx/1szy0Vx2ydHfKIzGHlqHi8zjT6z121mPzsCD/JA4+ZVykufJ1TiPrOVl325g/YyiW0bX8up9TxFo6N4/Ve9XAWBazuo+2HlkH2wDNhWHycqmkH2w49sH4yTYB1u7zI3tg51RZ3gf7Lzxm+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAyds66Qo8ZTZf/VL6xaL6svuBwCN5R+P0vH5jQUbLLLIWoasatoEX9MF2zqpmDjS/qt9wlxeyMFWX1HUpKjNUxzx2qzpxmQfPq1LdP3ns2dCNNXgfFuazsc/vDDSznG9V+1tRleXIpKvKLC5UobM6VlOiql22pkZELMs5tJq+LNbgvdhN0++59440/fHHrqTpaYcVnVLdb1XfVvfQcrFczTu8gBbpA0tCr8ZhbAEppW0qQldzvFzjBto/3rfFvVKtZ0llNvacSAMV862KsYFJVK4fRYRx2YN/LEIbXoeTIvvYjTU8t0byllXZwPu+wWdnufYNPITram9uFgEA487kPthZZh8sKXO0LpvYB4OMfbB16rcf4ej7YNx65ePAPliS87j3wc6ms7EPdr74zXMAAAAAAAAAJs/hOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDytk66Ak9ZLvtK2mzW0ryrOQ9RZc5DDwUfqkdEtKrMTRWQlVnGXj94G6x4FXq4/YlZ8XGP3vPgVd37QPvruuSV6enADTZ+sBOz5CrEsrowy9Or+7CMk6haX8UoeytpaDk/i+TRsU/jV8NTxCiXoZFpUWUebU+RnoWZz4s5XpR57dru2rGrC9V8G1VFGVnPyryDy8disUxCFEE29MzK7q1q3IbbuYkhGmxPK14wNhTVenP02OV4VrEH1pAydrn0jT6z139m1fN2bG6NrX1DRR7yvmf9Ipd99Z6NGH8/tIk3clU7+wbquIG3mQDAEZzFfbAzzT7YBuoysg8GR2QfbMgm9sE4RvbB1s593Ptgp96Z3gc7X/zmOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHlbJ12Bw/Te0/TZfPXMf7nI87aWx27FharMLHue8zDVK6pKrp0zimpvRGtVn1S1qeKM5R8LXl1YfzzLOVEVWZQ5Sy70ZRGkCF72VZGepbbqozFFmaNzqM0GboqybwfviaSSy7JBRejB7CMd03te71nWV3FI+5Myh++fwXZm47lc5BM3W4MjInau764dOyKiJ+t21c6q+cvi3qryZ2v8aN8uqzlRpI/cWtUzqJ4qA9Gr+pVFFuvnyLo1GruaK8sifxq7KHP0EZw1ZzTIYO4s+lB/H6J8f5PUpl6bx+pSr3HHF3sjIzT4PCzn80be9xw99nG+/QIANuu074OdZSM/OtkHK4oc2AeDIfbBkvQ0eSP7YJwe9sGSvBvaBztvzsI+2HnjN88BAAAAAAAAmDyH5wAAAAAAAABMnsNzAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJ2zrpCrxfX026cGk7zdraatr1xV6RN8kcEb0nBRaxi+rFrOWfPahiR1XmvKjjcjV/L+pX1btS1DBGwlTNHKzK4AvyzFWIodCj7RkY5jYb65VqfKpPu4zGT2NUc7/ql4EiW9m31YQ+epllkKITqzr2ZDT6siozD5LcyvtlDkzc5bIsNK9JNYkGzGZ5Z12/tpumX7r9QlGXojJbqw3N1r19VWfl+au6Z91Y1m9UNaBZm45+yx5eZtqm0efhWJ/XY7e+0Xk+Yla9Hyjyp2v56MCNdeHgM7gYt/I5uf6a2Ko3G6Oq4czGYkNdW1n/jqjfa9WzJbdM7omRdf+wF4ysW9W9PDyfAYDNOoP7YGfa2PZDyj5YkXzuJgu3nH2wxPHtg3ECimG2D7a+0X2w8+Ys7IOdN37zHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmLytk67AU2bztpK22FvkeWerZ/7z5PUREctFL8rLPzewXC7T9Bar8XvPY/fI01vL69iXef4ieC4PXcraU+fdTJlD/VK0s+rzsiqzwUpuQlLF8Vocvd7DfVL0eTFt0xKqvHWMTciDl2VWc2vk5mrVPBysSzlK60+iZbF+FLfK0MyqemRre56mbxfp16/vrl3AhQv5Y2l3Z6+oTW6xyNfyWTr/i7W56sTKSKeX91vxLKtil8+hLG2sPeV6O3BzDfdh9Zws25+EKEJX7R+q4ui9PLyuDqjqPfixyHR6Dq6fZezieZM/9wfnZ1XmyDpcFjnY0Mr6b2+Oty6j9yEAcEucxX2wjb1POgH2wY7R2Z0WnGb2wYra5Mb2wbjVyn0t+2Dr29A+2Fl1JvbBzpmJTC0AAAAAAAAAqDk8BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYvNb7yX8Z/IW75v0Fn3TnSvqjjz2Z5l/sLVfSZrNWRM/Tq3ZXUUZil7nHsg+phrFVhY4lD2nHGLzuw/zCSJ+XfTUoizMaerQuWe5W3BNl7NGlIAlTjX05Dcv7tsi/gTGql7z8Qpq/inGs93hVv4F6H5J/rG+LGMV49mWe/+Jt2ytpO9f38tij60q1JqYvyDMvi75aFu0ZUo3PyDw8JFCWv3zeb2o+D5Q5+tZjZH6Ovq85zmfzuOT5cfQQ+8nl26Rb3wFDJR5j/crHYXWrjN776y83w2vZRt5qFZkfet311/beXz4SCgAY01o7+c24m3Dnx479Do59sA3Etg+W58/SJr4P9sB/emIoNkf3gt9ye5puH2ztIof3wR563bWj14W13fsJq3N2s+yDrWa2DzaS/6j7YI/+8k7sXl6mYfzmOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHlbJ12BiIjF3jIefuSJtfNfuLBa7b3dRZ653WytnjlQm+XB+7Ln6XnyWBWLzG0wvQw/+oINyIscq8d4tW9tO6uxP+QVaWo5Pll6UeZwVQotCdTL6Hm9sxj7FzYwPmVDx+o4Sz5itCzu8fomL9aK8YmRhK766ugTYLFYFmXm+YslMW6/42Kafv367krafJ5/pqvuqmK9rXL31TZtYBgO4gwEGh2ewTpmQ1HNleq+rW/PPM4y6dtSuZQVa0URJuvzWfVs3kTnDt5uo8/UrI599Dlexa7yZ4VW9R6dh1WYkThF5tG1L80/tmSXi9zI/CwXytLYMyvNv6HxBACwD7YZ9sHSV6Sp9sE4zap9IPtgWeahZD+vnhb2wcbqYh9s7Ri1W7wPdsjY+M1zAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8rZOugJPaUnafGue5t3bW66k9SxARMxn+YXlIs/fo6fpt91+YSXt2pXreZBWVCYPnTc+InqSv8h66JUhSZlVn7SqnYVjr/tA7MGqFzFufb03EiKbWBFlp5Q1GahiNYeWq7fyQVXG6jiibv7ADVrFKNab8t4vjGTvRYOWy9FC119wtrbztblqf1WTrMiqPZVyPAfz53nHgpexkwvl+lFOw/zCYHeNKWLXY5S1qXh+lGUW7axKTPpx9JnVRwa0XD+O83lQlDn6gmo808SqD4dCR6/W+IHg5b1crHFlHdM1rihzU4+g5AXDz9TBTu/JG+JNPMcBACIiev1DfPGCIpB9sKE4Y+yDrZj4PhjHpzq7sA92fPtg3GL2wUZC2wc7i/tgh7TRb54DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJs/hOQAAAAAAAACTt3XSFYiIaC1ivjVfSZ/NWpp/L/pqjMjzLpereW/GtSs7K2m9CJ3X5LALR8/fRmMXeta3VfDRrh1pz2DoMk4VKKl72c7ByqTZRypySPayjuvXJKJt5p5I+7C4Z8u5UjWnaGcWpu6SsT6v7ufel1UBq3mXG7rJk8r0ooJV+nw29tmo3b29lbStZF0+rMy77rotTb92dXX9PIi0krIsuru+PfMLiyJQdg9V91X9/Cju2yp3Er+ab4PTtuyXkbu8bGVZyQGbWsyLQENVHFzi09DV2lRUpJpbZbWT7IOPj2OWV6Zehkcn+kBNiiWufG+WFjn2PDikNuunVk2vHjUbuId6sZaVz2wAgIJ9sMHg9sHWq8gh2e2DrZ2VE3DnXZfSdPtgx7cPxi1mH2wgNeyDrZ/1TOyD+c1zAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8rZOugIREb1HLPaWqxe28rP9+Ww1vfee5m2tpenLRZ5/Ps/LXC5X88+SehxWlyiSI69ikVxk3piB+INVqZu/eqVvqPXlvEgi9aKGrRd12UhXHeN4VvOwmm+DVcn6cHSOb0JajzjkPqziVB8lysa/ak916w/WJctfrWXj8rpsbc3XqkdExMWL22n6E49dzUtM1s/KbGPtzGVtGh2fagJUa8hxGqn6ptpZ3+gDMdrgc3KkzKLI0fcJaXo5Pcfm7Ujzq1tieLYNDGdZ5mAfjrzBqdbycpJv4nYbfmYNPyjXr8ro7TZyP29sEgEAUzcr9szsg+Xsg41dObKJ74Nx69kH80PleVdPT/tgQ4XaB1utymnZBzskrN88BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEze1klX4Ck9+Wb25TL/tva+WCap+ZfAZ3EPyR6LNHbE1tZ87bxlkUWZY4o+6WPBq7pspo5V7KMHr5rZigHdRHvKOTRQZh2jilxUfANzq4y9ifzlvBotc+BC1VVjt37Zt2lyNZzlMI+1fzZbzd+rBhWWvVifNnCvVGvfxUvbafrVKzt5oKRNdT0G+7AIlPVj9ayZzYsYVddWNjBvq45pA2tLFXtwakU9FlmgkRurjl0+s5J7ZVk9mwuDXV7EGO7EotAs9mae75V01DbVnKG6DC7a5fNw8AUbKLTur9U4VeSy2uXbgdFFJIuxoYEGACaj/LnUPlgR2z7YuuyDDVw4xjnLGPtghWPcB+N0sA+Wsw92vvbB/OY5AAAAAAAAAJPn8BwAAAAAAACAyXN4DgAAAAAAAMDkOTwHAAAAAAAAYPIcngMAAAAAAAAweVsnXYGIiNZaXLiwWpXZrKX5r1/rq4k9SdsPPlyXTF+uxq/y1vI6jlV9tD2jF0aCF+lFe4ZCD1evKvTo7WwbiLGp2L1qZ0/ilOMz2lfVBF1NmlUxNnN7pnF60Z5NTPGIiJaVWWYu0os6buBWqdesweB7e4uVtK3t+VCM69d20/RZVcckua73WIOWyZr9DAWsxlhsYoRirOrVXBmsSnVfZDZ1r/SB9WxTq2o6zoNLWbmGZIGK2OP34cCAjk7DakCrdmbvtY5xzSoDjU6KTUyioq8Gu/CQeyibn4PP/cFOz+ZiHeL43t8AAOeTfbAi3T7YscW2D5Ykjf6QwLGxD1Y4gX0wbi37YIPsg63tNO2D+c1zAAAAAAAAACbP4TkAAAAAAAAAk+fwHAAAAAAAAIDJc3gOAAAAAAAAwOQ5PAcAAAAAAABg8rZOugLv17PElmZtSXIv8o6azaoyV9OXe4u18x6mzJ8l97Sjoo22v4iTpVb120yP5+NZR8/rXQTZjOHQ67+gaE0ZoRrndNwGyyym/pAq9sh8i9jU3Fr/Xj6szJ7Vsqh4r+7P0cHI8hcx+nKszKqO29vzlbRlkffCxfzRsXN9L01f7C2LuqTJqdH2lPmzjqzm50gFDym0pVOoKnOsyLKO60/bstDqeXi89+1Y8IHHZF3vkWdwpXo0VdkH1qG63kXs8p44+nuqskvKe6jInxS6iWVyPNBgvTdQmdF1pRq3Kky2bh/nWyQAYFr6Mv/Zzj7YGPtg60ewD8ZpVu2b2AfL6rGZfTBOCftgI8n2wQacpn0wv3kOAAAAAAAAwOQ5PAcAAAAAAABg8hyeAwAAAAAAADB5Ds8BAAAAAAAAmDyH5wAAAAAAAABM3tZJVyAiokePxWK5kr7sPc3fZm01xiLPO1yXZR6nx2p6a6v1ONRo/jTE0WNsLH7V5aN1zOIUIVp1YdDx9uP6DRrvquKeGAg03vYN9NUGpsRw6CJI1Ydlmck6VOUtx6cc/6r2q3Gq9bAX6ZWqzDZb/SzVrFgPr1/fzeuyuoxHxCFreVKX9XukjnGYkf4q+2q0zJE1oZqfg4+40XmRWRbjX0qatKm1tppbI6tFXZNydq0du/woYhF6VvRL1ufDK/bwPTGS9+jPoMPiFMGL9DL6BupRBK/aX75pGZmfVZnFC6q6J8kbmOEAABER8eQb65+G4UbP/c2X0nT7YLlN7IO9eheH4wAAuUhJREFU6LfcuZG6DO2DFT+XVD/zVpV58KefXKNip0+1b2If7Nbvg3E8Hv75nZOuwk17zidfTNPtgw0En/g+mN88BwAAAAAAAGDyHJ4DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJm/rpCsQERE9Ytn7avoiSSu0VoReP8RwAb0IXlQlYgN1qUJU7S8NvyCLUaQX/VI2P6tLNXBlmVXokYmR5z3OrhqOM1CZTdR7U3HKEEXw8t7aSPvHJlFP8rf6TkxT0/UtDqnjwFrRZmN9WDV/uViuZi3yzmbzNH13dy8vsoiTJZf1LqzW+qlA618o59Xg+PSBgSvbWSUP5s86fTZ4v1XtaVXHDKwVw+0ZUE79stpVv2R5x5RTaLn+mjCy7kVsZv0cmcs3U5e8zFwrLlTraiUf52LsyzcVVfRqPifPj+ptyWifb+qNBQAAHAP7YGPBJ78PdkZle2kR9sHSvJvaB4NjYB/MPljGb54DAAAAAAAAMHkOzwEAAAAAAACYPIfnAAAAAAAAAEyew3MAAAAAAAAAJm/rpCvwfiPfDz/w5fBl1vKb6qsvu19Nb1WMUUWZG4lftrPKv1bSTZW5md7aTOy8+QOdcogs92jktoEyR/tqtMyh4KPtGZj7o7dJr+7xIaPrR568LO/9m6jS02PM8iDLZV7mLMm/fSl/ROztLvIY8/zzWMvFMk3vm1gUNjGcg7F7fWHt5PFbpbqw/vOjmvt1FxZlDk7/TcQeCX6ca0IfXFeL2y2GJkvxMcfRNXu5zO/DTay3o+vqSJnDa3a13g4sFlX1ynpv5LGykRsrDVNF2MjjEAAAEvbB7INlqn2ws8o+2PrJm9sHg/XYB7MPtk7ow0rzm+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAyXN4DgAAAAAAAMDkbZ10BW5KXyvpUK2PvmK9ehxaZhu8kCVXZQ6EOPzCcQUZDL+Z0ENaMQ6baf7YwPUifyvC9KTu5Rwv2tmL/G2goVUflvmHco+9YPQWr6o+FGewQSPZB2/9ut7Fhfl8vlZaRMTe7rKoTDGHZnktF4siziYMjX9R77Jzi+Sq0zfwzCoHdOCeG2zOSOgy/ui8rS7UzV99QTUOo30+G+2ARLmuFA1NU4vbpBf3WzkPK1n2TayHh8ZZDTTyrLkZ6ViMdtVgB8xmyWdUy3ViM/M2fQ5XsTfxXhgAAFL2wfLYgya8D3YmVPvx9sHWDVHz8ypHVe6NJ2n2wVJT3wfzm+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJPn8BwAAAAAAACAybvpw/PW2ktaa/++tfam1tobWmt/6SD92a21V7XWfvXg3/durroAAAAAcGvZBwMAgGnYOsJr9yLir/TeX9dauysiXttae1VE/KmIeHXv/Wtaa18REV8REV9+c0X0Ir2tpqwmHRphIPQzXUhi58F7z2NUdc/q2MrMx2i4r4rs1Rhl7RyMUZe5gf4aGJ+DQtcOsbnKrFePiKFqH+Qv76JVyyp4FXsoe/6CTd38rfos0Wr+8WVibAb05KaoQxdXlsVgFPmXSZnLRR6jKnKxl+dfLgbmUDWcy2pdLcKMdPnA2rR/YSB2RKRLfxEjG/vDDM2solNmRWWGn5/rF3lI344NaN5fxbO2qPjQc2LweTA6P9Pn4Yaee1Vd0jV+cI6XdRmYoUPPmkPjFHUZWoaq52cxh6r82Vo++oZgcB0aGc8TeU8JAGfbLdgHg/Nh5GeBZ4q0flb7YEMXTtE+2FlV7ZvZB1s/xug+GKxvYG/HPlgRe9r7YDf9m+e993f23l938N9PRMSbIuK+iPi8iPiWg2zfEhF/6GbLAAAAAICTZh8MAACmYSPfed5ae2lEfHJE/HREfEjv/Z0R+z9YRMTzN1EGAAAAAJw0+2AAAHB+HeXPtkdERGvtzoj47oj4st774+v+6ntr7Usj4ksjItr2UWsBAAAAAMdrE/tgAADA6XWk3zxvrW3H/g8M39Z7/56D5He31l54cP2FEfGe7LW992/ovb+89/7yNj9KLQAAAADgeG1qH+zW1BYAALgZN3143vY/WvuNEfGm3vvX33Dp+yPiiw/++4sj4t/cfPUAAAAA4GTZBwMAgGk4yp9t//SI+JMR8UuttZ8/SPuqiPiaiPiu1tqfiYhfj4g/cvNFrPenryIi+miE9UMfUkIepPqTXVUdh2rR8yjr/pmwZ5KFKYqMtqG6ZNnb4ABtovXDXVi8YCTOaDur7JsZ/TFp3UebU3ZWPrfSKbes5uFYXZbL5dgLEqPrUJl/A/dzm+UxFkV/zear+ReLvE92dxd5mVW9Z0VLk+RqjSvXz8GuSsMPDlw5niNxqtijYz/wYKn6djT/UB2r50dZ5mCggbxVhJF2tmoqD/ftwPub8iF89GftaF3qNwRV9g2886krPhQmfxdXvF+r5kSxrh65IvuV2YgszCbefwIAEXFL9sHgnCh/nrYPlpv2PtiZZR9s/Rdsah8M1mQfLAltH2zITR+e995/IuomvuJm4wIAAADAaWIfDAAApuFI33kOAAAAAAAAAOeBw3MAAAAAAAAAJs/hOQAAAAAAAACT5/AcAAAAAAAAgMnbOukK3IzWNhLlyLn7sZZYBRmMsoFCR4us+qWVF8bi5zGOPp513o2MXBV8Q3HWn6Gj7Snzj4Qpxr6XdRxQZB6dbtUU6kmgLG2/zM1M8ixOKyrYq8pUsYv821urj4O9xSKPscxjzOZ5HWdF3ZdJXarYbTY20GWvbOCeG137R8coU92Hm4hd9cms5Z+v20SZ9b1SGLg/R5VTIpufo7E3ct+Ozf2RtazKX9ZvA7FreeYqRC+CH+MTO0YXnGz8y6GvQhcvqOZWGmf4mQUAAMfEPtiRQ5/HfbCzqmqlfbDj2weDddkH24Rp74P5zXMAAAAAAAAAJs/hOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5G2ddAVuSva97sX3xY+qvnc+zbuZIg+Jn5RQFVp9132VPlT5TXVukTzS6YXe84aW3ZWVWfVVfaGwGrts4mDoVnzcJQ9fdfhYmb2oZDo/K8NlFmGSjqzGfjR2dWEkfp21uFD1SzY9i+DD7V/m+S9cXH0cXH3k+ljsoi57e8s0fZaM52xeTPJqfFoxP6v8A7FLxbiNjMXoslfdh3X85F7ZxL08aLTeVcfU/bUaf/CWGKthFbyq4GhlsufH+lkPiizGuajj6BqSxz5yiKhGoqzeaKFZ9tG5Mvhea7lYvZCtexEx/larqEy22pb3+NGHHgAAxtgHK8oswkxlH+yMsg92evbB4OnqrTr7YOua+j6Y3zwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJg8h+cAAAAAAAAATJ7DcwAAAAAAAAAmb+ukK3BTWpLWq7xZ5kOUcdYPUWcdrEuSvYrQiwvDdRmp4gb6qgozGKI2Ov5pjNEXJC0qBmhZdGJZ7aGBLmIXMVpRaO95nDS9qN5sNvY5narMetKdDlUfDt8sZfvXL7Pqw9k8H4vr13bXjl21Z29vmaZXYZZJHeezYn4W6ctFFTuvSzYXe9GeahjKJaFqaBpobGEpQ1d1T9JHl7L63s/zDy23Q30VscyH85ar5uGoem5l62pxj1fBy66tnjerL6jX4MKG3g/kMYo1ocxfhVm/MmX7R9uZvR2oxqEIMrrGZ2Vma+1BoQAAnHLP/qQLQ/lH3vfWMY4cIt772mtHD3JCXvApt6fpp30f7J0/fXmozNPkBZ+a9/mIcg+jyH/b7av3VrY3FhGxWOSbEu/+matr1e20ee5vvpimn4V9sLPq3motH9x7u9U2NQ4jc6vcB6mjF2XaB1uXfbCc3zwHAAAAAAAAYPIcngMAAAAAAAAweQ7PAQAAAAAAAJg8h+cAAAAAAAAATJ7DcwAAAAAAAAAmb+ukK3Cotom8fewFI2VupsTSRpq/AWXs6qMXVQcco9aO3gN1jNEGrcYp58TGBm79OpY5+1g7e5K/DrFMU6s+L0cii7+pG64MkwQajF32SxupfJF3LDlms7zyy+XqKy5czB8RVy5fT9NHl+GsLlVfZfPtsEKruTU2b8fqks6VyJtftqdq5uhH3bI4A32yn724PzfxcBqctyNlllOljDHSoM3chyN1qafn6PubPH/P4gzOldE1Mc2+qbdl9UNuNWW0C4v0kTlXrk3JGnwzWrbGFxUcXfsAADg9Tvs+2Hl06vfBzrK0X07/PthZdS73wU650dXWPthQ9CLZPthKin2wIedsGQIAAAAAAACAcQ7PAQAAAAAAAJg8h+cAAAAAAAAATJ7DcwAAAAAAAAAmz+E5AAAAAAAAAJO3ddIVOFRfP7m1Y63JiehJQ4+7nUPhi/EZjZ6l1u0c7IDjbdDajnvcNjFXetn+ItBsNb0VIZbL/MKs+PhO30R/DQ5nG+iwKufoDGoDE7Ss32BlqrHYvrD6OHjyiatp3vk8H7jFYllUJteTiVv2yfB8HrkwOPeL9LLMbOyym/aQIqvsI7L+3mT+dI4e37J6SD3KK0V6Xsl8Xa3mZx6jms9VmLE+39SD5ehrX6VqTfo+brTQ8j1idWGg9gPvPyMOq/tA3ybP1MNKrabK0BzaxMICAMCxGtmr2H/BSGbvBzNlr5z2fbAzLN8bPv37YGfXNPbBpsI+2Cj7YOvHzk1lH+y8rfwAAAAAAAAAMMzhOQAAAAAAAACT5/AcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDytk66Aodp7TiDH2PsTQU/1jr2PLUnhRb1GK3eyHj2vHpljGOdKkWhRRWH8pb13kCD6vrlV9pooWmYkV6px7mS1bAan+WyaGfRzD5Q9yL0TaxZ6wca7auyOUX6Ym+R5M0zj7Z/uczTZ7PVF9R9WI1zHrwKU83+NG/R/mrOjZRZxahUdTlWgwtXWscixsj9th97KHuqlffbSPJmbsSR9gw/P6pZvoE3VWW1j3F6HufUH52HdZxc2uPDz49ivSnzr38fHu8bbQAAjtNp3wc7l075PtiZljTpLOyDnV32wW610fbYB1tlH2wDse2DVUFSfvMcAAAAAAAAgMlzeA4AAAAAAADA5Dk8BwAAAAAAAGDyHJ4DAAAAAAAAMHlbJ12Bp2Rf1d6rL5NfO/EQQ99qP2bwu+6HbK7a67+ibs8GGjSoD02K+P+z928xsmVpfti3dkRknmvdu6qru6eb3T0XkSNKnOE0qaEoWxIo2IZtmHwQARkQMJAJ0w+GbRgGzJFf9CSDMAxDfpJByLbGlixhQNkiIcCSKQo0ZXFEci4cau49l75X173qXPMSsbcfqno4qv39s2OdjDyZeeL3AwrV/cWKb1332pFrR1a2NtUv9KyhWGfPGF7G+kw5UvGh7w09Tcn9D3WGeavDdY6djfkucqS11VF86mzgOPZdK0ePT2axgxv1LWJ9uinj01jnXoSvaXXNUbgOh5Qk5U7j0pM7iJmLF1LqNG+pLXF/KsJ5/+zYJ0PuXHQXF9YZW3xP2ThWHfPceY133yWLN8StObzQOc270dn/qo3xVhv3+LBu47VSlA0t3Nm10lE4Xymh/x2lh0X8gBNrBQDgariu52DXWfo59qqfgz1rrsM52HUVj9KuwTnYvnAOVpV1DtYTdw5WFe67r/jNcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDvrS67Ad8zPeX6hvRCakh8wznL7kxnpZfSxg6hfbnZfR2qprl/SHaxWHqrrOus+9M5iJ0XYU/xIdQZutPaUL9Qp0n9DKV721L0NI1t99DG+Tz/jrhY1q0ZQ523796cxR7cf9xX5yLUuR7L+FBMxjiGuY/T3Lv3zcvvYrxbi8u2XBip3YvwlbYpjEtuzPZ1dne/Y8iHqS48hXU4hDWUVHlS7p1szSl36GeqM67zMti338R9KG9yW+u93nrq7L2U08LNVXZc+51tuYRPA7GfPddQ/5gDAPC05c9se3IOdhnSj30dKS7lHOwa28XPq5dxDnZt7WgJXalzsKtuBz/Dt+YcrCfuHMw52KxsZwP95jkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw91aX3YCdmUJ8SMXrNwxDeMM5yz6Jvux9A3CRLe/OXbwh57jYMd+FnSyLuG6D4oW0xnOSPl3rP9TZPVZVnpCjN3VqyzBU3zHqHMR4eV7cep6mvj3u4YOjWezmrcOy7PHjk7rOsW7LYlHXWTWxd18N3czK/Sa1r06e6uxp+Th2NjyMy9A9AHPTjpZhPZ912e55jvfsquyuOtRRtrPKfE10VNq59+1k60/XRGeaqo07WMof5Y5z0XEDiT3qa2S5J6ZruXM+h+X2+2qyqzEHAOAi7ck52BXSe55SJ6nDF3kOdp3t4oz9Ms7Brqs0JtfhHOy6GsI5UOIcbPs6nYOlV5yDnadsa37zHAAAAAAAAAA8PAcAAAAAAAAAD88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDvrS67Ab9vKmLDuYueof8ds3ZMVUueoMZh+7akGs/fm37ddXa84cL7WSTqm83clmpZdEzxEzVm6K7ggoR2T0N6ISXq6M8YknQOSRzDcsNJZeu29E9P9YY695j6H4ybsYwvV/PvUq1PN2XZtPUNYZ5T+Z5rJe23ad7iqPRUGuJDyN51S+jZQFr//lSn7hvDnKjjhSmMYcfl9vE7tq5zEddE3z5Ulu+89vv705Old92G7EXb43XV+bmnZ+Fe9F2s3lV7P8edfz3nMQxJFmkuQpqi1rxnpxwAADxznvI52HXW9TPyVToHu8bqMb/652DXVV6Gz9Y52FWy/alW/zucgzkH2za/c7CUIzSlrzgAAAAAAAAAPHs8PAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL23uuwG/L6OP9be93fdwx+1D6XjH5M/f0O6/yJ9aEpX2SG8MnWOS5kjDNaQ+pnGdieDm3LHmd5J/rrOnsIpXL+Q1udO5EVUF68a09mfKObZRY6+9Tm1ceuyu9md6gp2NfWLjuvz1p3DsuijB8chRWhlMYSttdaGonzaJxbpmogTV+cp+t87tmlfiW3pS17Hu25OrexU3g87m9KRI4/JLu4TrbWpms++edjF5RxzxO5v38bee2pv/8scY+d6ixtu5+eEDr3XW1W6+96UxrxjLnr7nuYipiniOxhuAGDHFjdbu/2D2/8+S9/Pwp3nYD119v5ofwkfRFKNH/zD9VNtx2W5Kudgr/7EzVA4hfvOwXaytDqH5Kqfg73+T93eTVu6Bqav4bElxdheh3Ow6+qdnz+67CY8sZd/vJ6jXSyY3iO58vyl75jSOVhVdEfnYO//8unWdbIbL/2TB7PYdT4H85vnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN5bXXYDzjIMF5d76n3DDtoyTXWtw0V2tFPVwl01L455+UIoHdoyhBfymKfGbC/VWQ9iSNI3KHGtpH725Ohd42WeztSd3S8Txf6EHFPn2qpeuOhrYhq7d6hzq+p89OC4LpsHN2Xfvh3pmu253lpeF2W4szvDIuQObe+4PLuu5dbyWkltrJN0hbv24bhWOnOnPF33z7hWOhrT2Z2OraxfStJ5n6xMQ+d1GJ2/p/maCNfhuWs8Q2/yqbgmOq/xvIhCY3q+Fvv0bzUAwPfhHIxPij8LOQdLibbO4RwsNcY52KysH56uDOdgzsEuJjm78Wydg/nNcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDvrS67AWeZpjo+lMEy2m0XWYYdtWUnLrQpdfIwbV1NiUO4o7Et25jWW6hyij0ts3Q0JBdPF0W55lLueGF1jm1RPGYIuYeuizzkuYzLLTS7Z0Wc+Y6qm3khlsbOsR3Hovx6LMse3KhvHevTTRlPTekxVe1rrXv+q7aka3lIe1xoyxQ6WoV7l22a/8Wqjo+b7SsdFqGfu5i4Hd0nUv+rNsaynVdoOW/n3yY/bktHjjgPYV/tbUy130whd/d+u/0I5C0rLdzOlnQ0Pq79zkuirDKMbdyHUrt38oF1BzkAgJ1yDrYDV6gpu7CrsXUOViYJbwicg20b7k90Tc/BePqWq/p3QZ2DVXXu+TkYT92zdg7mN88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvbe67AbszDTV8aE3UXhDkX4Y+pKn0qHlfbljUzrb2D1e566yDT1v2MVgJZ3tTk2p06T1GUp393MXA1PnSPPTNVydzeu6tvom4glUFYQx6b7I02qZv2Ec0/x0Cm0Zx3EWO7xxUJbdrOdlzzIs0r46b0xa+9WYtNZaS01JA9MzYKHsuKkrHUPjFzvZWGtTWhdFlWkZxrW1g2b35oh7X8emmD8OdO3ObRi2X59pjaf56dkTc9G+zS/NRRnv3cxiI3vaGNZh2j+673s9e3lvneleXn14DBmm7e8HH6XZ/t4c1+3FbU0AwNPgHKyz1mvKOVhna86fwzmYc7BP6j0H4+I4B9u+6L6fg3FFXONzML95DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOy91WU34PdNRWzYvmgypMKduYdQvidJT7s/qnSr0NnJe9rdra506Kx0KvIMXQO+G6nG7nnrSnKBE9eZonfMu67DzlGcplC+aGP3NdGpGpZqzbbW2jCF1nTOxbTZvvFj3G/6BqCa/zQPi2X9vavNeqxzhzo3Rf5xU+dISyLFF+mrYUVjFsu6heMY2pJSh2sotbFOkl6ok+wkd8f1dkZTdrNtpSo7+tl9+0jdLzqU29c3KP15nrbO9dZ9j5uL8xbXZ8qz/brtXcpT5zVR3j929Bmx97LdRZ0AwI45Bysq3Sp0dvKnf5x0sS6wP87BnINtWaVzsHAOxtPnHGz7HJFzMC7Is3YOZucHAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHtvddkN2JX0d+HTH4Efwjv6/sB8nT3ljo3MFWwTOjP3MMV3bFtlTB7HPNSZmrJYVJlC4Z4J6pTXSl/5i6yzew1VKS5wDFOHps5LIo5LsYhS7rTeese2ypPGMO4JqZEdUp1D/ApUaGPcE+blh/LabG1cj3Xu0P9UZRlP/axTtLxa6vhiUQxY3G76Vmju5/yFlDreP5Ke4jva5NIaKtu+q2v/AvetOBdFvPOWmveKOIbbR+t75xn3pjSfW9f4JLZfAHnu+2rMe1yVO81PX+503VbFY/t6ByDkGYvtOV4/u/ggAwBcGudgIdz7oX2POQfbAedgdeo9OQfjEjgHO7e9OQfjqXvWzsH85jkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw91aX3YDvmdo0iw1tKMsOZTiULfLuTl1nrHHaRVtCP0PqMbUmld8U81BXGbuzWY9l/OBgWcYXh3W80tuWmKev+LlzDKnhvXV2pEl1xhTphZ4l1NnN3iuiLN+ZJBXPTT//3FX721mNGRbnrzPlSPvqNM4bszndlGUXKXfvdVikSe2ewkW+GOrvgMX+F+GUO+0r8XqO5eexsRjvs3IkaS6q/GGoWps6N9a0PKt4yDEsQ2NSnT3hHazDmKd3fuJSCeu8CC8Wfd9zHLpviNvvN7FkXFsp3tHGdC/bwW01LvHOa6XaP6Pudp//Jpf2uJ18GAIAnphzsPPV2X0Odk05Bzt/nc7Bas7Bzn8OxtPnHGz7ssnen4PxdF3jczC/eQ4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsvdVlN+D3TUVoKoJ10RhN4SF9bWAYOsqH5DsytKItdfOiRXrDoo6vDravcwhjtToMg5umqJjn1eGyLHtytK5zbOrkQ9+yqIV+xuJVfWEtx/WWksc0xTtSJ2PyNNEhXPSp+4ronJ+eqYhlU/Lu8eppS9/YTkVj8rTVr8Q1F8LjOM5iy1V9LY/heovz37Fu01AVzTuzfBqvzXqeKF6eYZ+Mb+iwSLl3pMqfWt3bzXhplffxvhy9+21VQZydlDrVWSaqsy/SXt65QOM9e+uWZKktPXlid2LutFdsf+3vSrkWwwJN+013neWH294cQc/9cAc5AIAL4BxsXudFnoNdV+mIzTnY1mWdg3XGnYPNy4brjavDOVhHpXtyDsbT96ydg/nNcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw98798HwYhuUwDL80DMN/9PH/f3kYhr8xDMNXP/73S+dvJgAAAABcHmdgAADw7FvtIMf/orX266215z/+/z/dWvub0zT95WEYfvrj//+Xvl+SYRiK4PaNqN7eWmvT2FFfa20IXydYFOWn0JZpSq+EtqSOVuGQeliE/uRKS1NVwZQK1405ebyuq0yTVFifhInr1DMTPe1rrWt5XmiO1uo1F6+JMJ9D12jVUn/yJVG/kMdl+xHrvAzjeO3COIZ+pku/ozFTyB2HqmNTSGM4hhdSPxdhf6qmfwxrYrUKm3MYq/Xppi7fo3dsdyCNVbzfxLU1z9O/xjvfUKyLZZi3eH32XhM998lUZchdrcXe+0TqZrwkevat2M+whjpyx26GHOlzT/mZIuSZQrt7P8fE4kX5zlvTGTe5Olxdz2ke4mfHzo9D5efY3gkFAM6ykzOw1pyDhReK5KFo5znYSz92sH2dnZ9NU/97f36ojOu+sXUOVpV1DlZmvkLnYN/9u48urjEX6JWfuFHGe87B0s/Nq+VuzsGqayWtlV39/N3DOVgIX5FzsPd+6SRkgbn3f/n0spuwU+f6zfNhGH6gtfbfa639W38g/Gdbaz/z8f/+mdbanztPHQAAAABwmZyBAQDAfjjvf7b932it/a/bf/33Yj49TdMbrbX28b9fO2cdAAAAAHCZ/o3mDAwAAJ55T/zwfBiG/35r7a1pmn7hCd//F4dh+PlhGH5+2sF/XRcAAAAAdu28Z2Af53AOBgAA18B5/ub5n26t/Q+GYfjvttZuttaeH4bh32mtvTkMw2emaXpjGIbPtNbeqt48TdNfaa39ldZaW94a/NFFAAAAAK6ic52BteYcDAAArosn/s3zaZr+1WmafmCapi+21v6l1tp/Nk3Tv9xa++uttZ/6uNhPtdb+2rlbCQAAAACXwBkYAADsj/P85nnyl1trPzsMw19orX2jtfbnt3nTcM6/vp6+srtYDnV9dbi1Vr8wVeGL/p5wT/6pLjyljqbcRXxIhRdpbOPgXhm7aGIawjL1rsZkF2k6l8Ru1nlYn12D2NpQviEV7gpHPVOX+tO7v03FeA2h5UO4DscxjPk4lvHFct7IxaK34XXucVO3pRrbZdGO1lrbhP6MY/3fO4zjVU5omrg6nIrfuHVQxjfr+biMm3qsorQNh/GaqvHqvd5iPLxQrcVQZ7XGz8yd9OxPKXXszvb9SaZ0b05N6eh/yt27brty9++g2zcm9qfvpjWGPOWV3zmfvUNb5e/9/NkW8SLaWq7y6n9eA4Br4InOwFpzDlZX2lPWOVgP52BzzsFC+Us4B7uuynOD5hzMOVgVvqbnYLDHdvLwfJqmv9Va+1sf/+93W2t/Zhd5AQAAAOCqcAYGAADPtj35HhgAAAAAAAAAZB6eAwAAAAAAALD3PDwHAAAAAAAAYO/t5G+e78RUxIZQtCg7DHXhqSrcWpumuvxQNiS35aoIrW5D6H8UxrGn0im2JlV5GYM7rzOtle72nX8Ic4r4hvOPYexnSl2M15jGsLcxaW0VieI1G67x7sZ0LOc4DSlH2m4W80Qpd++SWCyXIc8803JVf79qPBn76iz601rdz84dqy1Tf9LeV4Rv3joMRescJ8frMp6uobKfm7p5vWM4jhd3z0p1JkNR6ZhvFHU47iFhbIsB696yU/kiPtVLP6+3zrZUay71Pc1Pd1uK8vHyCS/0rpW6MeHzWlrjHZlj9s4Np3d/KnN0fywL89zRmt7rCgB4SpyDnYtzsF7OweYpnIP1tKVMvaNzsOvKOZhzsE961s7BYJ/5zXMAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg760uuwHfM20d7MrQWhu621JmL9LHzEP9Sio/hbYPu2h7rvTcxmpQzqiypy1xTMLY9vdn/obe0e4p3z0mnXaUpks15L1rNk5nXFvFG0KOXY15WoulMeXoa8o0zt+xSIPVmTu9MK7njd8Mm7rspu5ouj6H8DWteD3XhctwNVYfxVOeomxYb6fruv+p3acndfkqfxyr1M90TaTy1R7XeW/qle4JPTqXeV/51LwQ30F3orhXDttXmtZ+r77PNylHX1uqtRhThHjX/tFaG6pEsT99benRO1b9+eex3usKAHg6nINV5Z2DzVI4B7vINF2cgxV2dA52XTkHcw52XvtyDgbXkd88BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvefhOQAAAAAAAAB7z8NzAAAAAAAAAPbe6rIb8D3DhRXuTBFeqMJDZ0OmNoXcHZV2muoqc51F+WkH7fherduGe9p3VupUPqXpSZ27U3aoK3fuZsc7hrpsns6eUQnFUz/TdKb1md7QIfams5tVS+L89KyJzsaMYbC696FxrPMUjV+fbsqyBzfqW8dmU+eO12HRp9SfaayTVDlaa22x3H5cTk/XdY5F/f2ytJdHO1jPcQV1NCWOYee6HTvWUPe2EsovlufPEeets41lijC2Ucc9oXe99e599X7bOVbd81xc+3ED7bv2k2FRrc8dTP6ZaTr6GXOn/tfly9mMe3DYswGAp8I52PZt6arTOVhXmp7UzsG2T+4c7PznYNdB+XNma87BnINt7bqeg8E+8JvnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN5bXXYDdmfoiJ5h6krfZRh2kCTmDi/09ieV30GKWH4Hde7CrqZnqkYgDkpfpWXulDoUnUKVqXyuYB5ahP70tDuk/viF4pWwgHrWVUrdX7ZvPoeO8qk7cWw7L8Rqf5rGOsnBYX3ruBEG5uGDo9CYuXEay/iwSHt86FDPsKSyof+xyrDoVgfLWWy93oQcde7edV6NV1q38VJJudN1XoxXLBuqjHtI7/5UiG1JY9sRjV9F7L0hVvMWisZBSeGO8t338c5ropyLmCNUGsR1voNF1Juj2p/695WuKsMeFy/mvuQAwBXjHKzkHGz73M7B+jgHq17pq/NCV/TTd/v2jTLuHMw52LZ1Xv1zMNhffvMcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2Hury27AmYaeF6ay5BSSdKXelbqJWdGW2LzO3F397xyT3iHcfjb7k6c8PatiGM6/KHaQ4vvkn1cwTaH3veuwY9DHkDxl6B6W1Kcq94Wulb6y3eu5eENuR3ilc9B7romjRydlPK65oCqdrrdpPH/u1sJ+Ey+VvmtouazbPm7GrXOkxqT+D4v6O3BDObihztSU1Mi0hhbFC937TehnWBdlPLSvc3mWb5iKqTwrdzkmndJeli6JdB3GJVe8MoRB7MnRWuc+3DlBca/ouG5T++L+kersuoH03Sm67yvFK7F53RcFAHDhnINtE3qi3M7BOqLOwbYu6RysL/eF7jeX4OGDo67yzsG2b4xzsKtxDgb7zG+eAwAAAAAAALD3PDwHAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC9t7rsBpxpCvFh62CInvXC9sWn2MCQYwiVpjRFfErtDjlilT3l+7oZx7ZnLjqnJzelI1Eu2rUQQ/ld9SjUmCZ0F2LTO/rZuW5jbzr6Gdf4onOvqHKPKXdfY/J1uJOF26WczZB7saxfWJ/WA5P6WeXZrOsc41gnWS7rQU/XxFCUH8KK673yX3j5Thl/cO9oFluG7MdH6zJ+ePOgjJ8c1+Wr8Upjsloty3i8r4YBGIv86Xqbwnzmaz/Eh6LOzs8D6V5eDlfofFpDRfNaa/VYxfKp4WEMo7TfdNyE09zHMQ9vqOa/9zbW+xmsauKubp1dt8m0VtJYpTGP95X5G9L67PqQBAA8Hc7B5iHnYH1NcQ52fs7B5rkv+Bzsukrr0DmYc7BZW67rORjsMb95DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOy91WU34PcNl92As00dDdxZVzoSDb2VXsJ4T20q48NUNKazfbF498D0qPuzi8EdQrunKdV5/txPkGn7oqHZsTepn0XbpzGV7cudR3b79ZnmJ85nqLWKpu50z2Zoy3q9mcWWy7ps6s9i2fd9rM163LrsYtHX04PDZRlfruZtXJ/O+95aa1No3s07h2X83geP67YczNtydHRalj280XdbjuNSzNGNWwdl0aNHJ111xsuzp3Dcy/r2viqc1m28B6X1XC3n3r0sWMQ9YS6u/M5rIm39Q1FDHu/eedu+eOeWHfvTdZuMlaZw5x5fNKYa7zN13ld6VtG4g88UAMA5XMNzsHv/1foSWrIbL/6x+uehi+QcbHvOwc5/Dvb2Lxx9/3axU9f1HOxb//mDrtzJW+0i19xxGX3tT96sizsHm5fdxTkY7DGXBAAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3VpfdgH9kKGJTXXQq4kP1/pD2iVRt6UweuhPTdFW5m7aUVYbUsTu9/exJ3l28fqVcbaGjQ/fYzuucQo44ttUab2dN/84W+oVI85P7WfenLB8v/b4xmeJa2f5C7F6HYd7KYUndSes2lB/DmC+W8zcc3jgoyx4fnYY660o3m7GMT+O8LcOib97i1h/yVPE7z90syz68f1TGb906LOOvvPZcGX/z2+/PYjdu1rffdE2kBbAoxrC11hZFP0+O13XmjrFqrZ63WD71J679zr2vTJKqTNdtuj57Ku3cb9K4FOFYNq39eC8L5YuvUeb9s46PYU2ktdLzYaPeg7s/JnSJV2HPnt3qayJe4p3Sui3LXvRHZADgCV3Hc7BrzDnYvKRzsAtzGedgXIIw0Vf9HOw6Wyzr3wV1DlZVeZHnYPDs85vnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN5bXXYDft80bV92GOah7vo6yxcVdNeZ3tDT9V3VuYPivW0Zwjuq7hdT/ERSnV2N71mb3Tl20L5eF9mUHS3QqWPMhx0tlrhWOuqMTQndSd1cVHk6+9m9bIvyx0enZdHlqv7e1WY99tVZ9rMuuigHJZdPa2hVtP30dFOWvfPczTK+Xtfl773/qIzfvHM4iz1+eBLatyzjsT8H28/FYpmutzKc12eYi7p8ulbq5OnamsbtF3TP/tFaa2PKvYOtP121PZdzbsaObhRFBb1rZRG+ipmGth7zvgHv3frL7KHKIX21NJVPxXsq7Vxvu/hoAgBcsmt4Dnat7eDMwznYLnI4B6tcxjkY59d7/nBVzsGuM+dgVTuuzjkYPEuerd0TAAAAAAAAAJ6Ah+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsBZ5lCfChfGeocIUlduq8xU2jhMITsqUM7EZJPdVtSE7t05ujpfn/z+t4xFQtjSDkWKXca8yLWO1a9a6XnDaEtQ0d3WqvX+TSmst+/WX/QYicLtLaLy7BaP2fp3RPKse1syy72oZgjWCzDPpzyF7HlQf2drmnsG/M7z93cuuzp6UkZf/jgtIw//+LtMv7o4XEZH4u237h5UJZdn6zL+GYTV0CIb9eO1lpbrnYz5tV8btb1ppDWVu96rkrHHGHzS/tNT+4oXUPpdlNMRdpXx7AmYhPjvazInea+Y8/66IXQxiJRugeltb8K6zbeb4s0Q0gRx7Dz1lQVn8LnsjhWnZ9j6zXatzcDAJfnqp+DXWc7OWVwDrZ92DlYl4s8B+PiXNdzsOts3ISLrirrHKyM95yDwT7zm+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsB3zMVsSGWzq/MSqaiVYVnpU7ln7IptCP28yLz9I5JyF2F+4e7fsfQsVZy6s7WVIMYckxDZ7tDuErfuyaikKhnWKbU/ydpzyeF9g0p3tmWaZy/EnOneJi4NEdVW9IY9s5zrnP+wlj0/aOyIUfvtVJYn4z1C6HdN28dlPGjx6dlfLPZzGKLRZ18say/X/bwwXHdmLS2ivjR45M6R9C7tuocdXzapBtCX57qDcswhmNaKykcytdzFPaszvVcvTKEtdK7maUxLOczlQ1ff9yswzUU+p/mqJKuiTS2i9DRsYqHZi/DmKdrYn06v8Zba221Ws5i+aPgbva+uo1pnwht6bjvt1av0Vj2iny2BYB95Rzs6XIO1pPaOdi2dSaXcQ7G07dJ5ykdLuMc7DpLZwF12TruHCx5xm78cE5+8xwAAAAAAACAvefhOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYe6vLbsD3DGWwjJamlDe8MIX49jW2NoT2TSl5Z56uxlwDqTtV9+N8dmdPdXaUj0W3z9FV3xPYRfa8bLdfz6kdMXd4Q88VNITkvddhakw1d7mfndf+omMA0l6WkvduckX5xbIuPI59Y57ii6L/q4NlV47NeizjqY2V0/WmjK9WdVvGsa7z5q2DMn5yMs+f2jekr7SF7izDeK2LOtN8VvNwRpXx1lyFp6kuXLf6jPtqXHPzWOxPXJ91W1Keyrip10TvLlS9YRNyp6UyrOpX1uFaqcZlEbKnMdmEQRzChlPlWYZ2jyF3GvO0r1bxG4fpmj0t4+uwV6Q1VI3tchn6GfaVtIji6uy6gT5jHzQB4Jq5judg9HEOdnGcg3EVXNdzsOvMOdg8drHnYMd1YdgDfvMcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2Hury27A2aYQH86doSPF2XmqsqHwuBnrpgx1Y5YH8+82pGanOttQvzCETFOVKLQvhONgxTGsXgi5+/sZihevdLWvndH/Dudf4U/6hiJFyDF29H9X11se8+0T9c5PufZDnamfi1DpGAYxLNtdTGfsT2r8ZpzvT6th2Zm79+KfWy7r73RtNpsyvl7X8Z61cvPWYRk/Pjot48tV3cZiCFtrdRvTWpnGvs3vJLSxI0V7/lN3y/i9Dx7VeToWaFori0U9hlO4VuL9czFvzCZtWj038tba+nReZ1XfmfG+KtuiyLM6TOut7lAaw3qVtzZVQxsa3vN5pbW85lZTsbeE6+fo6KQr98Gq/mj73PO35lWGJOuw3wxhHYbl3KqBjPea9Lmsd+Fu1QoA4Oq6nudg15lzsKrSkMM52MxVOgfjElzTc7DrzDnY0z0Hg33mN88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvbe67AacbXjqGaaOF8Zx7EoyDHVrFss6Pizm8VR2c1q3pXsEizbGHGmweivtKd+ZO89nfGVeNMxbyj50NDKW7OxnT/HU8zQksfs7EMeqo84p9Cj1ZxE7VMerPIvi2jyrznTtR7sY875lW7axc+nHSpdh31qvN7PY4lZd9vSkrnS5rL8D1jNHx0enZdnUzylOdNgTirakFDdv1rflxw9Pts7dWmvjOK/g8LDO/eF7D7fOcaaiKVO4TY5tPvetPcFtZTN/x5gGN01byl2VDRdF2oeSNC7l2krtTl9/TBduGJeqT8uDOnlcE+vt135rrS2Xy1ns9HRdll2Ejq5uzHO01tpiUZdfrubxZRirm+Hz3bip41MYl6r/m2LNnmkX94N4499BbgBgx672OdgzyTnYvKhzsAtzkedgXIbreQ52rYUL1DnY9skvcIuDZ4rfPAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD23uqyG/A9UxEbpioaDClveKEvTfnCEEpPZW9aG4a6/GKxfXwa+3JPYQxD8TKepiHV2TOGKRxnPralq3jI0bdWcqKiHZ0dGqa+tlRZ0jpM0nruSRPnIeWI3dz+DbHdKXPveu5I37uE0vU5FfOf9omUIw1hz1SMm779YxPKJzdvHW5ddkj9D3viOrRlLMovV/X3yIbw9bLlsn7h6NFpXb7In+Yt5ejZP1ur5+j0dF0X7pu2eK1UY5uSp3tz7y5c1Rmvw979qSwbrolUvjNPT1viNT6OXbmHItFmXefo3eRTdxaLzdapDw7qj6qr1bKM37l7q4yfnMyvrfV63o6PyoZrJViEPWGzKfL3LpYg3vs6LqLezwkAwG5dx3Owa+2anoO990snKfuV9qmfuBleufrnYG///FFXHvZXfQ6SXZVzsNf/1O26znAZpnOz05P6Z+ryHCy0Ox9r1i989+88qt9wxb32T9VnFVf9HOzVP1Hv5d3nYJ3zX9YZ+1MnefcXr+f9k6vDb54DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL23uuwGnGUK8WHYPkdH0bPr7Ei+WKRaQzx1aCpaM4bUfTXmjhYWPQN+hpyleiU0MA5t/UJP/7vm/ow3jMW8DXEM63jH9OzM1DsC1frsvOKmMkdOM5Rt7Jv7PLb1K0ORKeborDSvi7lx7Lz4kzDmVbS3ztVB3/exhmKvXB4sy7LT0WkZv3n7oIw/fnRSxhfLeZ29/dys6/Jp76/Kr0I/x02du1qHrbW4tg4P57f30+N1naL70k9v2MGeEOJpXJbL+ZqL1+d4/p019X1Y1Gt/Smur574fehSnIUjrs9z7O3NX13JrZ2yJReOnMFTHY33tp+SPHx+X8Vu3Due5j0Pu0P+DcN2erjdlvByXkHsa6hfSZ7B4FRbrPO0fad4AgMtz5c/BrrPreg72zLkO52CwHedgl3AO9oxxDnZx52BwXn7zHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7q8tuwO+bitjQUTYUnkKOlDrF8wvnLtymqexQGzddaboMHU2c6gFvi5AkdKdL19SfWWmdqaf/vYuib/YvUpqf3gnqm/+OpnQXr5qemjGGfg6d63ZTvNDV9x3J7e6bz5SnGoCU+eatwzJ+cFjfUg4Ol2X80cPjWez0+LRuXmjLyfG6jA9p/Y/n36BShp5taH1at3uxCN9pC9O2WNQvbNbjLNbd8/CGtObi2uoRUiyXHd/1SxPRsfaT1MdxB+vqo/xV7p2kfoK9v0xSh0PxOORdddbhx49PyvhqVe83p+v5h6pNGNxFWG8pd7pu10Wd6034cNf9wSekKQY9zsOO1hYA8ISeqXOwq++6noPRY1fnYLCd23dulnHnYPPQrs7Brqvee61zMLh8fvMcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2Hury27A9wzDPDZ1JeitsPeFojWhgVN6oepka22IearCddlkCHWmsa2KD6HSqWuCcvkhDUBVtvOV0P0+cbBS+Y6B6W5g56B3yE3ZwSDGue/LXe8TfWOSyqd1XoVjnZ39nDrWSu8y7E5UWIR2Hx+dlvGjxydl/PNf/lQZf3D/8Sy22Yx1Y8JYbTZ18aQe8/Ovw5y7zn9wWN9+U/8PVssyvj6tB6BqSu867FmfqXzPdfVRkq4q6zZ23pt7mjJtQo5FyhLuTeGri9M4L78IZccxtCWtzzpcv9DXndb6LtuutTWOdfLlsr4mHj48LuNHxb518/ZhWTZdV6en6zI+xbmo5rOe0PVY15nWSrzfVEUv7qMDAHAO1/Ic7Bq7rudg11bufG+iczcl2cmZIXvt/oePyrhzsIs7B3vmOAebxXZ1Dgbn5TfPAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDeO9fD82EYXhyG4a8Ow/AbwzD8+jAMf2oYhpeHYfgbwzB89eN/v7SrxgIAAADAZXAOBgAAz77VOd//f2yt/cfTNP2LwzActtZut9b+N621vzlN018ehuGnW2s/3Vr7S98v0bR1sLU2bN/AWDTmrl8YikxTTNLZlvDCUMSnUGXHkJxdvsrfm7yz0rrKVGnfmKfx2s0aCmulmLgpNqSzzvBKnX379n0UTzWmOrfvU6qzczrL7ue1sn2OXrHZvS+kcSlT9MzyGdJUdCSK6znkfvs7H26fewypw1iltqT4YjH/ztg4ps73jflyWX8frWr7Ypmuqzp+++6NMn7/w8d1Y4o+dW5DLe43ce+bx07X67Ls4WH98SO1Mc9z0Y46RZy4fNnOX4lbWVxvaQxTW7avM+6rvR3t2RN3kSOlDtfhwUFaK30LerOZby6PHx2XZat9orXWbtw4KOOnJ5syfnCwnMWOH4RrNgnzHJpY76Gd+yQAcKa9Pge7zq7vOdh+uErnYLA152Bl/CLPwVq7H+JXWz5PSnHnYPP4bp4Xwbae+DfPh2F4vrX232yt/Z9ba22appNpmj5orf3Z1trPfFzsZ1prf+58TQQAAACAy+McDAAA9sN5/rPtX26tvd1a+78Ow/BLwzD8W8Mw3GmtfXqapjdaa+3jf7+2g3YCAAAAwGVxDgYAAHvgPA/PV621P95a+zenafrx1trD9tF/mmorwzD8xWEYfn4Yhp+f6v/aJQAAAABcBc7BAABgD5zn4fm3Wmvfmqbp7378//9q++iHiDeHYfhMa619/O+3qjdP0/RXpmn6yjRNXxnmfxISAAAAAK4K52AAALAHnvjh+TRN322tfXMYhn/s49Cfaa39Wmvtr7fWfurj2E+11v7auVoIAAAAAJfIORgAAOyH1Tnf/z9rrf27wzActtZ+t7X2r7SPHsj/7DAMf6G19o3W2p/fJtFQBcOj/WEoS4e825ftFdvRF24t5Zmm8+eIxevyU5vX2a1zyPvmqLef26cphvv7VJnGcPvcQxjv7lmoOprqTP1JlabrcKoShSRxAOrGpCaORZ7Fom5gWsu93e8xLDoXfxiXKhrb3TnPcZ2XZftGZRrr+K27N8r4cjWfu/ffeVCWreb+LD173CLM28GN+hZ5elL/NxZfff2FLVvX2sMHR2V8s64H8f6Hj8t417B0jmG6KvLampdfrepfqYnXypjqDNd5UWdat917X899tXPri23cvsYnmM/aUKSJmXvvK+nzUPGGYZn28tCU3hc67vvTWF+Hp6frunw1iK21R49Pizo75y3sqz3rM9W5mxUEAHtnr8/BrrPrew52PV3rczDYknOwp38Odl05B7s652CwrXM9PJ+m6R+01r5SvPRnzpMXAAAAAK4S52AAAPDsO8/fPAcAAAAAAACAZ4KH5wAAAAAAAADsPQ/PAQAAAAAAANh75/qb57s0DMOF5J3a1NeO1tOOkHsKOUJ4Gus89ZDUSXY3ekWmvu6ckbrjHWnaYltS7u0TLdL8dLalLBqS97a6y44WRVqfZZWdY7gIb0h5yvIheRzb3rXVNY67SV5Fp9jwvpb07Yl1+1Jbbt46KOMvvXK3jL/15gfz3KF9aR5u3j4s48dHp3X5oo2Hh/Wt8OGD4zJ+cLgs4ycn6zL+qMjz4it3yrJHj+t2p+uwa1mEQZymMRTv3PyLtizC3jeG/qwO6rEdN3X55WL+HcD16SY0MAj9KduYbvtpH+r8bNM1nWFs05oYYuO3b0j3R7WOKlPD09guirk/sylFnnRdbULDd3JvDnbRn9bq5Rw/g1xkhwCA7+t6noM9i674Odg1dZ3PwWBbzsGe/jnYdeUcLOTpKNt7Dgbn5TfPAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL23uuwGnGm4wNRDSD51JdlRW3oK76TKrvTDrioNY1v2f1f9DINbRdPU72Kae5ZVa7n7U0g0FS8sFjsaxJBm+5HNY1i1u9cOUnycaPtw7/yk5GmOusblQveEvsE9enxSxr/zzffK+PHR6Sy2Okzf6ao7euv2YRlfhrF97TMvzmJvv3WvLPvSp+6W8TQ/jx4cl/Ebtw5msXffvt+VO81zuszHcZ4npg4X6LgZy/jNoj+ttbZez8unNb5c1vN881Y9n2klPn44H/Mh1FmNyVmqYUk5Up3de1yRpnNJ5HvWFMal4zpPa2Uz1mslfX6oxiW1It7L4k07FK/Kd9xTP4rX/YxtLMKrg2VdNpjiuu1Yc51jBQBcoqt+DvYMeubOwa6pK3UOBltyDvb0z8Guqxs36sdwzsGqHFsX/Sj+jK0Vrg6/eQ4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsvWGapstuQ1veHqa7P7R8yrUOHdGzXuipMSTpC/flGMILHdOeUvTbvqO7qjL2fyfJU3j7OtP1l6YndqdjPntzp/6M4ziLLRb193HyNNQv9OxLqWya+3hJhCqr4rF9nevtQpdnSD6mNVfEpzGtz5SjbsuXfuTTZfzdt+/NYo8fnZRl01g99+LtMr5Y1m94eP+oTlRYrur1fPToNNRZl6/GMfXn5u3DMv744XEZHxbhGgpzV5YNRQ8Pw305NH5VjNfNW3V/Xv/sS2X867/3dhk/Cv2/ceNgXva4np9pU3d0DGO1Ws37vz7dlGXTPGzW832ytTP2oTpc5+i8U6Z+9uy38RYUUsTcRThds70fkvIeX+1xocrePT6Ur/aQ7k/dnWNbRdPIpjXx/i+f/sI0TV/5/o0DAJ6Uc7AdVOkcrE59Rc7B3vr5xxfXDkqvfeVWGb8O52Bv/n3r5Wn6gX/2bhl3DuYc7JOcg9Uu8hzs3V+qz8a5ONM0lZPhN88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvbe67Aa01lqbPv7nk4bzpx6GHSTpzT1VnWn9/ekqn9pygblj8vPXuZNmt9amNBc9wjwPIfVUtX5Xy7BnYNIyDG0ZQiPL/rTWFsvtv3uTp6F+Ic5b0cTea3wMubtWeR7EKyOOYZqLnkulM8c73/2wjG+mcRY7OFyWZV/51HNl/DNfeLmM/+5Xv1vGqyZOm3k7WutfW9NYD8A4Fv28Ud9+T45Py/hzL9wq4w/uHYXWzNue2peu8bSg/8g/+fky/tzzN2ex3/3qm2XZDz98WMaXy7rOm7cPy/immLvVql5Dp+O6jKc9oex+2PbGuIbq8smieEPvbSzf98Je3tHIMa7xsK8udvH5oW8vi1tfx+fMuCTipVInCsNSp9i+aGuttUUY22JbzWu8XrYAwNPgHGwH5Z2DlXmuyjkYV8a+nIOxvXyG4Rys4hysyOEcrIzv5hyMq8JvngMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvefhOQAAAAAAAAB7b3XZDTjTVIeHoYx25UjFk7L41NXAFL5Qu+j+FLIMIUsu39GWNFhxzEPyIKWpU9eFc4p5Y9K3VHrnJ5YvXhh2tOBilrLOviRpHhaL7UesYyo/yp3WbW+iQh7xVGe4VhZF+dC+dL3FcKizives8dZaG6qF2Fo7PdmU8U+9/tws9tIrd8uyX/rhT5fx3/z1b5fxo8enZXxRLNIxLNzNum73clmvz7vP3yzjn/nCS7PYu2/fL8ve/+BxGT85WZfxNEf1fNalDw/rjwLpOlytlmX8+Hjexs9/8dWy7Le/8U4Zf/7F22X8pMjdWmuPHh7PYkenJ2XZ5Es/Uq+tb/zu27NY3FfDlhWvoZ7LNlQ5jnWSVVifi2pfaa2dFNfnNI51paExactO+03Vlt49uNwnW2tTGJcyR2/u3vtE0ZaYoveW3bEWh+kSPoACAE/GOdi5OQfrS1OnPv85GJcg/ohw9c/BeLrS2YZzMOdgn+Qc7Oqcg/H0+c1zAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3VpfdgNZaa8PH/2xpKlNU0e8l3zJJZ/HY5JC7s8ryhSGV7hi/XZlCj4bhEhrTOQBlE6fQn5B7CuWr4mnuY7PjG7Yvnq6J2OwdXCqx2bHOvrGtyi9Cu8cx9L8uHttShePcp7USr5WQpsqf2td78afiY9WMvnanYTk4XJbx17/w8iz24fsPy7I/95//Zhl/+VN3y/hrr79Qxt/8zvuzWL4m6o6uDur+fPlHPl3G3/9g3qdxU1ea1u36dFPGp1B+uZx/Ny7187XXXyzjX/7Dr5fxm7cPyvjd52/OYvfvPS7LHv3WSRm/fWeeo7XWHj48KuPHj09nsU0Y29VB/ZHnnTfvlfHN6fyiWCw77wc7uDmn/ePwRt2fcVNczK2103W9hobia5RprDbrOvdYh+P+XA5X581pDJXmPbHrk1xoSl1+E8a8ug5jP3OtZTRd+/XYdlYJAFw852Bbv+AcLLna52Bcgt7r8Cqdg/FUOQd7sYw7B3MO9kmXcg7GleE3zwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC9t7rsBrTWWps+/mdLwzDsoMq6wqGdP3dMMdV1TqE/Q1F8qoKttWHqbPcFdjPOZVedIckO5j4Kqccwb2kdltHQnWkXuUP6kDpKxReLutbe/HWdfUmmaSxiu1kTaS6qcF6GaaJD8Y6mp/b1ilUW87yYD/eZbVks6+9j/eiPfaGM/8CXPzWL/Sf/4S+WZf/4T365jP/Qj36mjP/mr32njL/79v1ZbLM+KcuuT+oB+Ml/7kfK+CuffqGM//Z/9Muz2KMHx2XZYom31vJ1mCa0Cqccb333gzJ+43b9EeG552+V8XsfHs5i9z94XJZdLOq1ktbWwUHdlir++FE9n+k6PHp8WsaHookHB8uy7HpdT1y+brffzRdVQ1prm01d5zjW8YPDegw3683WzYu9SeU7ut87UvGaiImKcezeV+vyq1U9R+O4i327L0f5+SF8dgQALpFzsDqNc7AixzU9B+PKu+rnYFykeoKcgzkHm9fnHKxykedgXB1+8xwAAAAAAACAvefhOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYe6vLbkBrrbXh43/OYWpTSF0nTvGkp/Q01W1ZDCHLOfveWgu9PyN1esMO6mxDmIupp/+hbBjbKA1AlWZH01POf5z7Ot49nz05esaktTaO27dmkXLvaDrLadvB9fNR8u372VH0zHhP/zunbSfjsggTOobyy2X9fazNVL/jb/+NX5mX3dRl7334uIwfHZ2W8bff+LCMP7x3NIvdvHVQlv1T/9wfLuPr0MZf+aVvlPGjx/M2HhzWt9/VwbLO8eikjA/xoqsK1+F0b/r2194t43efv1XGX//MS7PY7Ts3yrLHxZi01tq9Dx6V8Vc//UIZf//dB7PYK68+V5Z98zsflPF0FR0Uc5HWZxrbdE2cHK/L+I0b87W4Xm/Ksmn/WK3qNZQ+m1R9Wg51jm4day7dauK2mu6f4TNI140/jFW6Hy7CV1GHKt55r039TG0s6wz9TGsCAHgKnIOdm3Ow1JYQf9rnYDx9/RO3daLLOAfj4qRzA+dgzsE+yTlYpx2cg3F1+M1zAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsBrbXWpo//+aRh+xTDEApXeVtrqfgZFWxdNH4jIeYIjewZgJAjZU6Gqs7OZudWd/Rz6utPrDO8oUofc8S11TG6PWXPqnM3xUOS8xeP3Uy5e+uc5m+YQqXlWj5Dbvv8hbze6lem7itxezFzWvuheLWGxrEuu1jW/Xzt9RfK+PGj0zJ+6+bhLPb4wXFZ9rd//Y0yfvTopIxvTuvG333+5iz2J//ZHynLrtebMr7Y1P1/7617ZfzW7Xk/jx7XY3JytC7jU5iLcQzrv5jQdG+alnV8saj7+TiM+de/9tYsdvS4LpsW4osv3ynjP/SHXy/jt27fmMV+7m/9Rll2taxHYHFQ93NdrKGDgzrHZlNPUJqfG4cHdfzWPD4+SntcbRH6eRzW3MHB/KPgaVj7UbgJFdvnR/Fqba37PrClvT+pi4fPGum+Eq6J3n24zJ1u5H0fb8s8MXW4ZwEAT4FzsPSGret0DtZX5VM/B+Pp65ye63oOxvn90//CHynjzsGcg32Sc7DgIs/BuDL85jkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw91aX3YCdmUJ8CMVD+SGU7xJzpEZ25IkpehteJ5qqgYljmwY3lQ/FizqHzonorLJ8Ia6J+EJoS8c0x26GHN397Ckcr4nwhh1cKyl3uQ5TnWNddDPVL6Rmx37u4JLovfTLFJ3jndu4/ZhPIcvzL94p47fv3ijjX/yh18r4V3/rO7PYe+/cL8ueHq3L+IfvPizjh7cOyvgf+sFXZ7HNZlOWvXmzznHjdh0/Pjot4+M4H8fNOizczrWyWNTzWc3zEMouln17+Ysv3S7jRTdjjs9/6VNl/Atfms9Pa6390I9+pox/6+vvzGI/+IdfL8s+enhSxj98r15Dp8fzdXHjRv2xKeV+/PC4jK8OlmX86Hi+hsZNvVbS3I+betBv3KjX7enp/NpapH0iTOg4hv12qL+jWd73Q3+6bqr9xUs994OzE+0gR3f5ai8PdvKhFwC4NM7B+nI7ByvaEYpe4DkYF2eTfi4L5a/6ORgXxzmYc7CKc7C5SzkH48rwm+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsBT2Jq0yw2tCEV3lGl2yeaQltCC/MLHXXuTNGWYegb21S+mrcz8/cIbdnFCMYcsf87qLRzrKaOtRKvldSSkLvK0933mLs2jtv3c5Ea0z0/xRtCu9Ma766zSpO63pm7Z62k3CcnpyF3Xf5rv/t2Gf/gnYez2LjpG8Nbd26U8R/+o58p43een5f/43/6S2XZb/72e2X8a7/9Vhl/9fUXyvh3vjHPs1j07atxbYWBqfLH/WOsMy8P6u/XvffugzL+5R9+fRa7dfugLHvnuXrePvfFl8v4C6/cKuPLg1dnsc9+oc7x5rc/KONf/516fb7z5r1ZbHNaD9aNW/XHqfV6XcYXy3ps1482s9it24dl2c26bstyuSzjx0cnZbzStU+0s+7jaUFvv6+m3GMov1imdd7xOS4UTbl77k35M9/2KT5Kkz5rbV92Jx9XAIAnMh61du9X5p/9uDgv/Vj9s4lzsI4cHedgn/rj9c98vXZyDrabg7oyz45SR10/ayTX4Bzs1Z+4uX3hCxzz1J87d+v1/Prn6vOHm3fqn+Pf/u4Hs9i99x+VZTeb+mf+z33hlTLuHMw52Cft4hzs7/073yjLQuXlH6/3vtKuHn12fI6rwh/8ej4v9ZvnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN5bXXYDnsTQhip4dUxTHR7qRu6i6eWYtNamVrcllQ9JOqU6U/GifBirqHcQqyamHJ3930V3whLKjakqSOswJe9cn1WemDrlCPGe4Ro6Bzf2P+YvYot0vcVKu8pX123qZ+d0RlX5m7dulGVfee35Mv7mG++X8fV6LOPlGhr79qwf+OKnyvjDB8dlvBVz95v/8I2y6L0PHpfxb33t3TL+3tv3y3g5R6GfncuzpVU0FkO+WPZlHk/reTu4UX90+PY35uPy4su3y7Jpfb7y6efq8uGa+0M/8uos9ujhSVl2GuqxeuM79bo9LPq5WdZjcvQo1FlGWxyA27fn11y69m/dqif0+Pi0jC9XdfnpdDOvM3y1chHasum4xs+Kl2U7P1PEra9oe2rFMvR/V/ttmbvzhXgfKvaWcarnZxFyAAA8i5yDdeRwDrZ1HudgsdKu8s7BivY5Bwucg33SRZ6DQY+effiqnIOdtQX5zXMAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg760uuwFnGdqQXnj6hl1UOtXRqSd3yBFKp2ZP8R1Fjp0NeEee2LzwQuhoqrEa8lg2xPPYnt+wOP+YD6GBUxrCkGcKb0j5yxxbl/y4fNcl0dmhmCeFixfiouhK3bXHbdZjWXTc1NmXq/DdqFRlEf/iD79Wlv2d33ijqy1nLK550bD2b9w6KON/92//Zhn/8Z/8chm/9+GjWezn/rPfKMvevnujjD/48HEZX5/Wc9Sjc2llxRvGMV3LqS31CyfH6zK+2cz7/+jBcVk2xX/r898p4y996nYZf//t+7NYWitpDF/7zAv1C8X6fPuNe2XRw1DnF159rowvV8sy/t3vvD+L3b5Vr8N0rbz/zoMyngZgvd7MYlO4ljdhv01raxHauCj2p03RjieRbgnVxRXXfudNq+dzUhqr5bLes6v5aS3PUdWU3L7L+EANAHA5nIN1lA1x52DOwbat0zlYHXYONucc7Gqfg0GPao+/zudgfvMcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2Hury25Aa60NQ2vDMDzdOp9qbbur9cLHqcg/pbJTeGWq2zikr2qkPD1SikVoS0c70pDHuSjypLKp2buY5SmNa2dbUmti/o4ccTnHplfrM63D7XOclef8vWytjSlcv1C1cbmsL6DVqq8/i3BNvPDS7Vns8LC+RaS2rE/XZTzPxTz2+udfLMu+/+6DMr5Y1G156bW7Zfz/+//+lVlsc1rPw/Gj0zKeFm6c/54Lum8552uoS51kHFNjwrVSxNM+cXJSr5Xf+tVvl/GXPnWnjP/Alz41i3328y/VZb/wchm/e/dmGf/g7fmae+31F8qyL75ct+/eB4/L+PFxvba+8qd+cBY7uFlfh7/xD+uxWh7U18Tpg3B9FtM/hH1iHOtrJe0JN24dlPHHj45nsc5bVsv3prr0okiU+tMr3leKxqQ9eNz0taXqz0eNmYdefKneDz/88GFXnQAAzyTnYPOyzsH68nfkcA7mHOyTnIN1hZ2DPeVzMOhxHc/BztpS/OY5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPdWl92AJzFcdgOeVGfDL6Wf09bBHE4Nn+o3lMV31PlpHLduyhTat1zW3zFJ5dswb/wUBmvYUUertuwsd2h7Fc01phydbazG/KIvlI6OpiUR25iuoZioQ6hzs66vic3pPH7n9s2y7Pp0Uycf63aPIT4s5o387jffL8se3KhvV7duH5TxX/wvfqeMr0/m/YztC2MY48v6haF6Q9o+wlfa4poI4bHaE+K67Zy3jmsureS7z90q4/fvHZXxe/cel/Hjk/Us9vjRSVm2GpPWWrt1+7CM/9hPfmkeDH1/9637ZfwP/7HPlvHbd+trq2riW9/5sCz7refeLeNpeh4/Oi7j5fUc1379wsFhfX2eFvOzO+f/bJJv432bfLWXJYtQNuyqra3rOl/9zItl/NGD+TX06mdeKMt+8P6DVCsAwP5wDjbjHMw52LZ1OgdzDlaXdw72Sdf1HOxn2y+UZaFSXftX/RzsrNuP3zwHAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHtvddkNOEvx9+UvT/WX40MDU7On8NfnhyvV0bnUvro3Z8xbeMNUlJ/G79usT9SZkodwMRfd8xCKl2mqTrbWpjiKnU25wDU0xBVdla3FtZLK97whlI3rNiavLYo8ad5S6jQ9aWyrNKnOOIZjXX65qr8z9cLLd2ax3/nqd8uyY8i9WNa5h2UYr+I636zrsi+8dFjnKKOt3f/gcf1Cde2nJL0LdwdfR+tdn90XXUeSuG5DfCzafhDW2/HJaRk/PdmU8c1Y3xQ2p/Pyae2//OpzdZ3Hde4XXrk9i92+W6/DL/+RT5fxT3/+hTL+8N5xGX/84GQWO7i5LMt+7XfeLuP3P6zX/mufebGMv/3Gh7PY8fG6LHv0aN6+1lo7PanLj5t6bKtlvlhc7Gehal3ke2ffZt5z3cb9M/T/8Ha95t59+14Z3xRj/nu/Ve/lV/3zJwDAZXEOlipNbakqdA7WVd452NZ1OgerOQc7fxLnYPNzMDivq34OdtbHCb95DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOy91WU34CzTDnIMO8pd5pnqLFOodIituTipzimMQFU6dLMNvd0J5av8MXXnhA6L+g1DVecifJdkB9M2pUFM4uCGNVdX2lVlKt3T/d7rqndYqvKLNFYhebwOOzparZ/eHK3l67BKFK/lkGIc6xcOl/U6v3fv8Sz2oIid1ZbUnc16rPMUc3fj9kFZ9tGDkzKeyqdxWRT9H9NeHsYwXc/jOtU5j6Vlm5dQmP/QxmoA0r0p9Sftn3E/K+I3btXzc/T4tIyntbI6qNftyfF80N9/+2FZ9o1vvFfGX37tuTI+LOf9v3XnsCy7CfNwfFQvipt36zyHt+Yfy+49OCrLfv4HXynjL37qbhn/O3/z18v4ohjbk3v1/KQ1MW7qeevZbuN+mFKHtvTZxSfNMxRNvHPnZln0zgt1/P23H5Txm7fqNXR6Ol9zpyeb0EAAAJyDddTZwTlYKO8cbOtEzsGcg5VtcQ42i13kORh0uYbnYGfdl/3mOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3VpfdgDNNO0gx1PEQzso3pCx1w1N3hvBCFR46Gz5NIXlHnlhnSt07uEX5ITUw5e6sc1hUb4gzVIfD2KYhL8vGF3oX/7x857SdoWMuOtvd282hWFxjSFKV/SjeV2dPkiGtiZgmra3tc6RXVqv6u1Hr07GM33v/0Txz6M+ivH6y5WpZxqvuT5u6zjH08/GDk7r8mNZFEevsT+9FNFVtCXWmNZHmYkr3m2oNhTFJ4qjEts9jD+8fl2WXy3p9pv6M61C+6NONm/VHm5OTdRk/OKzX5+HNefz0dFOWXSzrMUn9Xx3UdT58dDSv86Su81Ofeb6Mv/nGt8r4Qajz1q3DWWz9fF3nowd1fxZDnbtrvNJnijp1vMZ7xI9IaWse6/1zCOu5+iyTxuTD9x6W8cMbfR/V14/r/JWd3A8BAJ5BzsGcg20ddg5Wxp2DOQebcQ5Wxq/6ORj0uI7nYGfdI/3mOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYe+d6eD4Mw/9yGIZfHYbhV4Zh+PeGYbg5DMPLwzD8jWEYvvrxv1/aVWMBAAAA4DI4BwMAgGff6knfOAzD51pr//PW2o9O0/R4GIafba39S621H22t/c1pmv7yMAw/3Vr76dbaX9pJa3doCvGh9w09QvKe1FMoPHTmTv2cqnf09n2Ko7h1Y8p2tNaG0JY0LotFZ1t6ku8kReeEBkNP+dCYnKEuP43btyPN5zj2je1QLIBUZxqSMfR/0TnmlTTPqf850Tw0hLU8FvPwUbx3bKtgXXazqStNc7FchjkqYqndaQxXq/o7YFMYmGoc074SF1HeQLeOT6mfMXco3zHNeRtK12df+a5taFHn2KzrSsdQ/uatg1nswQdHZdnVF8P3BcNcvPPGvVns8YPjsuzdF27UucPiunV33u7WWnvwnXnbN+OmLHv7ubrO1z77fBk/+FNfLuPvvDnv5y//l79Xll2Eazntq8tluD6L8nH/jB986nD/B7yOFGEfXoR+3rp9uHXZtK+m+PHRaRlfrZbzHOG6SvsQAFDb5TnY8lZrd3/oiY/kvk9DL674B/9w3Zf8GnAO1pF8Jymcg/XoOQd75xfrn4Wvg0/9+Pzn2+twDvbOL9RnBFyc1/+p21uXdQ52/nOw6+x/8n/658t4zznYwwf12I7rsIY26fy2OAfrXG/d52AdqZNU5bI4e2qttbf+/uO+Cq648/5n21ettVvDMKxaa7dba99prf3Z1trPfPz6z7TW/tw56wAAAACAy+YcDAAAnnFP/PB8mqZvt9b+9621b7TW3mitfThN0/+ntfbpaZre+LjMG62113bRUAAAAAC4DM7BAABgPzzxw/OP/4bTn22tfam19tnW2p1hGP7ljvf/xWEYfn4Yhp8fn73/6hMAAAAAzwjnYAAAsB/O859t/xdaa783TdPb0zSdttb+n621f7q19uYwDJ9prbWP//1W9eZpmv7KNE1fmabpK4sL+jNPAAAAALADzsEAAGAPnOfh+Tdaaz85DMPtYRiG1tqfaa39emvtr7fWfurjMj/VWvtr52siAAAAAFwq52AAALAHnvi7rtM0/d1hGP5qa+0XW2vr1tovtdb+SmvtbmvtZ4dh+Avtox8s/vwuGrprQ4hPPeVTkvzChZlCw2NLOjo6hCwpxRRe+ehny45EhTHl7h3zKk3nokhjXoldn+ILIU+Yi3FePtXZvzrrdwzDvM4093mx9PWziqd+9s/n9hOayub5CXmKeWuttcVynifXWedObRnH0JhiwOKQpLYsUp2hn9V8xirrHOOm7k+VO0rrbfsMrbXeNRTicX5C+Y4Xetp3ZvmeoQ1f0ZtOQz9D+WVYW48ensxzh2Z/9b96o4y/+937ZfzFV+7MYi+/drcs+9pnXijj66NNGf/O77xfxh89PJ7FvvBDnyrLLlf1YL340u0yvggT91u/8u1Z7HRd/3dEx3U9b3GpdOxPY2eStH8m1T4U94me/aO19uLL87XSWmuL5XyOPnz/YVl2WZRtrbWhuB+cpdqHVwfLsux6Xa9PAKDmHOyacw5WJdm+bHMOduXPwa6zok/X4RyMpy+eHTgHm9nFOdh19sqr9Rmec7Dt60zSOdhb7XFXnqvuXP+hqGma/rXW2r/2ifBx++jbtwAAAADwTHAOBgAAz77z/GfbAQAAAAAAAOCZ4OE5AAAAAAAAAHvPw3MAAAAAAAAA9t65/ub5blV/8L7vD9VvnTaHz6iyeCElCTl6UveaUlsWIXl8w/aG1O5pBx2KY1i/EJuS+lk1Pq2VsW8RValTijSGQ3hhB9PWzhitznhRsnuswnyGdVsW7x3D0MaeoU25e42hLYui//ESX9VtGddjGc9rqHghL9CUJNRZV1q2cKrbvVjU3/XKl3jfXlFJ85OFtVWE496UMseOdqWpc4d2x52inqLyDUO4H8Q6Q/l1WM/VtXJyvC7Lvvv2/TL+4MFRGT86Op3FPvX6C2XZ+x88LuPffu+9Mv7VX3ujjL/1nQ9nsS/+8Gtl2T/93/rDZfyzn32pjN++c1jGf+Kf/vIs9uDDuj/f+Ubdn81pPT/jZvtrontfDV//TJfK4Y3lLLYJ6ypd+6vVPEdrrX3w/sMyvlzOG7kMe9lmU7flU688X8bfPqnXebX+Dw7rj/up/wDA03INz8Gus10cVTkH2zq1c7DQkgs8B7vWqnOTUPQ6nINxgXawKTgH2/4c7Dp7/QfqMzznYHO7Ogd71vjNcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDvrS67Af/IsFWotdba9FRb8QSV5ixdqas0oewQx6p+wxDf0KGn3WfWOU+UU/e1e0qZinGZNn0LKwxtOReLVf09ld5pWIQ3TKkxPUKKcUwd3Sr08Qv1K0Pv13eqsU1jEtq9i6Wf1vJmM3a1JcarcLquwhjGeQumooIhLIrU/84toVy3B4fLsmzqT57PMLZFa8YxzFu6ruK2Ur9QNn1Xe3PHNMf+hCpz97dfz8tl/TEj5ujcy6p7wul6U5Y9OV2HOuvcD+4dz2Lf+O23y7Ifvv+ojH/ra++W8Te/834ZX63m6//wRj2Gpyd1P59/ub6GXjm8W+c5mq//l16uy77xjbrdad32fDYZ0zURFuhiETa/dB0W6zPN/XJZ505zkfank5P5mlsP9by9+OKdMr6Z6v1pXNfxasw34ZpI9ywA4Gl5ls7Brj7nYM7B5knq8HU9B7vOrus5GE9f+BG5LuscLNRZ567Owa6zV151DrZl0Z2dgz1r/OY5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPdWl92A1lqbWmtTm2bxYRq2zjGEotM87cdvyG3pyd+jsynlG2KO8MIQByZV2qF3TOJkFKlDu6eUI4VD+Sqc6tycbsr4sKjLL1fLInfdvjg/ado22/cnGcJiiWsr9LNH7/XTM/9j55pI/UlrZVG0JZYNuce6KW11OF8rSWx3SD4sU/m67T1TlMr27sO37xzOYicn646W5Nw9ayguoRQPY5iuoXK9xL0pdqgn3KfzfpDGdrGcfx8v9SfufanO8FW/TTEXQ+f1eXR0Wsbvf/B4Fnuz6GNrrX3za+/WOe7Nc5zVlsPDg1ns0YOTsuyje3X8+Zfre9ZyVbf9iz/yWtHAvv0jL/46PBb3ssPD+iNp2vuOw7wtwxxV989lyL06qPfmVOeY9tUi/RQ+2z58eFzG1x8+KuNpyBeLef83m/pGcePmfL19XGuIAwC7si/nYFeKc7Ct63QOdk3Pwa6zovvX4RyMp6+6dz5Bki77fA52vdX9dw42t6tzsGeN3zwHAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9t7qshvQWmtDa20YhnPlmKbdtaWuoKN0X/iMF85V9MkSVf3srLS3jdXcp+kcesc8rKtpnNcwhVpXB8s696LOvSjiw7Ium5b9Zj2W8V2s8+4ceTIuLMe0i472rPGW11bVlLRWpnracqWpdFm8zjFu6hzLZf3dqPUU3lB0P+7LnddbdU201trJ8bpOVBg39eAuw/U5Ftd4ay1N6NZFP4qH+a+Ll3rvebu4xeUcoT/xWulJk66rzh5tth/zNLRjeCHNxcP7R0V9dTsePz6p2xf6mfb4xWJ+3f7KL32jLPvpz71Uxp9/+U4Z/+pvfKeM37lzYxb72lffKssOQ72vjGN9Laf+v/Di7Vns8196rSz7q//ga6EtZbitT+s9brmc7xXjWM9D2ptu3DzoKl/1f7mqx/A05QhrbhHnYt6nwxv1x/0XX6nXylvtcRkHAHbn+p6DXWPOwYo6nYPVbwjxq34Odo1V6/M6nINxtTkHO/852HX2i3/na2XcOdjcrs7BnjV+8xwAAAAAAACAvefhOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYe6vLbsDvmzrKDlvGOlN89EJnog6pi0NP33vrTMlDeOgdyO1T70ZoXnerl/N3pL735h6qr6RM9ahs1hc3Wmkpj2Oc/L78HdG49lP5MF49Uv+7M1dtSeswjfkOpnkawwupn2EMh549LuYI37uK/axfKIc2tG9YdNYZ2j4Vb0jLLY1hKt+z5nZ15ad1UbY9TX2+QPvaUtTZO1a967lq+5Suz7CE0rcIT9brWez0/U1Z9uBgWcY3YYJS/z949+Esdue5G2XZ/+T/9Ytl/Of+1m/UdS7qSleredtPj+d9b62105M6nqbnlVeeL+NHxyez2K/+8tfLsoswcZsxjW3dzzGU73ESxqXHuK7bUe1NreWxXR7W43Ljxvyj/XpT1/nud+/VyQGAp2MPzsGukvgzsnOwc+d2DjZ3Gedgz5prcQ7GU+ccrAhd4DnYdfZ3/tP6fMw52PZ2cQ52ndn5AQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDeW112A1prbZpam6ZpFk9/7L6O5txdSdIbQlvOWfQJ9I3J1HoHoMhx/iF5ggpCP0Od5+9lakdr0xmjW9msU2sqnYPYMxmpaGfqlKcKL+L8hLG9wLUV+xPa0jXLnWOVxDqrFzpzHxwuy/ituzfK+L33Hs2rTNdEiKc9exzr8svl/PtbvbmnkDu3vYyWZVN4ERZ6bHudpqfKzl1oN8nTmHdtIkNfpdMYiifV1peqDGtlDF8jHIrkU2jg6WnIkfbEeK0U+eM6rBv+5rc+KOMnoZGb03mdy1W9f0Rh0N97935d52Ze5yrUmfaPzbqei9VBnWe1nMfXRTtaa21cb8r4YlWPebr2q7mb0jXRec9en9ZtrL4WO27q5M+9eLuMv9WOQq0AwK48a+dg14NzsO3a4Rzsup6DXWvX9ByMK845WB3uOAe7zr7xO2+VcedgRZ27Ogd7xvjNcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDvrS67Aa211oaP/9nSNIUcKXeZo0rS2jDEN3SUDW3ZhaFOnqocegb2ozdsW+VZlXbp6tHUlzwWL9Kn+YzT2dmWSl5uodb0ho4cuT9bp+6W1mHq5k7aeIFjm0ydg9hVuncvW9TfjfrwvUcp0daVxnkLLywWdZ6haOK06csdt4o6nPN0ZMn9r+M9S6t3FXb1JySP97JOZZ7tb6kfFY9f6QtrcezJkTKH9Vl1J1xXaQiHuPbr+HI1/1iWZvjo6KSMn56uy/idu7fK+MMHR7PYuCkGtuX1mS/PcA0V6ZfLemxPT0/L+Gq1DG1J974iHvfP9Hmgc0+ocse1X9e5WddzsVyGtVV8NlnUQ9Xuf/i4fgEAuHDjUWv3fiX88HOFvfTHDp5+pd3HWs7Btk3vHGzr1N0u4xzslR+/EersPAPv0HfG0ukanIO9+hM3y3g6B1sUP8eNm84xvMBzsN75vMAj1uidXzy+uOTMfPon67OkXZ2DVXvljRv1Z43q+mmttaNH9fnY7bv19XnVz8G++3cfhFqT+tzsMlT3ofjYtvscrB6vg8PqLLWeh00xz+/96nw9fI/fPAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD23uqyG9Baa0NrbWjD061zOH990w7acZayiZ2VTuENsf9F8Vi0sy1pjqv8vWM7hcYshvT9kHn51J+4VLrWUG+P+tZn6v8FVlm3I/Szu3nj+dsS11son8awvFZ6yp6RO6nGcbms1/LBwUEZf+Hl22X8zW9/sHU7FmGwFqEt46aeuNt3b5bxh/ePimjfQoyld3FN5NXSlWWqhqU3ddyHwzU3zuNpfQ7LEL/Ar9d1bM1nhetx6Zz7Yqg+Sl3dDzvHZEjJe+6H6f62qBtzut6U8XsfPgptKYQ6x9Cf3j1ueTBv++lp3e6D1bJOEq6JlCe1vUd1XX3UlNCYItz7eXcIG3G6347jfMNZruq1cnxUjxUAQOIcrK8tzsF6OAc7L+dgzsHO7+qfg/F09Z6lOAer9ZyDXWfVfF71c7CzptJvngMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvefhOQAAAAAAAAB7b3XZDbhoQ+8r+Q1bF52629KZaAemqU4+DPNWhqJnJA/xMAB9+UO7Y/GQvOhnb8PLFClLSN07tmneLtIQ+j8VnYrN65z7IXytp+5/75XYp6ozzX1SXVcfZw/l5wMwrsey7HOv3irjb7/xYcgdmlKNYyi7WNQvvPzK82X8uZdvl/EH94+2rTIalvU7xnU9tru5hOo6w7CUX1NL13Jv8xaLcLEM21+f09hZa8dyTpnjPSjWuf09u2eJf9ya7d/Qe4OP5dP6nCfahGt/XKQxDHt2xzxPdZV5DcVEdXjchAoqy3qNT5s6+epgWZcft6+ze5o7PlP1VnqwqvszhA1nLOb56PFpWfYHf+QzZfy9f/D1ujEAwN5zDpaSh7hzsHnYOVhd3DnYLOYcrLbv52A8Zc7B6nhMVIe7zsGusTQXpStyDvarX38jNNBvngMAAAAAAACAh+cAAAAAAAAA4OE5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsvdVlN+D3DVuFznh/V+mdmC64/NPvUd3G3bWjHoGpCKfprMp+VD69IZTvydGrrLPOPQzbj8lH5VOl8xemkKS3n1MaxJ4Fncr2XhRFP3e2PjsS5Wb3jVUa22pZHN48KMs+uPe4zp0WUVKUH4b6+1XjZqxThP58/bfeCnUWsTAPu7jGox0toq42xj2ub97ylnDem2preaWnSSrWUMyQcnQ2pUfvJVHEhs4x6RzBdufujVns4MayLHvvg/raH8fzX/u920f//bNaK3WO9cmmjK8O6nGZQv97+tTdnfCGssrQkNS+ZWjLJuzD1f5889ZhWfaNb79XJwcACJyD7SK7c7AyhXOwwDnYJzkHC+Xr8A4Kn5HmEs7BeMri/DgH66x0nuNSPvVcrKnq0hU/Bzs9WdcVNr95DgAAAAAAAAAengMAAAAAAACAh+cAAAAAAAAA7D0PzwEAAAAAAADYe6vLbsD3hL8Dv730F+bPnzmm2VHmizWEVsbxujg9VcbZTP1JUvkdTN4UOlS1MfU9xVPzepb5IvQ9tTuN1ZBaU4SnNHMhvFj0tbFr2nZ1gV7gpZLWc9X/wxv1dv3o8XEZv/vCrTL+8P5R3Ziqn2EMxzA/H7z/qH7DBQ5iXCtpbY3z8nmphGsivSHNZ9H/dF0Nw27GahdbfN6f6hd2clt5+remOP/1dKZ7asgRvqK4WY9lfLGYv+H+h/U1O27qHPl+U79Q3is69+y4V2xCoqrpYayWq/qFtH+mcdnJDaRzbMuhLfag1lq7dfdmGT8+OulqSzVem/WmLLsZw1gBAATOwfo4B6ty1HHnYM7BPsk5WMjsHIynyjlY6QLPwa61Ysyv+jlY/IzQns0pAgAAAAAAAIAuHp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL23uuwGfM/UUXa4sMxnZK/S9DUktqQzTWeSzv5PRfkhJE9DNXb2tAgPIcUU+jOkNoby01SV78ud66zKhhdiPzsTFW8ou3iWau7PqLMMh0rTvPVfn1u24wnkMb+45D1r6O7zt+oXFnWOV157vow/vH9UxqvpH8exLHv77o0yfvz4tIwnPXOX2rJY1knGzfZrq3dvjpdK2kOK2BiSDKHW7jtZmSbth325e8pPqZ8XfuFWlaZ4xx6XbmMhR9r7btw8KOOf+/wrs9jXf/etsuzj003dmHAPXoS9YizKLxZ9363sud5aa20o2rIIY5iulbQn9OzZudW998N0by7GdlmP7fHRSVdTeq7Darxba62FIQQA2BXnYM7BtqzSOVgH52DOwcrye34OxgVxDlbnuMBzsGfNdT4H85vnAAAAAAAAAOw9D88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN5bXXYDvmfoiLY2nTdxm0KKoSP3NPW1bxjq8lNqTNH4kKJrSC5a6udF5uivshiwHbS7tby2SqHKOM3bL5XuOrsvlmp9hpJjZ8PTNbHomKN4jccx7xnE7uSlxSL0v4g9ePC4LLtc1t+Bev1zL5bxr//2W3Vjilpv3KhvEZv1GHL02n7M457Qe010XJ9T517ecwnlfaJvM+9Zt93bR/c9ay6t8V0pWxKaF9uSmlj0P019ulaGUOfduzfL+OHNeZ7Tk3VoYJD2lbhtbT9H4yZd+3WONObVHjJ1fp0zbgnn/4gYX0l7Qgx3NCbNw2JRD8x6vSnjL736/Cz2/tv3t24HAMBZen+OcQ52cTmcg52/TudgzsE+yTnY1T8H4+lyDnZ1zsGug2ftHOwZnCIAAAAAAAAA6OPhOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYe6vLbsD3TB3R4fyJ+3IkIckw1C9MoS0tlL8MVdt31ryORL115rFN4eKFkGOKOUK8o+1TSp4a0yFnDq/EQUx5to8uFul7Ouka334QU7PTdZjzhLZ0pFmEwuM41nXW4XLyPvu5l8ui9+49Crnr/ty+e1jGHz84mcVO15vQvIvbs/K8hRWX5r/3wt2JOvkwzBuZLolx7Ox/bEvH9dy5DfUMYVwrnXXG3nTsW6uDZRlfn9Tr/NZz82vl8aP5ddJaa5/5gfr6XB3WdR7erD9+/fqvfHMWy9dhrfeuslzOF+NmXW9Oq1Xd7jS2R4/r8RoW81b23vXi1Hd8Hhg3deE0P2n+V6u6/4uin1G4H4xD/cKt2/VefnK8nsU2mzrHoph7AIAzOQfrTX4RRVtrzsHKdsTMzsHqPM7BPsk5WK+nfw7G05XWm3Owp38Odh3ke1/hGpyDOTUDAAAAAAAAYO95eA4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHtvmKbL/9P0q9vDdPeHV7P40JEj9SLmGHqy91Xam7q77WWddekpZE/lQ5KdyFVWL/SOSuhnKF+VzmPSl3v7DLt9x7Ypukc2rfOOr97EbWYHjYkpFmHux/odi1C+WhdjyDGNY51jWQ9WastzL9yaxdbrTVk2SeU367qN1b2gZ423dsY1FMPb59/Vvrqr/azSs6/23nvTmkvrdhd15jG8uEHsTV0NeRqrF168XcY3m/qaOD1Zz2L/zL/wo9s3rrX2/Mt3yvjDB0dl/O/95781iy2Xy7Lso4d1jniNp32rCKeyy7CXpTFMqnU7btLNJiTpvH9U6z+tlRs3Dsp4ut5+8B/7TBn/tV/+xix289ZhWfb0tN6z18U6bK21W3dulPFqLk5P6xw3b9dt+db/7/4vTNP0lfJFAGAnhmG4/MM4roVXfrz+3OccbPsUzsGcg5Vt2cE52Du/eNxVHnh6Pv0n5/tKa87BKrs6B/vb//ZX68ZccdM0lR31m+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO95eA4AAAAAAADA3ltddgN+37RV6CPDVqGPXwivTDH79nlipSlHV7hs4pD6E6vsLV+0o6dwDp/5yrZ1DuGVPJsd5TuXRBt631BUuYNl+FGiqnDIkbOH6Pn7GWtc1HVOYWCq8tMY2hfCi1hnSFO8EOdhEb6PlPoT8vwTX/lDs9jv/tabZdkP3n1QxlfLZRnfnI51pR1rKI1V1/psrU3FC/17eXrD+eX9trfS7cvntd9ZZZmkb0K752In+sa2Gq80ho8fn5Txf/JPfLGM//hPfmkWe+H522XZb379nTL+wkt3y/hv/8Z3yvj6ZDOL3XnpZln2wYePynjvnljtFZs2b0drrY0h9xS2lcMb9T60Xhdv2NGySv3fbOZ1fu7zr5Rlb965UcaPj07L+O9+9bt1Y4o+pTFM1+FyVY/hyfG6zlM2ox7cl8L6/Fa7v3VuAAAumnOwOlFVOOTI2UPUOdisHc7BgOvGOdgsduHnYM8Yv3kOAAAAAAAAwN7z8BwAAAAAAACAvefhOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7L3VZTfgLMNQx6epiKUcZ7xyXjHD+VPHNGlMLlSoc7jAjg5TX+6pWhQhdwynKkPuWGUxSansrkzFOu8dw3gVdcz/ZhzLsstl/T2daqzOaElrZfq+dqe10jefu5nQlOYX/ovfmcWef+lWWfb4eF3nHuvkcZl3lE370GpVz/N6Xa+LehzDmkj9iTeKOlznSK+EJDF8/nWR+tNzP4y5c6V17s7+TMU0996z4p6Qrs/FvHxYhu2lV+6W8W9//d0y/oN/5NOz2Kc+X+f4k3/mh8v4//Z/9VfL+P0PHpfxagzf/u6HoWzf/Ixp71vP95CqHa21tgyDm+b5JOxP5bytlmXZ9XpTxtM+vFjUbTw4nH/kvXHrsCy72dQDsFjWHT05qftZXUJjnLe09sNkdEhj9fZb9doCAOAqSZ8TnYPN2uEcrM7tHKwu31H2Us7jgXNxDnYJ52DPGL95DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOy91WU34HuGYR6bYuGtQt9HzL598arRT5A6GXoGJQ1AKJ+a3pd6Nx0dpu0bk+qM/QlNrKocUtmQeggjM+1kWOokKXdflX2LaBq3H/Plsv4+TpqfcRxD+f4repYjxGPvuy6KvrFK0no+Pjqdxd55c12WPThclvGT47p8GpkqOsXFXOc4Pd2U8c9+/uUy/sa33g/5qxrT9Va3cbFIc1TEUp2911vX9Pdtzr37Ss9yTrl7x3wHl1DrvXKrtoyhfe+8da+M37h1UMb/w3/3781i/9L/+E/XOQ5ulPEXX3mujN88rMs/uP94Fnv86KQsO4Q1PsY9O31mmZcfwlcr1+v6Gl8swt4f2ljZbDrvB6GNm03dxir/u+/Ua+L0pN4/N6d1G6dNPeZf/sc+M4t98/feLsuuQ7vTGKbrdn0yz/P5L32qLPvWdz+skwAAcGU4B+sp3ZfbOZhzsE/qPQcDri7nYE//HOxZ4zfPAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDe+74Pz4dh+L8Mw/DWMAy/8gdiLw/D8DeGYfjqx/9+6Q+89q8Ow/DbwzD85jAM/+2LajgAAAAA7JJzMAAA2G/DNE1nFxiG/2Zr7UFr7f82TdMf/Tj2v2utvTdN018ehuGnW2svTdP0l4Zh+NHW2r/XWvuTrbXPttb+09baj0zTtDmrjtXtYbr7w6vtG90RbS31L5RPaTrsIEXOPXS2O3Q/penRObLt+yy1LZN05Gi5n2Wa7g6lOudviO0IOb7fdXmeOpNYY2jLOM7jr//Ay2XZ99+5X8bXp/XWUOVurbXbd27MYifHp2XZTciRpDFfFAOZyvbOZyq/Oph/r2nc1IUPDpdlfLMZu+osF0DvNhkWXTWGUec13r3h7qKfHanPfqGncGdrquI72uNS+XKd996Cw1rp2RNj2VDnYll/j3BYzN/w4iu3y7Jf+qHXy/i9Dx6V8Te/80EZf3j/aB6M+0odjzr3oco41vvK6qDeh9breo9fhjEv6wx73xAm9Ae+9Eqoc97Gb33tnbrOcP+IW1kYw2q80nqbQp2901yN7RSyTGFs3/z5x78wTdNXOqsGgGfG0zgHG4ah9zbPnnr5xw67yjsH255zMOdgM53nQ+/84nF4Bbhsn/4Tt8q4c7Cizh2dg33379fnoFfdNE1lT7/vrE3T9Ldba+99IvxnW2s/8/H//pnW2p/7A/F/f5qm42mafq+19tvtox8gAAAAAOBKcw4GAAD77Un/5vmnp2l6o7XWPv73ax/HP9da++YfKPetj2MAAAAAcB05BwMAgD2x/X8rfTtb/4dih2H4i621v9haa8PBjlsBAAAAABfric7BAACAq+tJf/P8zWEYPtNaax//+62P499qrX3+D5T7gdbad6oE0zT9lWmavjJN01cWu36EDwAAAAC7sdNzsAttKQAAcC5P+tj6r7fWfqq19pc//vdf+wPx/8cwDP+H1tpnW2s/3Fr7e0/auPT36PNfqi/Uf+v9jOQ7KJ4bfnG5y+815/JTKl+l6KyzI3XWmWSKHaobX5VfLFLZrtR1W3rWbGtt6Cy/dTvOyJ2qHMc6vjpYzmIP7z3eqm3fc+vOjTL+6OFxGX/8+GQeTBPUuXBj6a6LJYXTC3XuzWY+6L1rYhxTP7fPM4UcN27V/7mQ05NNnahnKna1N6frsy99X47OvaJMkZbz9ily+c4kuZ872Pxjir59a6w2qNSOzvmpqnzw4VFZ9rvfeb+Mv//2gzJ+fHRaxheL+Xca4x4Urs9YPJRfLud1jiHJoijbWmubdX2jWC3n94nWWluv53tFmuNqP2yttcMb9UfYh+H+sT6d58n3yTLc/VmjTBRSpH5W99rWWhtD+du3i/tq+Krsvfcf1S8AAJWncg4G23IOtmU7zsjtHCyUdg42k87BWqvnDbh8zsEu4RzsGfN9H54Pw/Dvtdb+udbap4Zh+FZr7V9rH/2w8LPDMPyF1to3Wmt/vrXWpmn61WEYfra19muttXVr7X86TVN4mgIAAAAAV4dzMAAA2G/f9+H5NE3/w/DSnwnl//XW2r9+nkYBAAAAwNPmHAwAAPbbk/7NcwAAAAAAAAB4Znh4DgAAAAAAAMDe8/AcAAAAAAAAgL33ff/m+dMydERL01RnGDpydFbZWbi1VrdxOn/v+5vSIQxtrjOVv0C981yVn8ZUto6ncamKT2NdeLHoa3ess0gzTZ2LIuS+89zNMn58dDqLna43ZdnT0zq+WPZ9f6cer7qf46ae0Lyc6zxT8Y643tI+FLqZ1txiMX/DFHJX7WutteWqrjSNy2q1rJJ31Zn2hLgSy3WbCqe2dNbZUbZ7K+updFf7ZKqzY09M+1Ne5uGeVc1nXkQhdx2PL1zk/abIfbAsrpPW2uakvq7GTWe7i7kYxzp32ofSzKf9ttpbeu9ZwzLsw2ltFXnSHlzuTa219Wk9Lh+++7CM7+Zz0vk/a6QUq4O6n2kvT/eE+/ceVQ0pyz7/4u0y/nY7KuMAAFwdzsGqss7BKs7BLvAcDLiynIPV4T4X+NDxGvCb5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDeW112A842hfBQBKtYzBBK970h5jh/6stT9jOM7VT3qLefIU2d4yIHa0e5q+7EsYp972tMmSfOT507je3jRydbl0+tPjhc1m0JbUzlx804j6UxXNStSd8YSm1J679OUoeXq9T/TR0vOrVYpnmr46tV3dNNGJfNpmh8GJMf/OHPlvFvfv2dMn70sF5Dq2Jcyna0ekxaa20I/UnzuZMLvTf39resuN52sj2ldofkvdtTNebx/hGyx372jFfnYKW1cuPm4Sx2fHRalj15+16de75lffxCChcvhBzlR6HW2iJdE2NqzPY5ehfLMKTruSN1930iDu68ylhnHU+61m1qXqj09KS+T6Q8hzcPZrHbd2+UZT9492GdBACA/eAcrOQczDnYJ6VzsDd+7vfKOHAFdBzuOAer48mVep55gfzmOQAAAAAAAAB7z8NzAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3hmmaLrsNbXV7mO7+8GoWH3aRfKizdOcu3jD0ZknFO6YgdKfFaQzlc8vnr0w9DWx5XC50rXX2fxeGMBm76Gea5zPeMW/HOO4k+eHh/NpsrbWxyD8swvUW6txs6jaOYz2GBwfLeftu1O179PC4jKfp6R/zjtxhXKbQ/yrNIuTIbakbk+ZiuZx/lyrlWBRlW2vth//xz5bxb//eO3Weg3meD999VJZNeq/D3dwR6tw9l35qdyyfE22do3dPiKlDP3t2vtz/zrHtqLTas1pr7SDscVUTe3f3KexlaUJf/tRzs9h7b9/vy53a0vVC30aZZjPt5dV+1ju2vddEGe39TNXdlu1z9K7xtJ5vP3dzFjt6dBLqrJO/9fOPf2Gapq+EFgEAOzAMw+UfxnEtvPxjh/ULV/wc7L1/UH8GBdhHn/4Tt8MrV/sc7Dv/5cPtK2QnXvvKrTLuHOxizsHe+7WjdvpwLFvuN88BAAAAAAAA2HsengMAAAAAAACw9zw8BwAAAAAAAGDveXgOAAAAAAAAwN7z8BwAAAAAAACAvbe67AZ8z1DEpo6ybSijfRV2mlILQ3hIlYbwNM0TFaGPUoT+527Wr1R9iu3u1DOfaTpj/8PXQFL5XYjzv4vcnamnaTx38rvP3SrjR0cndZpxnudgtSzLbtabMv76Z18q49/99ntl/OBgnn99WueO12Hnch6Lfq5W9YLbbOpKq7E6qzFlNG03oT8vvHSnjD9+XM9nNY6p3cOijv/6L3+zjKd5vvvizVns0YPQvpN6nqt98qMXtg8v0tfIwvykeY5rqyie97iwhvKNoitPZei62Z6Rp745d5Ttv8dVg5u6s4gTXauu/dyOTmHLfu+t+/Ng2icWdXzc1MnHMLiLMn/fZ4reedus521chn01Sbl3ct8PSWKdMc88NI71/KyK+1trrY3FWLXW2iLM/8P7R1uXvcCPMQAAXLBn7RwM4Fl2Xc/BePrSzDsHe/rnYH7zHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsvdVlN+As6Q/S78IU/jh8rLF4YUilO5ud21JW2pe785UpNWYHUtOraY5jEtbETtrdOZ07qbJnwbXcz8Vi/j2YKczxzZuHZfzhw6Myfuv2jTK+Pl3PYstl/X2cm7fqOlcHyzKeBub28zdnsffevh9y1OF0UfSsoc2mb/LjvHWs5yktlpD7/oeP6zrDHK2K+MGd+hYxbsYyfvpwU8Zf+9wLZfyDDx7OYpt1naP3Wum5cONshrHtvjUV5TdjPYb5vte35qprax3GNt8P6tK7uDfny63OnWpcdvRzWPTuq/Pyqd3d94O4bLcf27Gz0rjfVPPfOT+99+A0F2XuFB/T9dmRO+To3ROioimrVX3fOwj3w6N12CtClWmeyxwX9zEbAIAdedbOwQD20XU9B+Ppcw52dc7B/OY5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPdWl92AK2fYvujU+coQkqcqqywdzTurKVHZxlBpbHeoc0ovDPNMU2h4ypHGtksaq87URXdiktifIcU7GjPW4VTnYhHaOG7fls987uWy7Le/+U4Zf+u7p2U8uffew3k7wtiOab3twBC+djRt+uqM10RVNs5DV5VtXG/K+PJwfjt47oVbZdn1SZ1jDP3/yn/jB8v4f/Bv/1wZr3St/dZauqCnqciT9qzODTS1cX06H6/nXqzHdtzUF+7J8bqMb0L5dTHPi9C+uPXFIQ/3smpoU/LO+0Sai0XPPauzP1PYQ2vp3tRTulNnkp79pv96O78x7HGpn0O4Z8Vrv5yNvhypjWl93rh1OC+b+hnWW7nGW989LnykeIIPlQAAPG1j+MHk6p+DAfD9XN9zMC5Ker7gHOzpn4P5zXMAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg760uuwFnmjrKDn2pU/GhJ1EoOk27aUxnllIawqEneUjS3c1FGrCOHGFUppBkCB2dxu0rnULRmLssn9qXao2Lqw6nNIX16Sa0pa5zva7LT0Vbvv57b5Zll8tlGb95eFDGN5uxzrMq8izqspuxjndfFEU/p3pI4lpJepqSrp+0hNIaj9dh4b237m9dtrXWXnjxdhn/7jffL+OnJ/OBjNd4GNx8jZfhcmxT7hRfVeuwtTaGMT+8Ob/VphwnYd2mayK1cbGYfzdu7Cjb2hn3oB3cP9ILL758p4wfHNbj9fDh8Sx2/Ph0m5b9o5b0XrgdOc6f+az1Gd9RRtO10tmaHeTo2ytjs9Nnk1xr0Y64C5fRxbK+VlKe0+N1bM0njekaD+V7hqVzqQAAcIVc33MwAP6RZ+scjAvkHKx0GedgfvMcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD2nofnAAAAAAAAAOw9D88BAAAAAAAA2Hury27AR4aP//mkafsUU/X+kPasNFOos8gzhDqHUGfKPYRGDmWijjGJOXKaqXhhWMQOhUr7inf1KE1zmItpDGNejEvP3J+lypJSpL5P01jGF4v6+y5VdHmwTMl7wm0R5n99Om/jsKzbN451f+7ff1znXm/qttyetyWN7Y2bB2X89HhdxuP8VzV0rpVFuA7HWOf5xczhmjg4nK+XTSj7uS+8XMaXq3r+Hz44LuN/5I99bhb7rV95oyx7/PC0jI+hjUk1z2kaVsv6Glouw34TEo2b+fp/7fXny7KbcK381q98p4x/8UdeK+Pf/tp7s9gyXJ957+vb/Ko0p6f19fYDX3yljL/z5r26KWEf2qyLe1ZsX+da6ckRU4f9NpTuGfIx3CeSzlvZTqR7cDWOQ7i/5a25by7i56HCchX27E36TFHnqcqnfTKJ6zl/2Nw6d+81AQDAJbim52AA/COf/tyLZfyqn4Px9DkHq13GOZjfPAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL3n4TkAAAAAAAAAe8/DcwAAAAAAAAD23uqyG/CR6eN/tjQMF9aSqGreENo81e2LrY5d7xiTlL2z0rL4VJftbnZXE3czx8OiI0/sUJ1jDOOyXBbfSUlLJbxQ5mhxKtpidf7vwUxpnjvmc9yMZdHFsh7DTSh/cFhvTa+8+vwsdnx0WpY9Ojop4ydHPddVrXftp3mOq7Njj+u83NqNWwdl/OjxfBw3Yz0/m9MQD+V/9Re/uXWdL71yuyz73UcflvHedVuFx6lu96vFemuttQ/ee1jGx3H7StM1fny0LuMvvnSnjH/43qMyXuVfhX1iva77H4Vubk43s9gf/coX6hQhx5vf+SAkDyu6ShSun7Rnp2ulLJ4Kp+Z1Dm3djr49awj9z/tWR/6O66q1vPcPxeek1M9xU8dXB8vQmDDPRVPS2p/Ctbw6rOtcF2u/tdZWq3n5ND9j2D/PWKFbF0/9ef6ler99ux2FOgEAuOquzDkYAL/vhVfqc70rfw7GU5eerzgHu5hzsHvL+tlSa37zHAAAAAAAAAA8PAcAAAAAAAAAD88BAAAAAAAA2HsengMAAAAAAACw91aX3YCPDPVfsO8R/l58+vvyncXDC3XpKWQfOvuY2thTeuhLshOpmz1jnspOU+hnnrnt84QU4ziW8dVqmZLPUy9S8jo+jnU/Dw7qS7bKf3J0WpZdHdbtTmO72Ww/c0P4Ok7qT7w+Q1sePjiaxb74w58uy379t9+qq1ycdNVZzWcS5zlJ67njooitS0tuU6/nk5P1LPbq6y+UZdMa+uDDh2X8/Xce1HkO5nm++80Py7LJYlEvunjdLud1rudd/yi+2ZTxW3cP6/IfzNdna/U94au//kZdabpUwtrarOs2VktrsaxzpFWbln4a28/9oZdnsX/+v/NPlGX/7//m3wq19jWmDIcO9d3fO6V5CzfEtN/Efagjd3T+La4tluF6C+sw3T8W1XoO3VkedH7PM34GmbflIOxlX/jSq2X8jW+/f+6m9H6OSZ8pe+Yt6VlvAABcjut6DgbAP/Ltr73b94arfg7GhXEO9nTPwc5K6zfPAQAAAAAAANh7Hp4DAAAAAAAAsPc8PAcAAAAAAABg73l4DgAAAAAAAMDe8/AcAAAAAAAAgL23uuwGnGUI8amncMrdlbyOT0NdeAiNmcZQfrF942PuKTS8c1zK3J0vxPIdaabO5OM0lvHValnGN8V4DWFRLMP89CyhcZPmvs4xbur+bMY6viwSpXWVcidxaRXrf5rCWIWxHULydK1U0d/5zTfKsmPIsTqo18TJ8WkZr6SxPQi50zq8eeegjJ+ebGaxh/ePyrJTWFsHh/X2vl7X83/z5rwtx49PyrKvf+7FMr48qBf0h+88KuNV2+Pe3GmxrNtS7ZVpTfyL/6M/Vcb/q1/6Rhn/L//Gb23ZurwnHBzWbUnr+XNffKUuv56Xv3n7sCz73Eu3yviv/WLdz8987uUyvinW1n/07/98Wfbxg+My3vq2p3q9pE1rBzentD57U1+K0PaeIdyczvem1lpbhuvts3+oXp9vf/fDWezkaPs9uLX8GWwT7nGLxbyNr332+bLsO2/fL+Prdd3/JI1jmXtT50770xT6We0VKceDe/V9BQC4eMtbQ3vuR+Y/s/UeVfXoPgcrvP/LfZ/ZOL/3/8FVGvP11iVf/rH65890DpY+x68O6rON6meQdfh5pfecIZ+DldGuOsdwrpfOzZ578fbWOdK5QRqXeA5WpQnt29U52G//J+/Vbbni/vS/8uUy/ru/8WYZ38mRV++RR7Gg3/i79TkdF+e6noN9+k/UZ4Y95x0flX/6J2c910QcwrCvXuQ52Nu/8PTPat78+/UZcK/X/8T8npVclXOws56V+c1zAAAAAAAAAPaeh+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsBT2QqYkNdNITrHK21YajfMRVvSGV7c6fyufEduWPyjtKd/Rmnsat8ZxNLi2X9PZDNuH1bpqluSBzZ0O4U7zGEWlNbTk/W87JpLXe2Ly6tjrJxbBfh+zuh/KOHx1vXuT7dlPHDGwd1W8LoVi1ZLuuym0293j7z+ZfL+He//X4ZXy7m+W/cqtt9elL38/bdG2X80YOjOk8xXq+89lxZ9uGjOsfXf+etMt6Gej6ncfvF1bEMP04e8hQL5sWX7pRl//Z//OtlPPVzEdbF7TvzuTh6dFKWvXX7sIyfhHl++417ZXws1mK63oZv1O0+OKg/IjwursPWWjs6Op3FjotYa60tw57dxvNvoGmP6/08UMXzvt9b6fbF44j0DlXHLTju+8Xe1Fprr37mhTL+1hsffN9m/X6dIXev1WpZxpcH8zX3znfr62cR2hI/a6zrvb9nkmLucF/J9/h5+ZQDALhGrsg5GFwU52D7fQ52XV3XczCevnjm4Rxsm2Z8nxc6koc01/kc7Crp+ex4Hc7B/OY5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsPQ/PAQAAAAAAANh7Hp4DAAAAAAAAsPdWl92Aj0wf//NJQ1l6qMO7aclUtaO1oah0GlPZlD280NGfqRyns1J01ln0f7GoC282Y1fuNF6LZfEdjpB6nOoXVstlXT7U+cKLt2exDz94VJZNayLlrtbKalW3L43VuFl3taXj8snrNsxzFJpS5u5Z5K3Fi2hzupnFFsu+Nb4ucrTW2uGtgzJ+/OhkFnvu+Ttl2YOb9ZZ6dDTP0VprJyf1PK+Ka+Iw5F6t6u9APXxwVMZv3Tos4+PN+YSuN/VY/dg/8+Uyvght+eWf+1oZrxZR3JrS/SCUj+u/iH3w3sOy7HvvPijjL7w03z9aa+25u7fK+M078zF/4xvvl2UfPazXSr/inpX2snW9r9az39o6lK/yV/vhR2Xr3Dm+/X6bkkw7+fAQGpgX7rmzp76n+GJRX4dp76+k+/vhjXofeufND+s6O/u/C2lcTo/n+20aq2QT1n5uzFah7/NCLd3LVofzzxvp88qlTBAA8LHreQ4G23IO5hysks7Brqt//Ce+UMav+jkYT59zsO2LOwe7xp6xczC/eQ4AAAAAAADA3vPwHAAAAAAAAIC95+E5AAAAAAAAAHvPw3MAAAAAAAAA9p6H5wAAAAAAAADsvdVlN+Ajw8f//NdNbTqj/CcLh7JDUfas8kFVOqUu29dyf4YpJirq3L7s92oto+P2GTZxbLuqjG2fxuINKXfIsVwt69yn6zJ+797jednQzyE1Ji6teZ7T9aYsu1jUSeI8p3DxNZjUnzxvHddbKF61o7Uwx63ltdIxLotQ6eqgznHn7s0yfnJSr5X1ap7//r1HZdnlo3odvvjynTJ+40bYgotxeeGlOseb336/ThHG9vDGQRl/cH9+Tbzy2nNl2f/0P/jlMv7o0XFdaZc093Xp3q2/Mqb1GTy4f1TGVwf1Wnzn7fuzWNzi4it9yj0kjVW4B6V71rjZ/gayPq33voOw9g9D/OT4tIxXbUz7Z5rnRSpfLK7d3IFbXLhVNI334WE9VpvQz02Yi+deuD2L/fGf/MGy7PvvPSjj3/r6O2X83vv1XlkN5Lip2706CPf3NJ/p/rHY/vuiaV+J99Uefbfa3M9l3Z96nYf1tov+AABP6Hqeg8G2nIM5B6vEc7C2i/Okp+9rX31rB1me/jkYV4dzsKIde34Odp2VPbri52BnfTz2m+cAAAAAAAAA7D0PzwEAAAAAAADYex6eAwAAAAAAALD3PDwHAAAAAAAAYO+tLrsBZxmG+q/G1380PvyF+Zw9xMMfpF/My6c/Xh+/khCKV3+ovrXWhqrOlCSIo9LT/dC+EC7H6qPy4Q1F8WGqc6xWyzJ+enJaxscwR2ltVbrHvModqju8UV+CpyfrMr5c1v0f2ziPpfWZ5iHYjPPcrbW2XMwXerwmQv+H8EJcK1WOMJcvvXy3jN+6fVjGv/udD8r4Zj3v/yuvPleWfXD/qIzf++BhGU/GYszv3L1Rln3p1bqf995/XMbv33sU6pyP+W/9ynfKsq++/kIZXy4v7vtYcftI94m4b/Wt/8q6WBOt5b1vUbSx2t9ba20MuaO0lxX9jGMVb059TSn38tDPVz/9fBn/J378D5Xx/+w//odlfLOZN3Kz3pRlV2H/TN2sWh73uCCv2/SGeSjd99absA7DvvpHw9h+5U//8Cy2vFHX+Qv/xW+X8cPDgzIeFU1P10+at81Uz3PXZ63Oj459nxzrF9L1lu+HderDm/W4HD+uPw9VFhe4ZwMAT+aqn4PBttLPPM7BnIM9S/blHIzzcw6W3jAP7fs52LV2Dc/BznpM6NQMAAAAAAAAgL3n4fn/v737j7HsrO87/vneHzOzP73rXdvYu4ANss0PK4HUhTShKQpp4zYIokoVoFpCRVUVKVKTqlWJmz+iVuIPlCpKK7WVEKFQlRpFKXZdFFIcCCJtY2NjJzYGGxwb8OL1j7W9P2d27o/z9I+5jrc+n+/4Hu96Z+4575eE8H7vM895zvN9znPufM+dGQAAAAAAAAAAAABA5/HwHAAAAAAAAAAAAADQeTw8BwAAAAAAAAAAAAB0Hg/PAQAAAAAAAAAAAACdN9jqAWymFB+PXszdNlXvYtMXSlU/gBtH1vZVjcV0U1xQUkQylmYjaSQ5pEqauKwf80LSxXQ6tfFez38OJBuj67+X5DPL83RS+b5N80hOfjya+OElczid+POv3Pr0o9sscTbcCz+3rnWT+Zak0vg6rM95Cd95NfXx1bWRjY9G47mHcvLEmh9fMoeTdZ+34bBv4/1BPX7sqZO27evffNDGn3v6hza+/+BuGz9r5uX0CT8np5LzP/ymAzZ+/NkzNu6ke3m6mTXc5UzzKlv7/WQdJmurP/DXymi9fp0XvyRS2T7krv2NL5i/72zdZjPboOt0TrI19PhfPmPj06nfb939o5/dD7I5TPq29+BkrrK+0z0xVe9/NPKLZc/eHTZ+2RWX2PgHbn63jf+frz1ci93zjUds22xfzd73ZPdm+54qmazJ2J9/eivzYbtu8/eO2U3r/I+Z3yeTtZU0H6359w8HLttTbzv2bdfOrCe9AwCArbLd62DAvKiDJWHqYP6YC+qS/TttfLvXwXDxUQfLUAdrFbNeFrkOxk+eAwAAAAAAAAAAAAA6j4fnAAAAAAAAAAAAAIDO4+E5AAAAAAAAAAAAAKDzeHgOAAAAAAAAAAAAAOg8Hp4DAAAAAAAAAAAAADpvsNUD2FQpPqyoxaIekiRVle+j10u+oIGs76xn33qz9tlXmLZJ06Zjsa8knZQqOWbDj2SESd60SjpPTjT6vnmVTYwJL+9Ysk3Pro0a9d0z59Pr+0ksyRpqkHpJfg5Ldu7Zus3ynA3GLZUs+dHwmFmezXW7d99O23b1zLrvO9srJv6Yw2F9m5xO/frM8pntN9Npdsx6+6Vlv11H5fu+7u1X2fizT5+08fH6tBYbDPyFNR7V20rSjx9/3sYzYTaXNPf5YknaJ81NvJ/kJ9vjs1ysnRknY6n33/TelM2L229S2X2i4dxmY+n36+ulSvbyU6fWbHz1kaM2nq25y6+8pBY7cXzVts3P38enJkcrO4a27d+/+Wds/LZb77LxSXI+br6ye+17/vZbbfzA5Xtt/IH7fmDjD977eH0cyd6U5b7hLcvu5U3flTV9T+UTnd3fkl6ycPombP6zmkz8mti1Z9nGl5b9Wjxzqn7vW9np22bDBgAAW2ib18GAeVEHow7mZHWwRbWodTBcfNTBqIPVYg37WAgtq4Pxk+cAAAAAAAAAAAAAgM7j4TkAAAAAAAAAAAAAoPN4eA4AAAAAAAAAAAAA6DwengMAAAAAAAAAAAAAOo+H5wAAAAAAAAAAAACAzhts9QA2lNn//n/RC9+61NuWyve8vOxPcTSa2rg/ope2TV6IRr1LMuepaNaH6WHTV9wYS9Y2+eiFG7aUD72qkuQZSytDGx+PJjY+HPr8T6b1/K+eWbdt+31/ohH+RN359LK1nGUomawqmdxGqyJrnBwz/YSNaZ91na1Ddy1L+bXvHH/+jO8jm9oGfWftl4d+HY7WxzY+Gfv95sBle238dW/YX4utnR7Ztle/5XIbf+ShJ218eYcf+8kX1mqxnbuWbNtsHVaT5FrON6KaXrIOs7WSdZ3lv1TmhWRNRDKWbL9Jx25iw2Hfth0u+fgkmdtpEvfzlewrZj+UpOhle5/vx40lu0/0kr4HA3/+mcrkM8vD3kt32vgLx07b+O5dy7XY6w7vs20f/d5RG7/+7Yds/OiRF2z8muvq1/MTf3nMtr1k724b/1+332/jg+RedvaM31uc/H1MtuHO3XXaOL1PJH03ed9zoe5ZGbcPpe+psmMm2+qzT5+w8StfX79/7Ej28rXkfQ8AALgYFrMOBswr/x6eOpjtuuN1sGd1ds7RbS8LWwfDRUcdjDrYeTZeDAtYB8vq3BI/eQ4AAAAAAAAAAAAAAA/PAQAAAAAAAAAAAADg4TkAAAAAAAAAAAAAoPN4eA4AAAAAAAAAAAAA6LxXfHgeEZ+JiGci4tvnxH47Ih6OiAci4raI2HfOa7dExKMR8UhE/OJrNG4AAAAAAADggqIOBgAAAHRblFI2bxDxc5JOS/ovpZQbZrG/I+lrpZRJRHxSkkopH4+It0m6VdK7JF0l6Y8lXVdKmW52jMHOXtlz3cAce/4T6fV84+z0qmnl++n7zxNUVb2jdHzZlDZt77pIDlqadLIZ002kc+uPmS8p/0K/35+77yzPLj+SNFyqrytJGq9P5m87qbeVlObNjT2bw6yPput53nFsFu/1mv0iCrsUG679dD0n+ewP5x9jNW12TWTXkBvjgcv32LbPPX2qUd87dy3b+Pr6uN5Hmnw/h/1sDSVzOzXz9cY3X2bbPvGDYzY+GNSvZWmTrc9sw9l5Vtm6TdZQ1r7BbUXT7D6RzG12DU0n9X52X7Ji266t1nO/0cemt1EzlvoYsyXUeI9P1pBrP1jyayLbs9O+k3iYOX/Dmw7atgevvMTGH/jm4/6Y5pBv+YmrbNsbf/Z6G/+Lex6z8fFZn88bbnxjLXbHF+62bSdj38d45O9Zkaz+bG594/mbbtqNe6+R3SYv0DEvhOyayO5lTfrILK8MbfzKqy+18avffHktdvCKvbbt0Seet/HbP3n/t0opN845RAAAWoc62Kw9dbB6U+pgPkwdzDTO+qAO5lAHq3st62BH7161bRfBFX99h41TB6u7EHWwJ//vadsWaJNSit0UXvEOXEr5hqTnXxb7SinlxXdSd0k6PPvvD0r6QillvZTyuKRHtfENBAAAAAAAALCtUQcDAAAAuu1C/M3zj0n68uy/D0l64pzXjsxiNRHxTyLi3oi4t5psox8rAgAAAAAAADzqYAAAAECLndfD84j4TUkTSZ9/MWSa2e8ISimfKqXcWEq5sTdo8ot0AQAAAAAAgIuLOhgAAADQfv6P28whIj4q6f2S3lde+gMPRyS9/pxmhyU9+eqHBwAAAAAAAGwt6mAAAABAN7yqh+cRcZOkj0v6W6WU1XNeukPSf4uI35F0laRrJX1zrj5tzH8S96XvUV4ynSa/8sq0laT+oG/jVVX58c39WeJNbMVv5cqOmX3I2cTdfG/Wt52rTQ46ndbnvNdLcp/1nBxzPJrYeGXX0NQfMzvPZCy9fv0XOpSqWfKrhu2dyBORaHbMYmYgO2S6hJIXsn6q7Do3sjWUzW3W93Cpns/jx87YtoOh/2Ueo/VkHZq1L0n7D+yuxdZWR7bt6ul1Gy/Z+TdY0D9+4jnfRzLu4a4lGx+vJ9eWHYcfdzTbhtQ316Hk85yuw2QOl5aHNp7tN66fs6vjZHx+brPzya5zd079ge9jOvHHzCa31/P9uGOm+1Ay5yUZymDo79kTM/YdO/w6fPrICzZ+3Q1X2vhzz56uxR781o9s2+8/9JSN77t0l41f/3b7mzz1Z19/uBY7+cKqaSkNkznJpPfyJn2cdw95T01ve/kdLnvFHaDZ+rwQPx/W9N60ftbvFb3k2nJr6N0/f61te9OH3mnjt3/yfhsHAKDLqIO92Lc/ZIo6mI1SB6ujDubbUwerow7mNamDLbJBci+jDlZ3IepgT6oeA7riFR+eR8Stkt4r6WBEHJH0W5JukbQs6c7ZhnBXKeVXSikPRcTvS/qONn6N1a+WUvzdAgAAAAAAANhGqIMBAAAA3faKD89LKR8x4d/bpP0nJH3ifAYFAAAAAAAAXGzUwQAAAIBu879zAgAAAAAAAAAAAACADuHhOQAAAAAAAAAAAACg83h4DgAAAAAAAAAAAADovFf8m+cXS3mN2vb6/vMBpSS9ZGETj/SjB9EgKpX0oA3aNpV0U1X1F6LnR95L4sX00bSfSCZrOq2SPpJkJHnum2NmayLLWypbWw1k59+k62ytpGs/O9Mk7GY86zo9n2wk2Rc0SEaVDCY7/2w9L+8Y1mKrp9Z9H4Nm415bG9n4W99xuBZ74N4f+q7zjSUZiv+CwbCe0ex6W1r2t45sbvM15/jxTSs/lsHAX/v5Gqr3k+0fvX6yx2V7RXJM1z5bn5nGl60ZSzX1nUwnUxtfWq6vfUlaPzu28RVzrYzWJ7Ztf9i38d17lmx89Yy/VnrmPB/73tO27S984CdtfM+lKzY+ndTn68F7fmDbrq36Oekn6/OB+30/Lxw7XYu5c9zQcGNNNLs+LxBzTpHtH2kfzQ7pu78Qe1a+D7tw1rV7/yVJl71ur42fPL7q+5nU97i1U/76OfmC7wMAAFwc1MHmGwt1MOpgcw+DOpg/JnUwG+9yHWyRNbmGqIOdfx3sgS8etW2BLuAnzwEAAAAAAAAAAAAAncfDcwAAAAAAAAAAAABA5/HwHAAAAAAAAAAAAADQeTw8BwAAAAAAAAAAAAB0Hg/PAQAAAAAAAAAAAACdN9jqAbwoYr7Y7JW525ZSmo2jl3XUoI8kXrJOknDYSUm6SMfX7Pz7/frnKbI5KZXv2457Ez3TvkpOKOs7y3OTdTEY+MthOp0mnfjwebdt3rxRJ03X+KDft/GqqkznjbpWJF+wtOxzMR7Xc5Gtw0zTNWTDyceODly+x8afefKEjbvrTZLuu+uxWizLQzpXI79upy5vksI07/X8+NK+p77vrJ9ev56L6cT3ka2idD2Hbz8Z1/vftWdo215xaL+N//DRZ2zcnY8kVZP6WPrJOuxl+222zNOLy/XjG/eTtZVdE8Ol+a/PXrLGp6atJJ1dHdt4dldx1/O+fbts2737V2y8H/78n3rquVpsfX1i2771HYf8+JLz//qXHrRxmeXfH/g+GrxFkrTZ+4Tzl99rz7+TZu8oNnvfV++plGQ/TK7DSbJue8lNweYue7/il6FG6/6Yu/Yu2/hfe8+ba7FsL7vz9gf8QQEAwEVBHcz0Qx1s7r6pg83fCXUw6mBOl+tgC406WC32WtbBgC7jJ88BAAAAAAAAAAAAAJ3Hw3MAAAAAAAAAAAAAQOfx8BwAAAAAAAAAAAAA0Hk8PAcAAAAAAAAAAAAAdB4PzwEAAAAAAAAAAAAAnTfY6gH8leJCJigpFHN9/asaRpUcs2eOmfVRGoxbUolk8PMfsrkGfWdzkp1n034i6oOp0raNDpmeZ6lMLDmf7DSbnE+ml6yr7Pyz83Ht+33fOBtftsarykyW/Hz1es0+j5Nd46P1ydzts+sqP2YzZ1dHtVg19b0cf27VxrO5PXjFXhs/eWJtrnFI0uFDB238ySeet/FszU2n9TwvDXzbiU9Pep7ZHldM88Fy37Zd7g9t/OwZPy8HL/dz+9zkVP2YS/6YRx5/1sank6mNl8qv/76Zx+HQH9PlYaNzH84XdP2FdM/O9smkfbY/ufggWUPZMUcjv7iy/eyAuYZeOHbatr31U//bxld2+LXl9spxMr4ytmGdOun3hN27d9j4aK3ef7bDNbwFp19wYd5qZPebZvdVJ7smsvhg4K/DyrRf2bnk+574vvvJu+ZBej2bvSK7DMOP+9Rpv4Zu+sg7bPxdf/O6Wuw7f3HEtv3j//nnfjAAAODioA7mvuC1Qx2sHqMOlvRNHezlqIPZ8MLWwdqJOtjLXYg6GNBl/OQ5AAAAAAAAAAAAAKDzeHgOAAAAAAAAAAAAAOg8Hp4DAAAAAAAAAAAAADqPh+cAAAAAAAAAAAAAgM7j4TkAAAAAAAAAAAAAoPMGWz2AvxLzNy0qTRr7w0VywGwcDQ6Ztm3ad4M5SZsm5xm9+TsvpcnJbzqaufWS8VWVH0uWzlIlBzBfMJ0kjZO+szGma8vIZ9a/kqWi369/DqZUyfkkH5nJ5tb1nWman0yja7zpR4CyPSHJp1v/2ZwcvGKPjT/z1AkbP/bMSRt387hn7w7b9uknj/s+pv5Eq6lfF/1B/ZxG6xPbdjD055/lLZuv5ZVhLba+NvbHNOOTpN2X+HnpDX0+91++uxY7fuy0bZsZDPv+mA322+lk6tsmfYxHPhfDpflv49lenh2z6dbv1lDTPrK9YteeFRt/weQu24cGA5+3ydhfE5NxPUfDJd/H0R8/b+Pjsc9bk/cm6Rwm8XTKkxd65vqssvtH2nfT9wnz95Gtz8nIX0M7d/m1srxsrpVkva2trtt4P/w+dPKFVRvfs6++Py25cUhaX8/2Pr/mKt9cf/KHD9Vid952n22bzSEAALhIqIPN375JU+pgHnWwGupg1MFerit1sKPy38MugibXFnWw86+DAV3GT54DAAAAAAAAAAAAADqPh+cAAAAAAAAAAAAAgM7j4TkAAAAAAAAAAAAAoPN4eA4AAAAAAAAAAAAA6LzBVg9gc5HEy3l3UZr0kXbk+4jwBx0u++kejyb+kK77bEoSSyvZMafNOjJ6yXlmqiRuZ7Ykc9voiHmeXY4uwGprLjnP7JjZ2qqq+uwOhn3bdjrxmcjSWSVj7PfqX1BVzWYrO59sXsIcMztivob8MUsy9l7fHDM5aDa3u/es2PjqmXU/lnG9n1GyT0yn/piTsW/fH/jPTNk1tOTX0DCJZ3O+snPJxnsmn9n5ZBfoys6hjY+T83d7X/T9nJRptib8WHq9pB83L8naH4393pxdz+6akKTKjD3bs7NrPNsTs+vWRadmXUlSP5nz7HxOnVyzcZfP5RW/JrJxTyZ+zl3eLj24x7Z9/tgpG882qJIs8/6wPi/TZHzZXpbempMX/HXb8I6YhdPmDe4V6b7i83zq+Bnfz76dtdBwqdnb4CrZnw5dfamNX/9Th2qxe77+fdt27yX18UnS2fWRjd/2uT+zcbfO0/dCjd9VAQCA1x51sLmGsQnqYNTBXo46GHUwp8t1sEVGHezi1sGALuMnzwEAAAAAAAAAAAAAncfDcwAAAAAAAAAAAABA5/HwHAAAAAAAAAAAAADQeTw8BwAAAAAAAAAAAAB0Hg/PAQAAAAAAAAAAAACdN9jqAbyomFjY6AU6XuXjvV7YeJh4VfnxleLj49Fk7r4lqZj+s76zcY/Wk2NGckzTf3bMLDtZ3+kxk35826R1ks/BsO+bT+tf0PR8Mna+sj6S+HCQjLvyJzo1a2Vlx5Jtu3527PswcyJJ/YH/jM10Um/fbKaaf0Fl5naY5HgyTuZqOrXx4ZLfDt21lc1VmfpVdM1bXmfjD//5ERt3czuZ+HG7fULabMn5F/rDep6XV/ycZNdVNi9LST9u7CsrQ9t29fTIxld2Ju3P+LGMR/V57CVzMkrmPNtv+8nH0SaT+Xe5fj9LnA9ne0KjbSgZS7L1b/LC/LI5HCdz3k8mt/TrY9m3f5dte+L4GRufmDUhSb9887trsfvvftz3Ya5ZKZ/bXpLnLJ9Odm+OSOaqwV6R9j3f0F75CxosofHY52fv/h02fviNB2z8lz50Yy22Y+eybfvv/82XbPzKw/ttPMvaN7/6/Vosm9tTJ9ZsPMtbkws3v5Rfu/fZAADglVEHM/1QBzNtqYM51MHqqIPZMHWwpOaxqKiDXdw62Gfu+1PbFugCfvIcAAAAAAAAAAAAANB5PDwHAAAAAAAAAAAAAHQeD88BAAAAAAAAAAAAAJ3Hw3MAAAAAAAAAAAAAQOfx8BwAAAAAAAAAAAAA0HlRStnqMSginpX0w9k/D0o6toXDwYVFPtuFfLYL+WwX8tke5LJdFi2fbyylXLbVgwAAoM2og7UWuWwX8tku5LNdyGe7kM92WaR8pjWwbfHw/FwRcW8p5catHgcuDPLZLuSzXchnu5DP9iCX7UI+AQDAZniv0B7ksl3IZ7uQz3Yhn+1CPtulLfnk17YDAAAAAAAAAAAAADqPh+cAAAAAAAAAAAAAgM7bjg/PP7XVA8AFRT7bhXy2C/lsF/LZHuSyXcgnAADYDO8V2oNctgv5bBfy2S7ks13IZ7u0Ip/b7m+eAwAAAAAAAAAAAABwsW3HnzwHAAAAAAAAAAAAAOCi2lYPzyPipoh4JCIejYjf2OrxYH4R8fqI+JOI+G5EPBQRvzaLXxoRd0bE92f/v3+rx4r5RUQ/Iu6PiC/N/k0+F1RE7IuIP4iIh2fX6d8gn4srIv7ZbK/9dkTcGhEr5HNxRMRnIuKZiPj2ObE0fxFxy+y90SMR8YtbM2pkknz+9my/fSAibouIfee8Rj4BAAA1sAVHHax9qIG1C3Ww9qAGttiogbVLl2pg2+bheUT0Jf0HSX9X0tskfSQi3ra1o0IDE0n/vJTyVkk/LelXZ/n7DUlfLaVcK+mrs39jcfyapO+e82/yubj+naQ/KqW8RdJPaiOv5HMBRcQhSf9U0o2llBsk9SV9WORzkXxW0k0vi9n8ze6lH5b09tnX/MfZeyZsH59VPZ93SrqhlPITkr4n6RaJfAIAgA3UwFqBOlj7UANrF+pgLUANrBU+K2pgbfJZdaQGtm0enkt6l6RHSymPlVJGkr4g6YNbPCbMqZRytJRy3+y/T2njDckhbeTwc7Nmn5P0y1syQDQWEYcl/ZKkT58TJp8LKCL2Svo5Sb8nSaWUUSnluMjnIhtI2hERA0k7JT0p8rkwSinfkPT8y8JZ/j4o6QullPVSyuOSHtXGeyZsEy6fpZSvlFIms3/eJenw7L/JJwAAkKiBLTzqYO1CDaxdqIO1DjWwBUYNrF26VAPbTg/PD0l64px/H5nFsGAi4mpJ75R0t6QrSilHpY1vLCRdvoVDQzO/K+lfSqrOiZHPxfQmSc9K+s+zX0H26YjYJfK5kEopP5b0byX9SNJRSSdKKV8R+Vx0Wf54f7T4Pibpy7P/Jp8AAEDiPUGrUAdrhd8VNbA2oQ7WEtTAWosaWHu1pga2nR6eh4mViz4KnJeI2C3pv0v69VLKya0eD16diHi/pGdKKd/a6rHgghhI+ilJ/6mU8k5JZ8SvM1pYs78D9EFJ10i6StKuiLh5a0eF1xDvjxZYRPymNn6l5+dfDJlm5BMAgO7hPUFLUAdbfNTAWok6WEtQA+sc3h8tsLbVwLbTw/Mjkl5/zr8Pa+NXcGBBRMRQG98wfL6U8sVZ+OmIuHL2+pWSntmq8aGRn5X0gYj4gTZ+fdzPR8R/FflcVEckHSml3D379x9o45sI8rmYfkHS46WUZ0spY0lflPQzIp+LLssf748WVER8VNL7Jf3DUsqL3xyQTwAAIPGeoBWog7UGNbD2oQ7WHtTA2okaWMu0sQa2nR6e3yPp2oi4JiKWtPGH5O/Y4jFhThER2vg7Mt8tpfzOOS/dIemjs//+qKT/cbHHhuZKKbeUUg6XUq7WxrX4tVLKzSKfC6mU8pSkJyLi+lnofZK+I/K5qH4k6acjYuds732fNv6+HvlcbFn+7pD04YhYjohrJF0r6ZtbMD40EBE3Sfq4pA+UUlbPeYl8AgAAiRrYwqMO1h7UwNqHOlirUANrJ2pgLdLWGli89CGArRcRf08bf2OmL+kzpZRPbO2IMK+IeI+kP5X0oF76+0D/Sht/7+n3Jb1BGze7f1BKeX5LBolXJSLeK+lflFLeHxEHRD4XUkS8Q9KnJS1JekzSP9LGB6jI5wKKiH8t6UPa+FU490v6x5J2i3wuhIi4VdJ7JR2U9LSk35J0u5L8zX7t0ce0ke9fL6V8ud4rtkqSz1skLUt6btbsrlLKr8zak08AAEANbMFRB2snamDtQR2sPaiBLTZqYO3SpRrYtnp4DgAAAAAAAAAAAADAVthOv7YdAAAAAAAAAAAAAIAtwcNzAAAAAAAAAAAAAEDn8fAcAAAAAAAAAAAAANB5PDwHAAAAAAAAAAAAAHQeD88BAAAAAAAAAAAAAJ3Hw3MAAAAAAAAAAAAAQOfx8BwAAAAAAAAAAAAA0Hk8PAcAAAAAAAAAAAAAdN7/Azbk7hXJprCKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Sanity check, RGB\n", + "\n", + "inputs_5 = inputs[:5]\n", + "rgb_index = [0, 2, 1] # Indices of [Red band, Blue band, Green band]\n", + "# Plot RGB reconstruction, minmax normed\n", + "plot_validate(inputs_5, outputs, masks, minmaxes, rgb_index)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "97a7aae1-c098-47ec-9df4-8df31c7a76e4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:ilab]", + "language": "python", + "name": "conda-env-ilab-py" + }, + "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.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pytorch_caney/data/transforms.py b/pytorch_caney/data/transforms.py index 4c8dd00..ed3e2f3 100644 --- a/pytorch_caney/data/transforms.py +++ b/pytorch_caney/data/transforms.py @@ -1,8 +1,8 @@ from .utils import RandomResizedCropNP -from .utils import TransformBrightnessAndReflectance from .utils import SimmimMaskGenerator import torchvision.transforms as T +import numpy as np class SimmimTransform: @@ -15,6 +15,7 @@ def __init__(self, config): self.transform_img = \ T.Compose([ + MinMaxEmissiveScaleReflectance(), # New transform for MinMax RandomResizedCropNP(scale=(0.67, 1.), ratio=(3. / 4., 4. / 3.)), T.ToTensor(), @@ -46,7 +47,8 @@ def __call__(self, img): return img, mask -class SimmimTransformScale: + +class TensorResizeTransform: """ torchvision transform which transforms the input imagery into addition to generating a MiM mask @@ -56,55 +58,141 @@ def __init__(self, config): self.transform_img = \ T.Compose([ - TransformBrightnessAndReflectance(), - RandomResizedCropNP(scale=(0.67, 1.), - ratio=(3. / 4., 4. / 3.)), T.ToTensor(), - #lambda x: x / 500.0, - #T.ConvertImageDtype(dtype=torch.float32), - #torchvision.ops.Permute(dims=[1, 2, 0]), T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), ]) - if config.MODEL.TYPE in ['swin', 'swinv2']: - - model_patch_size = config.MODEL.SWINV2.PATCH_SIZE - - else: - - raise NotImplementedError - - self.mask_generator = SimmimMaskGenerator( - input_size=config.DATA.IMG_SIZE, - mask_patch_size=config.DATA.MASK_PATCH_SIZE, - model_patch_size=model_patch_size, - mask_ratio=config.DATA.MASK_RATIO, - ) - def __call__(self, img): img = self.transform_img(img) - mask = self.mask_generator() - return img, mask + return img -class TensorResizeTransform: +class MinMaxEmissiveScaleReflectance(object): """ - torchvision transform which transforms the input imagery into - addition to generating a MiM mask + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) """ - def __init__(self, config): + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - self.transform_img = \ - T.Compose([ - T.ToTensor(), - T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), - ]) + self.emissive_mins = np.array( + [223.1222, 178.9174, 204.3739, 204.7677, + 194.8686, 202.1759, 201.3823, 203.3537], + dtype=np.float32) + + self.emissive_maxs = np.array( + [352.7182, 261.2920, 282.5529, 319.0373, + 295.0209, 324.0677, 321.5254, 285.9848], + dtype=np.float32) def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img + - img = self.transform_img(img) +class TransformBrightnessAndReflectance(object): + """ + Performs conversion of calibrated MODIS TOA data to radiance units + - Converts TOA brightness temperature to TOA radiance units + - Converts TOA reflectance percentage to TOA radiance units + """ + # Planck constant (Joule second) + h__ = np.float32(6.6260755e-34) + + # Speed of light in vacuum (meters per second) + c__ = np.float32(2.9979246e+8) + + # Boltzmann constant (Joules per Kelvin) + k__ = np.float32(1.380658e-23) + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emi_radiance_offsets = np.array([ + 2730.583496, 2730.583252, 2317.488281, 2730.583496, + 1560.333252, 1577.339722, 1658.221313, 2501.297607], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.emi_radiance_scales = np.array([ + 0.003149510128, 0.0001175572979, 0.0001924497337, + 0.0005324869417, 0.0004063234373, 0.0008400219958, + 0.0007296975818, 0.0002622638713], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_reflectance_offsets = np.array([ + 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_reflectance_scales = np.array([ + 5.665329445e-05, 3.402091534e-05, 6.13320808e-05, + 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_radiance_offsets = np.array([ + 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.rsb_radiance_scales = np.array([ + 0.02995670214, 0.01111282408, 0.04215827957, + 0.002742749639, 0.0009269224829, 0.003434347222], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + # Derived constants + self.c_1 = 2 * self.h__ * self.c__ * self.c__ + self.c_2 = (self.h__ * self.c__) / self.k__ + + self.cwn = np.array([ + 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, + 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], + dtype=np.float32)[np.newaxis, np.newaxis, :] + self.cwn = 1. / (self.cwn * 100) + + self.tcs = np.array([ + 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, + 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + self.tci = np.array([ + 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, + 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], + dtype=np.float32)[np.newaxis, np.newaxis, :] + + def __call__(self, img): + + # Reflectance to radiance units + reflectance_bands = img[:, :, self.reflectance_indices] + img[:, :, self.reflectance_indices] = \ + self.rsb_radiance_scales * ( + (((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + \ + self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) + + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp to radiance units: + emissive_bands = img[:, :, self.emissive_indices] + intermediate = emissive_bands * self.tcs + self.tci + exponent = self.c_2 / (intermediate * self.cwn) + img[:, :, self.emissive_indices] = self.c_1 / \ + (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) + return img + diff --git a/pytorch_caney/data/utils.py b/pytorch_caney/data/utils.py index 305fb17..f5e1f1d 100644 --- a/pytorch_caney/data/utils.py +++ b/pytorch_caney/data/utils.py @@ -115,113 +115,42 @@ def make_simmim_mask(token_count, mask_count, rand_size, scale): return mask -class ModisScalesAndOffsets(object): - - reflectance_indices = [0, 1, 2, 3, 4, 6] - emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - - @staticmethod - def rsb_radiance_scales() -> torch.tensor: - - radiance_scales_array = np.array([0.02995670214, 0.01111282408, 0.04215827957, - 0.002742749639, 0.0009269224829, 0.003434347222], dtype=np.float32) - - return torch.tensor(radiance_scales_array).view(6, 1, 1) - - @staticmethod - def rsb_radiance_offsets() -> torch.tensor: - - radiance_offsets_array = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], dtype=np.float32) - - return torch.tensor(radiance_offsets_array).view(6, 1, 1) - - @staticmethod - def rsb_reflectance_scales() -> torch.tensor: - - reflectance_scales_array = np.array([5.665329445e-05, 3.402091534e-05, 6.13320808e-05, - 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], dtype=np.float32) - - return torch.tensor(reflectance_scales_array).view(6, 1, 1) - - @staticmethod - def rsb_reflectance_offsets() -> torch.tensor: - - reflectance_offsets_array = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], dtype=np.float32) - - return torch.tensor(reflectance_offsets_array).view(6, 1, 1) +class MinMaxEmissiveScaleReflectance(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ - @staticmethod - def emi_radiance_scales() -> torch.tensor: + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - radiance_scales_array = np.array([ - 0.003149510128, 0.0001175572979, 0.0001924497337, - 0.0005324869417, 0.0004063234373, 0.0008400219958, - 0.0007296975818, 0.0002622638713], + self.emissive_mins = np.array( + [223.1222, 178.9174, 204.3739, 204.7677, + 194.8686, 202.1759, 201.3823, 203.3537], dtype=np.float32) - return torch.tensor(radiance_scales_array).view(8, 1, 1) - - @staticmethod - def emi_radiance_offsets() -> torch.tensor: - - # Radiance offsets - radiance_offsets_array = np.array([ - 2730.583496, 2730.583252, 2317.488281, 2730.583496, - 1560.333252, 1577.339722, 1658.221313, 2501.297607], + self.emissive_maxs = np.array( + [352.7182, 261.2920, 282.5529, 319.0373, + 295.0209, 324.0677, 321.5254, 285.9848], dtype=np.float32) - return torch.tensor(radiance_offsets_array).view(8, 1, 1) - - @staticmethod - def derived_constants() -> torch.tensor: + def __call__(self, img): - # Planck constant (Joule second) - h__ = np.float32(6.6260755e-34) - - # Speed of light in vacuum (meters per second) - c__ = np.float32(2.9979246e+8) - - # Boltzmann constant (Joules per Kelvin) - k__ = np.float32(1.380658e-23) - - # Derived constants - c_1 = 2 * h__ * c__ * c__ - c_2 = (h__ * c__) / k__ + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 - return torch.tensor(c_1), torch.tensor(c_2) - - # ev1km_band_names = [20,21,22,23,24,25,27,28,29,30,31,32,33,34,35,36] - # ev1km_band_names = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15] - - @staticmethod - def cwn() -> torch.tensor: - cwn_array = np.array([ - 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, - 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], - dtype=np.float32) - cwn_array = 1. / (cwn_array * 100) - return torch.tensor(cwn_array).view(8, 1, 1) - - @staticmethod - def tcs() -> torch.tensor: - # Temperature correction slope (no units) - tcs_array = np.array([ - 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, - 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], - dtype=np.float32) - return torch.tensor(tcs_array).view(8, 1, 1) - - @staticmethod - def tci() -> torch.tensor: - # Temperature correction intercept (Kelvin) - tci_array = np.array([ - 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, - 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], - dtype=np.float32) - return torch.tensor(tci_array).view(8, 1, 1) - - + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img + class TransformBrightnessAndReflectance(object): # Planck constant (Joule second) @@ -291,13 +220,19 @@ def __call__(self, img): # Reflectance to radiance units reflectance_bands = img[:, :, self.reflectance_indices] - img[:, :, self.reflectance_indices] = self.rsb_radiance_scales * ((((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) - img[:, :, self.reflectance_indices] = img[:, :, self.reflectance_indices] * 0.01 + img[:, :, self.reflectance_indices] = \ + self.rsb_radiance_scales * ( + (((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + \ + self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) + + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 # Brightness temp to radiance units: emissive_bands = img[:, :, self.emissive_indices] intermediate = emissive_bands * self.tcs + self.tci exponent = self.c_2 / (intermediate * self.cwn) - img[:, :, self.emissive_indices] = self.c_1 / (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) + img[:, :, self.emissive_indices] = self.c_1 / \ + (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) return img diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index df46be1..6aef37e 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -164,9 +164,8 @@ def execute_one_epoch(config, """ validationDataset = validation_setup(config) - ntrain = 1962000 num_steps = max(1, - ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) + NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) # Set up logging meters batch_time = AverageMeter() @@ -266,12 +265,10 @@ def main(config): logger.info(f"Total number of trainable parameters: {trainable_params}") # Total number of samples in current 2m dataset - ntrain = 1962000 - # Number of batches (or steps) to process per epoch num_steps = max( 1, - ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) + NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) # Calculate LR steps # total steps (or batches) for the entire training iteration @@ -296,19 +293,19 @@ def main(config): "zero_optimization": { "stage": 2, # "offload_optimizer": {"device": "cpu"}, - #"offload_param": {"device": "cpu"}, + # "offload_param": {"device": "cpu"}, "contiguous_gradients": True, "overlap_comm": True, "reduce_bucket_size": 5e8, "allgather_bucket_size": 5e8, - #"offload_optimizer": { - # "device": "cpu" - #}, + # "offload_optimizer": { + # "device": "cpu" + # }, }, "activation_checkpointing": { "partition_activations": True, - # "cpu_checkpointing": True, + # "cpu_checkpointing": True, "profile": False, }, @@ -353,18 +350,9 @@ def main(config): logger.info('Initializing deepspeed') - optimizer = torch.optim.AdamW(simmim_model.parameters(), - lr=config.TRAIN.BASE_LR,) - # weight_decay=config.TRAIN.WEIGHT_DECAY) - - """ - scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, - max_lr=config.TRAIN.BASE_LR, - total_steps=num_steps, - last_epoch=num_steps-1, - pct_start=0.4) - """ + lr=config.TRAIN.BASE_LR, + weight_decay=config.TRAIN.WEIGHT_DECAY) model_engine, optimizer, _, _ = deepspeed.initialize( model=simmim_model, @@ -484,7 +472,7 @@ def setup_seeding(config): setup_seeding(config) config.defrost() - base_batch_size = 2048 + base_batch_size = 2048 config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py deleted file mode 100644 index e338400..0000000 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py +++ /dev/null @@ -1,515 +0,0 @@ -from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset -from pytorch_caney.data.transforms import SimmimTransform, SimmimTransformScale -from pytorch_caney.data.utils import ModisScalesAndOffsets -from pytorch_caney.models.mim.mim import build_mim_model -from pytorch_caney.ptc_logging import create_logger -from pytorch_caney.config import get_config - -import deepspeed -from deepspeed.accelerator import get_accelerator - -from socket import gethostname -import argparse -import datetime -import joblib -import numpy as np -import os -import sys -import time - -import torch -import torch.distributed as dist - -from timm.utils import AverageMeter - - -NUM_SAMPLES: int = 1962000 - - -def parse_args(): - """ - Parse command-line arguments - """ - parser = argparse.ArgumentParser( - 'pytorch-caney implementation of MiM pre-training script', - add_help=False) - - parser.add_argument( - '--cfg', - type=str, - required=True, - metavar="FILE", - help='path to config file') - - parser.add_argument( - "--data-paths", - nargs='+', - required=True, - help="paths where dataset is stored") - - parser.add_argument('--validation-path', - type=str, - required=True, - help='validation dataset path') - - parser.add_argument('--dataset', - type=str, - required=True, - help='Dataset to use') - - parser.add_argument( - '--batch-size', - type=int, - help="batch size for single GPU") - - parser.add_argument( - '--resume', - help='resume from checkpoint') - - parser.add_argument( - '--use-checkpoint', - action='store_true', - help="whether to use gradient checkpointing to save memory") - - parser.add_argument( - '--output', - default='output', - type=str, - metavar='PATH', - help='root of output folder, the full path is ' + - '// (default: output)') - - parser.add_argument( - '--tag', - help='tag of experiment') - - args = parser.parse_args() - - config = get_config(args) - - return args, config - - -def train(config, - dataloader, - model_engine, - optimizer, - device): - """ - Start pre-training a specific model and dataset. - - Args: - config: config object - dataloader: dataloader to use - model: model to pre-train - model_wo_ddp: model to pre-train that is not the DDP version - optimizer: pytorch optimizer - lr_scheduler: learning-rate scheduler - """ - - logger.info("Start training") - - target_dtype = None - if model_engine.bfloat16_enabled(): - target_dtype = torch.bfloat16 - elif model_engine.fp16_enabled(): - target_dtype = torch.half - logger.info(f'Target dtype: {target_dtype}') - - torch.cuda.empty_cache() - - start_time = time.time() - - for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): - - start = time.time() - - execute_one_epoch(config, model_engine, dataloader, - optimizer, epoch, target_dtype, device) - - tag = f'ckpt_epoch_{epoch}' - model_engine.save_checkpoint(save_dir=config.OUTPUT, - tag=tag,) - - epoch_time = time.time() - start - logger.info( - f"EPOCH {epoch} training takes " + - f"{datetime.timedelta(seconds=int(epoch_time))}") - - - total_time = time.time() - start_time - - total_time_str = str(datetime.timedelta(seconds=int(total_time))) - - logger.info('Training time {}'.format(total_time_str)) - - -def execute_one_epoch(config, - model, - dataloader, - optimizer, - epoch, - target_dtype, - device): - """ - Execute training iterations on a single epoch. - - Args: - config: config object - model: model to pre-train - dataloader: dataloader to use - optimizer: pytorch optimizer - epoch: int epoch number - target_dtype: torch dtype, should match model dtype - device: device to move inputs to - """ - validationDataset = validation_setup(config) - - ntrain = 1962000 - num_steps = max(1, - ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) - - - # Set up logging meters - batch_time = AverageMeter() - data_time = AverageMeter() - loss_meter = AverageMeter() - - start = time.time() - end = time.time() - - for idx, img_mask in enumerate(dataloader): - - img_mask = img_mask[0] - - img = torch.stack([pair[0] for pair in img_mask]) - mask = torch.stack([pair[1] for pair in img_mask]) - - data_time.update(time.time() - start) - - img = img.to(device, non_blocking=True) - mask = mask.to(device, non_blocking=True) - - if target_dtype: - img = img.to(target_dtype) - - loss = model(img, mask) - - model.backward(loss) - - model.step() - - torch.cuda.synchronize() - - loss_meter.update(loss.item(), img.size(0)) - batch_time.update(time.time() - end) - end = time.time() - - if idx % config.VALIDATION_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - validate(model, validationDataset, lr, idx, epoch, target_dtype, device) - - if idx % config.PRINT_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) - etas = batch_time.avg * (num_steps - idx) - logger.info( - f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' - f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' - f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' - f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' - f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'mem {memory_used:.0f}MB') - - if idx == num_steps: - logger.info(f'Ending step loop for epoch {idx}') - break - - torch.distributed.barrier() - - -def main(config): - """ - Starts training process after building the proper model, optimizer, etc. - - Args: - config: config object - """ - - logger.info('In main') - - transform = SimmimTransformScale(config) - - dataset = MODIS22MDataset(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform, - batch_size=config.DATA.BATCH_SIZE).dataset() - - dataloader = torch.utils.data.DataLoader( - dataset, - batch_size=None, - num_workers=8, - shuffle=False, - pin_memory=True,) - - logger.info(f'MODEL CHECKPOINTING: {config.TRAIN.USE_CHECKPOINT}') - - simmim_model = build_model(config, logger) - - # Count the total number of parameters - total_params = sum(p.numel() for p in simmim_model.parameters()) - logger.info(f"Total number of parameters: {total_params}") - - # Count the total number of trainable parameters - trainable_params = sum(p.numel() for p in simmim_model.parameters() - if p.requires_grad) - logger.info(f"Total number of trainable parameters: {trainable_params}") - - # Total number of samples in current 2m dataset - ntrain = 1962000 - - # Number of batches (or steps) to process per epoch - num_steps = max( - 1, - ntrain // (config.DATA.BATCH_SIZE * dist.get_world_size())) - - # Calculate LR steps - # total steps (or batches) for the entire training iteration - total_steps = num_steps * config.TRAIN.EPOCHS - logger.info(f'Total steps for {config.TRAIN.EPOCHS} epochs: {total_steps}') - - cycle_one_percentage = 0.3 - cycle_stage_one = int(total_steps * cycle_one_percentage) - cycle_stage_two = (total_steps - cycle_stage_one) - 1 - - logger.info(f'OneCycle: stage-1 step size = {cycle_stage_one}') - logger.info(f'OneCycle: stage-2 step size = {cycle_stage_two}') - logger.info(f'OneCycle: min LR = {config.TRAIN.MIN_LR}') - logger.info(f'OneCycle: max LR = {config.TRAIN.BASE_LR}') - - deepspeed_config = { - "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, - - "steps_per_print": config.PRINT_FREQ, - "memory_breakdown": False, - - "zero_optimization": { - "stage": 2, - # "offload_optimizer": {"device": "cpu"}, - #"offload_param": {"device": "cpu"}, - "contiguous_gradients": True, - "overlap_comm": True, - "reduce_bucket_size": 5e8, - "allgather_bucket_size": 5e8, - #"offload_optimizer": { - # "device": "cpu" - #}, - }, - - "activation_checkpointing": { - "partition_activations": True, - # "cpu_checkpointing": True, - "profile": False, - }, - - "fp16": { - "enabled": False, - }, - - "bf16": { - "enabled": True, - }, - - "scheduler": { - "type": "OneCycle", - # "type": "WarmupLR", - "params": { - # "lr_range_test_step_size": 10, - # "lr_range_test_step_rate": 4, - # "lr_range_test_min_lr": config.TRAIN.BASE_LR, - # "lr_range_test_staircase": False, - # "warmup_min_lr": config.TRAIN.WARMUP_LR, - # "warmup_max_lr": config.TRAIN.BASE_LR, - # "warmup_num_steps": num_steps, - "cycle_min_lr": config.TRAIN.MIN_LR, - "cycle_max_lr": config.TRAIN.BASE_LR, - "cycle_first_step_size": cycle_stage_one, - "cycle_second_step_size": cycle_stage_two, - # "warmup_min_ratio": 0, - # "warmup_num_steps": config.TRAIN.WARMUP_STEPS, - }, - }, - - "flops_profiler": { - "enabled": False, - #"profile_step": 1, - "module_depth": -1, - #"top_modules": 1, - "detailed": True, - "output_file": f'profile_{time.time()}', - }, - - } - - logger.info('Initializing deepspeed') - - - optimizer = torch.optim.AdamW(simmim_model.parameters(), - lr=config.TRAIN.BASE_LR,) - # weight_decay=config.TRAIN.WEIGHT_DECAY) - - """ - scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, - max_lr=config.TRAIN.BASE_LR, - total_steps=num_steps, - last_epoch=num_steps-1, - pct_start=0.4) - """ - - model_engine, optimizer, _, _ = deepspeed.initialize( - model=simmim_model, - model_parameters=simmim_model.parameters(), - optimizer=optimizer, - dist_init_required=True, - config=deepspeed_config - ) - - if config.MODEL.RESUME: - - load_dir = os.path.dirname(config.MODEL.RESUME) - logger.info(f'Ckpt load dir: {load_dir}') - - tag = os.path.basename(config.MODEL.RESUME) - logger.info(f'Ckpt tag: {tag}') - - epoch = tag.split('_')[2] - logger.info(f'Ckpt epoch: {epoch}') - - load_path, _ = model_engine.load_checkpoint(load_dir=load_dir, - tag=tag) - config.defrost() - config.TRAIN.START_EPOCH = int(epoch) + 1 - config.freeze() - - logger.info(f'Loaded from checkpoint: {load_path}') - logger.info(f'Resuming from epoch {config.TRAIN.START_EPOCH}') - - local_rank = model_engine.local_rank - local_device = get_accelerator().device_name(local_rank) - - logger.info('Starting training block') - - torch.distributed.barrier() - - train(config, - dataloader, - model_engine, - optimizer, - local_device) - - -@torch.no_grad() -def validation_setup(config): - - transform = SimmimTransformScale(config) - validation_dataset_path = config.DATA.VALIDATION_PATH - validation_dataset = np.load(validation_dataset_path) - len_batch = range(validation_dataset.shape[0]) - imgMasks = [transform(validation_dataset[idx]) for idx \ - in len_batch] - img = torch.stack([imgMask[0] for imgMask in imgMasks]) - mask = torch.stack([torch.from_numpy(imgMask[1]) for \ - imgMask in imgMasks]) - return img, mask - - -@torch.no_grad() -def validate(model, img_masks, lr, step, epoch, target_dtype, device): - start_time = time.time() - - img, mask = img_masks - - img = img.to(device, non_blocking=True) - mask = mask.cuda(device, non_blocking=True) - - if target_dtype: - img = img.to(target_dtype) - - loss = model(img, mask) - - validation_time = time.time() - start_time - - logger.info( - f"Validation: [{step}/{epoch}]\t" - f"lr {lr}\t" - f"val_loss {loss:.4f}\t" - f"time {validation_time:.4f}s") - - del img, mask, loss - - -def build_model(config, logger): - - logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") - - model = build_mim_model(config) - - return model - - -def setup_seeding(config): - seed = config.SEED + dist.get_rank() - torch.manual_seed(seed) - np.random.seed(seed) - - -if __name__ == '__main__': - _, config = parse_args() - - world_size = int(os.environ["WORLD_SIZE"]) - rank = int(os.environ["RANK"]) - gpus_per_node = torch.cuda.device_count() - print(f" {gpus_per_node} allocated GPUs per node.", flush=True) - - deepspeed.init_distributed() - - torch.distributed.barrier() - - print(f"Hello from rank {rank} of {world_size} on" - f" {gethostname()} where there are" - f" {gpus_per_node} allocated GPUs per node.", flush=True) - - if rank == 0: - print(f"Group initialized? {dist.is_initialized()}", flush=True) - - setup_seeding(config) - - config.defrost() - base_batch_size = 2048 - config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.freeze() - - os.makedirs(config.OUTPUT, exist_ok=True) - logger = create_logger(output_dir=config.OUTPUT, - dist_rank=dist.get_rank(), - name=f"{config.MODEL.NAME}") - - if dist.get_rank() == 0: - path = os.path.join(config.OUTPUT, "config.json") - with open(path, "w") as f: - f.write(config.dump()) - logger.info(f"Full config saved to {path}") - logger.info(config.dump()) - config_file_name = f'{config.TAG}.config.sav' - config_file_path = os.path.join(config.OUTPUT, config_file_name) - joblib.dump(config, config_file_path) - - logger.info(f'Base LR (scaled): {config.TRAIN.BASE_LR}') - logger.info(f'Warmup LR (scaled): {config.TRAIN.WARMUP_LR}') - logger.info(f'Min LR (scaled): {config.TRAIN.MIN_LR}') - - sys.exit(main(config)) diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml index de13574..25092d9 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml @@ -5,7 +5,7 @@ MODEL: SWINV2: IN_CHANS: 14 EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] + DEPTHS: [ 2, 2, 128, 2 ] NUM_HEADS: [ 16, 32, 64, 128 ] WINDOW_SIZE: 8 NORM_PERIOD: 6 diff --git a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml index 14ccf1b..513870a 100644 --- a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml +++ b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml @@ -27,5 +27,5 @@ TRAIN: MULTISTEPS: [700,] PRINT_FREQ: 10 SAVE_FREQ: 1 -VALIDATION_FREQ: 10 -TAG: mim_pretrain_swinv2_g_satvision_128_window08__128heads_100ep +VALIDATION_FREQ: 20 +TAG: mim_pretrain_swinv2_g_satvision_128_window08_mpatch8_scaled_bt_minmax_100ep diff --git a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml deleted file mode 100644 index f5fd639..0000000 --- a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_scaling.yaml +++ /dev/null @@ -1,31 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-giant - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] - NUM_HEADS: [ 16, 32, 64, 128 ] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 100 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - WARMUP_LR: 1e-4 - MIN_LR: 2e-4 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 1 -VALIDATION_FREQ: 10 -TAG: scaled_mim_pretrain_swinv2_g_satvision_128_window08__128heads_100ep diff --git a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml index 4d5ced7..93264a9 100644 --- a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml +++ b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml @@ -30,4 +30,4 @@ TRAIN: PRINT_FREQ: 10 SAVE_FREQ: 1 VALIDATION_FREQ: 20 -TAG: mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_rsb_scaled_100ep +TAG: mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_bt_minmax_100ep diff --git a/runs/runners/README.md b/runs/runners/README.md new file mode 100644 index 0000000..be3d5cb --- /dev/null +++ b/runs/runners/README.md @@ -0,0 +1,26 @@ +# Runners + +softlink these to cwd with pytorch-caney + +## Discover + +For starting a model from scratch +```bash +$ sbatch discover_svtoa_pretraining_runner.sh mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml +``` + +For starting resuming a model + +```bash +$ sbatch discover_svtoa_pretraining_runner_resume.sh mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml mim_satvision_pretrain-huge/mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_100ep/ckpt_epoch_60 +``` + +- !! Deepspeed does not allow resuming training with a different world size (n gpus). You must use the same number of gpus (/nodes) when resuming. +- The 2nd arg should be the path to the checkpoint directory without a trailing `/`. I haven't edited to code to handle this obvious bug. + + +## Frontier + +For starting model from scratch +- same as above commands just switch out the discover runner script for the frontier runner script. +- If needed, switch out the cast command to copy from here: /lustre/orion/geo160/proj-shared/envs/rocm-torch-test-full-0.1.0.tar.gz instead of where it currently is. \ No newline at end of file diff --git a/runs/runners/discover_svtoa_pretraining_runner.sh b/runs/runners/discover_svtoa_pretraining_runner.sh index 5fcc4ec..1489d06 100644 --- a/runs/runners/discover_svtoa_pretraining_runner.sh +++ b/runs/runners/discover_svtoa_pretraining_runner.sh @@ -1,6 +1,6 @@ #!/bin/bash -#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job -#SBATCH --nodes=6 # node count +#SBATCH --job-name=sv-toa-deepspeed # create a short name for your job +#SBATCH --nodes=7 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) #SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) @@ -56,7 +56,7 @@ validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_lr_finding.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" echo $cmd srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" diff --git a/runs/runners/discover_svtoa_pretraining_runner_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_resume.sh index 0bcf791..464042f 100644 --- a/runs/runners/discover_svtoa_pretraining_runner_resume.sh +++ b/runs/runners/discover_svtoa_pretraining_runner_resume.sh @@ -1,5 +1,5 @@ #!/bin/bash -#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job +#SBATCH --job-name=sv-toa-deepspeed # create a short name for your job #SBATCH --nodes=7 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) @@ -56,7 +56,7 @@ validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_lr_finding.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2" echo $cmd srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" diff --git a/runs/runners/discover_svtoa_pretraining_runner_scaling.sh b/runs/runners/discover_svtoa_pretraining_runner_scaling.sh deleted file mode 100644 index f562306..0000000 --- a/runs/runners/discover_svtoa_pretraining_runner_scaling.sh +++ /dev/null @@ -1,66 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job -#SBATCH --nodes=7 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) -#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) -#SBATCH --gres=gpu:4 # number of allocated gpus per node -#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --partition=gpu_a100 -#SBATCH --reservation=warpsles15 -#SBATCH --constraint=rome -#SBATCH --qos=8n_a100 -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -export NCCL_NET_GDR_LEVEL=PHB -export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" - -launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" -echo $cmd - -srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -pkill -9 python - -echo "END TIME: $(date)" diff --git a/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh deleted file mode 100644 index 58ba10c..0000000 --- a/runs/runners/discover_svtoa_pretraining_runner_scaling_resume.sh +++ /dev/null @@ -1,66 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job -#SBATCH --nodes=7 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) -#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) -#SBATCH --gres=gpu:4 # number of allocated gpus per node -#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --partition=gpu_a100 -#SBATCH --reservation=warpsles15 -#SBATCH --constraint=rome -#SBATCH --qos=8n_a100 -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -export NCCL_NET_GDR_LEVEL=PHB -export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" - -launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed_scaling.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2 " -echo $cmd - -srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -pkill -9 python - -echo "END TIME: $(date)" diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 14e3759..bda0a4f 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -91,7 +91,7 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/26m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -batchsize=128 +batchsize=64 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" diff --git a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh index e728d31..92c2471 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh @@ -89,8 +89,8 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/02m -validationpath= -batchsize=128 +validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy +batchsize=64 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" From 79548c5fde5b63cd97c92c593fcb6cc0dcbb6fb3 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Mon, 10 Jun 2024 15:39:12 -0400 Subject: [PATCH 06/50] added note --- runs/runners/README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/runs/runners/README.md b/runs/runners/README.md index be3d5cb..81308f3 100644 --- a/runs/runners/README.md +++ b/runs/runners/README.md @@ -23,4 +23,7 @@ $ sbatch discover_svtoa_pretraining_runner_resume.sh mim_pretrain_swinv2_satvisi For starting model from scratch - same as above commands just switch out the discover runner script for the frontier runner script. -- If needed, switch out the cast command to copy from here: /lustre/orion/geo160/proj-shared/envs/rocm-torch-test-full-0.1.0.tar.gz instead of where it currently is. \ No newline at end of file +- If needed, switch out the cast command to copy from here: /lustre/orion/geo160/proj-shared/envs/rocm-torch-test-full-0.1.0.tar.gz instead of where it currently is. + +## !! Note +For 26m and 100m dataset, make sure to increase NUM_SAMPLES in the mim_deepspeed.py script, that reflects dataset length. From 3b3d10c61496a03b437b03aabcde3cc2364afa4f Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 3 Jul 2024 15:27:42 -0400 Subject: [PATCH 07/50] per step checkpointing --- .../pipelines/pretraining/mim_deepspeed.py | 47 +++++++++++++------ ...ision_giant_128_window08_50ep_32nodes.yaml | 4 +- 2 files changed, 34 insertions(+), 17 deletions(-) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 6aef37e..124f441 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -90,6 +90,7 @@ def parse_args(): def train(config, + resuming_step, dataloader, model_engine, optimizer, @@ -124,11 +125,8 @@ def train(config, start = time.time() execute_one_epoch(config, model_engine, dataloader, - optimizer, epoch, target_dtype, device) - - tag = f'ckpt_epoch_{epoch}' - model_engine.save_checkpoint(save_dir=config.OUTPUT, - tag=tag,) + optimizer, epoch, resuming_step, + target_dtype, device) epoch_time = time.time() - start logger.info( @@ -148,6 +146,7 @@ def execute_one_epoch(config, dataloader, optimizer, epoch, + resuming_step, target_dtype, device): """ @@ -176,6 +175,7 @@ def execute_one_epoch(config, end = time.time() for idx, img_mask in enumerate(dataloader): + idx = idx + resuming_step img_mask = img_mask[0] @@ -217,6 +217,11 @@ def execute_one_epoch(config, f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' f'mem {memory_used:.0f}MB') + + if idx % config.SAVE_FREQ or idx == num_steps-1: + tag = f'ckpt_epoch_{epoch}_step_{idx}' + model.save_checkpoint(save_dir=config.OUTPUT, + tag=tag,) if idx == num_steps: logger.info(f'Ending step loop for epoch {idx}') @@ -270,6 +275,24 @@ def main(config): 1, NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) + # The step/batch/idx we are resuming from (assume 0 for start) + resuming_step = 0 + + if config.MODEL.RESUME: + load_dir = os.path.dirname(config.MODEL.RESUME) + logger.info(f'Ckpt load dir: {load_dir}') + + tag = os.path.basename(config.MODEL.RESUME) + logger.info(f'Ckpt tag: {tag}') + + epoch = tag.split('_')[2] + logger.info(f'Ckpt epoch: {epoch}') + + step = tag.split('_')[4] + logger.info(f'Ckpt step: {step}') + resuming_step = int(step) + resuming_global_step = int(resuming_step + (int(epoch) * num_steps)) + # Calculate LR steps # total steps (or batches) for the entire training iteration total_steps = num_steps * config.TRAIN.EPOCHS @@ -284,6 +307,8 @@ def main(config): logger.info(f'OneCycle: min LR = {config.TRAIN.MIN_LR}') logger.info(f'OneCycle: max LR = {config.TRAIN.BASE_LR}') + last_batch_iteration = -1 if resuming_global_step == 0 else resuming_global_step + deepspeed_config = { "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, @@ -332,6 +357,7 @@ def main(config): "cycle_max_lr": config.TRAIN.BASE_LR, "cycle_first_step_size": cycle_stage_one, "cycle_second_step_size": cycle_stage_two, + "last_batch_iteration": last_batch_iteration, # "warmup_min_ratio": 0, # "warmup_num_steps": config.TRAIN.WARMUP_STEPS, }, @@ -364,19 +390,10 @@ def main(config): if config.MODEL.RESUME: - load_dir = os.path.dirname(config.MODEL.RESUME) - logger.info(f'Ckpt load dir: {load_dir}') - - tag = os.path.basename(config.MODEL.RESUME) - logger.info(f'Ckpt tag: {tag}') - - epoch = tag.split('_')[2] - logger.info(f'Ckpt epoch: {epoch}') - load_path, _ = model_engine.load_checkpoint(load_dir=load_dir, tag=tag) config.defrost() - config.TRAIN.START_EPOCH = int(epoch) + 1 + config.TRAIN.START_EPOCH = int(epoch) config.freeze() logger.info(f'Loaded from checkpoint: {load_path}') diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml index 25092d9..5113d78 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml @@ -5,7 +5,7 @@ MODEL: SWINV2: IN_CHANS: 14 EMBED_DIM: 512 - DEPTHS: [ 2, 2, 128, 2 ] + DEPTHS: [ 2, 2, 42, 2 ] NUM_HEADS: [ 16, 32, 64, 128 ] WINDOW_SIZE: 8 NORM_PERIOD: 6 @@ -26,6 +26,6 @@ TRAIN: GAMMA: 0.1 MULTISTEPS: [700,] PRINT_FREQ: 10 -SAVE_FREQ: 1 +SAVE_FREQ: 3000 VALIDATION_FREQ: 20 TAG: mim_pretrain_3b_26m_32nodes_128_window8_onecycle_50ep From 8c99c7249edaccd748c6446e5015f61acd41bf49 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 3 Jul 2024 16:29:26 -0400 Subject: [PATCH 08/50] fixed bug with checkpointing --- pytorch_caney/pipelines/pretraining/mim_deepspeed.py | 4 +++- ...2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml | 2 +- runs/runners/discover_svtoa_pretraining_runner.sh | 7 +++---- runs/runners/discover_svtoa_pretraining_runner_resume.sh | 7 +++---- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 124f441..b467cda 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -218,7 +218,7 @@ def execute_one_epoch(config, f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' f'mem {memory_used:.0f}MB') - if idx % config.SAVE_FREQ or idx == num_steps-1: + if idx % config.SAVE_FREQ == 0 or idx == num_steps-1: tag = f'ckpt_epoch_{epoch}_step_{idx}' model.save_checkpoint(save_dir=config.OUTPUT, tag=tag,) @@ -277,6 +277,7 @@ def main(config): # The step/batch/idx we are resuming from (assume 0 for start) resuming_step = 0 + resuming_global_step = 0 if config.MODEL.RESUME: load_dir = os.path.dirname(config.MODEL.RESUME) @@ -407,6 +408,7 @@ def main(config): torch.distributed.barrier() train(config, + resuming_step, dataloader, model_engine, optimizer, diff --git a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml index 93264a9..77c71ef 100644 --- a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml +++ b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml @@ -28,6 +28,6 @@ TRAIN: GAMMA: 0.1 MULTISTEPS: [700,] PRINT_FREQ: 10 -SAVE_FREQ: 1 +SAVE_FREQ: 50 VALIDATION_FREQ: 20 TAG: mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_bt_minmax_100ep diff --git a/runs/runners/discover_svtoa_pretraining_runner.sh b/runs/runners/discover_svtoa_pretraining_runner.sh index 1489d06..6946f84 100644 --- a/runs/runners/discover_svtoa_pretraining_runner.sh +++ b/runs/runners/discover_svtoa_pretraining_runner.sh @@ -1,6 +1,6 @@ #!/bin/bash #SBATCH --job-name=sv-toa-deepspeed # create a short name for your job -#SBATCH --nodes=7 # node count +#SBATCH --nodes=5 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) #SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) @@ -8,7 +8,6 @@ #SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) #SBATCH --mail-type=ALL # send email when job begins #SBATCH --partition=gpu_a100 -#SBATCH --reservation=warpsles15 #SBATCH --constraint=rome #SBATCH --qos=8n_a100 #SBATCH --mail-user=caleb.s.spradlin@nasa.gov @@ -51,12 +50,12 @@ echo $MASTER_ADDR echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/validation_test/data/sv_toa_128_chip_validation_04_24.npy" launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path}" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 32 --validation-path ${validation_path}" echo $cmd srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" diff --git a/runs/runners/discover_svtoa_pretraining_runner_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_resume.sh index 464042f..ce59268 100644 --- a/runs/runners/discover_svtoa_pretraining_runner_resume.sh +++ b/runs/runners/discover_svtoa_pretraining_runner_resume.sh @@ -1,6 +1,6 @@ #!/bin/bash #SBATCH --job-name=sv-toa-deepspeed # create a short name for your job -#SBATCH --nodes=7 # node count +#SBATCH --nodes=5 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) #SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) @@ -8,7 +8,6 @@ #SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) #SBATCH --mail-type=ALL # send email when job begins #SBATCH --partition=gpu_a100 -#SBATCH --reservation=warpsles15 #SBATCH --constraint=rome #SBATCH --qos=8n_a100 #SBATCH --mail-user=caleb.s.spradlin@nasa.gov @@ -51,12 +50,12 @@ echo $MASTER_ADDR echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/development/validation_test/data/sv_toa_128_chip_validation_04_24.npy" +validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/validation_test/data/sv_toa_128_chip_validation_04_24.npy" launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 512 --validation-path ${validation_path} --resume $2" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 32 --validation-path ${validation_path} --resume $2" echo $cmd srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" From 422b7bd4dd0dfa82ad3c26313923e961a89bf2fe Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 3 Jul 2024 16:35:03 -0400 Subject: [PATCH 09/50] updated data path --- pytorch_caney/data/datasets/mim_modis_22m_dataset.py | 3 +-- runs/runners/frontier_svtoa_pretraining_runner.sh | 4 ++-- runs/runners/frontier_svtoa_pretraining_runner_resume.sh | 3 ++- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py b/pytorch_caney/data/datasets/mim_modis_22m_dataset.py index 8234288..49a66a9 100644 --- a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py +++ b/pytorch_caney/data/datasets/mim_modis_22m_dataset.py @@ -56,8 +56,7 @@ def __init__( self.split = split - self.shard_path = pathlib.Path( - os.path.join(data_paths[0], self.SHARD_PATH)) + self.shard_path = pathlib.Path(data_paths[0]) shards = self.shard_path.glob('*.tar') diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index bda0a4f..2413802 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -1,6 +1,6 @@ #!/bin/bash #SBATCH -A geo160 -#SBATCH --job-name=sv-3b-26m-pt-15-epoch-test # create a short name for your job +#SBATCH --job-name=sv-3b-100m-pt-50-epoch-test # create a short name for your job #SBATCH --nodes=32 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --gres=gpu:8 # number of allocated gpus per node @@ -89,7 +89,7 @@ echo $MASTER_ADDR echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES -datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/26m +datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy batchsize=64 nprocpernode=8 diff --git a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh index 92c2471..5fdb0c0 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh @@ -16,6 +16,7 @@ module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 module load PrgEnv-gnu/8.4.0 export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich +export LD_LIBRARY_PATH=/lustre/orion/geo160/proj-shared/testing/aws-olf-rccl-plugin/aws-ofi-rccl/lib:$LD_LIBRARY_PATH module load amd-mixed/5.7.1 module load craype-accel-amd-gfx90a module load miniforge3/23.11.0 @@ -88,7 +89,7 @@ echo $MASTER_ADDR echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES -datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/02m +datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy batchsize=64 nprocpernode=8 From 30a573463f346903a765a256f18c0b60e0124444 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Mon, 26 Aug 2024 14:28:53 -0400 Subject: [PATCH 10/50] added config changes for hackathon --- ...ision_giant_128_window08_50ep_32nodes.yaml | 6 ++-- ...inv2_satvision_huge_128_window08_50ep.yaml | 31 +++++++++++++++++++ .../frontier_svtoa_pretraining_runner.sh | 10 +++--- ...rontier_svtoa_pretraining_runner_resume.sh | 6 ++-- 4 files changed, 42 insertions(+), 11 deletions(-) create mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml index 5113d78..024c6e8 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml @@ -25,7 +25,7 @@ TRAIN: NAME: 'multistep' GAMMA: 0.1 MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 3000 -VALIDATION_FREQ: 20 +PRINT_FREQ: 100 +SAVE_FREQ: 1000 +VALIDATION_FREQ: 200 TAG: mim_pretrain_3b_26m_32nodes_128_window8_onecycle_50ep diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml new file mode 100644 index 0000000..9c68763 --- /dev/null +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml @@ -0,0 +1,31 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-huge + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 352 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 100 +SAVE_FREQ: 1000 +VALIDATION_FREQ: 200 +TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 2413802..48861e6 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -1,15 +1,13 @@ #!/bin/bash #SBATCH -A geo160 -#SBATCH --job-name=sv-3b-100m-pt-50-epoch-test # create a short name for your job -#SBATCH --nodes=32 # node count +#SBATCH --job-name=hackathon-675m-batch-size-test # create a short name for your job +#SBATCH --nodes=1 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --gres=gpu:8 # number of allocated gpus per node #SBATCH --qos=debug -#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) +#SBATCH --time=00:30:00 # total run time limit (HH:MM:SS) #SBATCH --cpus-per-task=56 #SBATCH -C nvme -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov ##### Setup modules module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 @@ -91,7 +89,7 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -batchsize=64 +batchsize=1536 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" diff --git a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh index 5fdb0c0..6a914fe 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh @@ -1,8 +1,8 @@ #!/bin/bash #SBATCH -A geo160 +#SBATCH --qos=debug #SBATCH --job-name=satvision-giant-pretraining-15-epoch-test # create a short name for your job #SBATCH --nodes=32 # node count -#SBATCH --qos=debug #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --gres=gpu:8 # number of allocated gpus per node #SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) @@ -10,6 +10,7 @@ #SBATCH -C nvme #SBATCH --mail-type=ALL # send email when job begins #SBATCH --mail-user=caleb.s.spradlin@nasa.gov +#SBATCH --mail-user=cspradlindev@gmail.com ##### Setup modules module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 @@ -93,11 +94,12 @@ datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy batchsize=64 nprocpernode=8 +latest_ckpt=$(find mim_satvision_pretrain-giant/* -name "ckpt_epoch_*" | sort -n | tail -1) launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --resume $2 --validation-path ${validationpath}" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --resume ${latest_ckpt} --validation-path ${validationpath}" echo $cmd srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" From f433e119febd5d95727b49d31946e5fb8751c9c3 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Mon, 26 Aug 2024 14:48:30 -0400 Subject: [PATCH 11/50] made more config changes --- ..._mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename runs/configs/{frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml => frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml} (90%) diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml similarity index 90% rename from runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml rename to runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml index 024c6e8..a323994 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep_32nodes.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml @@ -28,4 +28,4 @@ TRAIN: PRINT_FREQ: 100 SAVE_FREQ: 1000 VALIDATION_FREQ: 200 -TAG: mim_pretrain_3b_26m_32nodes_128_window8_onecycle_50ep +TAG: mim_pretrain_3b_2m_128_window8_onecycle_50ep_hackathon From 7e72fd7ec43bd691ec433db4127cc47ab8cb267c Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Tue, 27 Aug 2024 13:18:00 -0400 Subject: [PATCH 12/50] changed batch size for example script --- runs/runners/frontier_svtoa_pretraining_runner.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 48861e6..2fbe96c 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -89,7 +89,7 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -batchsize=1536 +batchsize=256 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" From 5b435b6823b9c21826ecf3be6492d9ec077861fd Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Tue, 27 Aug 2024 15:31:15 -0400 Subject: [PATCH 13/50] added tensorboard notebook --- notebooks/torch_tensorboard_example.ipynb | 233 ++++++++++++++++++++++ 1 file changed, 233 insertions(+) create mode 100644 notebooks/torch_tensorboard_example.ipynb diff --git a/notebooks/torch_tensorboard_example.ipynb b/notebooks/torch_tensorboard_example.ipynb new file mode 100644 index 0000000..9fcde08 --- /dev/null +++ b/notebooks/torch_tensorboard_example.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "cf77f8bb-80ca-48c6-bd99-97a7fff86782", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-08-27 14:40:10.036795: I external/local_tsl/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-08-27 14:40:10.041036: I external/local_tsl/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2024-08-27 14:40:10.084690: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2024-08-27 14:40:10.981486: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "writer = SummaryWriter()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a592334b-02d2-4a0b-ab9c-29b071e47f07", + "metadata": {}, + "outputs": [], + "source": [ + "x = torch.arange(-5, 5, 0.1).view(-1, 1)\n", + "y = -5 * x + 0.1 * torch.randn(x.size())\n", + "\n", + "model = torch.nn.Linear(1, 1)\n", + "criterion = torch.nn.MSELoss()\n", + "optimizer = torch.optim.SGD(model.parameters(), lr = 0.1)\n", + "\n", + "def train_model(iter):\n", + " for epoch in range(iter):\n", + " y1 = model(x)\n", + " loss = criterion(y1, y)\n", + " writer.add_scalar(\"Loss/train\", loss, epoch)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " for tag, param in model.named_parameters():\n", + " writer.add_histogram(tag, param.grad.data, epoch)\n", + "\n", + "train_model(10)\n", + "writer.flush()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8071a6ae-8a96-46eb-975a-338c08cf2026", + "metadata": {}, + "outputs": [], + "source": [ + "writer.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "09919aaa-4e2e-4e38-a4ca-c72d4b7da92c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "runs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_520/3854095562.py:4: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + " from IPython.core.display import display, HTML\n" + ] + } + ], + "source": [ + "import os, pwd\n", + "from tensorboard import notebook\n", + "import getpass\n", + "from IPython.core.display import display, HTML\n", + "\n", + "def get_pid_owner(pid): # the /proc/PID is owned by process creator \n", + " proc_stat_file = os.stat(\"/proc/%d\" % pid) \n", + " # get UID via stat call \n", + " uid = proc_stat_file.st_uid \n", + " # look up the username from uid \n", + " username = pwd.getpwuid(uid)[0] \n", + " \n", + " return username\n", + "\n", + "def get_tb_port(username): \n", + " for tb_nb in notebook.manager.get_all(): \n", + " if get_pid_owner(tb_nb.pid) == username: \n", + " return tb_nb.port \n", + " \n", + "def tb_address(): \n", + " username = getpass.getuser() \n", + " tb_port = get_tb_port(username) \n", + " address = \"https://jupyter.olcf.ornl.gov\" + os.environ['JUPYTERHUB_SERVICE_PREFIX'] + 'proxy/' + str(tb_port) + \"/\" \n", + " address = address.strip()\n", + " \n", + " display(HTML('%s'%(address,address)))\n", + " \n", + "# %load_ext tensorboard \n", + "%reload_ext tensorboard\n", + "\n", + "username = os.environ['JUPYTERHUB_USER']\n", + "# log_dir = os.path.expandvars('/lustre/orion/proj-shared/geo152/hackathon_Fall24')\n", + "log_dir = os.path.expandvars('runs')\n", + "print(log_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6bdd6520-dcf4-488f-9e3d-cd3d829e2ca1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UsageError: %%capture is a cell magic, but the cell body is empty.\n" + ] + } + ], + "source": [ + "%%capture" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c431a92d-1e35-4da8-9508-8ae8fd0f881f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Reusing TensorBoard on port 33327 (pid 550), started 0:02:52 ago. (Use '!kill 550' to kill it.)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "https://jupyter.olcf.ornl.gov/user/cssprad1/proxy/33327/" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%tensorboard --logdir $log_dir --port 0\n", + "\n", + "tb_address()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c34eb7e-91ad-40c4-9895-cee83a38a4c9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "OLCF-base (ipykernel)", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From add1cb1512f695c571eef635f8d3c5429b401315 Mon Sep 17 00:00:00 2001 From: Jian Li Date: Tue, 27 Aug 2024 16:58:47 -0400 Subject: [PATCH 14/50] add tensorboard --- notebooks/tensorboard_load.ipynb | 169 ++++++++++++++++++ .../pipelines/pretraining/mim_deepspeed.py | 8 + 2 files changed, 177 insertions(+) create mode 100644 notebooks/tensorboard_load.ipynb diff --git a/notebooks/tensorboard_load.ipynb b/notebooks/tensorboard_load.ipynb new file mode 100644 index 0000000..9385023 --- /dev/null +++ b/notebooks/tensorboard_load.ipynb @@ -0,0 +1,169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "cf77f8bb-80ca-48c6-bd99-97a7fff86782", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/vit_160_exp_1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_120/2658875503.py:4: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + " from IPython.core.display import display, HTML\n" + ] + } + ], + "source": [ + "import os, pwd\n", + "from tensorboard import notebook\n", + "import getpass\n", + "from IPython.core.display import display, HTML\n", + "\n", + "def get_pid_owner(pid): # the /proc/PID is owned by process creator \n", + " proc_stat_file = os.stat(\"/proc/%d\" % pid) \n", + " # get UID via stat call \n", + " uid = proc_stat_file.st_uid \n", + " # look up the username from uid \n", + " username = pwd.getpwuid(uid)[0] \n", + " \n", + " return username\n", + "\n", + "def get_tb_port(username): \n", + " for tb_nb in notebook.manager.get_all(): \n", + " if get_pid_owner(tb_nb.pid) == username: \n", + " return tb_nb.port \n", + " \n", + "def tb_address(): \n", + " username = getpass.getuser() \n", + " tb_port = get_tb_port(username) \n", + " address = \"https://jupyter.olcf.ornl.gov\" + os.environ['JUPYTERHUB_SERVICE_PREFIX'] + 'proxy/' + str(tb_port) + \"/\" \n", + " address = address.strip()\n", + " \n", + " display(HTML('%s'%(address,address)))\n", + " \n", + "# %load_ext tensorboard \n", + "%reload_ext tensorboard\n", + "\n", + "username = os.environ['JUPYTERHUB_USER']\n", + "# log_dir = os.path.expandvars('/lustre/orion/proj-shared/geo152/hackathon_Fall24')\n", + "log_dir = os.path.expandvars('/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/vit_160_exp_1')\n", + "print(log_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6bdd6520-dcf4-488f-9e3d-cd3d829e2ca1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UsageError: %%capture is a cell magic, but the cell body is empty.\n" + ] + } + ], + "source": [ + "%%capture" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c431a92d-1e35-4da8-9508-8ae8fd0f881f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "https://jupyter.olcf.ornl.gov/user/jli30/proxy/40835/" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%tensorboard --logdir $log_dir --port 0\n", + "\n", + "tb_address()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c34eb7e-91ad-40c4-9895-cee83a38a4c9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "354c4cdb-a3c8-4524-902a-f3a9fbdea724", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "OLCF-base (ipykernel)", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index b467cda..b7b919c 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -21,6 +21,9 @@ from timm.utils import AverageMeter +from torch.utils.tensorboard import SummaryWriter + +writer = SummaryWriter('runs/vit_160_exp_1') NUM_SAMPLES: int = 1962000 @@ -140,6 +143,8 @@ def train(config, logger.info('Training time {}'.format(total_time_str)) + writer.close() + def execute_one_epoch(config, model, @@ -217,6 +222,9 @@ def execute_one_epoch(config, f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' f'mem {memory_used:.0f}MB') + writer.add_scalar('training loss ', loss_meter.val, idx) + writer.add_scalar('memory usage ', memory_used, idx) + writer.flush() if idx % config.SAVE_FREQ == 0 or idx == num_steps-1: tag = f'ckpt_epoch_{epoch}_step_{idx}' From aa846b02e50c916f117eac4ed56910defff7dc71 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 28 Aug 2024 10:25:30 -0400 Subject: [PATCH 15/50] added tensorboard updates --- pytorch_caney/config.py | 6 +++ .../pipelines/pretraining/mim_deepspeed.py | 44 +++++++++++++------ 2 files changed, 37 insertions(+), 13 deletions(-) diff --git a/pytorch_caney/config.py b/pytorch_caney/config.py index 13bf26b..919f0e0 100644 --- a/pytorch_caney/config.py +++ b/pytorch_caney/config.py @@ -119,6 +119,8 @@ # Gamma / Multi steps value, used in MultiStepLRScheduler _C.TRAIN.LR_SCHEDULER.GAMMA = 0.1 _C.TRAIN.LR_SCHEDULER.MULTISTEPS = [] +# OneCycle LR Scheduler max LR percentage +_C.TRAIN.LR_SCHEDULER.CYCLE_PERCENTAGE = 0.3 # Optimizer _C.TRAIN.OPTIMIZER = CN() @@ -133,6 +135,10 @@ # [SimMIM] Layer decay for fine-tuning _C.TRAIN.LAYER_DECAY = 1.0 +# Tensorboard settings +_C.TENSORBOARD = CN() +_C.TENSORBOARD.WRITER_DIR = '.' + # ----------------------------------------------------------------------------- # Testing settings diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index b7b919c..efb8cf1 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -23,11 +23,9 @@ from torch.utils.tensorboard import SummaryWriter -writer = SummaryWriter('runs/vit_160_exp_1') NUM_SAMPLES: int = 1962000 - def parse_args(): """ Parse command-line arguments @@ -97,7 +95,8 @@ def train(config, dataloader, model_engine, optimizer, - device): + device, + writer): """ Start pre-training a specific model and dataset. @@ -129,7 +128,7 @@ def train(config, execute_one_epoch(config, model_engine, dataloader, optimizer, epoch, resuming_step, - target_dtype, device) + target_dtype, device, writer) epoch_time = time.time() - start logger.info( @@ -143,8 +142,6 @@ def train(config, logger.info('Training time {}'.format(total_time_str)) - writer.close() - def execute_one_epoch(config, model, @@ -153,7 +150,8 @@ def execute_one_epoch(config, epoch, resuming_step, target_dtype, - device): + device, + writer): """ Execute training iterations on a single epoch. @@ -209,11 +207,20 @@ def execute_one_epoch(config, if idx % config.VALIDATION_FREQ == 0: lr = optimizer.param_groups[0]['lr'] - validate(model, validationDataset, lr, idx, epoch, target_dtype, device) + validate(model, + validationDataset, + lr, + idx, + epoch, + target_dtype, + device, + writer) if idx % config.PRINT_FREQ == 0: lr = optimizer.param_groups[0]['lr'] memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) + cached_memory = torch.cuda.memory_reserved() / (1024 * 1024) # in MB + max_memory = torch.cuda.max_memory_reserved() / (1024 * 1024) # in MB etas = batch_time.avg * (num_steps - idx) logger.info( f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' @@ -222,8 +229,10 @@ def execute_one_epoch(config, f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' f'mem {memory_used:.0f}MB') - writer.add_scalar('training loss ', loss_meter.val, idx) - writer.add_scalar('memory usage ', memory_used, idx) + writer.add_scalar('training_loss ', loss_meter.val, idx) + writer.add_scalar('memory_usage ', memory_used, idx) + writer.add_scalar('cached_memory', cached_memory, idx) + writer.add_scalar('max_memory', max_memory, idx) writer.flush() if idx % config.SAVE_FREQ == 0 or idx == num_steps-1: @@ -248,6 +257,10 @@ def main(config): logger.info('In main') + tensorboardDir = config.TENSORBOARD.WRITER_DIR + logger.info(f'Initializing tensorboard to {tensorboardDir}') + writer = SummaryWriter(tensorboardDir) + transform = SimmimTransform(config) dataset = MODIS22MDataset(config, @@ -307,7 +320,7 @@ def main(config): total_steps = num_steps * config.TRAIN.EPOCHS logger.info(f'Total steps for {config.TRAIN.EPOCHS} epochs: {total_steps}') - cycle_one_percentage = 0.3 + cycle_one_percentage = config.TRAIN.LR_SCHEDULER.CYCLE_PERCENTAGE cycle_stage_one = int(total_steps * cycle_one_percentage) cycle_stage_two = (total_steps - cycle_stage_one) - 1 @@ -420,7 +433,10 @@ def main(config): dataloader, model_engine, optimizer, - local_device) + local_device, + writer) + + writer.close() @torch.no_grad() @@ -438,7 +454,7 @@ def validation_setup(config): @torch.no_grad() -def validate(model, img_masks, lr, step, epoch, target_dtype, device): +def validate(model, img_masks, lr, step, epoch, target_dtype, device, writer): start_time = time.time() img, mask = img_masks @@ -458,6 +474,8 @@ def validate(model, img_masks, lr, step, epoch, target_dtype, device): f"lr {lr}\t" f"val_loss {loss:.4f}\t" f"time {validation_time:.4f}s") + writer.add_scalar('validation_loss', loss, step) + writer.flush() del img, mask, loss From 80ec8a24ab57974b439119f37f8431c2ddde8d20 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 28 Aug 2024 10:30:14 -0400 Subject: [PATCH 16/50] made tensorboard dir arg --- pytorch_caney/config.py | 2 ++ pytorch_caney/pipelines/pretraining/mim_deepspeed.py | 7 +++++++ 2 files changed, 9 insertions(+) diff --git a/pytorch_caney/config.py b/pytorch_caney/config.py index 919f0e0..9eae99f 100644 --- a/pytorch_caney/config.py +++ b/pytorch_caney/config.py @@ -224,6 +224,8 @@ def _check_args(name): config.EVAL_MODE = True if _check_args('enable_amp'): config.ENABLE_AMP = args.enable_amp + if _check_args('tensorboard_dir'): + config.TENSORBOARD.WRITER_DIR = args.tensorboard_dir # output folder config.OUTPUT = os.path.join(config.OUTPUT, config.MODEL.NAME, config.TAG) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index efb8cf1..2d41545 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -47,6 +47,13 @@ def parse_args(): required=True, help="paths where dataset is stored") + parser.add_argument( + '--tensorboard-dir', + type=str, + required=True, + help='Dir path for tensorboard to write to.' + ) + parser.add_argument('--validation-path', type=str, required=True, From 11342e21f6bc19f90f6af5b58e9b96e04c1df1cf Mon Sep 17 00:00:00 2001 From: Caleb Spradlin Date: Wed, 28 Aug 2024 12:51:20 -0400 Subject: [PATCH 17/50] made config changes --- pytorch_caney/pipelines/pretraining/mim_deepspeed.py | 5 +++-- ...train_swinv2_satvision_huge_128_window08_50ep.yaml | 6 +++--- runs/runners/frontier_svtoa_pretraining_runner.sh | 11 +++++++---- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 2d41545..9d4afd7 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -264,7 +264,8 @@ def main(config): logger.info('In main') - tensorboardDir = config.TENSORBOARD.WRITER_DIR + tensorboardMainDir = config.TENSORBOARD.WRITER_DIR + tensorboardDir = f'{tensorboardMainDir}/{config.TAG}' logger.info(f'Initializing tensorboard to {tensorboardDir}') writer = SummaryWriter(tensorboardDir) @@ -524,7 +525,7 @@ def setup_seeding(config): setup_seeding(config) config.defrost() - base_batch_size = 2048 + base_batch_size = 512 config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml index 9c68763..bf5bbec 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml @@ -25,7 +25,7 @@ TRAIN: NAME: 'multistep' GAMMA: 0.1 MULTISTEPS: [700,] -PRINT_FREQ: 100 +PRINT_FREQ: 10 SAVE_FREQ: 1000 -VALIDATION_FREQ: 200 -TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon +VALIDATION_FREQ: 20 +TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_cssprad1_0 diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 2fbe96c..52897c3 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -8,6 +8,8 @@ #SBATCH --time=00:30:00 # total run time limit (HH:MM:SS) #SBATCH --cpus-per-task=56 #SBATCH -C nvme +#SBATCH --mail-type=ALL # send email when job begins +#SBATCH --mail-user=caleb.s.spradlin@nasa.gov ##### Setup modules module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 @@ -28,11 +30,11 @@ mkdir -p ${MIOPEN_USER_DB_PATH} echo "copying torch_env to each node in the job" conda_env_name='rocm-torch-test-full-0.1.0' -sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz -echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz +sbcast -pf /lustre/orion/geo160/proj-shared/envs/${conda_env_name}.tar.gz.hackathon /mnt/bb/${USER}/${conda_env_name}.tar.gz +echo /lustre/orion/geo160/proj-shared/envs/${conda_env_name}.tar.gz.hackathon echo /mnt/bb/${USER}/${conda_env_name}.tar.gz ls -l /mnt/bb/${USER} -ls -l $MEMBERWORK/geo160 +ls -l /lustre/orion/geo160/proj-shared/envs if [ ! "$?" == "0" ]; then # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, @@ -89,13 +91,14 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy +tensorboard_dir=/lustre/orion/geo160/proj-shared/data/tensorboard/hackathon_2024 batchsize=256 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" echo $launcher -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --validation-path ${validationpath}" +cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --validation-path ${validationpath} --tensorboard-dir ${tensorboard_dir}" echo $cmd srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" From 2de0b35e9dfb42246bd42818e06c78b396b02e1f Mon Sep 17 00:00:00 2001 From: Jordan Caraballo-Vega Date: Wed, 28 Aug 2024 12:54:33 -0400 Subject: [PATCH 18/50] Adding optimizer module and lamb with fusedlamb with deepspeed --- pytorch_caney/optimizer/build.py | 277 ++++++++++++++++++ pytorch_caney/optimizer/lamb.py | 192 ++++++++++++ .../pipelines/pretraining/mim_deepspeed.py | 16 +- ...inv2_satvision_huge_128_window08_50ep.yaml | 2 + .../frontier_svtoa_pretraining_runner.sh | 4 +- 5 files changed, 486 insertions(+), 5 deletions(-) create mode 100644 pytorch_caney/optimizer/build.py create mode 100644 pytorch_caney/optimizer/lamb.py diff --git a/pytorch_caney/optimizer/build.py b/pytorch_caney/optimizer/build.py new file mode 100644 index 0000000..e4da05b --- /dev/null +++ b/pytorch_caney/optimizer/build.py @@ -0,0 +1,277 @@ +import torch +import deepspeed +from pytorch_caney.optimizer.lamb import Lamb + +OPTIMIZERS = { + 'adamw': torch.optim.AdamW, + 'lamb': Lamb, + 'fusedlamb': deepspeed.ops.lamb.FusedLamb +} + + +# #optimizer = torch.optim.AdamW(simmim_model.parameters(), +# # lr=config.TRAIN.BASE_LR, +# # weight_decay=config.TRAIN.WEIGHT_DECAY) +# +# # looks good +# #optimizer = Lamb(simmim_model.parameters(), +# # lr=config.TRAIN.BASE_LR, +# # weight_decay=config.TRAIN.WEIGHT_DECAY) +# +# optimizer = deepspeed.ops.lamb.FusedLamb(simmim_model.parameters(), lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) + + +def get_optimizer_from_dict(optimizer_name, config): + """Gets the proper optimizer given an optimizer name. + + Args: + optimizer_name (str): name of the optimizer + config: config object + + Raises: + KeyError: thrown if loss key is not present in dict + + Returns: + loss: pytorch optimizer + """ + + try: + + optimizer_to_use = OPTIMIZERS[optimizer_name.lower()] + + except KeyError: + + error_msg = f"{optimizer_name} is not an implemented optimizer" + + error_msg = f"{error_msg}. Available optimizer functions: {OPTIMIZERS.keys()}" + + raise KeyError(error_msg) + + return optimizer_to_use + + +def build_optimizer(config, model, is_pretrain=False, logger=None): + """ + Build optimizer, set weight decay of normalization to 0 by default. + AdamW only. + """ + logger.info('>>>>>>>>>> Build Optimizer') + + skip = {} + + skip_keywords = {} + + optimizer_name = config.TRAIN.OPTIMIZER.NAME + logger.info(f'Building {optimizer_name}') + + optimizer_to_use = get_optimizer_from_dict(optimizer_name, config) + + if hasattr(model, 'no_weight_decay'): + skip = model.no_weight_decay() + + if hasattr(model, 'no_weight_decay_keywords'): + skip_keywords = model.no_weight_decay_keywords() + + if is_pretrain: + parameters = get_pretrain_param_groups(model, skip, skip_keywords) + + else: + + depths = config.MODEL.SWIN.DEPTHS if config.MODEL.TYPE == 'swin' \ + else config.MODEL.SWINV2.DEPTHS + + num_layers = sum(depths) + + get_layer_func = partial(get_swin_layer, + num_layers=num_layers + 2, + depths=depths) + + scales = list(config.TRAIN.LAYER_DECAY ** i for i in + reversed(range(num_layers + 2))) + + parameters = get_finetune_param_groups(model, + config.TRAIN.BASE_LR, + config.TRAIN.WEIGHT_DECAY, + get_layer_func, + scales, + skip, + skip_keywords) + + optimizer = None + + optimizer = optimizer_to_use(parameters, + eps=config.TRAIN.OPTIMIZER.EPS, + betas=config.TRAIN.OPTIMIZER.BETAS, + lr=config.TRAIN.BASE_LR, + weight_decay=config.TRAIN.WEIGHT_DECAY) + logger.info("DUDE, I AM YOURS") + logger.info(optimizer) + + return optimizer + +""" +def build_optimizer(config): + Builds the optimizer function given a configuration object. + + Args: + config: config object + + Returns: + optimizer_to_use: pytorch optimizer function + + optimizer_name = config.TRAIN.OPTIMIZER.NAME + + optimizer_to_use = get_optimizer_from_dict(optimizer_name, config) + + return optimizer_to_use +""" + +def get_finetune_param_groups(model, + lr, + weight_decay, + get_layer_func, + scales, + skip_list=(), + skip_keywords=()): + + parameter_group_names = {} + + parameter_group_vars = {} + + for name, param in model.named_parameters(): + + if not param.requires_grad: + + continue + + if len(param.shape) == 1 or name.endswith(".bias") \ + or (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + + group_name = "no_decay" + + this_weight_decay = 0. + + else: + + group_name = "decay" + + this_weight_decay = weight_decay + + if get_layer_func is not None: + + layer_id = get_layer_func(name) + + group_name = "layer_%d_%s" % (layer_id, group_name) + + else: + + layer_id = None + if group_name not in parameter_group_names: + + if scales is not None: + + scale = scales[layer_id] + + else: + + scale = 1. + + parameter_group_names[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale, + } + + parameter_group_vars[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale + } + + parameter_group_vars[group_name]["params"].append(param) + + parameter_group_names[group_name]["params"].append(name) + + return list(parameter_group_vars.values()) + + +def check_keywords_in_name(name, keywords=()): + + isin = False + + for keyword in keywords: + + if keyword in name: + + isin = True + + return isin + + +def get_pretrain_param_groups(model, skip_list=(), skip_keywords=()): + + has_decay = [] + + no_decay = [] + + has_decay_name = [] + + no_decay_name = [] + + for name, param in model.named_parameters(): + + if not param.requires_grad: + + continue + + if len(param.shape) == 1 or name.endswith(".bias") or \ + (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + + no_decay.append(param) + + no_decay_name.append(name) + + else: + + has_decay.append(param) + + has_decay_name.append(name) + + return [{'params': has_decay}, + {'params': no_decay, 'weight_decay': 0.}] + + +def get_swin_layer(name, num_layers, depths): + + if name in ("mask_token"): + + return 0 + + elif name.startswith("patch_embed"): + + return 0 + + elif name.startswith("layers"): + + layer_id = int(name.split('.')[1]) + + block_id = name.split('.')[3] + + if block_id == 'reduction' or block_id == 'norm': + + return sum(depths[:layer_id + 1]) + + layer_id = sum(depths[:layer_id]) + int(block_id) + + return layer_id + 1 + + else: + + return num_layers - 1 + diff --git a/pytorch_caney/optimizer/lamb.py b/pytorch_caney/optimizer/lamb.py new file mode 100644 index 0000000..12c7c49 --- /dev/null +++ b/pytorch_caney/optimizer/lamb.py @@ -0,0 +1,192 @@ +""" PyTorch Lamb optimizer w/ behaviour similar to NVIDIA FusedLamb + +This optimizer code was adapted from the following (starting with latest) +* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py +* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py +* https://github.com/cybertronai/pytorch-lamb + +Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is +similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX. + +In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU. + +Original copyrights for above sources are below. + +Modifications Copyright 2021 Ross Wightman +""" +# Copyright (c) 2021, Habana Labs Ltd. All rights reserved. + +# Copyright (c) 2019-2020, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +# MIT License +# +# Copyright (c) 2019 cybertronai +# +# 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 math + +import torch +from torch.optim import Optimizer + + +class Lamb(Optimizer): + """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB + reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py + + LAMB was proposed in `Large Batch Optimization for Deep Learning: Training BERT in 76 minutes`_. + + Arguments: + params (iterable): iterable of parameters to optimize or dicts defining parameter groups. + lr (float, optional): learning rate. (default: 1e-3) + betas (Tuple[float, float], optional): coefficients used for computing + running averages of gradient and its norm. (default: (0.9, 0.999)) + eps (float, optional): term added to the denominator to improve + numerical stability. (default: 1e-8) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + grad_averaging (bool, optional): whether apply (1-beta2) to grad when + calculating running averages of gradient. (default: True) + max_grad_norm (float, optional): value used to clip global grad norm (default: 1.0) + trust_clip (bool): enable LAMBC trust ratio clipping (default: False) + always_adapt (boolean, optional): Apply adaptive learning rate to 0.0 + weight decay parameter (default: False) + + .. _Large Batch Optimization for Deep Learning - Training BERT in 76 minutes: + https://arxiv.org/abs/1904.00962 + .. _On the Convergence of Adam and Beyond: + https://openreview.net/forum?id=ryQu7f-RZ + """ + + def __init__( + self, params, lr=1e-3, bias_correction=True, betas=(0.9, 0.999), eps=1e-6, + weight_decay=0.01, grad_averaging=True, max_grad_norm=1.0, trust_clip=False, always_adapt=False): + defaults = dict( + lr=lr, bias_correction=bias_correction, betas=betas, eps=eps, weight_decay=weight_decay, + grad_averaging=grad_averaging, max_grad_norm=max_grad_norm, + trust_clip=trust_clip, always_adapt=always_adapt) + super().__init__(params, defaults) + + @torch.no_grad() + def step(self, closure=None): + """Performs a single optimization step. + Arguments: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + device = self.param_groups[0]['params'][0].device + one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly + global_grad_norm = torch.zeros(1, device=device) + for group in self.param_groups: + for p in group['params']: + if p.grad is None: + continue + grad = p.grad + if grad.is_sparse: + raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.') + global_grad_norm.add_(grad.pow(2).sum()) + + global_grad_norm = torch.sqrt(global_grad_norm) + # FIXME it'd be nice to remove explicit tensor conversion of scalars when torch.where promotes + # scalar types properly https://github.com/pytorch/pytorch/issues/9190 + max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], device=device) + clip_global_grad_norm = torch.where( + global_grad_norm > max_grad_norm, + global_grad_norm / max_grad_norm, + one_tensor) + + for group in self.param_groups: + bias_correction = 1 if group['bias_correction'] else 0 + beta1, beta2 = group['betas'] + grad_averaging = 1 if group['grad_averaging'] else 0 + beta3 = 1 - beta1 if grad_averaging else 1.0 + + # assume same step across group now to simplify things + # per parameter step can be easily support by making it tensor, or pass list into kernel + if 'step' in group: + group['step'] += 1 + else: + group['step'] = 1 + + if bias_correction: + bias_correction1 = 1 - beta1 ** group['step'] + bias_correction2 = 1 - beta2 ** group['step'] + else: + bias_correction1, bias_correction2 = 1.0, 1.0 + + for p in group['params']: + if p.grad is None: + continue + grad = p.grad.div_(clip_global_grad_norm) + state = self.state[p] + + # State initialization + if len(state) == 0: + # Exponential moving average of gradient valuesa + state['exp_avg'] = torch.zeros_like(p) + # Exponential moving average of squared gradient values + state['exp_avg_sq'] = torch.zeros_like(p) + + exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq'] + + # Decay the first and second moment running average coefficient + exp_avg.mul_(beta1).add_(grad, alpha=beta3) # m_t + exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) # v_t + + denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps']) + update = (exp_avg / bias_correction1).div_(denom) + + weight_decay = group['weight_decay'] + if weight_decay != 0: + update.add_(p, alpha=weight_decay) + + if weight_decay != 0 or group['always_adapt']: + # Layer-wise LR adaptation. By default, skip adaptation on parameters that are + # excluded from weight decay, unless always_adapt == True, then always enabled. + w_norm = p.norm(2.0) + g_norm = update.norm(2.0) + # FIXME nested where required since logical and/or not working in PT XLA + trust_ratio = torch.where( + w_norm > 0, + torch.where(g_norm > 0, w_norm / g_norm, one_tensor), + one_tensor, + ) + if group['trust_clip']: + # LAMBC trust clipping, upper bound fixed at one + trust_ratio = torch.minimum(trust_ratio, one_tensor) + update.mul_(trust_ratio) + + p.add_(update, alpha=-group['lr']) + + return loss diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index b467cda..fc501b9 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -3,6 +3,7 @@ from pytorch_caney.models.mim.mim import build_mim_model from pytorch_caney.ptc_logging import create_logger from pytorch_caney.config import get_config +from pytorch_caney.optimizer.build import build_optimizer import deepspeed from deepspeed.accelerator import get_accelerator @@ -315,6 +316,7 @@ def main(config): "steps_per_print": config.PRINT_FREQ, "memory_breakdown": False, + "zero_allow_untested_optimizer": True, "zero_optimization": { "stage": 2, @@ -377,9 +379,17 @@ def main(config): logger.info('Initializing deepspeed') - optimizer = torch.optim.AdamW(simmim_model.parameters(), - lr=config.TRAIN.BASE_LR, - weight_decay=config.TRAIN.WEIGHT_DECAY) + # optimizer = torch.optim.AdamW(simmim_model.parameters(), + # lr=config.TRAIN.BASE_LR, + # weight_decay=config.TRAIN.WEIGHT_DECAY) + # optimizer = Lamb(simmim_model.parameters(), + # lr=config.TRAIN.BASE_LR, + # weight_decay=config.TRAIN.WEIGHT_DECAY) + # optimizer = deepspeed.ops.lamb.FusedLamb( + # simmim_model.parameters(), lr=config.TRAIN.BASE_LR, + # weight_decay=config.TRAIN.WEIGHT_DECAY) + optimizer = build_optimizer( + config, simmim_model, is_pretrain=True, logger=logger) model_engine, optimizer, _, _ = deepspeed.initialize( model=simmim_model, diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml index 9c68763..f6d471c 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml @@ -21,6 +21,8 @@ TRAIN: MIN_LR: 2e-4 WARMUP_LR: 1e-4 WEIGHT_DECAY: 0.05 + OPTIMIZER: + NAME: lamb LR_SCHEDULER: NAME: 'multistep' GAMMA: 0.1 diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 48861e6..76c3021 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -4,7 +4,7 @@ #SBATCH --nodes=1 # node count #SBATCH --ntasks-per-node=1 # total number of tasks per node #SBATCH --gres=gpu:8 # number of allocated gpus per node -#SBATCH --qos=debug +#SBATCH -q debug #SBATCH --time=00:30:00 # total run time limit (HH:MM:SS) #SBATCH --cpus-per-task=56 #SBATCH -C nvme @@ -89,7 +89,7 @@ echo $MASTER_PORT nnodes=$SLURM_JOB_NUM_NODES datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -batchsize=1536 +batchsize=256 nprocpernode=8 launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" From d01a940b6bc7c1a02402e25dd4c7411558d7a3fc Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 28 Aug 2024 13:15:06 -0400 Subject: [PATCH 19/50] added lamb gradient logging --- pytorch_caney/optimizer/lamb.py | 22 +++++++++++++ .../pipelines/pretraining/mim_deepspeed.py | 6 ++++ ...atvision_huge_128_window08_50ep_adamw.yaml | 33 +++++++++++++++++++ ...atvision_huge_128_window08_50ep_lamb.yaml} | 4 +-- 4 files changed, 63 insertions(+), 2 deletions(-) create mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml rename runs/configs/{frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml => frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml} (86%) diff --git a/pytorch_caney/optimizer/lamb.py b/pytorch_caney/optimizer/lamb.py index 12c7c49..de6aebb 100644 --- a/pytorch_caney/optimizer/lamb.py +++ b/pytorch_caney/optimizer/lamb.py @@ -51,11 +51,28 @@ # 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 collections import math import torch from torch.optim import Optimizer +from torch.utils.tensorboard import SummaryWriter + + +def log_lamb_rs(optimizer: Optimizer, event_writer: SummaryWriter, token_count: int): + """Log a histogram of trust ratio scalars in across layers.""" + results = collections.defaultdict(list) + for group in optimizer.param_groups: + for p in group['params']: + state = optimizer.state[p] + for i in ('weight_norm', 'adam_norm', 'trust_ratio'): + if i in state: + results[i].append(state[i]) + + for k, v in results.items(): + event_writer.add_histogram(f'lamb/{k}', torch.tensor(v), token_count) + class Lamb(Optimizer): """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB @@ -185,6 +202,11 @@ def step(self, closure=None): if group['trust_clip']: # LAMBC trust clipping, upper bound fixed at one trust_ratio = torch.minimum(trust_ratio, one_tensor) + + state['weight_norm'] = w_norm + state['adam_norm'] = g_norm + state['trust_ratio'] = trust_ratio + update.mul_(trust_ratio) p.add_(update, alpha=-group['lr']) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 580b1c3..0653db0 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -174,6 +174,10 @@ def execute_one_epoch(config, """ validationDataset = validation_setup(config) + # Setup lamb gradient logging + if config.OPTIMIZER.NAME == 'lamb': + from pytorch_caney.optimizer.lamb import log_lamb_rs + num_steps = max(1, NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) @@ -241,6 +245,8 @@ def execute_one_epoch(config, writer.add_scalar('memory_usage ', memory_used, idx) writer.add_scalar('cached_memory', cached_memory, idx) writer.add_scalar('max_memory', max_memory, idx) + if config.OPTIMIZER.NAME == 'lamb': + log_lamb_rs(optimizer, writer, idx) writer.flush() if idx % config.SAVE_FREQ == 0 or idx == num_steps-1: diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml new file mode 100644 index 0000000..131dc94 --- /dev/null +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml @@ -0,0 +1,33 @@ +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-huge + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 352 + DEPTHS: [ 2, 2, 18, 2 ] + NUM_HEADS: [ 4, 8, 16, 32] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 1 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + OPTIMIZER: + NAME: adamw + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +PRINT_FREQ: 10 +SAVE_FREQ: 1000 +VALIDATION_FREQ: 20 +TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_adamw diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml similarity index 86% rename from runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml rename to runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml index 7d93e5e..a2d18f0 100644 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep.yaml +++ b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml @@ -29,5 +29,5 @@ TRAIN: MULTISTEPS: [700,] PRINT_FREQ: 10 SAVE_FREQ: 1000 -VALIDATION_FREQ: 20 -TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_cssprad1_0 +VALIDATION_FREQ: 20 +TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_lamb From 2211008cdece91d5f4665e1f0188ebdb6a5b1a09 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 28 Aug 2024 13:21:48 -0400 Subject: [PATCH 20/50] added lamb gradient logging --- pytorch_caney/pipelines/pretraining/mim_deepspeed.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py index 0653db0..4995091 100644 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py @@ -175,7 +175,7 @@ def execute_one_epoch(config, validationDataset = validation_setup(config) # Setup lamb gradient logging - if config.OPTIMIZER.NAME == 'lamb': + if config.TRAIN.OPTIMIZER.NAME == 'lamb': from pytorch_caney.optimizer.lamb import log_lamb_rs num_steps = max(1, @@ -245,7 +245,7 @@ def execute_one_epoch(config, writer.add_scalar('memory_usage ', memory_used, idx) writer.add_scalar('cached_memory', cached_memory, idx) writer.add_scalar('max_memory', max_memory, idx) - if config.OPTIMIZER.NAME == 'lamb': + if config.TRAIN.OPTIMIZER.NAME == 'lamb': log_lamb_rs(optimizer, writer, idx) writer.flush() From f0597d74e651f54f90b3a5af6dde8d499b8918e8 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 28 Aug 2024 13:29:25 -0400 Subject: [PATCH 21/50] rmd address for slurm --- runs/runners/frontier_svtoa_pretraining_runner.sh | 2 -- 1 file changed, 2 deletions(-) diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh index 05cebe7..4828798 100644 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ b/runs/runners/frontier_svtoa_pretraining_runner.sh @@ -8,8 +8,6 @@ #SBATCH --time=00:30:00 # total run time limit (HH:MM:SS) #SBATCH --cpus-per-task=56 #SBATCH -C nvme -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov ##### Setup modules module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 From 0b9ef0fd7c3142f92979594f3584858ead452d23 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 29 Aug 2024 10:34:30 -0400 Subject: [PATCH 22/50] Update Dockerfile --- requirements/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/Dockerfile b/requirements/Dockerfile index 46f2e76..5f26ebb 100644 --- a/requirements/Dockerfile +++ b/requirements/Dockerfile @@ -1,5 +1,5 @@ # Arguments to pass to the image -ARG VERSION_DATE=23.01 +ARG VERSION_DATE=24.01 ARG FROM_IMAGE=nvcr.io/nvidia/pytorch # Import RAPIDS container as the BASE Image (cuda base image) From 34262972d297ca38c8010678e9e04332dcb55105 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 29 Aug 2024 10:34:41 -0400 Subject: [PATCH 23/50] Update Dockerfile.dev --- requirements/Dockerfile.dev | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/Dockerfile.dev b/requirements/Dockerfile.dev index b7fc5d6..8581a70 100644 --- a/requirements/Dockerfile.dev +++ b/requirements/Dockerfile.dev @@ -1,5 +1,5 @@ # Arguments to pass to the image -ARG VERSION_DATE=23.01 +ARG VERSION_DATE=24.01 ARG FROM_IMAGE=nvcr.io/nvidia/pytorch # Import RAPIDS container as the BASE Image (cuda base image) From 91bb882690662b71e75d4a21d2208cf8ba5c44a1 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 29 Aug 2024 10:45:32 -0400 Subject: [PATCH 24/50] Update dockerhub-dev.yml --- .github/workflows/dockerhub-dev.yml | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/.github/workflows/dockerhub-dev.yml b/.github/workflows/dockerhub-dev.yml index ffd2cd3..31a30b6 100644 --- a/.github/workflows/dockerhub-dev.yml +++ b/.github/workflows/dockerhub-dev.yml @@ -28,10 +28,24 @@ jobs: - name: Lower github-runner storage run: | - sudo rm -rf /usr/share/dotnet - sudo rm -rf /opt/ghc - sudo rm -rf "/usr/local/share/boost" - sudo rm -rf "$AGENT_TOOLSDIRECTORY" + # Remove software and language runtimes we're not using + sudo rm -rf \ + "$AGENT_TOOLSDIRECTORY" \ + /opt/google/chrome \ + /opt/microsoft/msedge \ + /opt/microsoft/powershell \ + /opt/pipx \ + /usr/lib/mono \ + /usr/local/julia* \ + /usr/local/lib/android \ + /usr/local/lib/node_modules \ + /usr/local/share/chromium \ + /usr/local/share/powershell \ + /usr/share/dotnet \ + /usr/share/swift + df -h / + + - name: Build and push From 2dbbc9bb4d8c343f11f3d4fab7ed56ea50f35450 Mon Sep 17 00:00:00 2001 From: Jian Li Date: Fri, 6 Sep 2024 16:45:20 -0400 Subject: [PATCH 25/50] add DeepSpeed Flops Profiler to tensorboard --- notebooks/tensorboard_load.ipynb | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/notebooks/tensorboard_load.ipynb b/notebooks/tensorboard_load.ipynb index 9385023..c95e196 100644 --- a/notebooks/tensorboard_load.ipynb +++ b/notebooks/tensorboard_load.ipynb @@ -10,14 +10,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/vit_160_exp_1\n" + "/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/mim_pretrain_675m_2m_128_window8_onecycle_hackathon_lamb_debug\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_120/2658875503.py:4: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + "/tmp/ipykernel_285/3984413349.py:4: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", " from IPython.core.display import display, HTML\n" ] } @@ -55,10 +55,21 @@ "\n", "username = os.environ['JUPYTERHUB_USER']\n", "# log_dir = os.path.expandvars('/lustre/orion/proj-shared/geo152/hackathon_Fall24')\n", - "log_dir = os.path.expandvars('/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/vit_160_exp_1')\n", + "log_dir = os.path.expandvars('/lustre/orion/geo160/proj-shared/hackathon/jli30/runs/mim_pretrain_675m_2m_128_window8_onecycle_hackathon_lamb_debug')\n", + "#log_dir = os.path.expandvars('/lustre/orion/geo160/proj-shared/hackathon/jli30/log/svtoa')\n", "print(log_dir)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "58268832-4d72-48df-a2d9-e7af69958dca", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install torch_tb_profiler" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -87,13 +98,13 @@ "data": { "text/html": [ "\n", - " \n", " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "https://jupyter.olcf.ornl.gov/user/jli30/proxy/34273/" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%tensorboard --logdir $log_dir --port 0\n", - "\n", - "tb_address()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ee302434-c511-4391-b6ca-f710701c5c98", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "354c4cdb-a3c8-4524-902a-f3a9fbdea724", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "OLCF-base (ipykernel)", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/torch_tensorboard_example.ipynb b/notebooks/torch_tensorboard_example.ipynb deleted file mode 100644 index 9fcde08..0000000 --- a/notebooks/torch_tensorboard_example.ipynb +++ /dev/null @@ -1,233 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "cf77f8bb-80ca-48c6-bd99-97a7fff86782", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-08-27 14:40:10.036795: I external/local_tsl/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n", - "2024-08-27 14:40:10.041036: I external/local_tsl/tsl/cuda/cudart_stub.cc:32] Could not find cuda drivers on your machine, GPU will not be used.\n", - "2024-08-27 14:40:10.084690: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-08-27 14:40:10.981486: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" - ] - } - ], - "source": [ - "import torch\n", - "from torch.utils.tensorboard import SummaryWriter\n", - "writer = SummaryWriter()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "a592334b-02d2-4a0b-ab9c-29b071e47f07", - "metadata": {}, - "outputs": [], - "source": [ - "x = torch.arange(-5, 5, 0.1).view(-1, 1)\n", - "y = -5 * x + 0.1 * torch.randn(x.size())\n", - "\n", - "model = torch.nn.Linear(1, 1)\n", - "criterion = torch.nn.MSELoss()\n", - "optimizer = torch.optim.SGD(model.parameters(), lr = 0.1)\n", - "\n", - "def train_model(iter):\n", - " for epoch in range(iter):\n", - " y1 = model(x)\n", - " loss = criterion(y1, y)\n", - " writer.add_scalar(\"Loss/train\", loss, epoch)\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - " for tag, param in model.named_parameters():\n", - " writer.add_histogram(tag, param.grad.data, epoch)\n", - "\n", - "train_model(10)\n", - "writer.flush()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8071a6ae-8a96-46eb-975a-338c08cf2026", - "metadata": {}, - "outputs": [], - "source": [ - "writer.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "09919aaa-4e2e-4e38-a4ca-c72d4b7da92c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "runs\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_520/3854095562.py:4: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", - " from IPython.core.display import display, HTML\n" - ] - } - ], - "source": [ - "import os, pwd\n", - "from tensorboard import notebook\n", - "import getpass\n", - "from IPython.core.display import display, HTML\n", - "\n", - "def get_pid_owner(pid): # the /proc/PID is owned by process creator \n", - " proc_stat_file = os.stat(\"/proc/%d\" % pid) \n", - " # get UID via stat call \n", - " uid = proc_stat_file.st_uid \n", - " # look up the username from uid \n", - " username = pwd.getpwuid(uid)[0] \n", - " \n", - " return username\n", - "\n", - "def get_tb_port(username): \n", - " for tb_nb in notebook.manager.get_all(): \n", - " if get_pid_owner(tb_nb.pid) == username: \n", - " return tb_nb.port \n", - " \n", - "def tb_address(): \n", - " username = getpass.getuser() \n", - " tb_port = get_tb_port(username) \n", - " address = \"https://jupyter.olcf.ornl.gov\" + os.environ['JUPYTERHUB_SERVICE_PREFIX'] + 'proxy/' + str(tb_port) + \"/\" \n", - " address = address.strip()\n", - " \n", - " display(HTML('%s'%(address,address)))\n", - " \n", - "# %load_ext tensorboard \n", - "%reload_ext tensorboard\n", - "\n", - "username = os.environ['JUPYTERHUB_USER']\n", - "# log_dir = os.path.expandvars('/lustre/orion/proj-shared/geo152/hackathon_Fall24')\n", - "log_dir = os.path.expandvars('runs')\n", - "print(log_dir)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "6bdd6520-dcf4-488f-9e3d-cd3d829e2ca1", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UsageError: %%capture is a cell magic, but the cell body is empty.\n" - ] - } - ], - "source": [ - "%%capture" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c431a92d-1e35-4da8-9508-8ae8fd0f881f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Reusing TensorBoard on port 33327 (pid 550), started 0:02:52 ago. (Use '!kill 550' to kill it.)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "https://jupyter.olcf.ornl.gov/user/cssprad1/proxy/33327/" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%tensorboard --logdir $log_dir --port 0\n", - "\n", - "tb_address()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c34eb7e-91ad-40c4-9895-cee83a38a4c9", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "OLCF-base (ipykernel)", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/pytorch_caney/__init__.py b/pytorch_caney/__init__.py old mode 100755 new mode 100644 diff --git a/pytorch_caney/config.py b/pytorch_caney/config.py deleted file mode 100644 index 9eae99f..0000000 --- a/pytorch_caney/config.py +++ /dev/null @@ -1,243 +0,0 @@ -import os -import yaml -from yacs.config import CfgNode as CN - -_C = CN() - -# Base config files -_C.BASE = [''] - -# ----------------------------------------------------------------------------- -# Data settings -# ----------------------------------------------------------------------------- -_C.DATA = CN() -# Batch size for a single GPU, could be overwritten by command line argument -_C.DATA.BATCH_SIZE = 128 -# Path(s) to dataset, could be overwritten by command line argument -_C.DATA.DATA_PATHS = [''] -# Path to validation numpy dataset -_C.DATA.VALIDATION_PATH = '' -# Dataset name -_C.DATA.DATASET = 'MODIS' -# Input image size -_C.DATA.IMG_SIZE = 224 -# Interpolation to resize image (random, bilinear, bicubic) -_C.DATA.INTERPOLATION = 'bicubic' -# Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU. -_C.DATA.PIN_MEMORY = True -# Number of data loading threads -_C.DATA.NUM_WORKERS = 8 -# [SimMIM] Mask patch size for MaskGenerator -_C.DATA.MASK_PATCH_SIZE = 32 -# [SimMIM] Mask ratio for MaskGenerator -_C.DATA.MASK_RATIO = 0.6 - -# ----------------------------------------------------------------------------- -# Model settings -# ----------------------------------------------------------------------------- -_C.MODEL = CN() -# Model type -_C.MODEL.TYPE = 'swinv2' -# Decoder type -_C.MODEL.DECODER = None -# Model name -_C.MODEL.NAME = 'swinv2_base_patch4_window7_224' -# Pretrained weight from checkpoint, could be from previous pre-training -# could be overwritten by command line argument -_C.MODEL.PRETRAINED = '' -# Checkpoint to resume, could be overwritten by command line argument -_C.MODEL.RESUME = '' -# Number of classes, overwritten in data preparation -_C.MODEL.NUM_CLASSES = 17 -# Dropout rate -_C.MODEL.DROP_RATE = 0.0 -# Drop path rate -_C.MODEL.DROP_PATH_RATE = 0.1 - -# Swin Transformer V2 parameters -_C.MODEL.SWINV2 = CN() -_C.MODEL.SWINV2.PATCH_SIZE = 4 -_C.MODEL.SWINV2.IN_CHANS = 3 -_C.MODEL.SWINV2.EMBED_DIM = 96 -_C.MODEL.SWINV2.DEPTHS = [2, 2, 6, 2] -_C.MODEL.SWINV2.NUM_HEADS = [3, 6, 12, 24] -_C.MODEL.SWINV2.WINDOW_SIZE = 7 -_C.MODEL.SWINV2.MLP_RATIO = 4. -_C.MODEL.SWINV2.QKV_BIAS = True -_C.MODEL.SWINV2.APE = False -_C.MODEL.SWINV2.PATCH_NORM = True -_C.MODEL.SWINV2.PRETRAINED_WINDOW_SIZES = [0, 0, 0, 0] -_C.MODEL.SWINV2.NORM_PERIOD = 0 -_C.MODEL.SWINV2.NORM_STAGE = False - -# ----------------------------------------------------------------------------- -# Training settings -# ----------------------------------------------------------------------------- -_C.LOSS = CN() -_C.LOSS.NAME = 'tversky' -_C.LOSS.MODE = 'multiclass' -_C.LOSS.CLASSES = None -_C.LOSS.LOG = False -_C.LOSS.LOGITS = True -_C.LOSS.SMOOTH = 0.0 -_C.LOSS.IGNORE_INDEX = None -_C.LOSS.EPS = 1e-7 -_C.LOSS.ALPHA = 0.5 -_C.LOSS.BETA = 0.5 -_C.LOSS.GAMMA = 1.0 - -# ----------------------------------------------------------------------------- -# Training settings -# ----------------------------------------------------------------------------- -_C.TRAIN = CN() -_C.TRAIN.START_EPOCH = 0 -_C.TRAIN.EPOCHS = 300 -_C.TRAIN.WARMUP_EPOCHS = 20 -_C.TRAIN.WARMUP_STEPS = 200 -_C.TRAIN.WEIGHT_DECAY = 0.05 -_C.TRAIN.BASE_LR = 5e-4 -_C.TRAIN.WARMUP_LR = 5e-7 -_C.TRAIN.MIN_LR = 5e-6 -# Clip gradient norm -_C.TRAIN.CLIP_GRAD = 5.0 -# Auto resume from latest checkpoint -_C.TRAIN.AUTO_RESUME = True -# Gradient accumulation steps -# could be overwritten by command line argument -_C.TRAIN.ACCUMULATION_STEPS = 0 -# Whether to use gradient checkpointing to save memory -# could be overwritten by command line argument -_C.TRAIN.USE_CHECKPOINT = False - -# LR scheduler -_C.TRAIN.LR_SCHEDULER = CN() -_C.TRAIN.LR_SCHEDULER.NAME = 'cosine' -# Epoch interval to decay LR, used in StepLRScheduler -_C.TRAIN.LR_SCHEDULER.DECAY_EPOCHS = 30 -# LR decay rate, used in StepLRScheduler -_C.TRAIN.LR_SCHEDULER.DECAY_RATE = 0.1 -# Gamma / Multi steps value, used in MultiStepLRScheduler -_C.TRAIN.LR_SCHEDULER.GAMMA = 0.1 -_C.TRAIN.LR_SCHEDULER.MULTISTEPS = [] -# OneCycle LR Scheduler max LR percentage -_C.TRAIN.LR_SCHEDULER.CYCLE_PERCENTAGE = 0.3 - -# Optimizer -_C.TRAIN.OPTIMIZER = CN() -_C.TRAIN.OPTIMIZER.NAME = 'adamw' -# Optimizer Epsilon -_C.TRAIN.OPTIMIZER.EPS = 1e-8 -# Optimizer Betas -_C.TRAIN.OPTIMIZER.BETAS = (0.9, 0.999) -# SGD momentum -_C.TRAIN.OPTIMIZER.MOMENTUM = 0.9 - -# [SimMIM] Layer decay for fine-tuning -_C.TRAIN.LAYER_DECAY = 1.0 - -# Tensorboard settings -_C.TENSORBOARD = CN() -_C.TENSORBOARD.WRITER_DIR = '.' - - -# ----------------------------------------------------------------------------- -# Testing settings -# ----------------------------------------------------------------------------- -_C.TEST = CN() -# Whether to use center crop when testing -_C.TEST.CROP = True - -# ----------------------------------------------------------------------------- -# Misc -# ----------------------------------------------------------------------------- -# Whether to enable pytorch amp, overwritten by command line argument -_C.ENABLE_AMP = False -# Enable Pytorch automatic mixed precision (amp). -_C.AMP_ENABLE = True -# Path to output folder, overwritten by command line argument -_C.OUTPUT = '' -# Tag of experiment, overwritten by command line argument -_C.TAG = 'pt-caney-default-tag' -# Frequency to save checkpoint -_C.SAVE_FREQ = 1 -# Frequency to logging info -_C.PRINT_FREQ = 10 -# Frequency for running validation step -_C.VALIDATION_FREQ = 1 -# Fixed random seed -_C.SEED = 42 -# Perform evaluation only, overwritten by command line argument -_C.EVAL_MODE = False - - -def _update_config_from_file(config, cfg_file): - config.defrost() - with open(cfg_file, 'r') as f: - yaml_cfg = yaml.load(f, Loader=yaml.FullLoader) - - for cfg in yaml_cfg.setdefault('BASE', ['']): - if cfg: - _update_config_from_file( - config, os.path.join(os.path.dirname(cfg_file), cfg) - ) - print('=> merge config from {}'.format(cfg_file)) - config.merge_from_file(cfg_file) - config.freeze() - - -def update_config(config, args): - _update_config_from_file(config, args.cfg) - - config.defrost() - - def _check_args(name): - if hasattr(args, name) and eval(f'args.{name}'): - return True - return False - - # merge from specific arguments - if _check_args('batch_size'): - config.DATA.BATCH_SIZE = args.batch_size - if _check_args('data_paths'): - config.DATA.DATA_PATHS = args.data_paths - if _check_args('validation_path'): - config.DATA.VALIDATION_PATH = args.validation_path - if _check_args('dataset'): - config.DATA.DATASET = args.dataset - if _check_args('resume'): - config.MODEL.RESUME = args.resume - if _check_args('pretrained'): - config.MODEL.PRETRAINED = args.pretrained - if _check_args('resume'): - config.MODEL.RESUME = args.resume - if _check_args('accumulation_steps'): - config.TRAIN.ACCUMULATION_STEPS = args.accumulation_steps - if _check_args('use_checkpoint'): - config.TRAIN.USE_CHECKPOINT = True - if _check_args('disable_amp'): - config.AMP_ENABLE = False - if _check_args('output'): - config.OUTPUT = args.output - if _check_args('tag'): - config.TAG = args.tag - if _check_args('eval'): - config.EVAL_MODE = True - if _check_args('enable_amp'): - config.ENABLE_AMP = args.enable_amp - if _check_args('tensorboard_dir'): - config.TENSORBOARD.WRITER_DIR = args.tensorboard_dir - - # output folder - config.OUTPUT = os.path.join(config.OUTPUT, config.MODEL.NAME, config.TAG) - - config.freeze() - - -def get_config(args): - """Get a yacs CfgNode object with default values.""" - # Return a clone so that the defaults will not be altered - # This is for the "local variable" use pattern - config = _C.clone() - update_config(config, args) - - return config diff --git a/pytorch_caney/console/cli.py b/pytorch_caney/console/cli.py deleted file mode 100755 index e02d571..0000000 --- a/pytorch_caney/console/cli.py +++ /dev/null @@ -1,62 +0,0 @@ -from pytorch_lightning.utilities.cli import LightningCLI - -import torch - - -class TerraGPULightningCLI(LightningCLI): - - def add_arguments_to_parser(self, parser): - - # Trainer - performance - parser.set_defaults({"trainer.accelerator": "auto"}) - parser.set_defaults({"trainer.devices": "auto"}) - parser.set_defaults({"trainer.auto_select_gpus": True}) - parser.set_defaults({"trainer.precision": 32}) - - # Trainer - training - parser.set_defaults({"trainer.max_epochs": 500}) - parser.set_defaults({"trainer.min_epochs": 1}) - parser.set_defaults({"trainer.detect_anomaly": True}) - parser.set_defaults({"trainer.logger": True}) - parser.set_defaults({"trainer.default_root_dir": "output_model"}) - - # Trainer - optimizer - TODO - _ = { - "class_path": torch.optim.Adam, - "init_args": { - "lr": 0.01 - } - } - - # Trainer - callbacks - default_callbacks = [ - {"class_path": "pytorch_lightning.callbacks.DeviceStatsMonitor"}, - { - "class_path": "pytorch_lightning.callbacks.EarlyStopping", - "init_args": { - "monitor": "val_loss", - "patience": 5, - "mode": "min" - } - }, - # { - # "class_path": "pytorch_lightning.callbacks.ModelCheckpoint", - # "init_args": { - # "dirpath": "output_model", - # "monitor": "val_loss", - # "auto_insert_metric_name": True - # } - # }, - ] - parser.set_defaults({"trainer.callbacks": default_callbacks}) - - # { - # "class_path": "pytorch_lightning.callbacks.ModelCheckpoint", - # "init_args": { - # "dirpath": "output_model", - # "monitor": "val_loss", - # "auto_insert_metric_name": True - # } - # }, - # ] - # parser.set_defaults({"trainer.callbacks": default_callbacks}) diff --git a/pytorch_caney/console/dl_pipeline.py b/pytorch_caney/console/dl_pipeline.py deleted file mode 100755 index 4840a95..0000000 --- a/pytorch_caney/console/dl_pipeline.py +++ /dev/null @@ -1,62 +0,0 @@ -# -*- coding: utf-8 -*- -# RF pipeline: preprocess, train, and predict. - -import sys -import logging - -# from terragpu import unet_model -# from terragpu.decorators import DuplicateFilter -# from terragpu.ai.deep_learning.datamodules.segmentation_datamodule \ -# import SegmentationDataModule - -from pytorch_lightning import seed_everything # , trainer -# from pytorch_lightning import LightningModule, LightningDataModule -from terragpu.ai.deep_learning.console.cli import TerraGPULightningCLI - - -# ----------------------------------------------------------------------------- -# main -# -# python rf_pipeline.py options here -# ----------------------------------------------------------------------------- -def main(): - - # ------------------------------------------------------------------------- - # Set logging - # ------------------------------------------------------------------------- - logger = logging.getLogger() - logger.setLevel(logging.INFO) - ch = logging.StreamHandler(sys.stdout) - ch.setLevel(logging.INFO) - - # Set formatter and handlers - formatter = logging.Formatter( - "%(asctime)s; %(levelname)s; %(message)s", "%Y-%m-%d %H:%M:%S") - ch.setFormatter(formatter) - logger.addHandler(ch) - - # ------------------------------------------------------------------------- - # Execute pipeline step - # ------------------------------------------------------------------------- - # Seed every library - seed_everything(1234, workers=True) - _ = TerraGPULightningCLI(save_config_callback=None) - # unet_model.UNetSegmentation, SegmentationDataModule) - - # train - # trainer = pl.Trainer() - # trainer.fit(model, datamodule=dm) - # validate - # trainer.validate(datamodule=dm) - # test - # trainer.test(datamodule=dm) - # predict - # predictions = trainer.predict(datamodule=dm) - return - - -# ----------------------------------------------------------------------------- -# Invoke the main -# ----------------------------------------------------------------------------- -if __name__ == "__main__": - sys.exit(main()) diff --git a/pytorch_caney/data/benchmark.py b/pytorch_caney/data/benchmark.py deleted file mode 100644 index 8966ea8..0000000 --- a/pytorch_caney/data/benchmark.py +++ /dev/null @@ -1,142 +0,0 @@ -from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset -from pytorch_caney.data.transforms import SimmimTransform -from pytorch_caney.config import get_config - -import argparse -import os -import sys -import time - -import torch -from torch.utils.data import DataLoader - - -NUM_SAMPLES: int = 2000180 - - -def parse_args(): - """ - Parse command-line arguments - """ - parser = argparse.ArgumentParser( - 'pytorch-caney implementation of MiM pre-training script', - add_help=False) - - parser.add_argument( - '--cfg', - type=str, - required=True, - metavar="FILE", - help='path to config file') - - parser.add_argument( - "--data-paths", - nargs='+', - required=True, - help="paths where dataset is stored") - - parser.add_argument( - '--batch-size', - type=int, - help="batch size for single GPU") - - parser.add_argument( - '--gpu', - action='store_true', - default=False, - help="Copy batches to gpu") - - parser.add_argument( - '--dtype', - type=str, - default='bf16', - help='target dtype') - - args = parser.parse_args() - - config = get_config(args) - - return args, config - - -def benchmark(dataLoader: DataLoader, target_dtype, gpu: bool) -> None: - """ - Benchmark the speed of iterating through a PyTorch dataset using DataLoader. - - Args: - - dataLoader: PyTorch DataLoader object - """ - - start_time = time.time() - num_batches = 0 - - for _, img_mask in enumerate(dataLoader): - - img_mask = img_mask[0] - - img = torch.stack([pair[0] for pair in img_mask]) - mask = torch.stack([pair[1] for pair in img_mask]) - - if gpu: - img = img.to('cuda:0', non_blocking=True) - mask = mask.to('cuda:0', non_blocking=True) - - if target_dtype: - img = img.to(target_dtype) - - num_batches += 1 - - end_time = time.time() - total_time = end_time - start_time - - samples_processed = NUM_SAMPLES - samples_per_second = samples_processed / total_time - - print(f"Processed {samples_processed} samples in {total_time:.2f} seconds.") - print(f"Avg time per batch: {total_time / num_batches:.4f} seconds") - print(f"Samples per second: {samples_per_second:.2f}") - - -def main(config, args): - pin_memory = True - - if args.dtype == 'bf16': - dtype = torch.bfloat16 - elif args.dtype == 'f16': - dtype = torch.half - else: - dtype = None - - gpu = args.gpu - - transform = SimmimTransform(config) - - dataset = MODIS22MDataset(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform, - batch_size=config.DATA.BATCH_SIZE).dataset() - - dataloader = torch.utils.data.DataLoader( - dataset, - batch_size=None, - num_workers=int(os.environ["SLURM_CPUS_PER_TASK"]), - shuffle=False, - pin_memory=pin_memory,) - - print(f'Batch size: {config.DATA.BATCH_SIZE}') - print(f'Img size: {config.DATA.IMG_SIZE}') - print(f'Num workers: {int(os.environ["SLURM_CPUS_PER_TASK"])}') - print(f'PIN MEMORY {pin_memory}') - print(f'GPU: {gpu}') - print(f'Datatype: {dtype}') - - benchmark(dataloader, dtype, gpu) - - -if __name__ == '__main__': - - args, config = parse_args() - - sys.exit(main(config=config, args=args)) diff --git a/pytorch_caney/data/datamodules/__init__.py b/pytorch_caney/data/datamodules/__init__.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/data/datamodules/finetune_datamodule.py b/pytorch_caney/data/datamodules/finetune_datamodule.py deleted file mode 100644 index bdbed40..0000000 --- a/pytorch_caney/data/datamodules/finetune_datamodule.py +++ /dev/null @@ -1,114 +0,0 @@ -from ..datasets.modis_dataset import MODISDataset -from ..datasets.modis_lc_five_dataset import MODISLCFiveDataset -from ..datasets.modis_lc_nine_dataset import MODISLCNineDataset - -from ..transforms import TensorResizeTransform - -import torch.distributed as dist -from torch.utils.data import DataLoader, DistributedSampler - - -DATASETS = { - 'modis': MODISDataset, - 'modislc9': MODISLCNineDataset, - 'modislc5': MODISLCFiveDataset, - # 'modis tree': MODISTree, -} - - -def get_dataset_from_dict(dataset_name: str): - """Gets the proper dataset given a dataset name. - - Args: - dataset_name (str): name of the dataset - - Raises: - KeyError: thrown if dataset key is not present in dict - - Returns: - dataset: pytorch dataset - """ - - dataset_name = dataset_name.lower() - - try: - - dataset_to_use = DATASETS[dataset_name] - - except KeyError: - - error_msg = f"{dataset_name} is not an existing dataset" - - error_msg = f"{error_msg}. Available datasets: {DATASETS.keys()}" - - raise KeyError(error_msg) - - return dataset_to_use - - -def build_finetune_dataloaders(config, logger): - """Builds the dataloaders and datasets for a fine-tuning task. - - Args: - config: config object - logger: logging logger - - Returns: - dataloader_train: training dataloader - dataloader_val: validation dataloader - """ - - transform = TensorResizeTransform(config) - - logger.info(f'Finetuning data transform:\n{transform}') - - dataset_name = config.DATA.DATASET - - logger.info(f'Dataset: {dataset_name}') - logger.info(f'Data Paths: {config.DATA.DATA_PATHS}') - - dataset_to_use = get_dataset_from_dict(dataset_name) - - logger.info(f'Dataset obj: {dataset_to_use}') - - dataset_train = dataset_to_use(data_paths=config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform) - - dataset_val = dataset_to_use(data_paths=config.DATA.DATA_PATHS, - split="val", - img_size=config.DATA.IMG_SIZE, - transform=transform) - - logger.info(f'Build dataset: train images = {len(dataset_train)}') - - logger.info(f'Build dataset: val images = {len(dataset_val)}') - - sampler_train = DistributedSampler( - dataset_train, - num_replicas=dist.get_world_size(), - rank=dist.get_rank(), - shuffle=True) - - sampler_val = DistributedSampler( - dataset_val, - num_replicas=dist.get_world_size(), - rank=dist.get_rank(), - shuffle=False) - - dataloader_train = DataLoader(dataset_train, - config.DATA.BATCH_SIZE, - sampler=sampler_train, - num_workers=config.DATA.NUM_WORKERS, - pin_memory=True, - drop_last=True) - - dataloader_val = DataLoader(dataset_val, - config.DATA.BATCH_SIZE, - sampler=sampler_val, - num_workers=config.DATA.NUM_WORKERS, - pin_memory=True, - drop_last=False) - - return dataloader_train, dataloader_val diff --git a/pytorch_caney/data/datamodules/mim_datamodule.py b/pytorch_caney/data/datamodules/mim_datamodule.py deleted file mode 100644 index b70ee74..0000000 --- a/pytorch_caney/data/datamodules/mim_datamodule.py +++ /dev/null @@ -1,80 +0,0 @@ -from ..datasets.simmim_modis_dataset import MODISDataset - -from ..transforms import SimmimTransform - -import torch.distributed as dist -from torch.utils.data import DataLoader, DistributedSampler -from torch.utils.data._utils.collate import default_collate - - -DATASETS = { - 'MODIS': MODISDataset, -} - - -def collate_fn(batch): - if not isinstance(batch[0][0], tuple): - return default_collate(batch) - else: - batch_num = len(batch) - ret = [] - for item_idx in range(len(batch[0][0])): - if batch[0][0][item_idx] is None: - ret.append(None) - else: - ret.append(default_collate( - [batch[i][0][item_idx] for i in range(batch_num)])) - ret.append(default_collate([batch[i][1] for i in range(batch_num)])) - return ret - - -def get_dataset_from_dict(dataset_name): - - try: - - dataset_to_use = DATASETS[dataset_name] - - except KeyError: - - error_msg = f"{dataset_name} is not an existing dataset" - - error_msg = f"{error_msg}. Available datasets: {DATASETS.keys()}" - - raise KeyError(error_msg) - - return dataset_to_use - - -def build_mim_dataloader(config, logger): - - transform = SimmimTransform(config) - - logger.info(f'Pre-train data transform:\n{transform}') - - dataset_name = config.DATA.DATASET - - dataset_to_use = get_dataset_from_dict(dataset_name) - - dataset = dataset_to_use(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform) - - logger.info(f'Build dataset: train images = {len(dataset)}') - - sampler = DistributedSampler( - dataset, - num_replicas=dist.get_world_size(), - rank=dist.get_rank(), - shuffle=True) - - dataloader = DataLoader(dataset, - config.DATA.BATCH_SIZE, - sampler=sampler, - num_workers=config.DATA.NUM_WORKERS, - pin_memory=True, - drop_last=True, - collate_fn=collate_fn) - - return dataloader diff --git a/pytorch_caney/data/datamodules/mim_webdataset_datamodule.py b/pytorch_caney/data/datamodules/mim_webdataset_datamodule.py deleted file mode 100644 index 47b9a35..0000000 --- a/pytorch_caney/data/datamodules/mim_webdataset_datamodule.py +++ /dev/null @@ -1,48 +0,0 @@ -from ..datasets.mim_modis_22m_dataset import MODIS22MDataset - -from ..transforms import SimmimTransform - -from torch.utils.data import DataLoader -from torch.utils.data._utils.collate import default_collate - -import os - - -def collate_fn(batch): - if not isinstance(batch[0][0], tuple): - return default_collate(batch) - else: - batch_num = len(batch) - ret = [] - for item_idx in range(len(batch[0][0])): - if batch[0][0][item_idx] is None: - ret.append(None) - else: - ret.append(default_collate( - [batch[i][0][item_idx] for i in range(batch_num)])) - ret.append(default_collate([batch[i][1] for i in range(batch_num)])) - return ret - - -def build_mim_dataloader(config, logger): - - transform = SimmimTransform(config) - - logger.info(f'Pre-train data transform:\n{transform}') - - dataset = MODIS22MDataset(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform, - batch_size=config.DATA.BATCH_SIZE).dataset() - - dataloader = DataLoader(dataset, - batch_size=None, - shuffle=False, - num_workers=int(os.environ["SLURM_CPUS_PER_TASK"]), - pin_memory=True) - # NEED TO GET ACTUAL SIZE - # dataloader = dataloader.ddp_equalize(21643764 // config.DATA.BATCH_SIZE) - - return dataloader diff --git a/pytorch_caney/data/datamodules/segmentation_datamodule.py b/pytorch_caney/data/datamodules/segmentation_datamodule.py deleted file mode 100755 index fb6d166..0000000 --- a/pytorch_caney/data/datamodules/segmentation_datamodule.py +++ /dev/null @@ -1,164 +0,0 @@ -import os -import logging -from typing import Any, Union, Optional - -import torch -from torch.utils.data import DataLoader -from torch.utils.data.dataset import random_split -from pytorch_lightning import LightningDataModule -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY - -from terragpu.ai.deep_learning.datasets.segmentation_dataset \ - import SegmentationDataset - - -@DATAMODULE_REGISTRY -class SegmentationDataModule(LightningDataModule): - - def __init__( - self, - - # Dataset parameters - dataset_dir: str = 'dataset/', - images_regex: str = 'dataset/images/*.tif', - labels_regex: str = 'dataset/labels/*.tif', - generate_dataset: bool = True, - tile_size: int = 256, - max_patches: Union[float, int] = 100, - augment: bool = True, - chunks: dict = {'band': 1, 'x': 2048, 'y': 2048}, - input_bands: list = ['CB', 'B', 'G', 'Y', 'R', 'RE', 'N1', 'N2'], - output_bands: list = ['B', 'G', 'R'], - seed: int = 24, - normalize: bool = True, - pytorch: bool = True, - - # Datamodule parameters - val_split: float = 0.2, - test_split: float = 0.1, - num_workers: int = os.cpu_count(), - batch_size: int = 32, - shuffle: bool = True, - pin_memory: bool = False, - drop_last: bool = False, - - # Inference parameters - raster_regex: str = 'rasters/*.tif', - - *args: Any, - **kwargs: Any, - - ) -> None: - - super().__init__(*args, **kwargs) - - # Dataset parameters - self.images_regex = images_regex - self.labels_regex = labels_regex - self.dataset_dir = dataset_dir - self.generate_dataset = generate_dataset - self.tile_size = tile_size - self.max_patches = max_patches - self.augment = augment - self.chunks = chunks - self.input_bands = input_bands - self.output_bands = output_bands - self.seed = seed - self.normalize = normalize - self.pytorch = pytorch - - self.val_split = val_split - self.test_split = test_split - self.raster_regex = raster_regex - - # Performance parameters - self.batch_size = batch_size - self.num_workers = num_workers - self.shuffle = shuffle - self.pin_memory = pin_memory - self.drop_last = drop_last - - def prepare_data(self): - if self.generate_dataset: - SegmentationDataset( - images_regex=self.images_regex, - labels_regex=self.labels_regex, - dataset_dir=self.dataset_dir, - generate_dataset=self.generate_dataset, - tile_size=self.tile_size, - max_patches=self.max_patches, - augment=self.augment, - chunks=self.chunks, - input_bands=self.input_bands, - output_bands=self.output_bands, - seed=self.seed, - normalize=self.normalize, - pytorch=self.pytorch, - ) - - def setup(self, stage: Optional[str] = None): - - # Split into train, val, test - segmentation_dataset = SegmentationDataset( - images_regex=self.images_regex, - labels_regex=self.labels_regex, - dataset_dir=self.dataset_dir, - generate_dataset=False, - tile_size=self.tile_size, - max_patches=self.max_patches, - augment=self.augment, - chunks=self.chunks, - input_bands=self.input_bands, - output_bands=self.output_bands, - seed=self.seed, - normalize=self.normalize, - pytorch=self.pytorch, - ) - - # Split datasets into train, val, and test sets - val_len = round(self.val_split * len(segmentation_dataset)) - test_len = round(self.test_split * len(segmentation_dataset)) - train_len = len(segmentation_dataset) - val_len - test_len - - # Initialize datasets - self.train_set, self.val_set, self.test_set = random_split( - segmentation_dataset, lengths=[train_len, val_len, test_len], - generator=torch.Generator().manual_seed(self.seed) - ) - logging.info("Initialized datasets...") - - def train_dataloader(self) -> DataLoader: - loader = DataLoader( - self.train_set, - batch_size=self.batch_size, - shuffle=self.shuffle, - num_workers=self.num_workers, - drop_last=self.drop_last, - pin_memory=self.pin_memory, - ) - return loader - - def val_dataloader(self) -> DataLoader: - loader = DataLoader( - self.val_set, - batch_size=self.batch_size, - shuffle=False, - num_workers=self.num_workers, - drop_last=self.drop_last, - pin_memory=self.pin_memory, - ) - return loader - - def test_dataloader(self) -> DataLoader: - loader = DataLoader( - self.test_set, - batch_size=self.batch_size, - shuffle=False, - num_workers=self.num_workers, - drop_last=self.drop_last, - pin_memory=self.pin_memory, - ) - return loader - - def predict_dataloader(self) -> DataLoader: - raise NotImplementedError diff --git a/pytorch_caney/data/datamodules/simmim_datamodule.py b/pytorch_caney/data/datamodules/simmim_datamodule.py deleted file mode 100644 index b70ee74..0000000 --- a/pytorch_caney/data/datamodules/simmim_datamodule.py +++ /dev/null @@ -1,80 +0,0 @@ -from ..datasets.simmim_modis_dataset import MODISDataset - -from ..transforms import SimmimTransform - -import torch.distributed as dist -from torch.utils.data import DataLoader, DistributedSampler -from torch.utils.data._utils.collate import default_collate - - -DATASETS = { - 'MODIS': MODISDataset, -} - - -def collate_fn(batch): - if not isinstance(batch[0][0], tuple): - return default_collate(batch) - else: - batch_num = len(batch) - ret = [] - for item_idx in range(len(batch[0][0])): - if batch[0][0][item_idx] is None: - ret.append(None) - else: - ret.append(default_collate( - [batch[i][0][item_idx] for i in range(batch_num)])) - ret.append(default_collate([batch[i][1] for i in range(batch_num)])) - return ret - - -def get_dataset_from_dict(dataset_name): - - try: - - dataset_to_use = DATASETS[dataset_name] - - except KeyError: - - error_msg = f"{dataset_name} is not an existing dataset" - - error_msg = f"{error_msg}. Available datasets: {DATASETS.keys()}" - - raise KeyError(error_msg) - - return dataset_to_use - - -def build_mim_dataloader(config, logger): - - transform = SimmimTransform(config) - - logger.info(f'Pre-train data transform:\n{transform}') - - dataset_name = config.DATA.DATASET - - dataset_to_use = get_dataset_from_dict(dataset_name) - - dataset = dataset_to_use(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform) - - logger.info(f'Build dataset: train images = {len(dataset)}') - - sampler = DistributedSampler( - dataset, - num_replicas=dist.get_world_size(), - rank=dist.get_rank(), - shuffle=True) - - dataloader = DataLoader(dataset, - config.DATA.BATCH_SIZE, - sampler=sampler, - num_workers=config.DATA.NUM_WORKERS, - pin_memory=True, - drop_last=True, - collate_fn=collate_fn) - - return dataloader diff --git a/pytorch_caney/data/datamodules/test_wds.py b/pytorch_caney/data/datamodules/test_wds.py deleted file mode 100644 index 7c6f2f7..0000000 --- a/pytorch_caney/data/datamodules/test_wds.py +++ /dev/null @@ -1,82 +0,0 @@ -import sys - -sys.path.append('pytorch-caney') - -from pytorch_caney.config import get_config -from pytorch_caney.loss.build import build_loss -from pytorch_caney.lr_scheduler import build_scheduler, setup_scaled_lr -from pytorch_caney.ptc_logging import create_logger -from pytorch_caney.training.mim_utils import get_grad_norm - -import argparse -import datetime -import joblib -import numpy as np -import os -import time - -import torch -import torch.cuda.amp as amp -import torch.backends.cudnn as cudnn -import torch.distributed as dist - -from timm.utils import AverageMeter - - -from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset - -from pytorch_caney.data.transforms import SimmimTransform, SimmimMaskGenerator - -from torch.utils.data import DataLoader, DistributedSampler -from torch.utils.data._utils.collate import default_collate - -import torch.distributed as dist - -def collate_fn(batch): - if not isinstance(batch[0][0], tuple): - return default_collate(batch) - else: - batch_num = len(batch) - ret = [] - for item_idx in range(len(batch[0][0])): - if batch[0][0][item_idx] is None: - ret.append(None) - else: - ret.append(default_collate( - [batch[i][0][item_idx] for i in range(batch_num)])) - ret.append(default_collate([batch[i][1] for i in range(batch_num)])) - return ret - - - -def build_mim_dataloader(config, logger): - - transform = SimmimTransform(config) - - logger.info(f'Pre-train data transform:\n{transform}') - - dataset_to_use = MODIS22MDataset - - dataset = dataset_to_use(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform) - - logger.info(f'Build dataset: train images = {len(dataset)}') - - sampler = DistributedSampler( - dataset, - num_replicas=dist.get_world_size(), - rank=dist.get_rank(), - shuffle=True) - - dataloader = DataLoader(dataset, - config.DATA.BATCH_SIZE, - sampler=sampler, - num_workers=config.DATA.NUM_WORKERS, - pin_memory=True, - drop_last=True, - collate_fn=collate_fn) - - return dataloader diff --git a/pytorch_caney/data/datasets/__init__.py b/pytorch_caney/data/datasets/__init__.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/data/datasets/classification_dataset.py b/pytorch_caney/data/datasets/classification_dataset.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py b/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py deleted file mode 100644 index f5d446c..0000000 --- a/pytorch_caney/data/datasets/mim_modis_22m_4band_dataset.py +++ /dev/null @@ -1,83 +0,0 @@ -import os -import numpy as np -import pathlib -import logging - -from io import BytesIO -import webdataset as wds -import torch.distributed as dist - - -def nodesplitter(src, group=None): - if dist.is_initialized(): - if group is None: - group = dist.group.WORLD - rank = dist.get_rank(group=group) - size = dist.get_world_size(group=group) - logging.info(f"nodesplitter: rank={rank} size={size}") - count = 0 - for i, item in enumerate(src): - if i % size == rank: - yield item - count += 1 - logging.info(f"nodesplitter: rank={rank} size={size} " + \ - f"count={count} DONE") - else: - yield from src - - -class MODIS22MDataset(object): - """ - MODIS MOD09GA 22-million pre-training dataset - """ - SHARD_PATH = os.path.join("shard") - - INPUT_KEY = 'input.npy' - - OUTPUT_KEY = 'output.npy' - - def __init__( - self, - config, - data_paths: list, - split: str, - img_size: tuple = (192, 192), - transform=None, - batch_size=64, - ): - - self.random_state = 42 - - self.config = config - - self.img_size = img_size - - self.transform = transform - - self.split = split - - self.shard_path = pathlib.Path(os.path.join(data_paths[0], - self.SHARD_PATH)) - - shards = self.shard_path.glob('*.tar') - - self.shards = list(map(str, shards)) - - self.batch_size = batch_size - - def dataset(self): - - dataset = ( - wds.WebDataset(self.shards, - shardshuffle=True, - handler=wds.ignore_and_continue, - nodesplitter=nodesplitter) - .shuffle(self.random_state) - .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) # , self.OUTPUT_KEY) - .map_tuple(BytesIO) - .map_tuple(np.load) - .map_tuple(self.transform) - .batched(self.batch_size, partial=False) - ) - - return dataset diff --git a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py b/pytorch_caney/data/datasets/mim_modis_22m_dataset.py deleted file mode 100644 index 49a66a9..0000000 --- a/pytorch_caney/data/datasets/mim_modis_22m_dataset.py +++ /dev/null @@ -1,86 +0,0 @@ -import os -import numpy as np -import pathlib -import logging - -from io import BytesIO -import webdataset as wds -import torch.distributed as dist - - -def nodesplitter(src, group=None): - if dist.is_initialized(): - if group is None: - group = dist.group.WORLD - rank = dist.get_rank(group=group) - size = dist.get_world_size(group=group) - logging.info(f"nodesplitter: rank={rank} size={size}") - count = 0 - for i, item in enumerate(src): - if i % size == rank: - yield item - count += 1 - logging.info(f"nodesplitter: rank={rank} size={size} " + \ - f"count={count} DONE") - else: - yield from src - - -class MODIS22MDataset(object): - """ - MODIS MOD09GA 22-million pre-training dataset - """ - SHARD_PATH = os.path.join("shards") - - INPUT_KEY = 'input.npy' - - OUTPUT_KEY = 'output.npy' - - def __init__( - self, - config, - data_paths: list, - split: str, - img_size: tuple = (192, 192), - transform=None, - batch_size=64, - ): - - self.random_state = 1000 - - self.config = config - - self.img_size = img_size - - self.transform = transform - - self.split = split - - self.shard_path = pathlib.Path(data_paths[0]) - - shards = self.shard_path.glob('*.tar') - - self.shards = list(map(str, shards)) - - self.batch_size = batch_size - - def dataset(self): - - dataset = ( - wds.WebDataset(self.shards, - shardshuffle=True, - # resampled=True, - repeat=True, - handler=wds.ignore_and_continue, - nodesplitter=nodesplitter) - .shuffle(self.random_state) - .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) # , self.OUTPUT_KEY) - .map_tuple(BytesIO) - .map_tuple(np.load) - .map_tuple(self.transform) - .batched(self.batch_size, partial=False) - .repeat(2) - .with_length(1962000) - ) - - return dataset diff --git a/pytorch_caney/data/datasets/modis_dataset.py b/pytorch_caney/data/datasets/modis_dataset.py deleted file mode 100644 index 89a4923..0000000 --- a/pytorch_caney/data/datasets/modis_dataset.py +++ /dev/null @@ -1,82 +0,0 @@ -import os -import random - -import numpy as np - -from torch.utils.data import Dataset - - -class MODISDataset(Dataset): - """ - MODIS Landcover 17-class pytorch fine-tuning dataset - """ - - IMAGE_PATH = os.path.join("images") - MASK_PATH = os.path.join("labels") - - def __init__( - self, - data_paths: list, - split: str, - img_size: tuple = (256, 256), - transform=None, - ): - self.img_size = img_size - self.transform = transform - self.split = split - self.data_paths = data_paths - self.img_list = [] - self.mask_list = [] - - self._init_data_paths(self.data_paths) - - # Split between train and valid set (80/20) - random_inst = random.Random(12345) # for repeatability - n_items = len(self.img_list) - idxs = set(random_inst.sample(range(n_items), n_items // 5)) - total_idxs = set(range(n_items)) - if self.split == "train": - idxs = total_idxs - idxs - - print(f'> Found {len(idxs)} patches for this dataset ({split})') - self.img_list = [self.img_list[i] for i in idxs] - self.mask_list = [self.mask_list[i] for i in idxs] - - def _init_data_paths(self, data_paths: list) -> None: - """ - Given a list of datapaths, get all filenames matching - regex from each subdatapath and compile to a single list. - """ - for data_path in data_paths: - img_path = os.path.join(data_path, self.IMAGE_PATH) - mask_path = os.path.join(data_path, self.MASK_PATH) - self.img_list.extend(self.get_filenames(img_path)) - self.mask_list.extend(self.get_filenames(mask_path)) - - def __len__(self): - return len(self.img_list) - - def __getitem__(self, idx, transpose=True): - - # load image - img = np.load(self.img_list[idx]) - - # load mask - mask = np.load(self.mask_list[idx]) - if len(mask.shape) > 2: - mask = np.argmax(mask, axis=-1) - - # perform transformations - if self.transform is not None: - img = self.transform(img) - - return img, mask - - def get_filenames(self, path): - """ - Returns a list of absolute paths to images inside given `path` - """ - files_list = [] - for filename in sorted(os.listdir(path)): - files_list.append(os.path.join(path, filename)) - return files_list diff --git a/pytorch_caney/data/datasets/modis_lc_five_dataset.py b/pytorch_caney/data/datasets/modis_lc_five_dataset.py deleted file mode 100644 index c8948a0..0000000 --- a/pytorch_caney/data/datasets/modis_lc_five_dataset.py +++ /dev/null @@ -1,79 +0,0 @@ -import os -from torch.utils.data import Dataset - -import numpy as np -import random - - -class MODISLCFiveDataset(Dataset): - """ - MODIS Landcover five-class pytorch fine-tuning dataset - """ - - IMAGE_PATH = os.path.join("images") - MASK_PATH = os.path.join("labels") - - def __init__( - self, - data_paths: list, - split: str, - img_size: tuple = (224, 224), - transform=None, - ): - self.img_size = img_size - self.transform = transform - self.split = split - self.data_paths = data_paths - self.img_list = [] - self.mask_list = [] - for data_path in data_paths: - img_path = os.path.join(data_path, self.IMAGE_PATH) - mask_path = os.path.join(data_path, self.MASK_PATH) - self.img_list.extend(self.get_filenames(img_path)) - self.mask_list.extend(self.get_filenames(mask_path)) - # Split between train and valid set (80/20) - - random_inst = random.Random(12345) # for repeatability - n_items = len(self.img_list) - print(f'Found {n_items} possible patches to use') - range_n_items = range(n_items) - range_n_items = random_inst.sample(range_n_items, int(n_items*0.5)) - idxs = set(random_inst.sample(range_n_items, len(range_n_items) // 5)) - total_idxs = set(range_n_items) - if split == 'train': - idxs = total_idxs - idxs - print(f'> Using {len(idxs)} patches for this dataset ({split})') - self.img_list = [self.img_list[i] for i in idxs] - self.mask_list = [self.mask_list[i] for i in idxs] - print(f'>> {split}: {len(self.img_list)}') - - def __len__(self): - return len(self.img_list) - - def __getitem__(self, idx, transpose=True): - - # load image - img = np.load(self.img_list[idx]) - - img = np.clip(img, 0, 1.0) - - # load mask - mask = np.load(self.mask_list[idx]) - - mask = np.argmax(mask, axis=-1) - - mask = mask-1 - - # perform transformations - img = self.transform(img) - - return img, mask - - def get_filenames(self, path): - """ - Returns a list of absolute paths to images inside given `path` - """ - files_list = [] - for filename in sorted(os.listdir(path)): - files_list.append(os.path.join(path, filename)) - return files_list diff --git a/pytorch_caney/data/datasets/modis_lc_nine_dataset.py b/pytorch_caney/data/datasets/modis_lc_nine_dataset.py deleted file mode 100644 index e601b6a..0000000 --- a/pytorch_caney/data/datasets/modis_lc_nine_dataset.py +++ /dev/null @@ -1,79 +0,0 @@ -import os -import random - -import numpy as np - -from torch.utils.data import Dataset - - -class MODISLCNineDataset(Dataset): - """ - MODIS Landcover nine-class pytorch fine-tuning dataset - """ - IMAGE_PATH = os.path.join("images") - MASK_PATH = os.path.join("labels") - - def __init__( - self, - data_paths: list, - split: str, - img_size: tuple = (224, 224), - transform=None, - ): - self.img_size = img_size - self.transform = transform - self.split = split - self.data_paths = data_paths - self.img_list = [] - self.mask_list = [] - for data_path in data_paths: - img_path = os.path.join(data_path, self.IMAGE_PATH) - mask_path = os.path.join(data_path, self.MASK_PATH) - self.img_list.extend(self.get_filenames(img_path)) - self.mask_list.extend(self.get_filenames(mask_path)) - # Split between train and valid set (80/20) - - random_inst = random.Random(12345) # for repeatability - n_items = len(self.img_list) - print(f'Found {n_items} possible patches to use') - range_n_items = range(n_items) - range_n_items = random_inst.sample(range_n_items, int(n_items*0.5)) - idxs = set(random_inst.sample(range_n_items, len(range_n_items) // 5)) - total_idxs = set(range_n_items) - if split == 'train': - idxs = total_idxs - idxs - print(f'> Using {len(idxs)} patches for this dataset ({split})') - self.img_list = [self.img_list[i] for i in idxs] - self.mask_list = [self.mask_list[i] for i in idxs] - print(f'>> {split}: {len(self.img_list)}') - - def __len__(self): - return len(self.img_list) - - def __getitem__(self, idx, transpose=True): - - # load image - img = np.load(self.img_list[idx]) - - img = np.clip(img, 0, 1.0) - - # load mask - mask = np.load(self.mask_list[idx]) - - mask = np.argmax(mask, axis=-1) - - mask = mask-1 - - # perform transformations - img = self.transform(img) - - return img, mask - - def get_filenames(self, path): - """ - Returns a list of absolute paths to images inside given `path` - """ - files_list = [] - for filename in sorted(os.listdir(path)): - files_list.append(os.path.join(path, filename)) - return files_list diff --git a/pytorch_caney/data/datasets/object_dataset.py b/pytorch_caney/data/datasets/object_dataset.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/data/datasets/segmentation_dataset.py b/pytorch_caney/data/datasets/segmentation_dataset.py deleted file mode 100755 index d81c757..0000000 --- a/pytorch_caney/data/datasets/segmentation_dataset.py +++ /dev/null @@ -1,284 +0,0 @@ -import os -import logging -from glob import glob -from pathlib import Path -from typing import Optional, Union - -import torch -import numpy as np -from torch.utils.data import Dataset -from torch.utils.dlpack import from_dlpack - -import xarray as xr -from terragpu.engine import array_module, df_module - -import terragpu.ai.preprocessing as preprocessing - -xp = array_module() -xf = df_module() - - -class PLSegmentationDataset(Dataset): - - def __init__( - self, - images_regex: Optional[str] = None, - labels_regex: Optional[str] = None, - dataset_dir: Optional[str] = None, - generate_dataset: bool = False, - tile_size: int = 256, - max_patches: Union[float, int] = 100, - augment: bool = True, - chunks: dict = {'band': 1, 'x': 2048, 'y': 2048}, - input_bands: list = ['CB', 'B', 'G', 'Y', 'R', 'RE', 'N1', 'N2'], - output_bands: list = ['B', 'G', 'R'], - seed: int = 24, - normalize: bool = True, - pytorch: bool = True): - - super().__init__() - - # Dataset metadata - self.input_bands = input_bands - self.output_bands = output_bands - self.chunks = chunks - self.tile_size = tile_size - self.seed = seed - self.max_patches = max_patches - - # Preprocessing metadata - self.generate_dataset = generate_dataset - self.normalize = normalize - - # Validate several input sources - assert dataset_dir is not None, \ - f'dataset_dir: {dataset_dir} does not exist.' - - # Setup directories structure - self.dataset_dir = dataset_dir # where to store dataset - self.images_dir = os.path.join(self.dataset_dir, 'images') - self.labels_dir = os.path.join(self.dataset_dir, 'labels') - - if self.generate_dataset: - - logging.info(f"Starting to prepare dataset: {self.dataset_dir}") - # Assert images_dir and labels_dir to be not None - self.images_regex = images_regex # images location - self.labels_regex = labels_regex # labels location - - # Create directories to store dataset - os.makedirs(self.images_dir, exist_ok=True) - os.makedirs(self.labels_dir, exist_ok=True) - - self.prepare_data() - - assert os.path.exists(self.images_dir), \ - f'{self.images_dir} does not exist. Make sure prepare_data: true.' - assert os.path.exists(self.labels_dir), \ - f'{self.labels_dir} does not exist. Make sure prepare_data: true.' - - self.files = self.get_filenames() - self.augment = augment - self.pytorch = pytorch - - # ------------------------------------------------------------------------- - # Dataset methods - # ------------------------------------------------------------------------- - def __len__(self): - return len(self.files) - - def __repr__(self): - s = 'Dataset class with {} files'.format(self.__len__()) - return s - - def __getitem__(self, idx): - - idx = idx % len(self.files) - x, y = self.open_image(idx), self.open_mask(idx) - - if self.augment: - x, y = self.transform(x, y) - return x, y - - def transform(self, x, y): - - if xp.random.random_sample() > 0.5: # flip left and right - x = torch.fliplr(x) - y = torch.fliplr(y) - if xp.random.random_sample() > 0.5: # reverse second dimension - x = torch.flipud(x) - y = torch.flipud(y) - if xp.random.random_sample() > 0.5: # rotate 90 degrees - x = torch.rot90(x, k=1, dims=[1, 2]) - y = torch.rot90(y, k=1, dims=[0, 1]) - if xp.random.random_sample() > 0.5: # rotate 180 degrees - x = torch.rot90(x, k=2, dims=[1, 2]) - y = torch.rot90(y, k=2, dims=[0, 1]) - if xp.random.random_sample() > 0.5: # rotate 270 degrees - x = torch.rot90(x, k=3, dims=[1, 2]) - y = torch.rot90(y, k=3, dims=[0, 1]) - - # standardize 0.70, 0.30 - # if np.random.random_sample() > 0.70: - # image = preprocess.standardizeLocalCalcTensor(image, means, stds) - # else: - # image = preprocess.standardizeGlobalCalcTensor(image) - return x, y - - # ------------------------------------------------------------------------- - # preprocess methods - # ------------------------------------------------------------------------- - def prepare_data(self): - - logging.info("Preparing dataset...") - images_list = sorted(glob(self.images_regex)) - labels_list = sorted(glob(self.labels_regex)) - - for image, label in zip(images_list, labels_list): - - # Read imagery from disk and process both image and mask - filename = Path(image).stem - image = xr.open_rasterio(image, chunks=self.chunks).load() - label = xr.open_rasterio(label, chunks=self.chunks).values - - # Modify bands if necessary - in a future version, add indices - image = preprocessing.modify_bands( - img=image, input_bands=self.input_bands, - output_bands=self.output_bands) - - # Asarray option to force array type - image = xp.asarray(image.values) - label = xp.asarray(label) - - # Move from chw to hwc, squeze mask if required - image = xp.moveaxis(image, 0, -1).astype(np.int16) - label = xp.squeeze(label) if len(label.shape) != 2 else label - logging.info(f'Label classes from image: {xp.unique(label)}') - - # Generate dataset tiles - image_tiles, label_tiles = preprocessing.gen_random_tiles( - image=image, label=label, tile_size=self.tile_size, - max_patches=self.max_patches, seed=self.seed) - logging.info(f"Tiles: {image_tiles.shape}, {label_tiles.shape}") - - # Save to disk - for id in range(image_tiles.shape[0]): - xp.save( - os.path.join(self.images_dir, f'{filename}_{id}.npy'), - image_tiles[id, :, :, :]) - xp.save( - os.path.join(self.labels_dir, f'{filename}_{id}.npy'), - label_tiles[id, :, :]) - return - - # ------------------------------------------------------------------------- - # dataset methods - # ------------------------------------------------------------------------- - def list_files(self, files_list: list = []): - - for i in os.listdir(self.images_dir): - files_list.append( - { - 'image': os.path.join(self.images_dir, i), - 'label': os.path.join(self.labels_dir, i) - } - ) - return files_list - - def open_image(self, idx: int, invert: bool = True): - # image = imread(self.files[idx]['image']) - image = xp.load(self.files[idx]['image'], allow_pickle=False) - image = image.transpose((2, 0, 1)) if invert else image - image = ( - image / xp.iinfo(image.dtype).max) if self.normalize else image - return from_dlpack(image.toDlpack()) # .to(torch.float32) - - def open_mask(self, idx: int, add_dims: bool = False): - # mask = imread(self.files[idx]['label']) - mask = xp.load(self.files[idx]['label'], allow_pickle=False) - mask = xp.expand_dims(mask, 0) if add_dims else mask - return from_dlpack(mask.toDlpack()) # .to(torch.torch.int64) - - -class SegmentationDataset(Dataset): - - def __init__( - self, dataset_dir, pytorch=True, augment=True): - - super().__init__() - - self.files: list = self.list_files(dataset_dir) - self.augment: bool = augment - self.pytorch: bool = pytorch - self.invert: bool = True - self.normalize: bool = True - self.standardize: bool = True - - # ------------------------------------------------------------------------- - # Common methods - # ------------------------------------------------------------------------- - def __len__(self): - return len(self.files) - - def __repr__(self): - s = 'Dataset class with {} files'.format(self.__len__()) - return s - - def __getitem__(self, idx): - - # get data - x = self.open_image(idx) - y = self.open_mask(idx) - - # augment the data - if self.augment: - - if xp.random.random_sample() > 0.5: # flip left and right - x = torch.fliplr(x) - y = torch.fliplr(y) - if xp.random.random_sample() > 0.5: # reverse second dimension - x = torch.flipud(x) - y = torch.flipud(y) - if xp.random.random_sample() > 0.5: # rotate 90 degrees - x = torch.rot90(x, k=1, dims=[1, 2]) - y = torch.rot90(y, k=1, dims=[0, 1]) - if xp.random.random_sample() > 0.5: # rotate 180 degrees - x = torch.rot90(x, k=2, dims=[1, 2]) - y = torch.rot90(y, k=2, dims=[0, 1]) - if xp.random.random_sample() > 0.5: # rotate 270 degrees - x = torch.rot90(x, k=3, dims=[1, 2]) - y = torch.rot90(y, k=3, dims=[0, 1]) - - return x, y - - # ------------------------------------------------------------------------- - # IO methods - # ------------------------------------------------------------------------- - def get_filenames(self, dataset_dir: str, files_list: list = []): - - images_dir = os.path.join(dataset_dir, 'images') - labels_dir = os.path.join(dataset_dir, 'labels') - - for i in os.listdir(images_dir): - files_list.append( - { - 'image': os.path.join(images_dir, i), - 'label': os.path.join(labels_dir, i) - } - ) - return files_list - - def open_image(self, idx: int): - image = xp.load(self.files[idx]['image'], allow_pickle=False) - if self.invert: - image = image.transpose((2, 0, 1)) - if self.normalize: - image = (image / xp.iinfo(image.dtype).max) - if self.standardize: - image = preprocessing.standardize_local(image) - return from_dlpack(image.toDlpack()).float() - - def open_mask(self, idx: int, add_dims: bool = False): - mask = xp.load(self.files[idx]['label'], allow_pickle=False) - mask = xp.expand_dims(mask, 0) if add_dims else mask - return from_dlpack(mask.toDlpack()).long() diff --git a/pytorch_caney/data/datasets/simmim_modis_dataset.py b/pytorch_caney/data/datasets/simmim_modis_dataset.py deleted file mode 100644 index ff69735..0000000 --- a/pytorch_caney/data/datasets/simmim_modis_dataset.py +++ /dev/null @@ -1,90 +0,0 @@ -from ..utils import SimmimMaskGenerator - -import os -import numpy as np - -from torch.utils.data import Dataset - - -class MODISDataset(Dataset): - """ - MODIS MOD09GA pre-training dataset - """ - IMAGE_PATH = os.path.join("images") - - def __init__( - self, - config, - data_paths: list, - split: str, - img_size: tuple = (192, 192), - transform=None, - ): - - self.config = config - - self.img_size = img_size - - self.transform = transform - - self.split = split - - self.data_paths = data_paths - - self.img_list = [] - - for data_path in data_paths: - - img_path = os.path.join(data_path, self.IMAGE_PATH) - - self.img_list.extend(self.get_filenames(img_path)) - - n_items = len(self.img_list) - - print(f'> Found {n_items} patches for this dataset ({split})') - - if config.MODEL.TYPE in ['swin', 'swinv2']: - - model_patch_size = config.MODEL.SWINV2.PATCH_SIZE - - else: - - raise NotImplementedError - - self.mask_generator = SimmimMaskGenerator( - input_size=config.DATA.IMG_SIZE, - mask_patch_size=config.DATA.MASK_PATCH_SIZE, - model_patch_size=model_patch_size, - mask_ratio=config.DATA.MASK_RATIO, - ) - - def __len__(self): - - return len(self.img_list) - - def __getitem__(self, idx, transpose=True): - - # load image - img = np.load(self.img_list[idx]) - - img = np.clip(img, 0, 1.0) - - # perform transformations - img = self.transform(img) - - mask = self.mask_generator() - - return img, mask - - def get_filenames(self, path): - """ - Returns a list of absolute paths to images inside given `path` - """ - - files_list = [] - - for filename in sorted(os.listdir(path)): - - files_list.append(os.path.join(path, filename)) - - return files_list diff --git a/pytorch_caney/data/transforms.py b/pytorch_caney/data/transforms.py deleted file mode 100644 index ed3e2f3..0000000 --- a/pytorch_caney/data/transforms.py +++ /dev/null @@ -1,198 +0,0 @@ -from .utils import RandomResizedCropNP -from .utils import SimmimMaskGenerator - -import torchvision.transforms as T -import numpy as np - - -class SimmimTransform: - """ - torchvision transform which transforms the input imagery into - addition to generating a MiM mask - """ - - def __init__(self, config): - - self.transform_img = \ - T.Compose([ - MinMaxEmissiveScaleReflectance(), # New transform for MinMax - RandomResizedCropNP(scale=(0.67, 1.), - ratio=(3. / 4., 4. / 3.)), - T.ToTensor(), - #lambda x: x / 500.0, - #T.ConvertImageDtype(dtype=torch.float32), - #torchvision.ops.Permute(dims=[1, 2, 0]), - T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), - ]) - - if config.MODEL.TYPE in ['swin', 'swinv2']: - - model_patch_size = config.MODEL.SWINV2.PATCH_SIZE - - else: - - raise NotImplementedError - - self.mask_generator = SimmimMaskGenerator( - input_size=config.DATA.IMG_SIZE, - mask_patch_size=config.DATA.MASK_PATCH_SIZE, - model_patch_size=model_patch_size, - mask_ratio=config.DATA.MASK_RATIO, - ) - - def __call__(self, img): - - img = self.transform_img(img) - mask = self.mask_generator() - - return img, mask - - -class TensorResizeTransform: - """ - torchvision transform which transforms the input imagery into - addition to generating a MiM mask - """ - - def __init__(self, config): - - self.transform_img = \ - T.Compose([ - T.ToTensor(), - T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), - ]) - - def __call__(self, img): - - img = self.transform_img(img) - - return img - - -class MinMaxEmissiveScaleReflectance(object): - """ - Performs scaling of MODIS TOA data - - Scales reflectance percentages to reflectance units (% -> (0,1)) - - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) - """ - - def __init__(self): - - self.reflectance_indices = [0, 1, 2, 3, 4, 6] - self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - - self.emissive_mins = np.array( - [223.1222, 178.9174, 204.3739, 204.7677, - 194.8686, 202.1759, 201.3823, 203.3537], - dtype=np.float32) - - self.emissive_maxs = np.array( - [352.7182, 261.2920, 282.5529, 319.0373, - 295.0209, 324.0677, 321.5254, 285.9848], - dtype=np.float32) - - def __call__(self, img): - - # Reflectance % to reflectance units - img[:, :, self.reflectance_indices] = \ - img[:, :, self.reflectance_indices] * 0.01 - - # Brightness temp scaled to (0,1) range - img[:, :, self.emissive_indices] = \ - (img[:, :, self.emissive_indices] - self.emissive_mins) / \ - (self.emissive_maxs - self.emissive_mins) - - return img - - -class TransformBrightnessAndReflectance(object): - """ - Performs conversion of calibrated MODIS TOA data to radiance units - - Converts TOA brightness temperature to TOA radiance units - - Converts TOA reflectance percentage to TOA radiance units - """ - - # Planck constant (Joule second) - h__ = np.float32(6.6260755e-34) - - # Speed of light in vacuum (meters per second) - c__ = np.float32(2.9979246e+8) - - # Boltzmann constant (Joules per Kelvin) - k__ = np.float32(1.380658e-23) - - def __init__(self): - - self.reflectance_indices = [0, 1, 2, 3, 4, 6] - self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - - self.emi_radiance_offsets = np.array([ - 2730.583496, 2730.583252, 2317.488281, 2730.583496, - 1560.333252, 1577.339722, 1658.221313, 2501.297607], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.emi_radiance_scales = np.array([ - 0.003149510128, 0.0001175572979, 0.0001924497337, - 0.0005324869417, 0.0004063234373, 0.0008400219958, - 0.0007296975818, 0.0002622638713], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_reflectance_offsets = np.array([ - 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_reflectance_scales = np.array([ - 5.665329445e-05, 3.402091534e-05, 6.13320808e-05, - 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_radiance_offsets = np.array([ - 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_radiance_scales = np.array([ - 0.02995670214, 0.01111282408, 0.04215827957, - 0.002742749639, 0.0009269224829, 0.003434347222], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - # Derived constants - self.c_1 = 2 * self.h__ * self.c__ * self.c__ - self.c_2 = (self.h__ * self.c__) / self.k__ - - self.cwn = np.array([ - 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, - 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], - dtype=np.float32)[np.newaxis, np.newaxis, :] - self.cwn = 1. / (self.cwn * 100) - - self.tcs = np.array([ - 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, - 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.tci = np.array([ - 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, - 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - def __call__(self, img): - - # Reflectance to radiance units - reflectance_bands = img[:, :, self.reflectance_indices] - img[:, :, self.reflectance_indices] = \ - self.rsb_radiance_scales * ( - (((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + \ - self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) - - img[:, :, self.reflectance_indices] = \ - img[:, :, self.reflectance_indices] * 0.01 - - # Brightness temp to radiance units: - emissive_bands = img[:, :, self.emissive_indices] - intermediate = emissive_bands * self.tcs + self.tci - exponent = self.c_2 / (intermediate * self.cwn) - img[:, :, self.emissive_indices] = self.c_1 / \ - (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) - - return img - diff --git a/pytorch_caney/data/utils.py b/pytorch_caney/data/utils.py deleted file mode 100644 index f5e1f1d..0000000 --- a/pytorch_caney/data/utils.py +++ /dev/null @@ -1,238 +0,0 @@ -import torch -import numpy as np - -from numba import njit - -# TRANSFORMS UTILS - - -class RandomResizedCropNP(object): - """ - Numpy implementation of RandomResizedCrop - """ - - def __init__(self, - scale=(0.08, 1.0), - ratio=(3.0/4.0, 4.0/3.0)): - - self.scale = scale - self.ratio = ratio - - def __call__(self, img): - - height, width = img.shape[:2] - area = height * width - - for _ in range(10): - target_area = np.random.uniform(*self.scale) * area - aspect_ratio = np.random.uniform(*self.ratio) - - w = int(round(np.sqrt(target_area * aspect_ratio))) - h = int(round(np.sqrt(target_area / aspect_ratio))) - - if np.random.random() < 0.5: - w, h = h, w - - if w <= width and h <= height: - x1 = np.random.randint(0, width - w + 1) - y1 = np.random.randint(0, height - h + 1) - cropped = img[y1:y1+h, x1:x1+w, :] - cropped = np.moveaxis(cropped, -1, 0) - cropped_resized = torch.nn.functional.interpolate( - torch.from_numpy(cropped).unsqueeze(0), - size=height, - mode='bicubic', - align_corners=False) - cropped_squeezed_numpy = cropped_resized.squeeze().numpy() - cropped_squeezed_numpy = np.moveaxis( - cropped_squeezed_numpy, 0, -1) - return cropped_squeezed_numpy - - # if crop was not successful after 10 attempts, use center crop - w = min(width, height) - x1 = (width - w) // 2 - y1 = (height - w) // 2 - cropped = img[y1:y1+w, x1:x1+w, :] - cropped = np.moveaxis(cropped, -1, 0) - cropped_resized = torch.nn.functional.interpolate(torch.from_numpy( - cropped).unsqueeze(0), - size=height, - mode='bicubic', - align_corners=False) - cropped_squeezed_numpy = cropped_resized.squeeze().numpy() - cropped_squeezed_numpy = np.moveaxis(cropped_squeezed_numpy, 0, -1) - return cropped_squeezed_numpy - -# MASKING - -class SimmimMaskGenerator: - """ - Generates the masks for masked-image-modeling - """ - def __init__(self, - input_size=192, - mask_patch_size=32, - model_patch_size=4, - mask_ratio=0.6): - self.input_size = input_size - self.mask_patch_size = mask_patch_size - self.model_patch_size = model_patch_size - self.mask_ratio = mask_ratio - - assert self.input_size % self.mask_patch_size == 0 - assert self.mask_patch_size % self.model_patch_size == 0 - - self.rand_size = self.input_size // self.mask_patch_size - self.scale = self.mask_patch_size // self.model_patch_size - - self.token_count = self.rand_size ** 2 - self.mask_count = int(np.ceil(self.token_count * self.mask_ratio)) - - def __call__(self): - mask = make_simmim_mask(self.token_count, self.mask_count, - self.rand_size, self.scale) - mask = mask.repeat(self.scale, axis=0).repeat(self.scale, axis=1) - return mask - - -@njit() -def make_simmim_mask(token_count, mask_count, rand_size, scale): - """JIT-compiled random mask generation - - Args: - token_count - mask_count - rand_size - scale - - Returns: - mask - """ - mask_idx = np.random.permutation(token_count)[:mask_count] - mask = np.zeros(token_count, dtype=np.int64) - mask[mask_idx] = 1 - mask = mask.reshape((rand_size, rand_size)) - return mask - - -class MinMaxEmissiveScaleReflectance(object): - """ - Performs scaling of MODIS TOA data - - Scales reflectance percentages to reflectance units (% -> (0,1)) - - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) - """ - - def __init__(self): - - self.reflectance_indices = [0, 1, 2, 3, 4, 6] - self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - - self.emissive_mins = np.array( - [223.1222, 178.9174, 204.3739, 204.7677, - 194.8686, 202.1759, 201.3823, 203.3537], - dtype=np.float32) - - self.emissive_maxs = np.array( - [352.7182, 261.2920, 282.5529, 319.0373, - 295.0209, 324.0677, 321.5254, 285.9848], - dtype=np.float32) - - def __call__(self, img): - - # Reflectance % to reflectance units - img[:, :, self.reflectance_indices] = \ - img[:, :, self.reflectance_indices] * 0.01 - - # Brightness temp scaled to (0,1) range - img[:, :, self.emissive_indices] = \ - (img[:, :, self.emissive_indices] - self.emissive_mins) / \ - (self.emissive_maxs - self.emissive_mins) - - return img - - -class TransformBrightnessAndReflectance(object): - - # Planck constant (Joule second) - h__ = np.float32(6.6260755e-34) - - # Speed of light in vacuum (meters per second) - c__ = np.float32(2.9979246e+8) - - # Boltzmann constant (Joules per Kelvin) - k__ = np.float32(1.380658e-23) - - def __init__(self): - - self.reflectance_indices = [0, 1, 2, 3, 4, 6] - self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] - - self.emi_radiance_offsets = np.array([ - 2730.583496, 2730.583252, 2317.488281, 2730.583496, - 1560.333252, 1577.339722, 1658.221313, 2501.297607], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.emi_radiance_scales = np.array([ - 0.003149510128, 0.0001175572979, 0.0001924497337, - 0.0005324869417, 0.0004063234373, 0.0008400219958, - 0.0007296975818, 0.0002622638713], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_reflectance_offsets = np.array([ - 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_reflectance_scales = np.array([ - 5.665329445e-05, 3.402091534e-05, 6.13320808e-05, - 3.468021168e-05, 3.117151937e-05, 2.858474545e-05], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_radiance_offsets = np.array([ - 0.0, 0.0, 0.0, 0.0, 0.0, 316.9721985], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.rsb_radiance_scales = np.array([ - 0.02995670214, 0.01111282408, 0.04215827957, - 0.002742749639, 0.0009269224829, 0.003434347222], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - # Derived constants - self.c_1 = 2 * self.h__ * self.c__ * self.c__ - self.c_2 = (self.h__ * self.c__) / self.k__ - - self.cwn = np.array([ - 2.505277E+3, 1.477967E+3, 1.362737E+3, 1.173190E+3, - 1.027715E+3, 9.080884E+2, 8.315399E+2, 7.483394E+2], - dtype=np.float32)[np.newaxis, np.newaxis, :] - self.cwn = 1. / (self.cwn * 100) - - self.tcs = np.array([ - 9.998646E-1, 9.994877E-1, 9.994918E-1, 9.995495E-1, - 9.997398E-1, 9.995608E-1, 9.997256E-1, 9.999160E-1], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - self.tci = np.array([ - 9.262664E-2, 2.204921E-1, 2.046087E-1, 1.599191E-1, - 8.253401E-2, 1.302699E-1, 7.181833E-2, 1.972608E-2], - dtype=np.float32)[np.newaxis, np.newaxis, :] - - def __call__(self, img): - - # Reflectance to radiance units - reflectance_bands = img[:, :, self.reflectance_indices] - img[:, :, self.reflectance_indices] = \ - self.rsb_radiance_scales * ( - (((reflectance_bands * 0.01) / self.rsb_reflectance_scales) + \ - self.rsb_reflectance_offsets) - self.rsb_radiance_offsets) - - img[:, :, self.reflectance_indices] = \ - img[:, :, self.reflectance_indices] * 0.01 - - # Brightness temp to radiance units: - emissive_bands = img[:, :, self.emissive_indices] - intermediate = emissive_bands * self.tcs + self.tci - exponent = self.c_2 / (intermediate * self.cwn) - img[:, :, self.emissive_indices] = self.c_1 / \ - (1000000 * self.cwn ** 5 * ((np.e ** exponent) - 1)) - - return img diff --git a/pytorch_caney/inference.py b/pytorch_caney/inference.py deleted file mode 100755 index d3695c6..0000000 --- a/pytorch_caney/inference.py +++ /dev/null @@ -1,383 +0,0 @@ -import logging -import math -import numpy as np - -import torch - -from tiler import Tiler, Merger - -from pytorch_caney.processing import normalize -from pytorch_caney.processing import global_standardization -from pytorch_caney.processing import local_standardization -from pytorch_caney.processing import standardize_image - -__author__ = "Jordan A Caraballo-Vega, Science Data Processing Branch" -__email__ = "jordan.a.caraballo-vega@nasa.gov" -__status__ = "Production" - -# --------------------------------------------------------------------------- -# module inference -# -# Data segmentation and prediction functions. -# --------------------------------------------------------------------------- - - -# --------------------------------------------------------------------------- -# Module Methods -# --------------------------------------------------------------------------- -def sliding_window_tiler_multiclass( - xraster, - model, - n_classes: int, - img_size: int, - pad_style: str = 'reflect', - overlap: float = 0.50, - constant_value: int = 600, - batch_size: int = 1024, - threshold: float = 0.50, - standardization: str = None, - mean=None, - std=None, - normalize: float = 1.0, - rescale: str = None, - window: str = 'triang', # 'overlap-tile' - probability_map: bool = False, - ): - """ - Sliding window using tiler. - """ - - tile_channels = xraster.shape[-1] # model.layers[0].input_shape[0][-1] - print(f'Standardizing: {standardization}') - # n_classes = out of the output layer, output_shape - - tiler_image = Tiler( - data_shape=xraster.shape, - tile_shape=(img_size, img_size, tile_channels), - channel_dimension=-1, - overlap=overlap, - mode=pad_style, - constant_value=constant_value - ) - - # Define the tiler and merger based on the output size of the prediction - tiler_mask = Tiler( - data_shape=(xraster.shape[0], xraster.shape[1], n_classes), - tile_shape=(img_size, img_size, n_classes), - channel_dimension=-1, - overlap=overlap, - mode=pad_style, - constant_value=constant_value - ) - - merger = Merger(tiler=tiler_mask, window=window) - # xraster = normalize_image(xraster, normalize) - - # Iterate over the data in batches - for batch_id, batch_i in tiler_image(xraster, batch_size=batch_size): - - # Standardize - batch = batch_i.copy() - - if standardization is not None: - for item in range(batch.shape[0]): - batch[item, :, :, :] = standardize_image( - batch[item, :, :, :], standardization, mean, std) - - input_batch = batch.astype('float32') - input_batch_tensor = torch.from_numpy(input_batch) - input_batch_tensor = input_batch_tensor.transpose(-1, 1) - # input_batch_tensor = input_batch_tensor.cuda(non_blocking=True) - with torch.no_grad(): - y_batch = model(input_batch_tensor) - y_batch = y_batch.transpose(1, -1).numpy() # .cpu().numpy() - print(y_batch.shape) - merger.add_batch(batch_id, batch_size, y_batch) - - prediction = merger.merge(unpad=True) - - if not probability_map: - if prediction.shape[-1] > 1: - prediction = np.argmax(prediction, axis=-1) - else: - prediction = np.squeeze( - np.where(prediction > threshold, 1, 0).astype(np.int16) - ) - else: - prediction = np.squeeze(prediction) - return prediction - - -# --------------------------- Segmentation Functions ----------------------- # - -def segment(image, model='model.h5', tile_size=256, channels=6, - norm_data=[], bsize=8): - """ - Applies a semantic segmentation model to an image. Ideal for non-scene - imagery. Leaves artifacts in boundaries if no post-processing is done. - :param image: image to classify (numpy array) - :param model: loaded model object - :param tile_size: tile size of patches - :param channels: number of channels - :param norm_data: numpy array with mean and std data - :param bsize: number of patches to predict at the same time - return numpy array with classified mask - """ - # Create blank array to store predicted label - seg = np.zeros((image.shape[0], image.shape[1])) - for i in range(0, image.shape[0], int(tile_size)): - for j in range(0, image.shape[1], int(tile_size)): - # If edge of tile beyond image boundary, shift it to boundary - if i + tile_size > image.shape[0]: - i = image.shape[0] - tile_size - if j + tile_size > image.shape[1]: - j = image.shape[1] - tile_size - - # Extract and normalise tile - tile = normalize( - image[i: i + tile_size, j: j + tile_size, :].astype(float), - norm_data - ) - out = model.predict( - tile.reshape( - (1, tile.shape[0], tile.shape[1], tile.shape[2]) - ).astype(float), - batch_size=4 - ) - out = out.argmax(axis=3) # get max prediction for pixel in classes - out = out.reshape(tile_size, tile_size) # reshape to tile size - seg[i: i + tile_size, j: j + tile_size] = out - return seg - - -def segment_binary(image, model='model.h5', norm_data=[], - tile_size=256, channels=6, bsize=8 - ): - """ - Applies binary semantic segmentation model to an image. Ideal for non-scene - imagery. Leaves artifacts in boundaries if no post-processing is done. - :param image: image to classify (numpy array) - :param model: loaded model object - :param tile_size: tile size of patches - :param channels: number of channels - :param norm_data: numpy array with mean and std data - return numpy array with classified mask - """ - # Create blank array to store predicted label - seg = np.zeros((image.shape[0], image.shape[1])) - for i in range(0, image.shape[0], int(tile_size)): - for j in range(0, image.shape[1], int(tile_size)): - # If edge of tile beyond image boundary, shift it to boundary - if i + tile_size > image.shape[0]: - i = image.shape[0] - tile_size - if j + tile_size > image.shape[1]: - j = image.shape[1] - tile_size - - # Extract and normalise tile - tile = normalize( - image[i:i + tile_size, j:j + tile_size, :].astype(float), - norm_data - ) - out = model.predict( - tile.reshape( - (1, tile.shape[0], tile.shape[1], tile.shape[2]) - ).astype(float), - batch_size=bsize - ) - out[out >= 0.5] = 1 - out[out < 0.5] = 0 - out = out.reshape(tile_size, tile_size) # reshape to tile size - seg[i:i + tile_size, j:j + tile_size] = out - return seg - - -def pad_image(img, target_size): - """ - Pad an image up to the target size. - """ - rows_missing = target_size - img.shape[0] - cols_missing = target_size - img.shape[1] - padded_img = np.pad( - img, ((0, rows_missing), (0, cols_missing), (0, 0)), 'constant' - ) - return padded_img - - -def predict_sliding(image, model='', stand_method='local', - stand_strategy='per-batch', stand_data=[], - tile_size=256, nclasses=6, overlap=0.25, spline=[] - ): - """ - Predict on tiles of exactly the network input shape. - This way nothing gets squeezed. - """ - model.eval() - stride = math.ceil(tile_size * (1 - overlap)) - tile_rows = max( - int(math.ceil((image.shape[0] - tile_size) / stride) + 1), 1 - ) # strided convolution formula - tile_cols = max( - int(math.ceil((image.shape[1] - tile_size) / stride) + 1), 1 - ) - logging.info("Need %i x %i prediction tiles @ stride %i px" % - (tile_cols, tile_rows, stride) - ) - - full_probs = np.zeros((image.shape[0], image.shape[1], nclasses)) - count_predictions = np.zeros((image.shape[0], image.shape[1], nclasses)) - tile_counter = 0 - for row in range(tile_rows): - for col in range(tile_cols): - x1 = int(col * stride) - y1 = int(row * stride) - x2 = min(x1 + tile_size, image.shape[1]) - y2 = min(y1 + tile_size, image.shape[0]) - x1 = max(int(x2 - tile_size), 0) - y1 = max(int(y2 - tile_size), 0) - - img = image[y1:y2, x1:x2] - padded_img = pad_image(img, tile_size) - tile_counter += 1 - - padded_img = np.expand_dims(padded_img, 0) - - if stand_method == 'local': - imgn = local_standardization( - padded_img, ndata=stand_data, strategy=stand_strategy - ) - elif stand_method == 'global': - imgn = global_standardization( - padded_img, strategy=stand_strategy - ) - else: - imgn = padded_img - - imgn = imgn.astype('float32') - imgn_tensor = torch.from_numpy(imgn) - imgn_tensor = imgn_tensor.transpose(-1, 1) - with torch.no_grad(): - padded_prediction = model(imgn_tensor) - # if padded_prediction.shape[1] > 1: - # padded_prediction = np.argmax(padded_prediction, axis=1) - padded_prediction = np.squeeze(padded_prediction) - padded_prediction = padded_prediction.transpose(0, -1).numpy() - prediction = padded_prediction[0:img.shape[0], 0:img.shape[1], :] - count_predictions[y1:y2, x1:x2] += 1 - full_probs[y1:y2, x1:x2] += prediction # * spline - # average the predictions in the overlapping regions - full_probs /= count_predictions - return full_probs - - -def predict_sliding_binary(image, model='model.h5', tile_size=256, - nclasses=6, overlap=1/3, norm_data=[] - ): - """ - Predict on tiles of exactly the network input shape. - This way nothing gets squeezed. - """ - stride = math.ceil(tile_size * (1 - overlap)) - tile_rows = max( - int(math.ceil((image.shape[0] - tile_size) / stride) + 1), 1 - ) # strided convolution formula - tile_cols = max( - int(math.ceil((image.shape[1] - tile_size) / stride) + 1), 1 - ) - logging.info("Need %i x %i prediction tiles @ stride %i px" % - (tile_cols, tile_rows, stride) - ) - full_probs = np.zeros((image.shape[0], image.shape[1], nclasses)) - count_predictions = np.zeros((image.shape[0], image.shape[1], nclasses)) - tile_counter = 0 - for row in range(tile_rows): - for col in range(tile_cols): - x1 = int(col * stride) - y1 = int(row * stride) - x2 = min(x1 + tile_size, image.shape[1]) - y2 = min(y1 + tile_size, image.shape[0]) - x1 = max(int(x2 - tile_size), 0) - y1 = max(int(y2 - tile_size), 0) - - img = image[y1:y2, x1:x2] - padded_img = pad_image(img, tile_size) - tile_counter += 1 - - imgn = normalize(padded_img, norm_data) - imgn = imgn.astype('float32') - padded_prediction = model.predict(np.expand_dims(imgn, 0))[0] - prediction = padded_prediction[0:img.shape[0], 0:img.shape[1], :] - count_predictions[y1:y2, x1:x2] += 1 - full_probs[y1:y2, x1:x2] += prediction - # average the predictions in the overlapping regions - full_probs /= count_predictions - full_probs[full_probs >= 0.8] = 1 - full_probs[full_probs < 0.8] = 0 - return full_probs.reshape((image.shape[0], image.shape[1])) - - -def predict_windowing(x, model, stand_method='local', - stand_strategy='per-batch', stand_data=[], - patch_sz=160, n_classes=5, b_size=128, spline=[] - ): - img_height = x.shape[0] - img_width = x.shape[1] - n_channels = x.shape[2] - # make extended img so that it contains integer number of patches - npatches_vertical = math.ceil(img_height / patch_sz) - npatches_horizontal = math.ceil(img_width / patch_sz) - extended_height = patch_sz * npatches_vertical - extended_width = patch_sz * npatches_horizontal - ext_x = np.zeros( - shape=(extended_height, extended_width, n_channels), dtype=np.float32 - ) - # fill extended image with mirrors: - ext_x[:img_height, :img_width, :] = x - for i in range(img_height, extended_height): - ext_x[i, :, :] = ext_x[2 * img_height - i - 1, :, :] - for j in range(img_width, extended_width): - ext_x[:, j, :] = ext_x[:, 2 * img_width - j - 1, :] - - # now we assemble all patches in one array - patches_list = [] - for i in range(0, npatches_vertical): - for j in range(0, npatches_horizontal): - x0, x1 = i * patch_sz, (i + 1) * patch_sz - y0, y1 = j * patch_sz, (j + 1) * patch_sz - patches_list.append(ext_x[x0:x1, y0:y1, :]) - patches_array = np.asarray(patches_list) - - # normalization(patches_array, ndata) - - if stand_method == 'local': # apply local zero center standardization - patches_array = local_standardization( - patches_array, ndata=stand_data, strategy=stand_strategy - ) - elif stand_method == 'global': # apply global zero center standardization - patches_array = global_standardization( - patches_array, strategy=stand_strategy - ) - - # predictions: - patches_predict = model.predict(patches_array, batch_size=b_size) - prediction = np.zeros( - shape=(extended_height, extended_width, n_classes), dtype=np.float32 - ) - logging.info("prediction shape: ", prediction.shape) - for k in range(patches_predict.shape[0]): - i = k // npatches_horizontal - j = k % npatches_horizontal - x0, x1 = i * patch_sz, (i + 1) * patch_sz - y0, y1 = j * patch_sz, (j + 1) * patch_sz - prediction[x0:x1, y0:y1, :] = patches_predict[k, :, :, :] * spline - return prediction[:img_height, :img_width, :] - - -# ------------------------------------------------------------------------------- -# module model Unit Tests -# ------------------------------------------------------------------------------- - -if __name__ == "__main__": - - logging.basicConfig(level=logging.INFO) - - # Add unit tests here diff --git a/pytorch_caney/loss/build.py b/pytorch_caney/loss/build.py deleted file mode 100644 index aa1cc16..0000000 --- a/pytorch_caney/loss/build.py +++ /dev/null @@ -1,64 +0,0 @@ -from segmentation_models_pytorch.losses import TverskyLoss - - -LOSSES = { - 'tversky': TverskyLoss, -} - - -def get_loss_from_dict(loss_name, config): - """Gets the proper loss given a loss name. - - Args: - loss_name (str): name of the loss - config: config object - - Raises: - KeyError: thrown if loss key is not present in dict - - Returns: - loss: pytorch loss - """ - - try: - - loss_to_use = LOSSES[loss_name] - - except KeyError: - - error_msg = f"{loss_name} is not an implemented loss" - - error_msg = f"{error_msg}. Available loss functions: {LOSSES.keys()}" - - raise KeyError(error_msg) - - if loss_name == 'tversky': - loss = loss_to_use(mode=config.LOSS.MODE, - classes=config.LOSS.CLASSES, - log_loss=config.LOSS.LOG, - from_logits=config.LOSS.LOGITS, - smooth=config.LOSS.SMOOTH, - ignore_index=config.LOSS.IGNORE_INDEX, - eps=config.LOSS.EPS, - alpha=config.LOSS.ALPHA, - beta=config.LOSS.BETA, - gamma=config.LOSS.GAMMA) - return loss - - -def build_loss(config): - """ - Builds the loss function given a configuration object. - - Args: - config: config object - - Returns: - loss_to_use: pytorch loss function - """ - - loss_name = config.LOSS.NAME - - loss_to_use = get_loss_from_dict(loss_name, config) - - return loss_to_use diff --git a/pytorch_caney/loss/utils.py b/pytorch_caney/loss/utils.py deleted file mode 100755 index 4319803..0000000 --- a/pytorch_caney/loss/utils.py +++ /dev/null @@ -1,26 +0,0 @@ -import numpy as np - -import torch - - -# --- -# Adapted from -# https://github.com/qubvel/segmentation_models.pytorch \ -# /tree/master/segmentation_models_pytorch/losses -# --- -def to_tensor(x, dtype=None) -> torch.Tensor: - if isinstance(x, torch.Tensor): - if dtype is not None: - x = x.type(dtype) - return x - if isinstance(x, np.ndarray): - x = torch.from_numpy(x) - if dtype is not None: - x = x.type(dtype) - return x - if isinstance(x, (list, tuple)): - x = np.array(x) - x = torch.from_numpy(x) - if dtype is not None: - x = x.type(dtype) - return x diff --git a/pytorch_caney/lr_scheduler.py b/pytorch_caney/lr_scheduler.py deleted file mode 100644 index cd693c9..0000000 --- a/pytorch_caney/lr_scheduler.py +++ /dev/null @@ -1,185 +0,0 @@ -from bisect import bisect_right - -from timm.scheduler.cosine_lr import CosineLRScheduler -from timm.scheduler.step_lr import StepLRScheduler -from timm.scheduler.scheduler import Scheduler - -import torch -import torch.distributed as dist - - -def build_scheduler(config, optimizer, n_iter_per_epoch): - num_steps = int(config.TRAIN.EPOCHS * n_iter_per_epoch) - warmup_steps = int(config.TRAIN.WARMUP_EPOCHS * n_iter_per_epoch) - decay_steps = int( - config.TRAIN.LR_SCHEDULER.DECAY_EPOCHS * n_iter_per_epoch) - multi_steps = [ - i * n_iter_per_epoch for i in config.TRAIN.LR_SCHEDULER.MULTISTEPS] - - lr_scheduler = None - if config.TRAIN.LR_SCHEDULER.NAME == 'cosine': - lr_scheduler = CosineLRScheduler( - optimizer, - t_initial=num_steps, - cycle_mul=1., - lr_min=config.TRAIN.MIN_LR, - warmup_lr_init=config.TRAIN.WARMUP_LR, - warmup_t=warmup_steps, - cycle_limit=1, - t_in_epochs=False, - ) - elif config.TRAIN.LR_SCHEDULER.NAME == 'linear': - lr_scheduler = LinearLRScheduler( - optimizer, - t_initial=num_steps, - lr_min_rate=0.01, - warmup_lr_init=config.TRAIN.WARMUP_LR, - warmup_t=warmup_steps, - t_in_epochs=False, - ) - elif config.TRAIN.LR_SCHEDULER.NAME == 'step': - lr_scheduler = StepLRScheduler( - optimizer, - decay_t=decay_steps, - decay_rate=config.TRAIN.LR_SCHEDULER.DECAY_RATE, - warmup_lr_init=config.TRAIN.WARMUP_LR, - warmup_t=warmup_steps, - t_in_epochs=False, - ) - elif config.TRAIN.LR_SCHEDULER.NAME == 'multistep': - lr_scheduler = MultiStepLRScheduler( - optimizer, - milestones=multi_steps, - gamma=config.TRAIN.LR_SCHEDULER.GAMMA, - warmup_lr_init=config.TRAIN.WARMUP_LR, - warmup_t=warmup_steps, - t_in_epochs=False, - ) - - return lr_scheduler - - -class LinearLRScheduler(Scheduler): - def __init__(self, - optimizer: torch.optim.Optimizer, - t_initial: int, - lr_min_rate: float, - warmup_t=0, - warmup_lr_init=0., - t_in_epochs=True, - noise_range_t=None, - noise_pct=0.67, - noise_std=1.0, - noise_seed=42, - initialize=True, - ) -> None: - super().__init__( - optimizer, param_group_field="lr", - noise_range_t=noise_range_t, noise_pct=noise_pct, - noise_std=noise_std, noise_seed=noise_seed, - initialize=initialize) - - self.t_initial = t_initial - self.lr_min_rate = lr_min_rate - self.warmup_t = warmup_t - self.warmup_lr_init = warmup_lr_init - self.t_in_epochs = t_in_epochs - if self.warmup_t: - self.warmup_steps = [(v - warmup_lr_init) / - self.warmup_t for v in self.base_values] - super().update_groups(self.warmup_lr_init) - else: - self.warmup_steps = [1 for _ in self.base_values] - - def _get_lr(self, t): - if t < self.warmup_t: - lrs = [self.warmup_lr_init + t * s for s in self.warmup_steps] - else: - t = t - self.warmup_t - total_t = self.t_initial - self.warmup_t - lrs = [v - ((v - v * self.lr_min_rate) * (t / total_t)) - for v in self.base_values] - return lrs - - def get_epoch_values(self, epoch: int): - if self.t_in_epochs: - return self._get_lr(epoch) - else: - return None - - def get_update_values(self, num_updates: int): - if not self.t_in_epochs: - return self._get_lr(num_updates) - else: - return None - - -class MultiStepLRScheduler(Scheduler): - def __init__(self, optimizer: torch.optim.Optimizer, - milestones, gamma=0.1, warmup_t=0, - warmup_lr_init=0, t_in_epochs=True) -> None: - super().__init__(optimizer, param_group_field="lr") - - self.milestones = milestones - self.gamma = gamma - self.warmup_t = warmup_t - self.warmup_lr_init = warmup_lr_init - self.t_in_epochs = t_in_epochs - if self.warmup_t: - self.warmup_steps = [(v - warmup_lr_init) / - self.warmup_t for v in self.base_values] - super().update_groups(self.warmup_lr_init) - else: - self.warmup_steps = [1 for _ in self.base_values] - - assert self.warmup_t <= min(self.milestones) - - def _get_lr(self, t): - if t < self.warmup_t: - lrs = [self.warmup_lr_init + t * s for s in self.warmup_steps] - else: - lrs = [v * (self.gamma ** bisect_right(self.milestones, t)) - for v in self.base_values] - return lrs - - def get_epoch_values(self, epoch: int): - if self.t_in_epochs: - return self._get_lr(epoch) - else: - return None - - def get_update_values(self, num_updates: int): - if not self.t_in_epochs: - return self._get_lr(num_updates) - else: - return None - - -def setup_scaled_lr(config): - # linear scale the learning rate according to total batch size, - # may not be optimal - - batch_size = config.DATA.BATCH_SIZE - - world_size = dist.get_world_size() - - denom_const = 512.0 - - accumulation_steps = config.TRAIN.ACCUMULATION_STEPS - - linear_scaled_lr = config.TRAIN.BASE_LR * \ - batch_size * world_size / denom_const - - linear_scaled_warmup_lr = config.TRAIN.WARMUP_LR * \ - batch_size * world_size / denom_const - - linear_scaled_min_lr = config.TRAIN.MIN_LR * \ - batch_size * world_size / denom_const - - # gradient accumulation also need to scale the learning rate - if accumulation_steps > 1: - linear_scaled_lr = linear_scaled_lr * accumulation_steps - linear_scaled_warmup_lr = linear_scaled_warmup_lr * accumulation_steps - linear_scaled_min_lr = linear_scaled_min_lr * accumulation_steps - - return linear_scaled_lr, linear_scaled_warmup_lr, linear_scaled_min_lr diff --git a/pytorch_caney/metrics.py b/pytorch_caney/metrics.py deleted file mode 100755 index 4679464..0000000 --- a/pytorch_caney/metrics.py +++ /dev/null @@ -1,80 +0,0 @@ -import logging -from typing import List - -import torch -import numpy as np -from sklearn.metrics import accuracy_score -from sklearn.metrics import precision_score -from sklearn.metrics import recall_score - -__author__ = "Jordan A Caraballo-Vega, Science Data Processing Branch" -__email__ = "jordan.a.caraballo-vega@nasa.gov" -__status__ = "Production" - -# --------------------------------------------------------------------------- -# module metrics -# -# General functions to compute custom metrics. -# --------------------------------------------------------------------------- - -# --------------------------------------------------------------------------- -# Module Methods -# --------------------------------------------------------------------------- - -EPSILON = 1e-15 - - -# ------------------------------ Metric Functions -------------------------- # - -def iou_val(y_true, y_pred): - intersection = np.logical_and(y_true, y_pred) - union = np.logical_or(y_true, y_pred) - iou_score = np.sum(intersection) / np.sum(union) - return iou_score - - -def acc_val(y_true, y_pred): - return accuracy_score(y_true, y_pred) - - -def prec_val(y_true, y_pred): - return precision_score(y_true, y_pred, average='macro'), \ - precision_score(y_true, y_pred, average=None) - - -def recall_val(y_true, y_pred): - return recall_score(y_true, y_pred, average='macro'), \ - recall_score(y_true, y_pred, average=None) - - -def find_average(outputs: List, name: str) -> torch.Tensor: - if len(outputs[0][name].shape) == 0: - return torch.stack([x[name] for x in outputs]).mean() - return torch.cat([x[name] for x in outputs]).mean() - - -def binary_mean_iou( - logits: torch.Tensor, - targets: torch.Tensor - ) -> torch.Tensor: - - output = (logits > 0).int() - - if output.shape != targets.shape: - targets = torch.squeeze(targets, 1) - - intersection = (targets * output).sum() - - union = targets.sum() + output.sum() - intersection - - result = (intersection + EPSILON) / (union + EPSILON) - - return result - - -# ------------------------------------------------------------------------------- -# module metrics Unit Tests -# ------------------------------------------------------------------------------- -if __name__ == "__main__": - - logging.basicConfig(level=logging.INFO) diff --git a/pytorch_caney/models/__init__.py b/pytorch_caney/models/__init__.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/models/build.py b/pytorch_caney/models/build.py deleted file mode 100644 index 9ffc47c..0000000 --- a/pytorch_caney/models/build.py +++ /dev/null @@ -1,105 +0,0 @@ -from .swinv2_model import SwinTransformerV2 -from .unet_swin_model import unet_swin -from .mim.mim import build_mim_model -from ..training.mim_utils import load_pretrained - -import logging - - -def build_model(config, - pretrain: bool = False, - pretrain_method: str = 'mim', - logger: logging.Logger = None): - """ - Given a config object, builds a pytorch model. - - Returns: - model: built model - """ - - if pretrain: - - if pretrain_method == 'mim': - model = build_mim_model(config) - return model - - encoder_architecture = config.MODEL.TYPE - decoder_architecture = config.MODEL.DECODER - - if encoder_architecture == 'swinv2': - - logger.info(f'Hit encoder only build, building {encoder_architecture}') - - window_sizes = config.MODEL.SWINV2.PRETRAINED_WINDOW_SIZES - - model = SwinTransformerV2( - img_size=config.DATA.IMG_SIZE, - patch_size=config.MODEL.SWINV2.PATCH_SIZE, - in_chans=config.MODEL.SWINV2.IN_CHANS, - num_classes=config.MODEL.NUM_CLASSES, - embed_dim=config.MODEL.SWINV2.EMBED_DIM, - depths=config.MODEL.SWINV2.DEPTHS, - num_heads=config.MODEL.SWINV2.NUM_HEADS, - window_size=config.MODEL.SWINV2.WINDOW_SIZE, - mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, - qkv_bias=config.MODEL.SWINV2.QKV_BIAS, - drop_rate=config.MODEL.DROP_RATE, - drop_path_rate=config.MODEL.DROP_PATH_RATE, - ape=config.MODEL.SWINV2.APE, - patch_norm=config.MODEL.SWINV2.PATCH_NORM, - use_checkpoint=config.TRAIN.USE_CHECKPOINT, - pretrained_window_sizes=window_sizes) - - if config.MODEL.PRETRAINED and (not config.MODEL.RESUME): - load_pretrained(config, model, logger) - - else: - - errorMsg = f'Unknown encoder architecture {encoder_architecture}' - - logger.error(errorMsg) - - raise NotImplementedError(errorMsg) - - if decoder_architecture is not None: - - if encoder_architecture == 'swinv2': - - window_sizes = config.MODEL.SWINV2.PRETRAINED_WINDOW_SIZES - - model = SwinTransformerV2( - img_size=config.DATA.IMG_SIZE, - patch_size=config.MODEL.SWINV2.PATCH_SIZE, - in_chans=config.MODEL.SWINV2.IN_CHANS, - num_classes=config.MODEL.NUM_CLASSES, - embed_dim=config.MODEL.SWINV2.EMBED_DIM, - depths=config.MODEL.SWINV2.DEPTHS, - num_heads=config.MODEL.SWINV2.NUM_HEADS, - window_size=config.MODEL.SWINV2.WINDOW_SIZE, - mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, - qkv_bias=config.MODEL.SWINV2.QKV_BIAS, - drop_rate=config.MODEL.DROP_RATE, - drop_path_rate=config.MODEL.DROP_PATH_RATE, - ape=config.MODEL.SWINV2.APE, - patch_norm=config.MODEL.SWINV2.PATCH_NORM, - use_checkpoint=config.TRAIN.USE_CHECKPOINT, - pretrained_window_sizes=window_sizes) - - else: - - raise NotImplementedError() - - if decoder_architecture == 'unet': - - num_classes = config.MODEL.NUM_CLASSES - - if config.MODEL.PRETRAINED and (not config.MODEL.RESUME): - load_pretrained(config, model, logger) - - model = unet_swin(encoder=model, num_classes=num_classes) - - else: - error_msg = f'Unknown decoder architecture: {decoder_architecture}' - raise NotImplementedError(error_msg) - - return model diff --git a/pytorch_caney/models/decoders/unet_decoder.py b/pytorch_caney/models/decoders/unet_decoder.py deleted file mode 100644 index b55fcb3..0000000 --- a/pytorch_caney/models/decoders/unet_decoder.py +++ /dev/null @@ -1,181 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F - -from segmentation_models_pytorch.base import modules as md - - -class DecoderBlock(nn.Module): - def __init__( - self, - in_channels, - skip_channels, - out_channels, - use_batchnorm=True, - attention_type=None, - ): - super().__init__() - - self.conv1 = md.Conv2dReLU( - in_channels + skip_channels, - out_channels, - kernel_size=3, - padding=1, - use_batchnorm=use_batchnorm, - ) - - in_and_skip_channels = in_channels + skip_channels - - self.attention1 = md.Attention(attention_type, - in_channels=in_and_skip_channels) - - self.conv2 = md.Conv2dReLU( - out_channels, - out_channels, - kernel_size=3, - padding=1, - use_batchnorm=use_batchnorm, - ) - - self.attention2 = md.Attention(attention_type, - in_channels=out_channels) - - self.in_channels = in_channels - self.out_channels = out_channels - self.skip_channels = skip_channels - - def forward(self, x, skip=None): - - if skip is None: - x = F.interpolate(x, scale_factor=2, mode="nearest") - - else: - - if x.shape[-1] != skip.shape[-1]: - x = F.interpolate(x, scale_factor=2, mode="nearest") - - if skip is not None: - - x = torch.cat([x, skip], dim=1) - x = self.attention1(x) - - x = self.conv1(x) - x = self.conv2(x) - x = self.attention2(x) - - return x - - -class CenterBlock(nn.Sequential): - def __init__(self, in_channels, out_channels, use_batchnorm=True): - conv1 = md.Conv2dReLU( - in_channels, - out_channels, - kernel_size=3, - padding=1, - use_batchnorm=use_batchnorm, - ) - conv2 = md.Conv2dReLU( - out_channels, - out_channels, - kernel_size=3, - padding=1, - use_batchnorm=use_batchnorm, - ) - super().__init__(conv1, conv2) - - -class UnetDecoder(nn.Module): - def __init__(self, - encoder_channels, - decoder_channels, - n_blocks=5, - use_batchnorm=True, - attention_type=None, - center=False): - super().__init__() - - if n_blocks != len(decoder_channels): - raise ValueError( - f"Model depth is {n_blocks}, but you provided " - f"decoder_channels for {len(decoder_channels)} blocks." - ) - - # remove first skip with same spatial resolution - encoder_channels = encoder_channels[1:] - - # reverse channels to start from head of encoder - encoder_channels = encoder_channels[::-1] - - # computing blocks input and output channels - head_channels = encoder_channels[0] - - in_channels = [head_channels] + list(decoder_channels[:-1]) - - skip_channels = list(encoder_channels[1:]) + [0] - - out_channels = decoder_channels - - if center: - - self.center = CenterBlock( - head_channels, head_channels, use_batchnorm=use_batchnorm) - - else: - - self.center = nn.Identity() - - # combine decoder keyword arguments - kwargs = dict(use_batchnorm=use_batchnorm, - attention_type=attention_type) - - blocks = [ - DecoderBlock(in_ch, skip_ch, out_ch, **kwargs) - for in_ch, skip_ch, out_ch in zip(in_channels, - skip_channels, - out_channels) - ] - - self.blocks = nn.ModuleList(blocks) - - def forward(self, *features): - - features = features[1:] - - # remove first skip with same spatial resolution - - features = features[:: -1] - # reverse channels to start from head of encoder - - head = features[0] - - skips = features[1:] - - x = self.center(head) - - for i, decoder_block in enumerate(self.blocks): - - skip = skips[i] if i < len(skips) else None - - x = decoder_block(x, skip) - - return x - - -class SegmentationHead(nn.Sequential): - - def __init__(self, - in_channels, - out_channels, - kernel_size=3, - upsampling=1): - - conv2d = nn.Conv2d(in_channels, - out_channels, - kernel_size=kernel_size, - padding=kernel_size // 2) - - upsampling = nn.UpsamplingBilinear2d( - scale_factor=upsampling) if upsampling > 1 else nn.Identity() - - super().__init__(conv2d, upsampling) diff --git a/pytorch_caney/models/maskrcnn_model.py b/pytorch_caney/models/maskrcnn_model.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/models/mim/__init__.py b/pytorch_caney/models/mim/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/pytorch_caney/models/mim/mim.py b/pytorch_caney/models/mim/mim.py deleted file mode 100644 index aaf69c7..0000000 --- a/pytorch_caney/models/mim/mim.py +++ /dev/null @@ -1,139 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -from timm.models.layers import trunc_normal_ - -from ..swinv2_model import SwinTransformerV2 - - -class SwinTransformerV2ForSimMIM(SwinTransformerV2): - def __init__(self, **kwargs): - super().__init__(**kwargs) - - assert self.num_classes == 0 - - self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim)) - trunc_normal_(self.mask_token, mean=0., std=.02) - - def forward(self, x, mask): - x = self.patch_embed(x) - - assert mask is not None - B, L, _ = x.shape - - mask_tokens = self.mask_token.expand(B, L, -1) - w = mask.flatten(1).unsqueeze(-1).type_as(mask_tokens) - x = x * (1. - w) + mask_tokens * w - - if self.ape: - x = x + self.absolute_pos_embed - x = self.pos_drop(x) - - for layer in self.layers: - x = layer(x) - x = self.norm(x) - - x = x.transpose(1, 2) - B, C, L = x.shape - H = W = int(L ** 0.5) - x = x.reshape(B, C, H, W) - return x - - @torch.jit.ignore - def no_weight_decay(self): - return super().no_weight_decay() | {'mask_token'} - - -class MiMModel(nn.Module): - """ - Masked-Image-Modeling model - - Given an encoder, makes a model that incorporates - the encoder and attaches a simple linear layer that - produces the raw-pixel predictions of the masked - inputs. - """ - def __init__(self, encoder, encoder_stride, in_chans, patch_size): - super().__init__() - self.encoder = encoder - self.encoder_stride = encoder_stride - self.in_chans = in_chans - self.patch_size = patch_size - self.decoder = nn.Sequential( - nn.Conv2d( - in_channels=self.encoder.num_features, - out_channels=self.encoder_stride ** 2 * self.in_chans, - kernel_size=1), - nn.PixelShuffle(self.encoder_stride), - ) - - # self.in_chans = self.encoder.in_chans - # self.patch_size = self.encoder.patch_size - - def forward(self, x, mask): - z = self.encoder(x, mask) - x_rec = self.decoder(z) - - mask = mask.repeat_interleave(self.patch_size, 1).repeat_interleave( - self.patch_size, 2).unsqueeze(1).contiguous() - loss_recon = F.l1_loss(x, x_rec, reduction='none') - loss = (loss_recon * mask).sum() / (mask.sum() + 1e-5) / self.in_chans - return loss - - @torch.jit.ignore - def no_weight_decay(self): - if hasattr(self.encoder, 'no_weight_decay'): - return {'encoder.' + i for i in self.encoder.no_weight_decay()} - return {} - - @torch.jit.ignore - def no_weight_decay_keywords(self): - if hasattr(self.encoder, 'no_weight_decay_keywords'): - return {'encoder.' + i for i in - self.encoder.no_weight_decay_keywords()} - return {} - - -def build_mim_model(config): - """Builds the masked-image-modeling model. - - Args: - config: config object - - Raises: - NotImplementedError: if the model is - not swinv2, then this will be thrown. - - Returns: - MiMModel: masked-image-modeling model - """ - model_type = config.MODEL.TYPE - if model_type == 'swinv2': - encoder = SwinTransformerV2ForSimMIM( - img_size=config.DATA.IMG_SIZE, - patch_size=config.MODEL.SWINV2.PATCH_SIZE, - in_chans=config.MODEL.SWINV2.IN_CHANS, - num_classes=0, - embed_dim=config.MODEL.SWINV2.EMBED_DIM, - depths=config.MODEL.SWINV2.DEPTHS, - num_heads=config.MODEL.SWINV2.NUM_HEADS, - window_size=config.MODEL.SWINV2.WINDOW_SIZE, - mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, - qkv_bias=config.MODEL.SWINV2.QKV_BIAS, - drop_rate=config.MODEL.DROP_RATE, - drop_path_rate=config.MODEL.DROP_PATH_RATE, - ape=config.MODEL.SWINV2.APE, - patch_norm=config.MODEL.SWINV2.PATCH_NORM, - use_checkpoint=config.TRAIN.USE_CHECKPOINT, - extra_norm_period=config.MODEL.SWINV2.NORM_PERIOD, - extra_norm_stage=config.MODEL.SWINV2.NORM_STAGE) - encoder_stride = 32 - in_chans = config.MODEL.SWINV2.IN_CHANS - patch_size = config.MODEL.SWINV2.PATCH_SIZE - else: - raise NotImplementedError(f"Unknown pre-train model: {model_type}") - - model = MiMModel(encoder=encoder, encoder_stride=encoder_stride, - in_chans=in_chans, patch_size=patch_size) - - return model diff --git a/pytorch_caney/models/simmim/__init__.py b/pytorch_caney/models/simmim/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/pytorch_caney/models/simmim/simmim.py b/pytorch_caney/models/simmim/simmim.py deleted file mode 100644 index b13cfca..0000000 --- a/pytorch_caney/models/simmim/simmim.py +++ /dev/null @@ -1,117 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -from timm.models.layers import trunc_normal_ - -from ..swinv2_model import SwinTransformerV2 - - -class SwinTransformerV2ForSimMIM(SwinTransformerV2): - def __init__(self, **kwargs): - super().__init__(**kwargs) - - assert self.num_classes == 0 - - self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim)) - trunc_normal_(self.mask_token, mean=0., std=.02) - - def forward(self, x, mask): - x = self.patch_embed(x) - - assert mask is not None - B, L, _ = x.shape - - mask_tokens = self.mask_token.expand(B, L, -1) - w = mask.flatten(1).unsqueeze(-1).type_as(mask_tokens) - x = x * (1. - w) + mask_tokens * w - - if self.ape: - x = x + self.absolute_pos_embed - x = self.pos_drop(x) - - for layer in self.layers: - x = layer(x) - x = self.norm(x) - - x = x.transpose(1, 2) - B, C, L = x.shape - H = W = int(L ** 0.5) - x = x.reshape(B, C, H, W) - return x - - @torch.jit.ignore - def no_weight_decay(self): - return super().no_weight_decay() | {'mask_token'} - - -class MiMModel(nn.Module): - def __init__(self, encoder, encoder_stride, in_chans, patch_size): - super().__init__() - self.encoder = encoder - self.encoder_stride = encoder_stride - self.in_chans = in_chans - self.patch_size = patch_size - self.decoder = nn.Sequential( - nn.Conv2d( - in_channels=self.encoder.num_features, - out_channels=self.encoder_stride ** 2 * self.in_chans, - kernel_size=1), - nn.PixelShuffle(self.encoder_stride), - ) - - # self.in_chans = self.encoder.in_chans - # self.patch_size = self.encoder.patch_size - - def forward(self, x, mask): - z = self.encoder(x, mask) - x_rec = self.decoder(z) - - mask = mask.repeat_interleave(self.patch_size, 1).repeat_interleave( - self.patch_size, 2).unsqueeze(1).contiguous() - loss_recon = F.l1_loss(x, x_rec, reduction='none') - loss = (loss_recon * mask).sum() / (mask.sum() + 1e-5) / self.in_chans - return loss - - @torch.jit.ignore - def no_weight_decay(self): - if hasattr(self.encoder, 'no_weight_decay'): - return {'encoder.' + i for i in self.encoder.no_weight_decay()} - return {} - - @torch.jit.ignore - def no_weight_decay_keywords(self): - if hasattr(self.encoder, 'no_weight_decay_keywords'): - return {'encoder.' + i for i in - self.encoder.no_weight_decay_keywords()} - return {} - - -def build_mim_model(config): - model_type = config.MODEL.TYPE - if model_type == 'swinv2': - encoder = SwinTransformerV2ForSimMIM( - img_size=config.DATA.IMG_SIZE, - patch_size=config.MODEL.SWINV2.PATCH_SIZE, - in_chans=config.MODEL.SWINV2.IN_CHANS, - num_classes=0, - embed_dim=config.MODEL.SWINV2.EMBED_DIM, - depths=config.MODEL.SWINV2.DEPTHS, - num_heads=config.MODEL.SWINV2.NUM_HEADS, - window_size=config.MODEL.SWINV2.WINDOW_SIZE, - mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, - qkv_bias=config.MODEL.SWINV2.QKV_BIAS, - drop_rate=config.MODEL.DROP_RATE, - drop_path_rate=config.MODEL.DROP_PATH_RATE, - ape=config.MODEL.SWINV2.APE, - patch_norm=config.MODEL.SWINV2.PATCH_NORM, - use_checkpoint=config.TRAIN.USE_CHECKPOINT) - encoder_stride = 32 - in_chans = config.MODEL.SWINV2.IN_CHANS - patch_size = config.MODEL.SWINV2.PATCH_SIZE - else: - raise NotImplementedError(f"Unknown pre-train model: {model_type}") - - model = MiMModel(encoder=encoder, encoder_stride=encoder_stride, - in_chans=in_chans, patch_size=patch_size) - - return model diff --git a/pytorch_caney/models/swinv2_model.py b/pytorch_caney/models/swinv2_model.py deleted file mode 100644 index 2ec866c..0000000 --- a/pytorch_caney/models/swinv2_model.py +++ /dev/null @@ -1,595 +0,0 @@ -import torch -import torch.nn as nn -import torch.utils.checkpoint as checkpoint -from timm.models.layers import DropPath, to_2tuple, trunc_normal_ - - -from pytorch_caney.network.mlp import Mlp -from pytorch_caney.network.attention import WindowAttention - - -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 SwinTransformerBlock(nn.Module): - r""" Swin Transformer Block. - - Args: - dim (int): Number of input channels. - input_resolution (tuple[int]): Input resulotion. - 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 - 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 - pretrained_window_size (int): Window size in pre-training. - """ - - def __init__(self, dim, input_resolution, num_heads, - window_size=7, shift_size=0, mlp_ratio=4., - qkv_bias=True, drop=0., attn_drop=0., drop_path=0., - act_layer=nn.GELU, norm_layer=nn.LayerNorm, - pretrained_window_size=0, extra_norm=False): - super().__init__() - self.dim = dim - self.input_resolution = input_resolution - self.num_heads = num_heads - self.window_size = window_size - self.shift_size = shift_size - self.mlp_ratio = mlp_ratio - if min(self.input_resolution) <= self.window_size: - # if window size is larger than input resolution, - # we don't partition windows - self.shift_size = 0 - self.window_size = min(self.input_resolution) - - 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, attn_drop=attn_drop, proj_drop=drop, - pretrained_window_size=to_2tuple(pretrained_window_size)) - - self.drop_path = DropPath( - drop_path) if drop_path > 0. else nn.Identity() - self.norm2 = norm_layer(dim) - - self.norm3 = norm_layer(dim) if extra_norm else nn.Identity() - mlp_hidden_dim = int(dim * mlp_ratio) - self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, - act_layer=act_layer, drop=drop) - - if self.shift_size > 0: - # calculate attention mask for SW-MSA - H, W = self.input_resolution - img_mask = torch.zeros((1, H, W, 1)) # 1 H W 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 - - # nW, window_size, window_size, 1 - mask_windows = window_partition(img_mask, self.window_size) - 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)) - else: - attn_mask = None - - self.register_buffer("attn_mask", attn_mask) - - def forward(self, x): - H, W = self.input_resolution - B, L, C = x.shape - assert L == H * W, "input feature has wrong size" - - shortcut = x - x = x.view(B, H, W, C) - - # cyclic shift - if self.shift_size > 0: - shifted_x = torch.roll( - x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) - else: - shifted_x = x - - # partition windows - # nW*B, window_size, window_size, C - 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) - - # W-MSA/SW-MSA - # nW*B, window_size*window_size, C - attn_windows = self.attn(x_windows, mask=self.attn_mask) - - # merge windows - attn_windows = attn_windows.view(-1, - self.window_size, self.window_size, C) - shifted_x = window_reverse( - attn_windows, self.window_size, H, W) # 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 - x = x.view(B, H * W, C) - x = shortcut + self.drop_path(self.norm1(x)) - - # FFN - x = x + self.drop_path(self.norm2(self.mlp(x))) - - x = self.norm3(x) - - return x - - def extra_repr(self) -> str: - return f"dim={self.dim}, input_resolution={self.input_resolution}," \ - f"num_heads={self.num_heads}, " \ - f"window_size={self.window_size}, " \ - f"shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}" - - def flops(self): - flops = 0 - H, W = self.input_resolution - # norm1 - flops += self.dim * H * W - # W-MSA/SW-MSA - nW = H * W / self.window_size / self.window_size - flops += nW * self.attn.flops(self.window_size * self.window_size) - # mlp - flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio - # norm2 - flops += self.dim * H * W - return flops - - -class PatchMerging(nn.Module): - r""" Patch Merging Layer. - - Args: - input_resolution (tuple[int]): Resolution of input feature. - dim (int): Number of input channels. - norm_layer (nn.Module, optional): Normalization layer. - Default: nn.LayerNorm - """ - - def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm): - super().__init__() - self.input_resolution = input_resolution - self.dim = dim - self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False) - self.norm = norm_layer(2 * dim) - - def forward(self, x): - """ - x: B, H*W, C - """ - H, W = self.input_resolution - B, L, C = x.shape - assert L == H * W, "input feature has wrong size" - assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even." - - x = x.view(B, H, W, C) - - 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.reduction(x) - x = self.norm(x) - - return x - - def extra_repr(self) -> str: - return f"input_resolution={self.input_resolution}, dim={self.dim}" - - def flops(self): - H, W = self.input_resolution - flops = (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim - flops += H * W * self.dim // 2 - return flops - - -class BasicLayer(nn.Module): - """ A basic Swin Transformer layer for one stage. - - Args: - dim (int): Number of input channels. - input_resolution (tuple[int]): Input resolution. - depth (int): Number of blocks. - num_heads (int): Number of attention heads. - window_size (int): Local window size. - 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 - 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. - pretrained_window_size (int): Local window size in pre-training. - """ - - def __init__(self, dim, input_resolution, depth, num_heads, window_size, - mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0., - drop_path=0., norm_layer=nn.LayerNorm, downsample=None, - use_checkpoint=False, pretrained_window_size=0, - extra_norm_period: int = 0, extra_norm_stage: bool = False,): - - super().__init__() - self.dim = dim - self.input_resolution = input_resolution - self.depth = depth - self.use_checkpoint = use_checkpoint - - def _extra_norm(index): - i = index + 1 - if extra_norm_period and i % extra_norm_period == 0: - return True - return i == depth if extra_norm_stage else False - - # build blocks - self.blocks = nn.ModuleList([ - SwinTransformerBlock(dim=dim, input_resolution=input_resolution, - 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, - drop=drop, attn_drop=attn_drop, - drop_path=drop_path[i] if isinstance( - drop_path, list) else drop_path, - norm_layer=norm_layer, - pretrained_window_size=pretrained_window_size, - extra_norm=_extra_norm(i)) - for i in range(depth)]) - - # patch merging layer - if downsample is not None: - self.downsample = downsample( - input_resolution, dim=dim, norm_layer=norm_layer) - else: - self.downsample = None - - def forward(self, x): - for blk in self.blocks: - if self.use_checkpoint: - x = checkpoint.checkpoint(blk, x, use_reentrant=False) - else: - x = blk(x) - if self.downsample is not None: - x = self.downsample(x) - return x - - def extra_repr(self) -> str: - return f"dim={self.dim}, " \ - f"input_resolution={self.input_resolution}," \ - f" depth={self.depth}" - - def flops(self): - flops = 0 - for blk in self.blocks: - flops += blk.flops() - if self.downsample is not None: - flops += self.downsample.flops() - return flops - - def _init_respostnorm(self): - for blk in self.blocks: - nn.init.constant_(blk.norm1.bias, 0) - nn.init.constant_(blk.norm1.weight, 0) - nn.init.constant_(blk.norm2.bias, 0) - nn.init.constant_(blk.norm2.weight, 0) - - -class PatchEmbed(nn.Module): - r""" Image to Patch Embedding - - Args: - img_size (int): Image size. Default: 224. - patch_size (int): Patch token size. Default: 4. - in_chans (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, - img_size=224, - patch_size=4, - in_chans=3, - embed_dim=96, - norm_layer=None): - super().__init__() - img_size = to_2tuple(img_size) - patch_size = to_2tuple(patch_size) - patches_resolution = [img_size[0] // - patch_size[0], img_size[1] // patch_size[1]] - self.img_size = img_size - self.patch_size = patch_size - self.patches_resolution = patches_resolution - self.num_patches = patches_resolution[0] * patches_resolution[1] - - self.in_chans = in_chans - self.embed_dim = embed_dim - - self.proj = nn.Conv2d(in_chans, 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): - B, C, H, W = x.shape - # FIXME look at relaxing size constraints - assert H == self.img_size[0] and W == self.img_size[1], \ - f"Input image size ({H}*{W})" \ - f"doesn't match model ({self.img_size[0]}*{self.img_size[1]})." - x = self.proj(x).flatten(2).transpose(1, 2) # B Ph*Pw C - if self.norm is not None: - x = self.norm(x) - return x - - def flops(self): - 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 - - -class SwinTransformerV2(nn.Module): - r""" Swin Transformer - A PyTorch impl of : `Swin Transformer: Hierarchical - Vision Transformer using Shifted Windows` - - https://arxiv.org/pdf/2103.14030 - - Args: - img_size (int | tuple(int)): Input image size. Default 224 - patch_size (int | tuple(int)): Patch size. Default: 4 - in_chans (int): Number of input image channels. - Default: 3 - num_classes (int): Number of classes for classification head. - Default: 1000 - embed_dim (int): Patch embedding dimension. Default: 96 - depths (tuple(int)): Depth of each Swin Transformer layer. - num_heads (tuple(int)): Number of attention heads in different layers. - 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 - drop_rate (float): Dropout rate. Default: 0 - attn_drop_rate (float): Attention dropout rate. Default: 0 - drop_path_rate (float): Stochastic depth rate. Default: 0.1 - 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 - use_checkpoint (bool): Whether to use checkpointing to save memory. - Default: False - pretrained_window_sizes (tuple(int)): Pretrained window sizes of - each layer. - """ - - def __init__(self, img_size=224, patch_size=4, in_chans=3, - num_classes=1000, embed_dim=96, depths=[2, 2, 6, 2], - num_heads=[3, 6, 12, 24], window_size=7, mlp_ratio=4., - qkv_bias=True, drop_rate=0., attn_drop_rate=0., - drop_path_rate=0.1, norm_layer=nn.LayerNorm, - ape=False, patch_norm=True, use_checkpoint=False, - pretrained_window_sizes=[0, 0, 0, 0], - extra_norm_period: int = 0, extra_norm_stage: bool = False, - **kwargs): - super().__init__() - - self.num_classes = num_classes - self.num_layers = len(depths) - self.embed_dim = embed_dim - self.ape = ape - self.patch_norm = patch_norm - self.num_features = int(embed_dim * 2 ** (self.num_layers - 1)) - self.mlp_ratio = mlp_ratio - - # split image into non-overlapping patches - self.patch_embed = PatchEmbed( - img_size=img_size, patch_size=patch_size, - in_chans=in_chans, embed_dim=embed_dim, - norm_layer=norm_layer if self.patch_norm else None) - num_patches = self.patch_embed.num_patches - patches_resolution = self.patch_embed.patches_resolution - self.patches_resolution = patches_resolution - - # absolute position embedding - if self.ape: - self.absolute_pos_embed = nn.Parameter( - torch.zeros(1, num_patches, embed_dim)) - 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), - input_resolution=(patches_resolution[0] // (2 ** i_layer), - patches_resolution[1] // (2 ** i_layer)), - depth=depths[i_layer], - num_heads=num_heads[i_layer], - window_size=window_size, - mlp_ratio=self.mlp_ratio, - qkv_bias=qkv_bias, - 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, - pretrained_window_size=pretrained_window_sizes[i_layer], - extra_norm_period=extra_norm_period, - extra_norm_stage=extra_norm_stage) - self.layers.append(layer) - - self.norm = norm_layer(self.num_features) - self.avgpool = nn.AdaptiveAvgPool1d(1) - self.head = nn.Linear( - self.num_features, num_classes) if \ - num_classes > 0 else nn.Identity() - - self.apply(self._init_weights) - for bly in self.layers: - bly._init_respostnorm() - - 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) - - @torch.jit.ignore - def no_weight_decay(self): - return {'absolute_pos_embed'} - - @torch.jit.ignore - def no_weight_decay_keywords(self): - return {"cpb_mlp", "logit_scale", 'relative_position_bias_table'} - - def forward_features(self, x): - x = self.patch_embed(x) - if self.ape: - x = x + self.absolute_pos_embed - x = self.pos_drop(x) - - for layer in self.layers: - x = layer(x) - - x = self.norm(x) # B L C - x = self.avgpool(x.transpose(1, 2)) # B C 1 - x = torch.flatten(x, 1) - return x - - def extra_features(self, x): - x = self.patch_embed(x) - if self.ape: - x = x + self.absolute_pos_embed - x = self.pos_drop(x) - feature = [] - - for layer in self.layers: - x = layer(x) - bs, n, f = x.shape - h = int(n**0.5) - - feature.append( - x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()) - return feature - - def get_unet_feature(self, x): - x = self.patch_embed(x) - if self.ape: - x = x + self.absolute_pos_embed - x = self.pos_drop(x) - bs, n, f = x.shape - h = int(n**0.5) - feature = [x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()] - - for layer in self.layers: - x = layer(x) - bs, n, f = x.shape - h = int(n**0.5) - - feature.append( - x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()) - return feature - - def forward(self, x): - x = self.forward_features(x) - x = self.head(x) - return x - - def flops(self): - flops = 0 - flops += self.patch_embed.flops() - for i, layer in enumerate(self.layers): - flops += layer.flops() - flops += self.num_features * \ - self.patches_resolution[0] * \ - self.patches_resolution[1] // (2 ** self.num_layers) - flops += self.num_features * self.num_classes - return flops diff --git a/pytorch_caney/models/unet_model.py b/pytorch_caney/models/unet_model.py deleted file mode 100755 index b8e0779..0000000 --- a/pytorch_caney/models/unet_model.py +++ /dev/null @@ -1,187 +0,0 @@ -from pl_bolts.models.vision.unet import UNet -from pytorch_lightning import LightningModule -from pytorch_lightning.utilities.cli import MODEL_REGISTRY - -import torch -from torch.nn import functional as F -from torchmetrics import MetricCollection, Accuracy, IoU - - -# ------------------------------------------------------------------------------- -# class UNet -# This class performs training and classification of satellite imagery using a -# UNet CNN. -# ------------------------------------------------------------------------------- -@MODEL_REGISTRY -class UNetSegmentation(LightningModule): - - # --------------------------------------------------------------------------- - # __init__ - # --------------------------------------------------------------------------- - def __init__( - self, - input_channels: int = 4, - num_classes: int = 19, - num_layers: int = 5, - features_start: int = 64, - bilinear: bool = False, - ): - super().__init__() - - self.input_channels = input_channels - self.num_classes = num_classes - self.num_layers = num_layers - self.features_start = features_start - self.bilinear = bilinear - - self.net = UNet( - input_channels=self.input_channels, - num_classes=num_classes, - num_layers=self.num_layers, - features_start=self.features_start, - bilinear=self.bilinear, - ) - - metrics = MetricCollection( - [ - Accuracy(), IoU(num_classes=self.num_classes) - ] - ) - self.train_metrics = metrics.clone(prefix='train_') - self.val_metrics = metrics.clone(prefix='val_') - - # --------------------------------------------------------------------------- - # model methods - # --------------------------------------------------------------------------- - def forward(self, x): - return self.net(x) - - def training_step(self, batch, batch_nb): - img, mask = batch - img, mask = img.float(), mask.long() - - # Forward step, calculate logits and loss - logits = self(img) - # loss_val = F.cross_entropy(logits, mask) - - # Get target tensor from logits for metrics, calculate metrics - probs = torch.nn.functional.softmax(logits, dim=1) - probs = torch.argmax(probs, dim=1) - - # metrics_train = self.train_metrics(probs, mask) - # log_dict = {"train_loss": loss_val.detach()} - # return {"loss": loss_val, "log": log_dict, "progress_bar": log_dict} - # return { - # "loss": loss_val, "train_acc": metrics_train['train_Accuracy'], - # "train_iou": metrics_train['train_IoU'] - # } - - tensorboard_logs = self.train_metrics(probs, mask) - tensorboard_logs['loss'] = F.cross_entropy(logits, mask) - # tensorboard_logs['lr'] = self._get_current_lr() - - self.log( - 'acc', tensorboard_logs['train_Accuracy'], - sync_dist=True, prog_bar=True - ) - self.log( - 'iou', tensorboard_logs['train_IoU'], - sync_dist=True, prog_bar=True - ) - return tensorboard_logs - - def training_epoch_end(self, outputs): - pass - - # Get average metrics from multi-GPU batch sources - # loss_val = torch.stack([x["loss"] for x in outputs]).mean() - # acc_train = torch.stack([x["train_acc"] for x in outputs]).mean() - # iou_train = torch.stack([x["train_iou"] for x in outputs]).mean() - - # tensorboard_logs = self.train_metrics(probs, mask) - # tensorboard_logs['loss'] = F.cross_entropy(logits, mask) - # tensorboard_logs['lr'] = self._get_current_lr() - - # self.log( - # 'acc', tensorboard_logs['train_Accuracy'], - # sync_dist=True, prog_bar=True - # ) - # self.log( - # 'iou', tensorboard_logs['train_IoU'], - # sync_dist=True, prog_bar=True - # ) - # # Send output to logger - # self.log( - # "loss", loss_val, on_epoch=True, prog_bar=True, logger=True) - # self.log( - # "train_acc", acc_train, - # on_epoch=True, prog_bar=True, logger=True) - # self.log( - # "train_iou", iou_train, - # on_epoch=True, prog_bar=True, logger=True) - # return tensorboard_logs - - def validation_step(self, batch, batch_idx): - - # Get data, change type for validation - img, mask = batch - img, mask = img.float(), mask.long() - - # Forward step, calculate logits and loss - logits = self(img) - # loss_val = F.cross_entropy(logits, mask) - - # Get target tensor from logits for metrics, calculate metrics - probs = torch.nn.functional.softmax(logits, dim=1) - probs = torch.argmax(probs, dim=1) - # metrics_val = self.val_metrics(probs, mask) - - # return { - # "val_loss": loss_val, "val_acc": metrics_val['val_Accuracy'], - # "val_iou": metrics_val['val_IoU'] - # } - tensorboard_logs = self.val_metrics(probs, mask) - tensorboard_logs['val_loss'] = F.cross_entropy(logits, mask) - - self.log( - 'val_loss', tensorboard_logs['val_loss'], - sync_dist=True, prog_bar=True - ) - self.log( - 'val_acc', tensorboard_logs['val_Accuracy'], - sync_dist=True, prog_bar=True - ) - self.log( - 'val_iou', tensorboard_logs['val_IoU'], - sync_dist=True, prog_bar=True - ) - return tensorboard_logs - - # def validation_epoch_end(self, outputs): - - # # Get average metrics from multi-GPU batch sources - # loss_val = torch.stack([x["val_loss"] for x in outputs]).mean() - # acc_val = torch.stack([x["val_acc"] for x in outputs]).mean() - # iou_val = torch.stack([x["val_iou"] for x in outputs]).mean() - - # # Send output to logger - # self.log( - # "val_loss", torch.mean(self.all_gather(loss_val)), - # on_epoch=True, prog_bar=True, logger=True) - # self.log( - # "val_acc", torch.mean(self.all_gather(acc_val)), - # on_epoch=True, prog_bar=True, logger=True) - # self.log( - # "val_iou", torch.mean(self.all_gather(iou_val)), - # on_epoch=True, prog_bar=True, logger=True) - - # def configure_optimizers(self): - # opt = torch.optim.Adam(self.net.parameters(), lr=self.lr) - # sch = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=10) - # return [opt], [sch] - - def test_step(self, batch, batch_idx, dataloader_idx=0): - return self(batch) - - def predict_step(self, batch, batch_idx, dataloader_idx=0): - return self(batch) diff --git a/pytorch_caney/models/unet_swin_model.py b/pytorch_caney/models/unet_swin_model.py deleted file mode 100644 index 8fa2982..0000000 --- a/pytorch_caney/models/unet_swin_model.py +++ /dev/null @@ -1,44 +0,0 @@ -from .decoders.unet_decoder import UnetDecoder -from .decoders.unet_decoder import SegmentationHead - -import torch.nn as nn - -from typing import Tuple - - -class unet_swin(nn.Module): - """ - Pytorch encoder-decoder model which pairs - an encoder (swin) with the attention unet - decoder. - """ - - FEATURE_CHANNELS: Tuple[int] = (3, 256, 512, 1024, 1024) - DECODE_CHANNELS: Tuple[int] = (512, 256, 128, 64) - IN_CHANNELS: int = 64 - N_BLOCKS: int = 4 - KERNEL_SIZE: int = 3 - UPSAMPLING: int = 4 - - def __init__(self, encoder, num_classes=9): - super().__init__() - - self.encoder = encoder - - self.decoder = UnetDecoder( - encoder_channels=self.FEATURE_CHANNELS, - n_blocks=self.N_BLOCKS, - decoder_channels=self.DECODE_CHANNELS, - attention_type=None) - self.segmentation_head = SegmentationHead( - in_channels=self.IN_CHANNELS, - out_channels=num_classes, - kernel_size=self.KERNEL_SIZE, - upsampling=self.UPSAMPLING) - - def forward(self, x): - encoder_featrue = self.encoder.get_unet_feature(x) - decoder_output = self.decoder(*encoder_featrue) - masks = self.segmentation_head(decoder_output) - - return masks diff --git a/pytorch_caney/network/__init__.py b/pytorch_caney/network/__init__.py deleted file mode 100755 index e69de29..0000000 diff --git a/pytorch_caney/network/attention.py b/pytorch_caney/network/attention.py deleted file mode 100644 index 1df9976..0000000 --- a/pytorch_caney/network/attention.py +++ /dev/null @@ -1,209 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -import numpy as np - - -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 - attn_drop (float, optional): Dropout ratio of attention weight. - Default: 0.0 - proj_drop (float, optional): Dropout ratio of output. Default: 0.0 - pretrained_window_size (tuple[int]): The height and width of the - window in pre-training. - """ - - def __init__(self, - dim, - window_size, - num_heads, - qkv_bias=True, - attn_drop=0., - proj_drop=0., - pretrained_window_size=[0, 0]): - - super().__init__() - - self.dim = dim - - self.window_size = window_size # Wh, Ww - - self.pretrained_window_size = pretrained_window_size - - self.num_heads = num_heads - - self.logit_scale = nn.Parameter( - torch.log(10 * torch.ones((num_heads, 1, 1))), requires_grad=True) - - # mlp to generate continuous relative position bias - self.cpb_mlp = nn.Sequential(nn.Linear(2, 512, bias=True), - nn.ReLU(inplace=True), - nn.Linear(512, num_heads, bias=False)) - - # get relative_coords_table - relative_coords_h = torch.arange( - -(self.window_size[0] - 1), - self.window_size[0], - dtype=torch.float32) - relative_coords_w = torch.arange( - -(self.window_size[1] - 1), - self.window_size[1], - dtype=torch.float32) - - # 1, 2*Wh-1, 2*Ww-1, 2 - relative_coords_table = torch.stack( - torch.meshgrid( - [relative_coords_h, - relative_coords_w])).permute(1, - 2, - 0).contiguous().unsqueeze(0) - - if pretrained_window_size[0] > 0: - - relative_coords_table[:, :, :, - 0] /= (pretrained_window_size[0] - 1) - - relative_coords_table[:, :, :, - 1] /= (pretrained_window_size[1] - 1) - - else: - - relative_coords_table[:, :, :, 0] /= (self.window_size[0] - 1) - - relative_coords_table[:, :, :, 1] /= (self.window_size[1] - 1) - - relative_coords_table *= 8 # normalize to -8, 8 - - relative_coords_table = torch.sign(relative_coords_table) * torch.log2( - torch.abs(relative_coords_table) + 1.0) / np.log2(8) - - self.register_buffer("relative_coords_table", relative_coords_table) - - # 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])) # 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=False) - - if qkv_bias: - - self.q_bias = nn.Parameter(torch.zeros(dim)) - self.v_bias = nn.Parameter(torch.zeros(dim)) - - else: - - self.q_bias = None - self.v_bias = None - - self.attn_drop = nn.Dropout(attn_drop) - self.proj = nn.Linear(dim, dim) - self.proj_drop = nn.Dropout(proj_drop) - self.softmax = nn.Softmax(dim=-1) - - def forward(self, x, mask=None): - """ - 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_bias = None - if self.q_bias is not None: - qkv_bias = torch.cat((self.q_bias, torch.zeros_like( - self.v_bias, requires_grad=False), self.v_bias)) - qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) - qkv = qkv.reshape(B_, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) - # make torchscript happy (cannot use tensor as tuple) - q, k, v = qkv[0], qkv[1], qkv[2] - - # cosine attention - attn = (F.normalize(q, dim=-1) @ - F.normalize(k, dim=-1).transpose(-2, -1)) - # logit_scale = torch.clamp( - # self.logit_scale, max=torch.log(torch.tensor(1. / 0.01))).exp() - logit_scale = torch.clamp(self.logit_scale, max=torch.log( - torch.tensor(1. / 0.01)).to(self.logit_scale.get_device())).exp() - attn = attn * logit_scale - - relative_position_bias_table = self.cpb_mlp( - self.relative_coords_table).view(-1, self.num_heads) - relative_position_bias = \ - 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 - - relative_position_bias = 16 * torch.sigmoid(relative_position_bias) - 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 - - def extra_repr(self) -> str: - return f'dim={self.dim}, window_size={self.window_size}, ' \ - f'pretrained_window_size={self.pretrained_window_size}, ' \ - f'num_heads={self.num_heads}' - - def flops(self, N): - # calculate flops for 1 window with token length of N - flops = 0 - # qkv = self.qkv(x) - flops += N * self.dim * 3 * self.dim - # attn = (q @ k.transpose(-2, -1)) - flops += self.num_heads * N * (self.dim // self.num_heads) * N - # x = (attn @ v) - flops += self.num_heads * N * N * (self.dim // self.num_heads) - # x = self.proj(x) - flops += N * self.dim * self.dim - return flops diff --git a/pytorch_caney/network/mlp.py b/pytorch_caney/network/mlp.py deleted file mode 100644 index d154808..0000000 --- a/pytorch_caney/network/mlp.py +++ /dev/null @@ -1,21 +0,0 @@ -import torch.nn as nn - - -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.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 diff --git a/pytorch_caney/optimizer/build.py b/pytorch_caney/optimizer/build.py deleted file mode 100644 index e4da05b..0000000 --- a/pytorch_caney/optimizer/build.py +++ /dev/null @@ -1,277 +0,0 @@ -import torch -import deepspeed -from pytorch_caney.optimizer.lamb import Lamb - -OPTIMIZERS = { - 'adamw': torch.optim.AdamW, - 'lamb': Lamb, - 'fusedlamb': deepspeed.ops.lamb.FusedLamb -} - - -# #optimizer = torch.optim.AdamW(simmim_model.parameters(), -# # lr=config.TRAIN.BASE_LR, -# # weight_decay=config.TRAIN.WEIGHT_DECAY) -# -# # looks good -# #optimizer = Lamb(simmim_model.parameters(), -# # lr=config.TRAIN.BASE_LR, -# # weight_decay=config.TRAIN.WEIGHT_DECAY) -# -# optimizer = deepspeed.ops.lamb.FusedLamb(simmim_model.parameters(), lr=config.TRAIN.BASE_LR, weight_decay=config.TRAIN.WEIGHT_DECAY) - - -def get_optimizer_from_dict(optimizer_name, config): - """Gets the proper optimizer given an optimizer name. - - Args: - optimizer_name (str): name of the optimizer - config: config object - - Raises: - KeyError: thrown if loss key is not present in dict - - Returns: - loss: pytorch optimizer - """ - - try: - - optimizer_to_use = OPTIMIZERS[optimizer_name.lower()] - - except KeyError: - - error_msg = f"{optimizer_name} is not an implemented optimizer" - - error_msg = f"{error_msg}. Available optimizer functions: {OPTIMIZERS.keys()}" - - raise KeyError(error_msg) - - return optimizer_to_use - - -def build_optimizer(config, model, is_pretrain=False, logger=None): - """ - Build optimizer, set weight decay of normalization to 0 by default. - AdamW only. - """ - logger.info('>>>>>>>>>> Build Optimizer') - - skip = {} - - skip_keywords = {} - - optimizer_name = config.TRAIN.OPTIMIZER.NAME - logger.info(f'Building {optimizer_name}') - - optimizer_to_use = get_optimizer_from_dict(optimizer_name, config) - - if hasattr(model, 'no_weight_decay'): - skip = model.no_weight_decay() - - if hasattr(model, 'no_weight_decay_keywords'): - skip_keywords = model.no_weight_decay_keywords() - - if is_pretrain: - parameters = get_pretrain_param_groups(model, skip, skip_keywords) - - else: - - depths = config.MODEL.SWIN.DEPTHS if config.MODEL.TYPE == 'swin' \ - else config.MODEL.SWINV2.DEPTHS - - num_layers = sum(depths) - - get_layer_func = partial(get_swin_layer, - num_layers=num_layers + 2, - depths=depths) - - scales = list(config.TRAIN.LAYER_DECAY ** i for i in - reversed(range(num_layers + 2))) - - parameters = get_finetune_param_groups(model, - config.TRAIN.BASE_LR, - config.TRAIN.WEIGHT_DECAY, - get_layer_func, - scales, - skip, - skip_keywords) - - optimizer = None - - optimizer = optimizer_to_use(parameters, - eps=config.TRAIN.OPTIMIZER.EPS, - betas=config.TRAIN.OPTIMIZER.BETAS, - lr=config.TRAIN.BASE_LR, - weight_decay=config.TRAIN.WEIGHT_DECAY) - logger.info("DUDE, I AM YOURS") - logger.info(optimizer) - - return optimizer - -""" -def build_optimizer(config): - Builds the optimizer function given a configuration object. - - Args: - config: config object - - Returns: - optimizer_to_use: pytorch optimizer function - - optimizer_name = config.TRAIN.OPTIMIZER.NAME - - optimizer_to_use = get_optimizer_from_dict(optimizer_name, config) - - return optimizer_to_use -""" - -def get_finetune_param_groups(model, - lr, - weight_decay, - get_layer_func, - scales, - skip_list=(), - skip_keywords=()): - - parameter_group_names = {} - - parameter_group_vars = {} - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") \ - or (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - group_name = "no_decay" - - this_weight_decay = 0. - - else: - - group_name = "decay" - - this_weight_decay = weight_decay - - if get_layer_func is not None: - - layer_id = get_layer_func(name) - - group_name = "layer_%d_%s" % (layer_id, group_name) - - else: - - layer_id = None - if group_name not in parameter_group_names: - - if scales is not None: - - scale = scales[layer_id] - - else: - - scale = 1. - - parameter_group_names[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale, - } - - parameter_group_vars[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale - } - - parameter_group_vars[group_name]["params"].append(param) - - parameter_group_names[group_name]["params"].append(name) - - return list(parameter_group_vars.values()) - - -def check_keywords_in_name(name, keywords=()): - - isin = False - - for keyword in keywords: - - if keyword in name: - - isin = True - - return isin - - -def get_pretrain_param_groups(model, skip_list=(), skip_keywords=()): - - has_decay = [] - - no_decay = [] - - has_decay_name = [] - - no_decay_name = [] - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") or \ - (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - no_decay.append(param) - - no_decay_name.append(name) - - else: - - has_decay.append(param) - - has_decay_name.append(name) - - return [{'params': has_decay}, - {'params': no_decay, 'weight_decay': 0.}] - - -def get_swin_layer(name, num_layers, depths): - - if name in ("mask_token"): - - return 0 - - elif name.startswith("patch_embed"): - - return 0 - - elif name.startswith("layers"): - - layer_id = int(name.split('.')[1]) - - block_id = name.split('.')[3] - - if block_id == 'reduction' or block_id == 'norm': - - return sum(depths[:layer_id + 1]) - - layer_id = sum(depths[:layer_id]) + int(block_id) - - return layer_id + 1 - - else: - - return num_layers - 1 - diff --git a/pytorch_caney/optimizer/lamb.py b/pytorch_caney/optimizer/lamb.py deleted file mode 100644 index de6aebb..0000000 --- a/pytorch_caney/optimizer/lamb.py +++ /dev/null @@ -1,214 +0,0 @@ -""" PyTorch Lamb optimizer w/ behaviour similar to NVIDIA FusedLamb - -This optimizer code was adapted from the following (starting with latest) -* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py -* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py -* https://github.com/cybertronai/pytorch-lamb - -Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is -similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX. - -In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU. - -Original copyrights for above sources are below. - -Modifications Copyright 2021 Ross Wightman -""" -# Copyright (c) 2021, Habana Labs Ltd. All rights reserved. - -# Copyright (c) 2019-2020, NVIDIA CORPORATION. All rights reserved. -# -# 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. - -# MIT License -# -# Copyright (c) 2019 cybertronai -# -# 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 collections -import math - -import torch -from torch.optim import Optimizer - -from torch.utils.tensorboard import SummaryWriter - - -def log_lamb_rs(optimizer: Optimizer, event_writer: SummaryWriter, token_count: int): - """Log a histogram of trust ratio scalars in across layers.""" - results = collections.defaultdict(list) - for group in optimizer.param_groups: - for p in group['params']: - state = optimizer.state[p] - for i in ('weight_norm', 'adam_norm', 'trust_ratio'): - if i in state: - results[i].append(state[i]) - - for k, v in results.items(): - event_writer.add_histogram(f'lamb/{k}', torch.tensor(v), token_count) - - -class Lamb(Optimizer): - """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB - reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py - - LAMB was proposed in `Large Batch Optimization for Deep Learning: Training BERT in 76 minutes`_. - - Arguments: - params (iterable): iterable of parameters to optimize or dicts defining parameter groups. - lr (float, optional): learning rate. (default: 1e-3) - betas (Tuple[float, float], optional): coefficients used for computing - running averages of gradient and its norm. (default: (0.9, 0.999)) - eps (float, optional): term added to the denominator to improve - numerical stability. (default: 1e-8) - weight_decay (float, optional): weight decay (L2 penalty) (default: 0) - grad_averaging (bool, optional): whether apply (1-beta2) to grad when - calculating running averages of gradient. (default: True) - max_grad_norm (float, optional): value used to clip global grad norm (default: 1.0) - trust_clip (bool): enable LAMBC trust ratio clipping (default: False) - always_adapt (boolean, optional): Apply adaptive learning rate to 0.0 - weight decay parameter (default: False) - - .. _Large Batch Optimization for Deep Learning - Training BERT in 76 minutes: - https://arxiv.org/abs/1904.00962 - .. _On the Convergence of Adam and Beyond: - https://openreview.net/forum?id=ryQu7f-RZ - """ - - def __init__( - self, params, lr=1e-3, bias_correction=True, betas=(0.9, 0.999), eps=1e-6, - weight_decay=0.01, grad_averaging=True, max_grad_norm=1.0, trust_clip=False, always_adapt=False): - defaults = dict( - lr=lr, bias_correction=bias_correction, betas=betas, eps=eps, weight_decay=weight_decay, - grad_averaging=grad_averaging, max_grad_norm=max_grad_norm, - trust_clip=trust_clip, always_adapt=always_adapt) - super().__init__(params, defaults) - - @torch.no_grad() - def step(self, closure=None): - """Performs a single optimization step. - Arguments: - closure (callable, optional): A closure that reevaluates the model - and returns the loss. - """ - loss = None - if closure is not None: - with torch.enable_grad(): - loss = closure() - - device = self.param_groups[0]['params'][0].device - one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly - global_grad_norm = torch.zeros(1, device=device) - for group in self.param_groups: - for p in group['params']: - if p.grad is None: - continue - grad = p.grad - if grad.is_sparse: - raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.') - global_grad_norm.add_(grad.pow(2).sum()) - - global_grad_norm = torch.sqrt(global_grad_norm) - # FIXME it'd be nice to remove explicit tensor conversion of scalars when torch.where promotes - # scalar types properly https://github.com/pytorch/pytorch/issues/9190 - max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], device=device) - clip_global_grad_norm = torch.where( - global_grad_norm > max_grad_norm, - global_grad_norm / max_grad_norm, - one_tensor) - - for group in self.param_groups: - bias_correction = 1 if group['bias_correction'] else 0 - beta1, beta2 = group['betas'] - grad_averaging = 1 if group['grad_averaging'] else 0 - beta3 = 1 - beta1 if grad_averaging else 1.0 - - # assume same step across group now to simplify things - # per parameter step can be easily support by making it tensor, or pass list into kernel - if 'step' in group: - group['step'] += 1 - else: - group['step'] = 1 - - if bias_correction: - bias_correction1 = 1 - beta1 ** group['step'] - bias_correction2 = 1 - beta2 ** group['step'] - else: - bias_correction1, bias_correction2 = 1.0, 1.0 - - for p in group['params']: - if p.grad is None: - continue - grad = p.grad.div_(clip_global_grad_norm) - state = self.state[p] - - # State initialization - if len(state) == 0: - # Exponential moving average of gradient valuesa - state['exp_avg'] = torch.zeros_like(p) - # Exponential moving average of squared gradient values - state['exp_avg_sq'] = torch.zeros_like(p) - - exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq'] - - # Decay the first and second moment running average coefficient - exp_avg.mul_(beta1).add_(grad, alpha=beta3) # m_t - exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) # v_t - - denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps']) - update = (exp_avg / bias_correction1).div_(denom) - - weight_decay = group['weight_decay'] - if weight_decay != 0: - update.add_(p, alpha=weight_decay) - - if weight_decay != 0 or group['always_adapt']: - # Layer-wise LR adaptation. By default, skip adaptation on parameters that are - # excluded from weight decay, unless always_adapt == True, then always enabled. - w_norm = p.norm(2.0) - g_norm = update.norm(2.0) - # FIXME nested where required since logical and/or not working in PT XLA - trust_ratio = torch.where( - w_norm > 0, - torch.where(g_norm > 0, w_norm / g_norm, one_tensor), - one_tensor, - ) - if group['trust_clip']: - # LAMBC trust clipping, upper bound fixed at one - trust_ratio = torch.minimum(trust_ratio, one_tensor) - - state['weight_norm'] = w_norm - state['adam_norm'] = g_norm - state['trust_ratio'] = trust_ratio - - update.mul_(trust_ratio) - - p.add_(update, alpha=-group['lr']) - - return loss diff --git a/pytorch_caney/pipelines/finetuning/finetune.py b/pytorch_caney/pipelines/finetuning/finetune.py deleted file mode 100644 index 4b3b05b..0000000 --- a/pytorch_caney/pipelines/finetuning/finetune.py +++ /dev/null @@ -1,454 +0,0 @@ -from pytorch_caney.models.build import build_model - -from pytorch_caney.data.datamodules.finetune_datamodule \ - import build_finetune_dataloaders - -from pytorch_caney.training.mim_utils \ - import build_optimizer, save_checkpoint, reduce_tensor - -from pytorch_caney.config import get_config -from pytorch_caney.loss.build import build_loss -from pytorch_caney.lr_scheduler import build_scheduler, setup_scaled_lr -from pytorch_caney.ptc_logging import create_logger -from pytorch_caney.training.mim_utils import get_grad_norm - -import argparse -import datetime -import joblib -import numpy as np -import os -import time - -import torch -import torch.cuda.amp as amp -import torch.backends.cudnn as cudnn -import torch.distributed as dist - -from timm.utils import AverageMeter - - -def parse_args(): - """ - Parse command-line arguments - """ - - parser = argparse.ArgumentParser( - 'pytorch-caney finetuning', - add_help=False) - - parser.add_argument( - '--cfg', - type=str, - required=True, - metavar="FILE", - help='path to config file') - - parser.add_argument( - "--data-paths", - nargs='+', - required=True, - help="paths where dataset is stored") - - parser.add_argument( - '--dataset', - type=str, - required=True, - help='Dataset to use') - - parser.add_argument( - '--pretrained', - type=str, - help='path to pre-trained model') - - parser.add_argument( - '--batch-size', - type=int, - help="batch size for single GPU") - - parser.add_argument( - '--resume', - help='resume from checkpoint') - - parser.add_argument( - '--accumulation-steps', - type=int, - help="gradient accumulation steps") - - parser.add_argument( - '--use-checkpoint', - action='store_true', - help="whether to use gradient checkpointing to save memory") - - parser.add_argument( - '--enable-amp', - action='store_true') - - parser.add_argument( - '--disable-amp', - action='store_false', - dest='enable_amp') - - parser.set_defaults(enable_amp=True) - - parser.add_argument( - '--output', - default='output', - type=str, - metavar='PATH', - help='root of output folder, the full path is ' + - '// (default: output)') - - parser.add_argument( - '--tag', - help='tag of experiment') - - args = parser.parse_args() - - config = get_config(args) - - return args, config - - -def train(config, - dataloader_train, - dataloader_val, - model, - model_wo_ddp, - optimizer, - lr_scheduler, - scaler, - criterion): - """ - Start fine-tuning a specific model and dataset. - - Args: - config: config object - dataloader_train: training pytorch dataloader - dataloader_val: validation pytorch dataloader - model: model to pre-train - model_wo_ddp: model to pre-train that is not the DDP version - optimizer: pytorch optimizer - lr_scheduler: learning-rate scheduler - scaler: loss scaler - criterion: loss function to use for fine-tuning - """ - - logger.info("Start fine-tuning") - - start_time = time.time() - - for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): - - dataloader_train.sampler.set_epoch(epoch) - - execute_one_epoch(config, model, dataloader_train, - optimizer, criterion, epoch, lr_scheduler, scaler) - - loss = validate(config, model, dataloader_val, criterion) - - logger.info(f'Model validation loss: {loss:.3f}%') - - if dist.get_rank() == 0 and \ - (epoch % config.SAVE_FREQ == 0 or - epoch == (config.TRAIN.EPOCHS - 1)): - - save_checkpoint(config, epoch, model_wo_ddp, 0., - optimizer, lr_scheduler, scaler, logger) - - total_time = time.time() - start_time - - total_time_str = str(datetime.timedelta(seconds=int(total_time))) - - logger.info('Training time {}'.format(total_time_str)) - - -def execute_one_epoch(config, - model, - dataloader, - optimizer, - criterion, - epoch, - lr_scheduler, - scaler): - """ - Execute training iterations on a single epoch. - - Args: - config: config object - model: model to pre-train - dataloader: dataloader to use - optimizer: pytorch optimizer - epoch: int epoch number - lr_scheduler: learning-rate scheduler - scaler: loss scaler - """ - model.train() - - optimizer.zero_grad() - - num_steps = len(dataloader) - - # Set up logging meters - batch_time = AverageMeter() - data_time = AverageMeter() - loss_meter = AverageMeter() - norm_meter = AverageMeter() - loss_scale_meter = AverageMeter() - - start = time.time() - end = time.time() - for idx, (samples, targets) in enumerate(dataloader): - - data_time.update(time.time() - start) - - samples = samples.cuda(non_blocking=True) - targets = targets.cuda(non_blocking=True) - - with amp.autocast(enabled=config.ENABLE_AMP): - logits = model(samples) - - if config.TRAIN.ACCUMULATION_STEPS > 1: - loss = criterion(logits, targets) - loss = loss / config.TRAIN.ACCUMULATION_STEPS - scaler.scale(loss).backward() - if config.TRAIN.CLIP_GRAD: - scaler.unscale_(optimizer) - grad_norm = torch.nn.utils.clip_grad_norm_( - model.parameters(), - config.TRAIN.CLIP_GRAD) - else: - grad_norm = get_grad_norm(model.parameters()) - if (idx + 1) % config.TRAIN.ACCUMULATION_STEPS == 0: - scaler.step(optimizer) - optimizer.zero_grad() - scaler.update() - lr_scheduler.step_update(epoch * num_steps + idx) - else: - loss = criterion(logits, targets) - optimizer.zero_grad() - scaler.scale(loss).backward() - if config.TRAIN.CLIP_GRAD: - scaler.unscale_(optimizer) - grad_norm = torch.nn.utils.clip_grad_norm_( - model.parameters(), - config.TRAIN.CLIP_GRAD) - else: - grad_norm = get_grad_norm(model.parameters()) - scaler.step(optimizer) - scaler.update() - lr_scheduler.step_update(epoch * num_steps + idx) - - torch.cuda.synchronize() - - loss_meter.update(loss.item(), targets.size(0)) - norm_meter.update(grad_norm) - loss_scale_meter.update(scaler.get_scale()) - batch_time.update(time.time() - end) - end = time.time() - - if idx % config.PRINT_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) - etas = batch_time.avg * (num_steps - idx) - logger.info( - f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' - f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' - f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' - f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' - f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'grad_norm {norm_meter.val:.4f} ({norm_meter.avg:.4f})\t' - f'loss_scale {loss_scale_meter.val:.4f}' + - f' ({loss_scale_meter.avg:.4f})\t' - f'mem {memory_used:.0f}MB') - - epoch_time = time.time() - start - logger.info( - f"EPOCH {epoch} training takes " + - f"{datetime.timedelta(seconds=int(epoch_time))}") - - -@torch.no_grad() -def validate(config, model, dataloader, criterion): - """Validation function which given a model and validation loader - performs a validation run and returns the average loss according - to the criterion. - - Args: - config: config object - model: pytorch model to validate - dataloader: pytorch validation loader - criterion: pytorch-friendly loss function - - Returns: - loss_meter.avg: average of the loss throught the validation - iterations - """ - - model.eval() - - batch_time = AverageMeter() - - loss_meter = AverageMeter() - - end = time.time() - - for idx, (images, target) in enumerate(dataloader): - - images = images.cuda(non_blocking=True) - - target = target.cuda(non_blocking=True) - - # compute output - output = model(images) - - # measure accuracy and record loss - loss = criterion(output, target.long()) - - loss = reduce_tensor(loss) - - loss_meter.update(loss.item(), target.size(0)) - - # measure elapsed time - batch_time.update(time.time() - end) - - end = time.time() - - if idx % config.PRINT_FREQ == 0: - - memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) - - logger.info( - f'Test: [{idx}/{len(dataloader)}]\t' - f'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' - f'Loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'Mem {memory_used:.0f}MB') - - return loss_meter.avg - - -def main(config): - """ - Performs the main function of building model, loader, etc. and starts - training. - """ - - dataloader_train, dataloader_val = build_finetune_dataloaders( - config, logger) - - model = build_finetune_model(config, logger) - - optimizer = build_optimizer(config, - model, - is_pretrain=False, - logger=logger) - - model, model_wo_ddp = make_ddp(model) - - n_iter_per_epoch = len(dataloader_train) - - lr_scheduler = build_scheduler(config, optimizer, n_iter_per_epoch) - - scaler = amp.GradScaler() - - criterion = build_loss(config) - - train(config, - dataloader_train, - dataloader_val, - model, - model_wo_ddp, - optimizer, - lr_scheduler, - scaler, - criterion) - - -def build_finetune_model(config, logger): - - logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") - - model = build_model(config, - pretrain=False, - pretrain_method='mim', - logger=logger) - - model.cuda() - - logger.info(str(model)) - - return model - - -def make_ddp(model): - - model = torch.nn.parallel.DistributedDataParallel( - model, - device_ids=[int(os.environ["RANK"])], - broadcast_buffers=False, - find_unused_parameters=True) - - model_without_ddp = model.module - - return model, model_without_ddp - - -def setup_rank_worldsize(): - if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: - rank = int(os.environ["RANK"]) - world_size = int(os.environ['WORLD_SIZE']) - print(f"RANK and WORLD_SIZE in environ: {rank}/{world_size}") - else: - rank = -1 - world_size = -1 - return rank, world_size - - -def setup_distributed_processing(rank, world_size): - torch.cuda.set_device(int(os.environ["RANK"])) - torch.distributed.init_process_group( - backend='nccl', init_method='env://', world_size=world_size, rank=rank) - torch.distributed.barrier() - - -def setup_seeding(config): - seed = config.SEED + dist.get_rank() - torch.manual_seed(seed) - np.random.seed(seed) - - -if __name__ == '__main__': - _, config = parse_args() - - rank, world_size = setup_rank_worldsize() - - setup_distributed_processing(rank, world_size) - - setup_seeding(config) - - cudnn.benchmark = True - - linear_scaled_lr, linear_scaled_min_lr, linear_scaled_warmup_lr = \ - setup_scaled_lr(config) - - config.defrost() - config.TRAIN.BASE_LR = linear_scaled_lr - config.TRAIN.WARMUP_LR = linear_scaled_warmup_lr - config.TRAIN.MIN_LR = linear_scaled_min_lr - config.freeze() - - os.makedirs(config.OUTPUT, exist_ok=True) - logger = create_logger(output_dir=config.OUTPUT, - dist_rank=dist.get_rank(), - name=f"{config.MODEL.NAME}") - - if dist.get_rank() == 0: - path = os.path.join(config.OUTPUT, "config.json") - with open(path, "w") as f: - f.write(config.dump()) - logger.info(f"Full config saved to {path}") - logger.info(config.dump()) - config_file_name = f'{config.TAG}.config.sav' - config_file_path = os.path.join(config.OUTPUT, config_file_name) - joblib.dump(config, config_file_path) - - main(config) diff --git a/pytorch_caney/pipelines/modis_segmentation.py b/pytorch_caney/pipelines/modis_segmentation.py deleted file mode 100644 index 2c58e9c..0000000 --- a/pytorch_caney/pipelines/modis_segmentation.py +++ /dev/null @@ -1,364 +0,0 @@ -from argparse import ArgumentParser, Namespace -import multiprocessing - -import torch -from torch import nn -import torch.nn.functional as F -from torch.utils.data import DataLoader - -import torchvision.transforms as transforms - -from lightning.pytorch import LightningModule, Trainer, cli_lightning_logo -from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint -from lightning.pytorch.loggers import CSVLogger - -from pytorch_caney.datasets.modis_dataset import MODISDataset -from pytorch_caney.utils import check_gpus_available - - -class UNet(nn.Module): - """ - Architecture based on U-Net: Convolutional Networks for - Biomedical Image Segmentation. - Link - https://arxiv.org/abs/1505.04597 - >>> UNet(num_classes=2, num_layers=3) \ - # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - UNet( - (layers): ModuleList( - (0): DoubleConv(...) - (1): Down(...) - (2): Down(...) - (3): Up(...) - (4): Up(...) - (5): Conv2d(64, 2, kernel_size=(1, 1), stride=(1, 1)) - ) - ) - """ - - def __init__( - self, - num_channels: int = 7, - num_classes: int = 19, - num_layers: int = 5, - features_start: int = 64, - bilinear: bool = False - ): - - super().__init__() - self.num_layers = num_layers - - layers = [DoubleConv(num_channels, features_start)] - - feats = features_start - for _ in range(num_layers - 1): - layers.append(Down(feats, feats * 2)) - feats *= 2 - - for _ in range(num_layers - 1): - layers.append(Up(feats, feats // 2, bilinear)) - feats //= 2 - - layers.append(nn.Conv2d(feats, num_classes, kernel_size=1)) - - self.layers = nn.ModuleList(layers) - - def forward(self, x): - xi = [self.layers[0](x)] - # Down path - for layer in self.layers[1: self.num_layers]: - xi.append(layer(xi[-1])) - # Up path - for i, layer in enumerate(self.layers[self.num_layers: -1]): - xi[-1] = layer(xi[-1], xi[-2 - i]) - return self.layers[-1](xi[-1]) - - -class DoubleConv(nn.Module): - """Double Convolution and BN and ReLU (3x3 conv -> BN -> ReLU) ** 2. - >>> DoubleConv(4, 4) \ - # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - DoubleConv( - (net): Sequential(...) - ) - """ - - def __init__(self, in_ch: int, out_ch: int): - super().__init__() - self.net = nn.Sequential( - nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1), - nn.BatchNorm2d(out_ch), - nn.ReLU(inplace=True), - nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1), - nn.BatchNorm2d(out_ch), - nn.ReLU(inplace=True), - ) - - def forward(self, x): - return self.net(x) - - -class Down(nn.Module): - """Combination of MaxPool2d and DoubleConv in series. - >>> Down(4, 8) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Down( - (net): Sequential( - (0): MaxPool2d( - kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False) - (1): DoubleConv( - (net): Sequential(...) - ) - ) - ) - """ - - def __init__(self, in_ch: int, out_ch: int): - super().__init__() - self.net = nn.Sequential( - nn.MaxPool2d(kernel_size=2, stride=2), DoubleConv(in_ch, out_ch)) - - def forward(self, x): - return self.net(x) - - -class Up(nn.Module): - """Upsampling (by either bilinear interpolation or transpose convolutions) - followed by concatenation of feature - map from contracting path, followed by double 3x3 convolution. - >>> Up(8, 4) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Up( - (upsample): ConvTranspose2d(8, 4, kernel_size=(2, 2), stride=(2, 2)) - (conv): DoubleConv( - (net): Sequential(...) - ) - ) - """ - - def __init__(self, in_ch: int, out_ch: int, bilinear: bool = False): - super().__init__() - self.upsample = None - if bilinear: - self.upsample = nn.Sequential( - nn.Upsample( - scale_factor=2, mode="bilinear", align_corners=True), - nn.Conv2d( - in_ch, in_ch // 2, kernel_size=1), - ) - else: - self.upsample = nn.ConvTranspose2d( - in_ch, in_ch // 2, kernel_size=2, stride=2) - - self.conv = DoubleConv(in_ch, out_ch) - - def forward(self, x1, x2): - x1 = self.upsample(x1) - - # Pad x1 to the size of x2 - diff_h = x2.shape[2] - x1.shape[2] - diff_w = x2.shape[3] - x1.shape[3] - - x1 = F.pad( - x1, - [ - diff_w // 2, diff_w - diff_w // 2, - diff_h // 2, diff_h - diff_h // 2 - ]) - - # Concatenate along the channels axis - x = torch.cat([x2, x1], dim=1) - return self.conv(x) - - -class SegmentationModel(LightningModule): - - def __init__( - self, - data_path: list = [], - n_classes: int = 18, - batch_size: int = 256, - lr: float = 3e-4, - num_layers: int = 5, - features_start: int = 64, - bilinear: bool = False, - **kwargs, - ): - super().__init__(**kwargs) - self.data_paths = data_path - self.n_classes = n_classes - self.batch_size = batch_size - self.learning_rate = lr - self.num_layers = num_layers - self.features_start = features_start - self.bilinear = bilinear - self.validation_step_outputs = [] - - self.net = UNet( - num_classes=self.n_classes, - num_layers=self.num_layers, - features_start=self.features_start, - bilinear=self.bilinear - ) - self.transform = transforms.Compose( - [ - transforms.ToTensor(), - transforms.Normalize( - mean=[0.0173, 0.0332, 0.0088, - 0.0136, 0.0381, 0.0348, 0.0249], - std=[0.0150, 0.0127, 0.0124, - 0.0128, 0.0120, 0.0159, 0.0164] - ), - ] - ) - print('> Init datasets') - self.trainset = MODISDataset( - self.data_paths, split="train", transform=self.transform) - self.validset = MODISDataset( - self.data_paths, split="valid", transform=self.transform) - print('Done init datasets') - - def forward(self, x): - return self.net(x) - - def training_step(self, batch, batch_nb): - img, mask = batch - img = img.float() - mask = mask.long() - out = self(img) - loss = F.cross_entropy(out, mask, ignore_index=250) - log_dict = {"train_loss": loss} - self.log_dict(log_dict) - return {"loss": loss, "log": log_dict, "progress_bar": log_dict} - - def validation_step(self, batch, batch_idx): - img, mask = batch - img = img.float() - mask = mask.long() - out = self(img) - loss_val = F.cross_entropy(out, mask, ignore_index=250) - self.validation_step_outputs.append(loss_val) - return {"val_loss": loss_val} - - def on_validation_epoch_end(self): - loss_val = torch.stack(self.validation_step_outputs).mean() - log_dict = {"val_loss": loss_val} - self.log("val_loss", loss_val, sync_dist=True) - self.validation_step_outputs.clear() - return { - "log": log_dict, - "val_loss": log_dict["val_loss"], - "progress_bar": log_dict - } - - def configure_optimizers(self): - opt = torch.optim.Adam(self.net.parameters(), lr=self.learning_rate) - # sch = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=10) - return [opt] # , [sch] - - def train_dataloader(self): - return DataLoader( - self.trainset, - batch_size=self.batch_size, - num_workers=multiprocessing.cpu_count(), - shuffle=True - ) - - def val_dataloader(self): - return DataLoader( - self.validset, - batch_size=self.batch_size, - num_workers=multiprocessing.cpu_count(), - shuffle=False - ) - - -def main(hparams: Namespace): - # ------------------------ - # 1 INIT LIGHTNING MODEL - # ------------------------ - ngpus = int(hparams.ngpus) - # PT ligtning does not expect this, del after use - del hparams.ngpus - - model = SegmentationModel(**vars(hparams)) - - # ------------------------ - # 2 SET LOGGER - # ------------------------ - # logger = True - # if hparams.log_wandb: - # logger = WandbLogger() - # # optional: log model topology - # logger.watch(model.net) - - train_callbacks = [ - # TQDMProgressBar(refresh_rate=20), - ModelCheckpoint(dirpath='models/', - monitor='val_loss', - save_top_k=5, - filename='{epoch}-{val_loss:.2f}.ckpt'), - EarlyStopping("val_loss", patience=10, mode='min'), - ] - - # See number of devices - check_gpus_available(ngpus) - - # ------------------------ - # 3 INIT TRAINER - # ------------------------ - # trainer = Trainer( - # ------------------------ - trainer = Trainer( - accelerator="gpu", - devices=ngpus, - strategy="ddp", - min_epochs=1, - max_epochs=500, - callbacks=train_callbacks, - logger=CSVLogger(save_dir="logs/"), - # precision=16 # makes loss nan, need to fix that - ) - - # ------------------------ - # 5 START TRAINING - # ------------------------ - trainer.fit(model) - trainer.save_checkpoint("best_model.ckpt") - - # ------------------------ - # 6 START TEST - # ------------------------ - # test_set = MODISDataset( - # self.data_path, split=None, transform=self.transform) - # test_dataloader = DataLoader(...) - # trainer.test(ckpt_path="best", dataloaders=) - - -if __name__ == "__main__": - cli_lightning_logo() - - parser = ArgumentParser() - parser.add_argument( - "--data_path", nargs='+', required=True, - help="path where dataset is stored") - parser.add_argument('--ngpus', type=int, - default=torch.cuda.device_count(), - help='number of gpus to use') - parser.add_argument( - "--n-classes", type=int, default=18, help="number of classes") - parser.add_argument( - "--batch_size", type=int, default=256, help="size of the batches") - parser.add_argument( - "--lr", type=float, default=3e-4, help="adam: learning rate") - parser.add_argument( - "--num_layers", type=int, default=5, help="number of layers on u-net") - parser.add_argument( - "--features_start", type=float, default=64, - help="number of features in first layer") - parser.add_argument( - "--bilinear", action="store_true", default=False, - help="whether to use bilinear interpolation or transposed") - # parser.add_argument( - # "--log-wandb", action="store_true", default=True, - # help="whether to use wandb as the logger") - hparams = parser.parse_args() - - main(hparams) diff --git a/pytorch_caney/pipelines/pretraining/mim.py b/pytorch_caney/pipelines/pretraining/mim.py deleted file mode 100644 index 3bcc795..0000000 --- a/pytorch_caney/pipelines/pretraining/mim.py +++ /dev/null @@ -1,371 +0,0 @@ -from pytorch_caney.data.datamodules.mim_datamodule \ - import build_mim_dataloader - -from pytorch_caney.models.mim.mim \ - import build_mim_model - -from pytorch_caney.training.mim_utils \ - import build_optimizer, save_checkpoint - -from pytorch_caney.training.mim_utils import get_grad_norm -from pytorch_caney.lr_scheduler import build_scheduler, setup_scaled_lr -from pytorch_caney.ptc_logging import create_logger -from pytorch_caney.config import get_config - -import argparse -import datetime -import joblib -import numpy as np -import os -import time - -import torch -import torch.cuda.amp as amp -import torch.backends.cudnn as cudnn -import torch.distributed as dist - -from timm.utils import AverageMeter - - -def parse_args(): - """ - Parse command-line arguments - """ - parser = argparse.ArgumentParser( - 'pytorch-caney implementation of MiM pre-training script', - add_help=False) - - parser.add_argument( - '--cfg', - type=str, - required=True, - metavar="FILE", - help='path to config file') - - parser.add_argument( - "--data-paths", - nargs='+', - required=True, - help="paths where dataset is stored") - - parser.add_argument( - '--dataset', - type=str, - required=True, - help='Dataset to use') - - parser.add_argument( - '--batch-size', - type=int, - help="batch size for single GPU") - - parser.add_argument( - '--resume', - help='resume from checkpoint') - - parser.add_argument( - '--accumulation-steps', - type=int, - help="gradient accumulation steps") - - parser.add_argument( - '--use-checkpoint', - action='store_true', - help="whether to use gradient checkpointing to save memory") - - parser.add_argument( - '--enable-amp', - action='store_true') - - parser.add_argument( - '--disable-amp', - action='store_false', - dest='enable_amp') - - parser.set_defaults(enable_amp=True) - - parser.add_argument( - '--output', - default='output', - type=str, - metavar='PATH', - help='root of output folder, the full path is ' + - '// (default: output)') - - parser.add_argument( - '--tag', - help='tag of experiment') - - args = parser.parse_args() - - config = get_config(args) - - return args, config - - -def train(config, - dataloader, - model, - model_wo_ddp, - optimizer, - lr_scheduler, - scaler): - """ - Start pre-training a specific model and dataset. - - Args: - config: config object - dataloader: dataloader to use - model: model to pre-train - model_wo_ddp: model to pre-train that is not the DDP version - optimizer: pytorch optimizer - lr_scheduler: learning-rate scheduler - scaler: loss scaler - """ - - logger.info("Start training") - - start_time = time.time() - - for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): - - dataloader.sampler.set_epoch(epoch) - - execute_one_epoch(config, model, dataloader, - optimizer, epoch, lr_scheduler, scaler) - - if dist.get_rank() == 0 and \ - (epoch % config.SAVE_FREQ == 0 or - epoch == (config.TRAIN.EPOCHS - 1)): - - save_checkpoint(config, epoch, model_wo_ddp, 0., - optimizer, lr_scheduler, scaler, logger) - - total_time = time.time() - start_time - - total_time_str = str(datetime.timedelta(seconds=int(total_time))) - - logger.info('Training time {}'.format(total_time_str)) - - -def execute_one_epoch(config, - model, - dataloader, - optimizer, - epoch, - lr_scheduler, - scaler): - """ - Execute training iterations on a single epoch. - - Args: - config: config object - model: model to pre-train - dataloader: dataloader to use - optimizer: pytorch optimizer - epoch: int epoch number - lr_scheduler: learning-rate scheduler - scaler: loss scaler - """ - - model.train() - - optimizer.zero_grad() - - num_steps = len(dataloader) - - # Set up logging meters - batch_time = AverageMeter() - data_time = AverageMeter() - loss_meter = AverageMeter() - norm_meter = AverageMeter() - loss_scale_meter = AverageMeter() - - start = time.time() - end = time.time() - for idx, (img, mask, _) in enumerate(dataloader): - - data_time.update(time.time() - start) - - img = img.cuda(non_blocking=True) - mask = mask.cuda(non_blocking=True) - - with amp.autocast(enabled=config.ENABLE_AMP): - loss = model(img, mask) - - if config.TRAIN.ACCUMULATION_STEPS > 1: - loss = loss / config.TRAIN.ACCUMULATION_STEPS - scaler.scale(loss).backward() - loss.backward() - if config.TRAIN.CLIP_GRAD: - scaler.unscale_(optimizer) - grad_norm = torch.nn.utils.clip_grad_norm_( - model.parameters(), - config.TRAIN.CLIP_GRAD) - else: - grad_norm = get_grad_norm(model.parameters()) - if (idx + 1) % config.TRAIN.ACCUMULATION_STEPS == 0: - scaler.step(optimizer) - optimizer.zero_grad() - scaler.update() - lr_scheduler.step_update(epoch * num_steps + idx) - else: - optimizer.zero_grad() - scaler.scale(loss).backward() - if config.TRAIN.CLIP_GRAD: - scaler.unscale_(optimizer) - grad_norm = torch.nn.utils.clip_grad_norm_( - model.parameters(), - config.TRAIN.CLIP_GRAD) - else: - grad_norm = get_grad_norm(model.parameters()) - scaler.step(optimizer) - scaler.update() - lr_scheduler.step_update(epoch * num_steps + idx) - - torch.cuda.synchronize() - - loss_meter.update(loss.item(), img.size(0)) - norm_meter.update(grad_norm) - loss_scale_meter.update(scaler.get_scale()) - batch_time.update(time.time() - end) - end = time.time() - - if idx % config.PRINT_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) - etas = batch_time.avg * (num_steps - idx) - logger.info( - f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' - f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' - f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' - f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' - f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'grad_norm {norm_meter.val:.4f} ({norm_meter.avg:.4f})\t' - f'loss_scale {loss_scale_meter.val:.4f}' + - f' ({loss_scale_meter.avg:.4f})\t' - f'mem {memory_used:.0f}MB') - - epoch_time = time.time() - start - logger.info( - f"EPOCH {epoch} training takes " + - f"{datetime.timedelta(seconds=int(epoch_time))}") - - -def main(config): - """ - Starts training process after building the proper model, optimizer, etc. - - Args: - config: config object - """ - - pretrain_data_loader = build_mim_dataloader(config, logger) - - simmim_model = build_model(config, logger) - - simmim_optimizer = build_optimizer(config, - simmim_model, - is_pretrain=True, - logger=logger) - - model, model_wo_ddp = make_ddp(simmim_model) - - n_iter_per_epoch = len(pretrain_data_loader) - - lr_scheduler = build_scheduler(config, simmim_optimizer, n_iter_per_epoch) - - scaler = amp.GradScaler() - - train(config, - pretrain_data_loader, - model, - model_wo_ddp, - simmim_optimizer, - lr_scheduler, - scaler) - - -def build_model(config, logger): - - logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") - - model = build_mim_model(config) - - model.cuda() - - logger.info(str(model)) - - return model - - -def make_ddp(model): - - model = torch.nn.parallel.DistributedDataParallel( - model, device_ids=[int(os.environ["RANK"])], broadcast_buffers=False) - - model_without_ddp = model.module - - return model, model_without_ddp - - -def setup_rank_worldsize(): - if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: - rank = int(os.environ["RANK"]) - world_size = int(os.environ['WORLD_SIZE']) - print(f"RANK and WORLD_SIZE in environ: {rank}/{world_size}") - else: - rank = -1 - world_size = -1 - return rank, world_size - - -def setup_distributed_processing(rank, world_size): - torch.cuda.set_device(int(os.environ["RANK"])) - torch.distributed.init_process_group( - backend='nccl', init_method='env://', world_size=world_size, rank=rank) - torch.distributed.barrier() - - -def setup_seeding(config): - seed = config.SEED + dist.get_rank() - torch.manual_seed(seed) - np.random.seed(seed) - - -if __name__ == '__main__': - _, config = parse_args() - - rank, world_size = setup_rank_worldsize() - - setup_distributed_processing(rank, world_size) - - setup_seeding(config) - - cudnn.benchmark = True - - linear_scaled_lr, linear_scaled_min_lr, linear_scaled_warmup_lr = \ - setup_scaled_lr(config) - - config.defrost() - config.TRAIN.BASE_LR = linear_scaled_lr - config.TRAIN.WARMUP_LR = linear_scaled_warmup_lr - config.TRAIN.MIN_LR = linear_scaled_min_lr - config.freeze() - - os.makedirs(config.OUTPUT, exist_ok=True) - logger = create_logger(output_dir=config.OUTPUT, - dist_rank=dist.get_rank(), - name=f"{config.MODEL.NAME}") - - if dist.get_rank() == 0: - path = os.path.join(config.OUTPUT, "config.json") - with open(path, "w") as f: - f.write(config.dump()) - logger.info(f"Full config saved to {path}") - logger.info(config.dump()) - config_file_name = f'{config.TAG}.config.sav' - config_file_path = os.path.join(config.OUTPUT, config_file_name) - joblib.dump(config, config_file_path) - - main(config) diff --git a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py b/pytorch_caney/pipelines/pretraining/mim_deepspeed.py deleted file mode 100644 index 9cdbc86..0000000 --- a/pytorch_caney/pipelines/pretraining/mim_deepspeed.py +++ /dev/null @@ -1,619 +0,0 @@ -from pytorch_caney.data.datasets.mim_modis_22m_dataset import MODIS22MDataset -from pytorch_caney.data.transforms import SimmimTransform -from pytorch_caney.models.mim.mim import build_mim_model -from pytorch_caney.ptc_logging import create_logger -from pytorch_caney.config import get_config -from pytorch_caney.optimizer.build import build_optimizer -import torch.profiler -from torch.profiler import profile, record_function, ProfilerActivity - - -import deepspeed -from deepspeed.accelerator import get_accelerator -from deepspeed.profiling.flops_profiler import FlopsProfiler - -from socket import gethostname -import argparse -import datetime -import joblib -import numpy as np -import os -import sys -import time - -import torch -import torch.distributed as dist - -from timm.utils import AverageMeter - -from torch.utils.tensorboard import SummaryWriter - - -NUM_SAMPLES: int = 1962000 - -def parse_args(): - """ - Parse command-line arguments - """ - parser = argparse.ArgumentParser( - 'pytorch-caney implementation of MiM pre-training script', - add_help=False) - - parser.add_argument( - '--cfg', - type=str, - required=True, - metavar="FILE", - help='path to config file') - - parser.add_argument( - "--data-paths", - nargs='+', - required=True, - help="paths where dataset is stored") - - parser.add_argument( - '--tensorboard-dir', - type=str, - required=True, - help='Dir path for tensorboard to write to.' - ) - - parser.add_argument('--validation-path', - type=str, - required=True, - help='validation dataset path') - - parser.add_argument('--dataset', - type=str, - required=True, - help='Dataset to use') - - parser.add_argument( - '--batch-size', - type=int, - help="batch size for single GPU") - - parser.add_argument( - '--resume', - help='resume from checkpoint') - - parser.add_argument( - '--use-checkpoint', - action='store_true', - help="whether to use gradient checkpointing to save memory") - - parser.add_argument( - '--output', - default='output', - type=str, - metavar='PATH', - help='root of output folder, the full path is ' + - '// (default: output)') - - parser.add_argument( - '--tag', - help='tag of experiment') - - args = parser.parse_args() - - config = get_config(args) - - return args, config - - -def train(config, - resuming_step, - dataloader, - model_engine, - optimizer, - device, - writer, - torchProf): - """ - Start pre-training a specific model and dataset. - - Args: - config: config object - dataloader: dataloader to use - model: model to pre-train - model_wo_ddp: model to pre-train that is not the DDP version - optimizer: pytorch optimizer - lr_scheduler: learning-rate scheduler - """ - - logger.info("Start training") - - target_dtype = None - if model_engine.bfloat16_enabled(): - target_dtype = torch.bfloat16 - elif model_engine.fp16_enabled(): - target_dtype = torch.half - logger.info(f'Target dtype: {target_dtype}') - - - torchProf.start() - - torch.cuda.empty_cache() - - start_time = time.time() - - for epoch in range(config.TRAIN.START_EPOCH, config.TRAIN.EPOCHS): - - start = time.time() - - execute_one_epoch(config, model_engine, dataloader, - optimizer, epoch, resuming_step, - target_dtype, device, writer, torchProf) - - epoch_time = time.time() - start - logger.info( - f"EPOCH {epoch} training takes " + - f"{datetime.timedelta(seconds=int(epoch_time))}") - - - total_time = time.time() - start_time - - total_time_str = str(datetime.timedelta(seconds=int(total_time))) - - logger.info('Training time {}'.format(total_time_str)) - - -def execute_one_epoch(config, - model, - dataloader, - optimizer, - epoch, - resuming_step, - target_dtype, - device, - writer, - torchProf): - """ - Execute training iterations on a single epoch. - - Args: - config: config object - model: model to pre-train - dataloader: dataloader to use - optimizer: pytorch optimizer - epoch: int epoch number - target_dtype: torch dtype, should match model dtype - device: device to move inputs to - """ - validationDataset = validation_setup(config) - - # Setup lamb gradient logging - if config.TRAIN.OPTIMIZER.NAME == 'lamb': - from pytorch_caney.optimizer.lamb import log_lamb_rs - - num_steps = max(1, - NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) - - # Set up logging meters - batch_time = AverageMeter() - data_time = AverageMeter() - loss_meter = AverageMeter() - - # Flops profiler - flopsProf = FlopsProfiler(model) - flops = 0 - macs = 0 - print_profile = True - - start = time.time() - end = time.time() - - for idx, img_mask in enumerate(dataloader): - #Start FLOPS profiling - if idx % config.PRINT_FREQ == 0: - #and idx % config.PRINT_FREQ == 0 and dist.get_rank()==0: - flopsProf.start_profile() - - torchProf.step() - - idx = idx + resuming_step - - img_mask = img_mask[0] - - img = torch.stack([pair[0] for pair in img_mask]) - mask = torch.stack([pair[1] for pair in img_mask]) - - data_time.update(time.time() - start) - - img = img.to(device, non_blocking=True) - mask = mask.to(device, non_blocking=True) - - if target_dtype: - img = img.to(target_dtype) - - loss = model(img, mask) - - model.backward(loss) - - model.step() - - torch.cuda.synchronize() - - loss_meter.update(loss.item(), img.size(0)) - batch_time.update(time.time() - end) - end = time.time() - - if idx % config.VALIDATION_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - validate(model, - validationDataset, - lr, - idx, - epoch, - target_dtype, - device, - writer) - - if idx % config.PRINT_FREQ == 0: - lr = optimizer.param_groups[0]['lr'] - memory_used = torch.cuda.max_memory_allocated() / (1024.0 * 1024.0) - cached_memory = torch.cuda.memory_reserved() / (1024 * 1024) # in MB - max_memory = torch.cuda.max_memory_reserved() / (1024 * 1024) # in MB - etas = batch_time.avg * (num_steps - idx) - #if idx == 100 : - flopsProf.stop_profile() - flops = flopsProf.get_total_flops() - macs = flopsProf.get_total_macs() - - logger.info( - f'Train: [{epoch}/{config.TRAIN.EPOCHS}][{idx}/{num_steps}]\t' - f'eta {datetime.timedelta(seconds=int(etas))} lr {lr:.6f}\t' - f'time {batch_time.val:.4f} ({batch_time.avg:.4f})\t' - f'data_time {data_time.val:.4f} ({data_time.avg:.4f})\t' - f'loss {loss_meter.val:.4f} ({loss_meter.avg:.4f})\t' - f'mem {memory_used:.0f}MB') - writer.add_scalar('training_loss ', loss_meter.val, idx) - writer.add_scalar('memory_usage ', memory_used, idx) - writer.add_scalar('cached_memory', cached_memory, idx) - writer.add_scalar('max_memory', max_memory, idx) - writer.add_scalar('total_flops', flops, idx) - writer.add_scalar('total_macs', macs, idx) - - if config.TRAIN.OPTIMIZER.NAME == 'lamb': - log_lamb_rs(optimizer, writer, idx) - writer.flush() - - if idx % config.SAVE_FREQ == 0 or idx == num_steps-1: - tag = f'ckpt_epoch_{epoch}_step_{idx}' - model.save_checkpoint(save_dir=config.OUTPUT, - tag=tag,) - - if idx == num_steps: - logger.info(f'Ending step loop for epoch {idx}') - break - - torch.distributed.barrier() - - -def main(config): - """ - Starts training process after building the proper model, optimizer, etc. - - Args: - config: config object - """ - - logger.info('In main') - - tensorboardMainDir = config.TENSORBOARD.WRITER_DIR - tensorboardDir = f'{tensorboardMainDir}/{config.TAG}' - logger.info(f'Initializing tensorboard to {tensorboardDir}') - writer = SummaryWriter(tensorboardDir) - - logger.info(f'Initializing torch profiler to {tensorboardDir}') - - # Torch Profiler - torchProf = torch.profiler.profile( - activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], - schedule=torch.profiler.schedule(skip_first=10, - wait=5, - warmup=1, - active=3, - repeat=2), - on_trace_ready=torch.profiler.tensorboard_trace_handler(tensorboardDir), - #on_trace_ready=torch.profiler.tensorboard_trace_handler("./log/svtoa"), - record_shapes=True, - with_flops=True, - with_stack=False, - ) - - - transform = SimmimTransform(config) - - dataset = MODIS22MDataset(config, - config.DATA.DATA_PATHS, - split="train", - img_size=config.DATA.IMG_SIZE, - transform=transform, - batch_size=config.DATA.BATCH_SIZE).dataset() - - dataloader = torch.utils.data.DataLoader( - dataset, - batch_size=None, - num_workers=8, - shuffle=False, - pin_memory=True,) - - logger.info(f'MODEL CHECKPOINTING: {config.TRAIN.USE_CHECKPOINT}') - - simmim_model = build_model(config, logger) - - # Count the total number of parameters - total_params = sum(p.numel() for p in simmim_model.parameters()) - logger.info(f"Total number of parameters: {total_params}") - - # Count the total number of trainable parameters - trainable_params = sum(p.numel() for p in simmim_model.parameters() - if p.requires_grad) - logger.info(f"Total number of trainable parameters: {trainable_params}") - - # Total number of samples in current 2m dataset - # Number of batches (or steps) to process per epoch - num_steps = max( - 1, - NUM_SAMPLES // (config.DATA.BATCH_SIZE * dist.get_world_size())) - - # The step/batch/idx we are resuming from (assume 0 for start) - resuming_step = 0 - resuming_global_step = 0 - - if config.MODEL.RESUME: - load_dir = os.path.dirname(config.MODEL.RESUME) - logger.info(f'Ckpt load dir: {load_dir}') - - tag = os.path.basename(config.MODEL.RESUME) - logger.info(f'Ckpt tag: {tag}') - - epoch = tag.split('_')[2] - logger.info(f'Ckpt epoch: {epoch}') - - step = tag.split('_')[4] - logger.info(f'Ckpt step: {step}') - resuming_step = int(step) - resuming_global_step = int(resuming_step + (int(epoch) * num_steps)) - - # Calculate LR steps - # total steps (or batches) for the entire training iteration - total_steps = num_steps * config.TRAIN.EPOCHS - logger.info(f'Total steps for {config.TRAIN.EPOCHS} epochs: {total_steps}') - - cycle_one_percentage = config.TRAIN.LR_SCHEDULER.CYCLE_PERCENTAGE - cycle_stage_one = int(total_steps * cycle_one_percentage) - cycle_stage_two = (total_steps - cycle_stage_one) - 1 - - logger.info(f'OneCycle: stage-1 step size = {cycle_stage_one}') - logger.info(f'OneCycle: stage-2 step size = {cycle_stage_two}') - logger.info(f'OneCycle: min LR = {config.TRAIN.MIN_LR}') - logger.info(f'OneCycle: max LR = {config.TRAIN.BASE_LR}') - - last_batch_iteration = -1 if resuming_global_step == 0 else resuming_global_step - - deepspeed_config = { - "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, - - "steps_per_print": config.PRINT_FREQ, - "memory_breakdown": False, - "zero_allow_untested_optimizer": True, - - "zero_optimization": { - "stage": 2, - # "offload_optimizer": {"device": "cpu"}, - # "offload_param": {"device": "cpu"}, - "contiguous_gradients": True, - "overlap_comm": True, - "reduce_bucket_size": 5e8, - "allgather_bucket_size": 5e8, - # "offload_optimizer": { - # "device": "cpu" - # }, - }, - - "activation_checkpointing": { - "partition_activations": True, - # "cpu_checkpointing": True, - "profile": False, - }, - - "fp16": { - "enabled": False, - }, - - "bf16": { - "enabled": True, - }, - - "scheduler": { - "type": "OneCycle", - # "type": "WarmupLR", - "params": { - # "lr_range_test_step_size": 10, - # "lr_range_test_step_rate": 4, - # "lr_range_test_min_lr": config.TRAIN.BASE_LR, - # "lr_range_test_staircase": False, - # "warmup_min_lr": config.TRAIN.WARMUP_LR, - # "warmup_max_lr": config.TRAIN.BASE_LR, - # "warmup_num_steps": num_steps, - "cycle_min_lr": config.TRAIN.MIN_LR, - "cycle_max_lr": config.TRAIN.BASE_LR, - "cycle_first_step_size": cycle_stage_one, - "cycle_second_step_size": cycle_stage_two, - "last_batch_iteration": last_batch_iteration, - # "warmup_min_ratio": 0, - # "warmup_num_steps": config.TRAIN.WARMUP_STEPS, - }, - }, - - "flops_profiler": { - "enabled": False, - #"profile_step": 1, - "module_depth": -1, - #"top_modules": 1, - "detailed": True, - "output_file": f'profile_{time.time()}', - }, - - } - - logger.info('Initializing deepspeed') - - # optimizer = torch.optim.AdamW(simmim_model.parameters(), - # lr=config.TRAIN.BASE_LR, - # weight_decay=config.TRAIN.WEIGHT_DECAY) - # optimizer = Lamb(simmim_model.parameters(), - # lr=config.TRAIN.BASE_LR, - # weight_decay=config.TRAIN.WEIGHT_DECAY) - # optimizer = deepspeed.ops.lamb.FusedLamb( - # simmim_model.parameters(), lr=config.TRAIN.BASE_LR, - # weight_decay=config.TRAIN.WEIGHT_DECAY) - optimizer = build_optimizer( - config, simmim_model, is_pretrain=True, logger=logger) - - model_engine, optimizer, _, _ = deepspeed.initialize( - model=simmim_model, - model_parameters=simmim_model.parameters(), - optimizer=optimizer, - dist_init_required=True, - config=deepspeed_config - ) - - if config.MODEL.RESUME: - - load_path, _ = model_engine.load_checkpoint(load_dir=load_dir, - tag=tag) - config.defrost() - config.TRAIN.START_EPOCH = int(epoch) - config.freeze() - - logger.info(f'Loaded from checkpoint: {load_path}') - logger.info(f'Resuming from epoch {config.TRAIN.START_EPOCH}') - - local_rank = model_engine.local_rank - local_device = get_accelerator().device_name(local_rank) - - logger.info('Starting training block') - - torch.distributed.barrier() - - train(config, - resuming_step, - dataloader, - model_engine, - optimizer, - local_device, - writer, - torchProf) - - writer.close() - torchProf.stop() - - -@torch.no_grad() -def validation_setup(config): - transform = SimmimTransform(config) - validation_dataset_path = config.DATA.VALIDATION_PATH - validation_dataset = np.load(validation_dataset_path) - len_batch = range(validation_dataset.shape[0]) - imgMasks = [transform(validation_dataset[idx]) for idx \ - in len_batch] - img = torch.stack([imgMask[0] for imgMask in imgMasks]) - mask = torch.stack([torch.from_numpy(imgMask[1]) for \ - imgMask in imgMasks]) - return img, mask - - -@torch.no_grad() -def validate(model, img_masks, lr, step, epoch, target_dtype, device, writer): - start_time = time.time() - - img, mask = img_masks - - img = img.to(device, non_blocking=True) - mask = mask.cuda(device, non_blocking=True) - - if target_dtype: - img = img.to(target_dtype) - - loss = model(img, mask) - - validation_time = time.time() - start_time - - logger.info( - f"Validation: [{step}/{epoch}]\t" - f"lr {lr}\t" - f"val_loss {loss:.4f}\t" - f"time {validation_time:.4f}s") - writer.add_scalar('validation_loss', loss, step) - writer.flush() - - del img, mask, loss - - -def build_model(config, logger): - - logger.info(f"Creating model:{config.MODEL.TYPE}/{config.MODEL.NAME}") - - model = build_mim_model(config) - - return model - - -def setup_seeding(config): - seed = config.SEED + dist.get_rank() - torch.manual_seed(seed) - np.random.seed(seed) - - -if __name__ == '__main__': - _, config = parse_args() - - world_size = int(os.environ["WORLD_SIZE"]) - rank = int(os.environ["RANK"]) - gpus_per_node = torch.cuda.device_count() - print(f" {gpus_per_node} allocated GPUs per node.", flush=True) - - deepspeed.init_distributed() - - torch.distributed.barrier() - - print(f"Hello from rank {rank} of {world_size} on" - f" {gethostname()} where there are" - f" {gpus_per_node} allocated GPUs per node.", flush=True) - - if rank == 0: - print(f"Group initialized? {dist.is_initialized()}", flush=True) - - setup_seeding(config) - - config.defrost() - base_batch_size = 512 - config.TRAIN.BASE_LR = (config.TRAIN.BASE_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.TRAIN.WARMUP_LR = (config.TRAIN.WARMUP_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.TRAIN.MIN_LR = (config.TRAIN.MIN_LR * config.DATA.BATCH_SIZE * dist.get_world_size()) / base_batch_size - config.freeze() - - os.makedirs(config.OUTPUT, exist_ok=True) - logger = create_logger(output_dir=config.OUTPUT, - dist_rank=dist.get_rank(), - name=f"{config.MODEL.NAME}") - - if dist.get_rank() == 0: - path = os.path.join(config.OUTPUT, "config.json") - with open(path, "w") as f: - f.write(config.dump()) - logger.info(f"Full config saved to {path}") - logger.info(config.dump()) - config_file_name = f'{config.TAG}.config.sav' - config_file_path = os.path.join(config.OUTPUT, config_file_name) - joblib.dump(config, config_file_path) - - logger.info(f'Base LR (scaled): {config.TRAIN.BASE_LR}') - logger.info(f'Warmup LR (scaled): {config.TRAIN.WARMUP_LR}') - logger.info(f'Min LR (scaled): {config.TRAIN.MIN_LR}') - - sys.exit(main(config)) diff --git a/pytorch_caney/processing.py b/pytorch_caney/processing.py deleted file mode 100755 index 30723d0..0000000 --- a/pytorch_caney/processing.py +++ /dev/null @@ -1,410 +0,0 @@ -import logging -import random -from tqdm import tqdm - -import numpy as np -from numpy import fliplr, flipud - -import scipy.signal - - -SEED = 42 -np.random.seed(SEED) - -__author__ = "Jordan A Caraballo-Vega, Science Data Processing Branch" -__email__ = "jordan.a.caraballo-vega@nasa.gov" -__status__ = "Production" - -# ---------------------------------------------------------------------------- -# module processing -# -# General functions to perform standardization of images (numpy arrays). -# A couple of methods have been implemented for testing, including global and -# local standardization for neural networks input. Data manipulation stage, -# extract random patches for training and store them in numpy arrays. -# --------------------------------------------------------------------------- - -# --------------------------------------------------------------------------- -# Module Methods -# --------------------------------------------------------------------------- - - -# --------------------------- Normalization Functions ----------------------- # -def normalize(images, factor=65535.0) -> np.array: - """ - Normalize numpy array in the range of [0,1] - :param images: numpy array in the format (n,w,h,c). - :param factor: float number to normalize images, e.g. 2^(16)-1 - :return: numpy array in the [0,1] range - """ - return images / factor - - -# ------------------------ Standardization Functions ----------------------- # -def global_standardization(images, strategy='per-batch') -> np.array: - """ - Standardize numpy array using global standardization. - :param images: numpy array in the format (n,w,h,c). - :param strategy: can select between per-image or per-batch. - :return: globally standardized numpy array - """ - if strategy == 'per-batch': - mean = np.mean(images) # global mean of all images - std = np.std(images) # global std of all images - for i in range(images.shape[0]): # for each image in images - images[i, :, :, :] = (images[i, :, :, :] - mean) / std - elif strategy == 'per-image': - for i in range(images.shape[0]): # for each image in images - mean = np.mean(images[i, :, :, :]) # image mean - std = np.std(images[i, :, :, :]) # image std - images[i, :, :, :] = (images[i, :, :, :] - mean) / std - return images - - -def local_standardization(images, filename='normalization_data', - ndata=None, strategy='per-batch' - ) -> np.array: - """ - Standardize numpy array using local standardization. - :param images: numpy array in the format (n,w,h,c). - :param filename: filename to store mean and std data. - :param ndata: pandas df with mean and std values for each channel. - :param strategy: can select between per-image or per-batch. - :return: locally standardized numpy array - """ - if ndata: # for inference only - for i in range(images.shape[-1]): # for each channel in images - # standardize all images based on given mean and std - images[:, :, :, i] = \ - (images[:, :, :, i] - ndata['channel_mean'][i]) / \ - ndata['channel_std'][i] - return images - elif strategy == 'per-batch': # for all images in batch - f = open(filename + "_norm_data.csv", "w+") - f.write( - "i,channel_mean,channel_std,channel_mean_post,channel_std_post\n" - ) - for i in range(images.shape[-1]): # for each channel in images - channel_mean = np.mean(images[:, :, :, i]) # mean for each channel - channel_std = np.std(images[:, :, :, i]) # std for each channel - images[:, :, :, i] = \ - (images[:, :, :, i] - channel_mean) / channel_std - channel_mean_post = np.mean(images[:, :, :, i]) - channel_std_post = np.std(images[:, :, :, i]) - # write to file for each channel - f.write('{},{},{},{},{}\n'.format(i, channel_mean, channel_std, - channel_mean_post, - channel_std_post - ) - ) - f.close() # close file - elif strategy == 'per-image': # standardization for each image - for i in range(images.shape[0]): # for each image - for j in range(images.shape[-1]): # for each channel in images - channel_mean = np.mean(images[i, :, :, j]) - channel_std = np.std(images[i, :, :, j]) - images[i, :, :, j] = \ - (images[i, :, :, j] - channel_mean) / channel_std - else: - raise RuntimeError(f'Standardization <{strategy}> not supported') - - return images - - -def standardize_image( - image, - standardization_type: str, - mean: list = None, - std: list = None, - global_min: list = None, - global_max: list = None -): - """ - Standardize image within parameter, simple scaling of values. - Loca, Global, and Mixed options. - """ - image = image.astype(np.float32) - if standardization_type == 'local': - for i in range(image.shape[-1]): - image[:, :, i] = (image[:, :, i] - np.mean(image[:, :, i])) / \ - (np.std(image[:, :, i]) + 1e-8) - elif standardization_type == 'minmax': - for i in range(image.shape[-1]): - image[:, :, i] = (image[:, :, i] - 0) / (55-0) - elif standardization_type == 'localminmax': - for i in range(image.shape[-1]): - image[:, :, i] = (image[:, :, i] - np.min(image[:, :, 0])) / \ - (np.max(image[:, :, i])-np.min(image[:, :, i])) - elif standardization_type == 'globalminmax': - for i in range(image.shape[-1]): - image[:, :, i] = (image[:, :, i] - global_min) / \ - (global_max - global_min) - elif standardization_type == 'global': - for i in range(image.shape[-1]): - image[:, :, i] = (image[:, :, i] - mean[i]) / (std[i] + 1e-8) - elif standardization_type == 'mixed': - raise NotImplementedError - return image - - -def standardize_batch( - image_batch, - standardization_type: str, - mean: list = None, - std: list = None -): - """ - Standardize image within parameter, simple scaling of values. - Loca, Global, and Mixed options. - """ - for item in range(image_batch.shape[0]): - image_batch[item, :, :, :] = standardize_image( - image_batch[item, :, :, :], standardization_type, mean, std) - return image_batch - -# ------------------------ Data Preparation Functions ----------------------- # - - -def get_rand_patches_rand_cond(img, mask, n_patches=16000, sz=160, nclasses=6, - nodata_ascloud=True, method='rand' - ) -> np.array: - """ - Generate training data. - :param images: ndarray in the format (w,h,c). - :param mask: integer ndarray with shape (x_sz, y_sz) - :param n_patches: number of patches - :param sz: tile size, will be used for both height and width - :param nclasses: number of classes present in the output data - :param nodata_ascloud: convert no-data values to cloud labels - :param method: choose between rand, cond, cloud - rand - select N number of random patches for each image - cond - select N number of random patches for each image, - with the condition of having 1+ class per tile. - cloud - select tiles that have clouds - :return: two numpy array with data and labels. - """ - if nodata_ascloud: - # if no-data present, change to final class - mask = mask.values # return numpy array - mask[mask > nclasses] = nclasses # some no-data are 255 or other big - mask[mask < 0] = nclasses # some no-data are -128 or smaller negative - - patches = [] # list to store data patches - labels = [] # list to store label patches - - for i in tqdm(range(n_patches)): - - # Generate random integers from image - xc = random.randint(0, img.shape[0] - sz) - yc = random.randint(0, img.shape[1] - sz) - - if method == 'cond': - # while loop to regenerate random ints if tile has only one class - while len(np.unique(mask[xc:(xc+sz), yc:(yc+sz)])) == 1 or \ - 6 in mask[xc:(xc+sz), yc:(yc+sz)] or \ - img[xc:(xc+sz), yc:(yc+sz), :].values.min() < 0: - xc = random.randint(0, img.shape[0] - sz) - yc = random.randint(0, img.shape[1] - sz) - elif method == 'rand': - while 6 in mask[xc:(xc+sz), yc:(yc+sz)] or \ - img[xc:(xc+sz), yc:(yc+sz), :].values.min() < 0: - xc = random.randint(0, img.shape[0] - sz) - yc = random.randint(0, img.shape[1] - sz) - elif method == 'cloud': - while np.count_nonzero(mask[xc:(xc+sz), yc:(yc+sz)] == 6) < 15: - xc = random.randint(0, img.shape[0] - sz) - yc = random.randint(0, img.shape[1] - sz) - - # Generate img and mask patches - patch_img = img[xc:(xc + sz), yc:(yc + sz)] - patch_mask = mask[xc:(xc + sz), yc:(yc + sz)] - - # Apply some random transformations - random_transformation = np.random.randint(1, 7) - if random_transformation == 1: # flip left and right - patch_img = fliplr(patch_img) - patch_mask = fliplr(patch_mask) - elif random_transformation == 2: # reverse second dimension - patch_img = flipud(patch_img) - patch_mask = flipud(patch_mask) - elif random_transformation == 3: # rotate 90 degrees - patch_img = np.rot90(patch_img, 1) - patch_mask = np.rot90(patch_mask, 1) - elif random_transformation == 4: # rotate 180 degrees - patch_img = np.rot90(patch_img, 2) - patch_mask = np.rot90(patch_mask, 2) - elif random_transformation == 5: # rotate 270 degrees - patch_img = np.rot90(patch_img, 3) - patch_mask = np.rot90(patch_mask, 3) - else: # original image - pass - patches.append(patch_img) - labels.append(patch_mask) - return np.asarray(patches), np.asarray(labels) - - -def get_rand_patches_aug_augcond(img, mask, n_patches=16000, sz=256, - nclasses=6, over=50, nodata_ascloud=True, - nodata=-9999, method='augcond' - ) -> np.array: - """ - Generate training data. - :param images: ndarray in the format (w,h,c). - :param mask: integer ndarray with shape (x_sz, y_sz) - :param n_patches: number of patches - :param sz: tile size, will be used for both height and width - :param nclasses: number of classes present in the output data - :param over: number of pixels to overlap between images - :param nodata_ascloud: convert no-data values to cloud labels - :param method: choose between rand, cond, cloud - aug - select N * 8 number of random patches for each - image after data augmentation. - augcond - select N * 8 number of random patches for - each image, with the condition of having 1+ per - tile, after data augmentation. - :return: two numpy array with data and labels. - """ - mask = mask.values # return numpy array - - if nodata_ascloud: - # if no-data present, change to final class - mask[mask > nclasses] = nodata # some no-data are 255 or other big - mask[mask < 0] = nodata # some no-data are -128 or smaller negative - - patches = [] # list to store data patches - labels = [] # list to store label patches - - for i in tqdm(range(n_patches)): - - # Generate random integers from image - xc = random.randint(0, img.shape[0] - sz - sz) - yc = random.randint(0, img.shape[1] - sz - sz) - - if method == 'augcond': - # while loop to regenerate random ints if tile has only one class - while len(np.unique(mask[xc:(xc + sz), yc:(yc + sz)])) == 1 or \ - nodata in mask[xc:(xc + sz), yc:(yc + sz)] or \ - nodata in mask[(xc + sz - over):(xc + sz + sz - over), - (yc + sz - over):(yc + sz + sz - over)] or \ - nodata in mask[(xc + sz - over):(xc + sz + sz - over), - yc:(yc + sz)]: - xc = random.randint(0, img.shape[0] - sz - sz) - yc = random.randint(0, img.shape[1] - sz - sz) - elif method == 'aug': - # while loop to regenerate random ints if tile has only one class - while nodata in mask[xc:(xc + sz), yc:(yc + sz)] or \ - nodata in mask[(xc + sz - over):(xc + sz + sz - over), - (yc + sz - over):(yc + sz + sz - over)] or \ - nodata in mask[(xc + sz - over):(xc + sz + sz - over), - yc:(yc + sz)]: - xc = random.randint(0, img.shape[0] - sz - sz) - yc = random.randint(0, img.shape[1] - sz - sz) - - # Generate img and mask patches - patch_img = img[xc:(xc + sz), yc:(yc + sz)] # original image patch - patch_mask = mask[xc:(xc + sz), yc:(yc + sz)] # original mask patch - - # Apply transformations for data augmentation - # 1. No augmentation and append to list - patches.append(patch_img) - labels.append(patch_mask) - - # 2. Rotate 90 and append to list - patches.append(np.rot90(patch_img, 1)) - labels.append(np.rot90(patch_mask, 1)) - - # 3. Rotate 180 and append to list - patches.append(np.rot90(patch_img, 2)) - labels.append(np.rot90(patch_mask, 2)) - - # 4. Rotate 270 - patches.append(np.rot90(patch_img, 3)) - labels.append(np.rot90(patch_mask, 3)) - - # 5. Flipped up and down’ - patches.append(flipud(patch_img)) - labels.append(flipud(patch_mask)) - - # 6. Flipped left and right - patches.append(fliplr(patch_img)) - labels.append(fliplr(patch_mask)) - - # 7. overlapping tiles - next tile, down - patches.append(img[(xc + sz - over):(xc + sz + sz - over), - (yc + sz - over):(yc + sz + sz - over)]) - labels.append(mask[(xc + sz - over):(xc + sz + sz - over), - (yc + sz - over):(yc + sz + sz - over)]) - - # 8. overlapping tiles - next tile, side - patches.append(img[(xc + sz - over):(xc + sz + sz - over), - yc:(yc + sz)]) - labels.append(mask[(xc + sz - over):(xc + sz + sz - over), - yc:(yc + sz)]) - return np.asarray(patches), np.asarray(labels) - - -# ------------------------ Artifact Removal Functions ----------------------- # - -def _2d_spline(window_size=128, power=2) -> np.array: - """ - Window method for boundaries/edge artifacts smoothing. - :param window_size: size of window/tile to smooth - :param power: spline polinomial power to use - :return: smoothing distribution numpy array - """ - intersection = int(window_size/4) - tria = scipy.signal.triang(window_size) - wind_outer = (abs(2*(tria)) ** power)/2 - wind_outer[intersection:-intersection] = 0 - - wind_inner = 1 - (abs(2*(tria - 1)) ** power)/2 - wind_inner[:intersection] = 0 - wind_inner[-intersection:] = 0 - - wind = wind_inner + wind_outer - wind = wind / np.average(wind) - wind = np.expand_dims(np.expand_dims(wind, 1), 2) - wind = wind * wind.transpose(1, 0, 2) - return wind - - -def _hann_matrix(window_size=128, power=2) -> np.array: - logging.info("Placeholder for next release.") - - -# ------------------------------------------------------------------------------- -# module preprocessing Unit Tests -# ------------------------------------------------------------------------------- -if __name__ == "__main__": - - logging.basicConfig(level=logging.INFO) - - # Unit Test #1 - Testing normalization distributions - x = (np.random.randint(65536, size=(10, 128, 128, 6))).astype('float32') - x_norm = normalize(x, factor=65535) # apply static normalization - assert x_norm.max() == 1.0, "Unexpected max value." - logging.info(f"UT #1 PASS: {x_norm.mean()}, {x_norm.std()}") - - # Unit Test #2 - Testing standardization distributions - standardized = global_standardization(x_norm, strategy='per-batch') - assert standardized.max() > 1.731, "Unexpected max value." - logging.info(f"UT #2 PASS: {standardized.mean()}, {standardized.std()}") - - # Unit Test #3 - Testing standardization distributions - standardized = global_standardization(x_norm, strategy='per-image') - assert standardized.max() > 1.73, "Unexpected max value." - logging.info(f"UT #3 PASS: {standardized.mean()}, {standardized.std()}") - - # Unit Test #4 - Testing standardization distributions - standardized = local_standardization(x_norm, filename='normalization_data', - strategy='per-batch' - ) - assert standardized.max() > 1.74, "Unexpected max value." - logging.info(f"UT #4 PASS: {standardized.mean()}, {standardized.std()}") - - # Unit Test #5 - Testing standardization distributions - standardized = local_standardization(x_norm, filename='normalization_data', - strategy='per-image' - ) - assert standardized.max() > 1.75, "Unexpected max value." - logging.info(f"UT #5 PASS: {standardized.mean()}, {standardized.std()}") diff --git a/pytorch_caney/console/__init__.py b/pytorch_caney/ptc_cli.py old mode 100755 new mode 100644 similarity index 100% rename from pytorch_caney/console/__init__.py rename to pytorch_caney/ptc_cli.py diff --git a/pytorch_caney/ptc_logging.py b/pytorch_caney/ptc_logging.py deleted file mode 100644 index 3b76462..0000000 --- a/pytorch_caney/ptc_logging.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -import sys -import logging -import functools -from termcolor import colored - - -@functools.lru_cache() -def create_logger(output_dir, dist_rank=0, name=''): - # create logger - logger = logging.getLogger(name) - - logger.setLevel(logging.DEBUG) - - logger.propagate = False - - # create formatter - fmt = '[%(asctime)s %(name)s] ' + \ - '(%(filename)s %(lineno)d): ' + \ - '%(levelname)s %(message)s' - - color_fmt = colored('[%(asctime)s %(name)s]', 'green') + \ - colored('(%(filename)s %(lineno)d)', 'yellow') + \ - ': %(levelname)s %(message)s' - - # create console handlers for master process - if dist_rank == 0: - - console_handler = logging.StreamHandler(sys.stdout) - - console_handler.setLevel(logging.DEBUG) - - console_handler.setFormatter( - logging.Formatter(fmt=color_fmt, datefmt='%Y-%m-%d %H:%M:%S')) - - logger.addHandler(console_handler) - - # create file handlers - file_handler = logging.FileHandler(os.path.join( - output_dir, f'log_rank{dist_rank}.txt'), mode='a') - - file_handler.setLevel(logging.DEBUG) - - file_handler.setFormatter(logging.Formatter( - fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')) - - logger.addHandler(file_handler) - - return logger diff --git a/pytorch_caney/tests/config/test_config.yaml b/pytorch_caney/tests/config/test_config.yaml deleted file mode 100644 index 525ff79..0000000 --- a/pytorch_caney/tests/config/test_config.yaml +++ /dev/null @@ -1,29 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: test_config - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 128 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 12 -DATA: - IMG_SIZE: 192 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -TRAIN: - EPOCHS: 800 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -LOSS: - NAME: 'tversky' -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: test_config_tag \ No newline at end of file diff --git a/pytorch_caney/tests/test_build.py b/pytorch_caney/tests/test_build.py deleted file mode 100644 index a472882..0000000 --- a/pytorch_caney/tests/test_build.py +++ /dev/null @@ -1,50 +0,0 @@ -from pytorch_caney.models.build import build_model -from pytorch_caney.config import get_config - -import unittest -import argparse -import logging - - -class TestBuildModel(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - config_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - args = argparse.Namespace(cfg=config_path) - self.config = get_config(args) - self.logger = logging.getLogger("TestLogger") - self.logger.setLevel(logging.DEBUG) - - def test_build_mim_model(self): - _ = build_model(self.config, - pretrain=True, - pretrain_method='mim', - logger=self.logger) - # Add assertions here to validate the returned 'model' instance - # For example: self.assertIsInstance(model, YourMimModelClass) - - def test_build_swinv2_encoder(self): - _ = build_model(self.config, logger=self.logger) - # Add assertions here to validate the returned 'model' instance - # For example: self.assertIsInstance(model, SwinTransformerV2) - - def test_build_unet_decoder(self): - self.config.defrost() - self.config.MODEL.DECODER = 'unet' - self.config.freeze() - _ = build_model(self.config, logger=self.logger) - # Add assertions here to validate the returned 'model' instance - # For example: self.assertIsInstance(model, YourUnetSwinModelClass) - - def test_unknown_decoder_architecture(self): - self.config.defrost() - self.config.MODEL.DECODER = 'unknown_decoder' - self.config.freeze() - with self.assertRaises(NotImplementedError): - build_model(self.config, logger=self.logger) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_config.py b/pytorch_caney/tests/test_config.py deleted file mode 100644 index f75c534..0000000 --- a/pytorch_caney/tests/test_config.py +++ /dev/null @@ -1,44 +0,0 @@ -from pytorch_caney.config import get_config - -import argparse -import unittest - - -class TestConfig(unittest.TestCase): - - @classmethod - def setUpClass(cls): - cls.config_yaml_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - - def test_default_config(self): - # Get the default configuration - args = argparse.Namespace(cfg=self.config_yaml_path) - config = get_config(args) - - # Test specific configuration values - self.assertEqual(config.DATA.BATCH_SIZE, 128) - self.assertEqual(config.DATA.DATASET, 'MODIS') - self.assertEqual(config.MODEL.TYPE, 'swinv2') - self.assertEqual(config.MODEL.NAME, 'test_config') - self.assertEqual(config.TRAIN.EPOCHS, 800) - - def test_custom_config(self): - # Test with custom arguments - args = argparse.Namespace( - cfg=self.config_yaml_path, - batch_size=64, - dataset='CustomDataset', - data_paths=['solongandthanksforallthefish'], - ) - config = get_config(args) - - # Test specific configuration values with custom arguments - self.assertEqual(config.DATA.BATCH_SIZE, 64) - self.assertEqual(config.DATA.DATASET, 'CustomDataset') - self.assertEqual(config.DATA.DATA_PATHS, - ['solongandthanksforallthefish']) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_data.py b/pytorch_caney/tests/test_data.py deleted file mode 100644 index d6a5852..0000000 --- a/pytorch_caney/tests/test_data.py +++ /dev/null @@ -1,38 +0,0 @@ -from pytorch_caney.data.datamodules.finetune_datamodule \ - import get_dataset_from_dict - -from pytorch_caney.data.datamodules.finetune_datamodule \ - import DATASETS - -import unittest - - -class TestGetDatasetFromDict(unittest.TestCase): - - def test_existing_datasets(self): - # Test existing datasets - for dataset_name in ['modis', 'modislc9', 'modislc5']: - dataset = get_dataset_from_dict(dataset_name) - self.assertIsNotNone(dataset) - - def test_non_existing_dataset(self): - # Test non-existing dataset - invalid_dataset_name = 'invalid_dataset' - with self.assertRaises(KeyError) as context: - get_dataset_from_dict(invalid_dataset_name) - expected_error_msg = f'"{invalid_dataset_name} ' + \ - 'is not an existing dataset. Available datasets:' + \ - f' {DATASETS.keys()}"' - self.assertEqual(str(context.exception), expected_error_msg) - - def test_dataset_name_case_insensitive(self): - # Test case insensitivity - dataset_name = 'MoDiSLC5' - dataset = get_dataset_from_dict(dataset_name) - self.assertIsNotNone(dataset) - -# Add more test cases as needed - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_inference.py b/pytorch_caney/tests/test_inference.py deleted file mode 100644 index 85f565d..0000000 --- a/pytorch_caney/tests/test_inference.py +++ /dev/null @@ -1,50 +0,0 @@ -import unittest -import argparse -import rioxarray as rxr -import segmentation_models_pytorch as smp - -from pytorch_caney.inference import sliding_window_tiler_multiclass - - -class TestInference(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - #config_path = 'pytorch_caney/' + \ - # 'tests/config/test_config.yaml' - #args = argparse.Namespace(cfg=config_path) - #self.config = get_config(args) - cog_url = ( - "https://oin-hotosm.s3.amazonaws.com/" - "5d7dad0becaf880008a9bc88/0/5d7dad0becaf880008a9bc89.tif" - ) - self.raster = rxr.open_rasterio(cog_url, masked=True, overview_level=4) - self.raster = self.raster.transpose("y", "x", "band") - - def test_sliding_window_tiler_multiclass(self): - - print(self.raster.shape) - - model = smp.Unet('resnet34', classes=4) - - sliding_window_tiler_multiclass( - self.raster, - model, - n_classes=4, - img_size=128, - pad_style='reflect', - overlap=0.50, - constant_value=600, - batch_size=1024, - threshold=0.50, - standardization=None, - mean=None, - std=None, - normalize=1.0, - rescale=None, - window='triang', # 'overlap-tile' - probability_map=False - ) - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_loss_build.py b/pytorch_caney/tests/test_loss_build.py deleted file mode 100644 index 9d6149e..0000000 --- a/pytorch_caney/tests/test_loss_build.py +++ /dev/null @@ -1,28 +0,0 @@ -import unittest -import argparse - -from pytorch_caney.config import get_config -from pytorch_caney.loss.build import build_loss - - -class TestLossBuild(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - config_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - args = argparse.Namespace(cfg=config_path) - self.config = get_config(args) - - def test_build_loss(self): - build_loss(self.config) - - def test_build_loss_fail(self): - fail_config = self.config - fail_config.defrost() - fail_config.LOSS.NAME = 'dummy_loss' - self.assertRaises(KeyError, build_loss, fail_config) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_loss_utils.py b/pytorch_caney/tests/test_loss_utils.py deleted file mode 100644 index 74a256a..0000000 --- a/pytorch_caney/tests/test_loss_utils.py +++ /dev/null @@ -1,46 +0,0 @@ -from pytorch_caney.loss.utils import to_tensor - -import unittest -import numpy as np -import torch - - -class TestToTensorFunction(unittest.TestCase): - - def test_tensor_input(self): - tensor = torch.tensor([1, 2, 3]) - result = to_tensor(tensor) - self.assertTrue(torch.equal(result, tensor)) - - def test_tensor_input_with_dtype(self): - tensor = torch.tensor([1, 2, 3]) - result = to_tensor(tensor, dtype=torch.float32) - self.assertTrue(torch.equal(result, tensor.float())) - - def test_numpy_array_input(self): - numpy_array = np.array([1, 2, 3]) - expected_tensor = torch.tensor([1, 2, 3]) - result = to_tensor(numpy_array) - self.assertTrue(torch.equal(result, expected_tensor)) - - def test_numpy_array_input_with_dtype(self): - numpy_array = np.array([1, 2, 3]) - expected_tensor = torch.tensor([1, 2, 3], dtype=torch.float32) - result = to_tensor(numpy_array, dtype=torch.float32) - self.assertTrue(torch.equal(result, expected_tensor)) - - def test_list_input(self): - input_list = [1, 2, 3] - expected_tensor = torch.tensor([1, 2, 3]) - result = to_tensor(input_list) - self.assertTrue(torch.equal(result, expected_tensor)) - - def test_list_input_with_dtype(self): - input_list = [1, 2, 3] - expected_tensor = torch.tensor([1, 2, 3], dtype=torch.float32) - result = to_tensor(input_list, dtype=torch.float32) - self.assertTrue(torch.equal(result, expected_tensor)) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_lr_scheduler.py b/pytorch_caney/tests/test_lr_scheduler.py deleted file mode 100644 index f0cd7f2..0000000 --- a/pytorch_caney/tests/test_lr_scheduler.py +++ /dev/null @@ -1,48 +0,0 @@ -from pytorch_caney.lr_scheduler import build_scheduler - -import unittest -from unittest.mock import Mock, patch - - -class TestBuildScheduler(unittest.TestCase): - def setUp(self): - self.config = Mock( - TRAIN=Mock( - EPOCHS=300, - WARMUP_EPOCHS=20, - MIN_LR=1e-6, - WARMUP_LR=1e-7, - LR_SCHEDULER=Mock( - NAME='cosine', - DECAY_EPOCHS=30, - DECAY_RATE=0.1, - MULTISTEPS=[50, 100], - GAMMA=0.1 - ) - ) - ) - - self.optimizer = Mock() - self.n_iter_per_epoch = 100 # Example value - - def test_build_cosine_scheduler(self): - with patch('pytorch_caney.lr_scheduler.CosineLRScheduler') \ - as mock_cosine_scheduler: - _ = build_scheduler(self.config, - self.optimizer, - self.n_iter_per_epoch) - - mock_cosine_scheduler.assert_called_once_with( - self.optimizer, - t_initial=300 * 100, - cycle_mul=1., - lr_min=1e-6, - warmup_lr_init=1e-7, - warmup_t=20 * 100, - cycle_limit=1, - t_in_epochs=False - ) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_metrics.py b/pytorch_caney/tests/test_metrics.py deleted file mode 100644 index 166987f..0000000 --- a/pytorch_caney/tests/test_metrics.py +++ /dev/null @@ -1,33 +0,0 @@ -import unittest -import argparse -import numpy as np -from pytorch_caney.config import get_config -from pytorch_caney import metrics - - -class TestMetrics(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - config_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - args = argparse.Namespace(cfg=config_path) - self.config = get_config(args) - self.dummy_y_true = np.ones((10, 10)) - self.dummy_y_pred = np.ones((10, 10)) - - def test_iou_val(self): - metrics.iou_val(self.dummy_y_true, self.dummy_y_pred) - - def test_acc_val(self): - metrics.acc_val(self.dummy_y_true, self.dummy_y_pred) - - def test_prec_val(self): - metrics.prec_val(self.dummy_y_true, self.dummy_y_pred) - - def test_recall_val(self): - metrics.recall_val(self.dummy_y_true, self.dummy_y_pred) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_mim_utils.py b/pytorch_caney/tests/test_mim_utils.py deleted file mode 100644 index 19cf531..0000000 --- a/pytorch_caney/tests/test_mim_utils.py +++ /dev/null @@ -1,503 +0,0 @@ -import unittest -from unittest.mock import Mock, patch -import torch -import numpy as np -from pytorch_caney.training.mim_utils import (build_optimizer, - set_weight_decay, - check_keywords_in_name, - get_pretrain_param_groups, - get_swin_layer, - remap_pretrained_keys_swin, - remap_pretrained_keys_vit, - load_pretrained, - reduce_tensor) - - - -class TestBuildOptimizer(unittest.TestCase): - - def setUp(self): - self.config = Mock() - self.config.TRAIN.LAYER_DECAY = 0.8 - self.config.TRAIN.BASE_LR = 0.001 - self.config.TRAIN.WEIGHT_DECAY = 0.05 - self.config.TRAIN.OPTIMIZER.EPS = 1e-8 - self.config.TRAIN.OPTIMIZER.BETAS = (0.9, 0.999) - self.model = Mock() - self.logger = Mock() - - @patch('pytorch_caney.training.mim_utils.get_pretrain_param_groups') - def test_build_optimizer_pretrain(self, mock_get_pretrain): - mock_get_pretrain.return_value = [{'params': [torch.nn.Parameter(torch.randn(2, 2))]}] - - optimizer = build_optimizer(self.config, self.model, is_pretrain=True, logger=self.logger) - - self.assertIsNotNone(optimizer) - mock_get_pretrain.assert_called_once() - self.logger.info.assert_called() - - @patch('pytorch_caney.training.mim_utils.get_finetune_param_groups') - def test_build_optimizer_finetune_swin(self, mock_get_finetune): - self.config.MODEL.TYPE = 'swin' - self.config.MODEL.SWIN.DEPTHS = [2, 2, 6, 2] - mock_get_finetune.return_value = [{'params': [torch.nn.Parameter(torch.randn(2, 2))]}] - - optimizer = build_optimizer(self.config, self.model, is_pretrain=False, logger=self.logger) - - self.assertIsNotNone(optimizer) - mock_get_finetune.assert_called_once() - self.logger.info.assert_called() - - @patch('pytorch_caney.training.mim_utils.get_finetune_param_groups') - def test_build_optimizer_finetune_swinv2(self, mock_get_finetune): - self.config.MODEL.TYPE = 'swinv2' - self.config.MODEL.SWINV2.DEPTHS = [2, 2, 6, 2] - mock_get_finetune.return_value = [{'params': [torch.nn.Parameter(torch.randn(2, 2))]}] - - optimizer = build_optimizer(self.config, self.model, is_pretrain=False, logger=self.logger) - - self.assertIsNotNone(optimizer) - mock_get_finetune.assert_called_once() - self.logger.info.assert_called() - - @patch('pytorch_caney.training.mim_utils.get_pretrain_param_groups') - def test_no_weight_decay(self, mock_get_pretrain): - self.model.no_weight_decay.return_value = {'skip_param'} - self.model.no_weight_decay_keywords.return_value = {'skip_keyword'} - mock_get_pretrain.return_value = [{'params': [torch.nn.Parameter(torch.randn(2, 2))]}] - - build_optimizer(self.config, self.model, is_pretrain=True, logger=self.logger) - - self.model.no_weight_decay.assert_called_once() - self.model.no_weight_decay_keywords.assert_called_once() - mock_get_pretrain.assert_called_once() - - -class TestSetWeightDecay(unittest.TestCase): - - def setUp(self): - self.model = Mock() - - def test_basic_weight_decay(self): - # Create a mock model with some parameters - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(1)) - param3 = torch.nn.Parameter(torch.randn(5, 5)) - - self.model.named_parameters.return_value = [ - ('layer1.weight', param1), - ('layer1.bias', param2), - ('layer2.weight', param3) - ] - - result = set_weight_decay(self.model) - - self.assertEqual(len(result), 2) - self.assertEqual(len(result[0]['params']), 2) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - self.assertEqual(result[1]['weight_decay'], 0.) - - def test_skip_list(self): - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(5, 5)) - - self.model.named_parameters.return_value = [ - ('layer1.weight', param1), - ('layer2.weight', param2) - ] - - result = set_weight_decay(self.model, skip_list=('layer1.weight',)) - - self.assertEqual(len(result[0]['params']), 1) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - - def test_skip_keywords(self): - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(5, 5)) - - self.model.named_parameters.return_value = [ - ('layer1_skip.weight', param1), - ('layer2.weight', param2) - ] - - result = set_weight_decay(self.model, skip_keywords=('skip',)) - - self.assertEqual(len(result[0]['params']), 1) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - - def test_frozen_weights(self): - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(5, 5)) - param2.requires_grad = False - - self.model.named_parameters.return_value = [ - ('layer1.weight', param1), - ('layer2.weight', param2) - ] - - result = set_weight_decay(self.model) - - self.assertEqual(len(result[0]['params']), 1) # has_decay - self.assertEqual(len(result[1]['params']), 0) # no_decay - - -class TestCheckKeywordsInName(unittest.TestCase): - - def test_no_keywords(self): - self.assertFalse(check_keywords_in_name("test_name")) - - def test_keyword_match(self): - self.assertTrue(check_keywords_in_name("test_name", ("test",))) - - def test_keyword_no_match(self): - self.assertFalse(check_keywords_in_name("test_name", ("keyword",))) - - def test_multiple_keywords(self): - self.assertTrue(check_keywords_in_name("test_name", ("test", "other"))) - self.assertFalse(check_keywords_in_name("test_name", ("keyword1", "keyword2"))) - -class TestGetPretrainParamGroups(unittest.TestCase): - - def setUp(self): - self.model = Mock() - - def test_param_grouping(self): - # Create mock parameters - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(1)) - param3 = torch.nn.Parameter(torch.randn(5, 5)) - param4 = torch.nn.Parameter(torch.randn(3, 3)) - param4.requires_grad = False - - # Set up mock model's named_parameters - self.model.named_parameters.return_value = [ - ('layer1.weight', param1), - ('layer1.bias', param2), - ('layer2.weight', param3), - ('layer3.weight', param4) - ] - - result = get_pretrain_param_groups(self.model) - - self.assertEqual(len(result), 2) - self.assertEqual(len(result[0]['params']), 2) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - self.assertEqual(result[1]['weight_decay'], 0.) - - def test_skip_list(self): - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(5, 5)) - - self.model.named_parameters.return_value = [ - ('layer1.weight', param1), - ('layer2.weight', param2) - ] - - result = get_pretrain_param_groups(self.model, skip_list=('layer1.weight',)) - - self.assertEqual(len(result[0]['params']), 1) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - - def test_skip_keywords(self): - param1 = torch.nn.Parameter(torch.randn(10, 10)) - param2 = torch.nn.Parameter(torch.randn(5, 5)) - - self.model.named_parameters.return_value = [ - ('layer1_skip.weight', param1), - ('layer2.weight', param2) - ] - - result = get_pretrain_param_groups(self.model, skip_keywords=('skip',)) - - self.assertEqual(len(result[0]['params']), 1) # has_decay - self.assertEqual(len(result[1]['params']), 1) # no_decay - - - -class TestGetSwinLayer(unittest.TestCase): - """ - Test suite for the get_swin_layer function. - - This test suite covers various scenarios for the get_swin_layer function: - 1. Testing special cases like 'mask_token' and 'patch_embed' - 2. Testing layer identification for different parts of the Swin Transformer - 3. Testing the default case for unknown layer names - - The tests use a sample depths configuration of [2, 2, 6, 2] and a total of 14 layers - (sum of depths + 2) to simulate a realistic Swin Transformer architecture. - """ - - def setUp(self): - self.num_layers = 14 # sum of depths (2+2+6+2) + 2 - self.depths = [2, 2, 6, 2] - - def test_special_cases(self): - self.assertEqual(get_swin_layer("mask_token", self.num_layers, self.depths), 0) - self.assertEqual(get_swin_layer("patch_embed", self.num_layers, self.depths), 0) - - def test_layers(self): - self.assertEqual(get_swin_layer("layers.0.0.norm", self.num_layers, self.depths), 2) - self.assertEqual(get_swin_layer("layers.1.1.norm", self.num_layers, self.depths), 4) - self.assertEqual(get_swin_layer("layers.2.5.norm", self.num_layers, self.depths), 10) - self.assertEqual(get_swin_layer("layers.3.1.reduction", self.num_layers, self.depths), 12) - - def test_reduction_and_norm(self): - self.assertEqual(get_swin_layer("layers.0.1.reduction", self.num_layers, self.depths), 2) - self.assertEqual(get_swin_layer("layers.1.1.norm", self.num_layers, self.depths), 4) - self.assertEqual(get_swin_layer("layers.2.2.norm", self.num_layers, self.depths), 10) - self.assertEqual(get_swin_layer("layers.3.2.norm", self.num_layers, self.depths), 12) - - def test_unknown_layer(self): - self.assertEqual(get_swin_layer("unknown_layer", self.num_layers, self.depths), 13) - - -class TestReduceTensor(unittest.TestCase): - """ - Test suite for the reduce_tensor function. - - This test covers: - 1. Tensor reduction across distributed processes - 2. Correct averaging of the reduced tensor - """ - - @patch('torch.distributed.all_reduce') - @patch('torch.distributed.get_world_size') - def test_reduce_tensor(self, mock_get_world_size, mock_all_reduce): - # Setup - input_tensor = torch.tensor([1.0, 2.0, 3.0]) - mock_get_world_size.return_value = 4 - - # Mock the all_reduce function to simulate summing across processes - def mock_all_reduce_func(tensor, op): - tensor *= 4 # Simulate summing across 4 processes - - mock_all_reduce.side_effect = mock_all_reduce_func - - # Call the function - result = reduce_tensor(input_tensor) - - # Assertions - expected_result = torch.tensor([1.0, 2.0, 3.0]) # (4 * input) / 4 - torch.testing.assert_close(result, expected_result) - - # Check if all_reduce was called - mock_all_reduce.assert_called_once() - - # Check if get_world_size was called - mock_get_world_size.assert_called_once() - - -class TestLoadPretrained(unittest.TestCase): - """ - Test suite for the load_pretrained function. - - This test covers: - 1. Loading a pre-trained model - 2. Handling of encoder prefix in checkpoint keys - 3. Remapping keys for SWIN models - 4. Loading state dict into the model - """ - - def setUp(self): - self.config = Mock() - self.model = Mock() - self.logger = Mock() - - @patch('torch.load') - @patch('torch.cuda.empty_cache') - @patch('pytorch_caney.training.mim_utils.remap_pretrained_keys_swin') - def test_load_pretrained(self, mock_remap, mock_empty_cache, mock_load): - # Setup - self.config.MODEL.PRETRAINED = 'pretrained_model.pth' - self.config.MODEL.TYPE = 'swin' - - # Mock torch.load - mock_load.return_value = { - 'model': { - 'encoder.layer1': torch.randn(3, 3), - 'encoder.layer2': torch.randn(3, 3), - 'other_key': torch.randn(3, 3) - } - } - - # Mock remap_pretrained_keys_swin - mock_remap.return_value = { - 'layer1': torch.randn(3, 3), - 'layer2': torch.randn(3, 3) - } - - # Mock model.load_state_dict - self.model.load_state_dict.return_value = Mock() - - # Call the function - load_pretrained(self.config, self.model, self.logger) - - # Assertions - mock_load.assert_called_once_with('pretrained_model.pth', map_location='cpu') - mock_remap.assert_called_once() - self.model.load_state_dict.assert_called_once() - mock_empty_cache.assert_called_once() - - # Check logger calls - self.logger.info.assert_any_call(">>>>>>>>>> Fine-tuned from pretrained_model.pth ..........") - self.logger.info.assert_any_call('Detect pre-trained model, remove [encoder.] prefix.') - self.logger.info.assert_any_call(">>>>>>>>>> Remapping pre-trained keys for SWIN ..........") - self.logger.info.assert_any_call(">>>>>>>>>> loaded successfully 'pretrained_model.pth'") - - @patch('torch.load') - def test_load_pretrained_non_encoder(self, mock_load): - # Setup for a non-encoder model - self.config.MODEL.PRETRAINED = 'non_encoder_model.pth' - self.config.MODEL.TYPE = 'swin' - - mock_load.return_value = { - 'model': { - 'layer1': torch.randn(3, 3), - 'layer2': torch.randn(3, 3) - } - } - - # Call the function - load_pretrained(self.config, self.model, self.logger) - - # Check logger calls - self.logger.info.assert_any_call('Detect non-pre-trained model, pass without doing anything.') - - @patch('torch.load') - def test_load_pretrained_unsupported_model(self, mock_load): - # Setup for an unsupported model type - self.config.MODEL.PRETRAINED = 'unsupported_model.pth' - self.config.MODEL.TYPE = 'unsupported' - - mock_load.return_value = {'model': {}} - - # Check that NotImplementedError is raised - with self.assertRaises(NotImplementedError): - load_pretrained(self.config, self.model, self.logger) - - -class TestRemapPretrainedKeysSwin(unittest.TestCase): - """ - Test suite for the remap_pretrained_keys_swin function. - - This test covers: - 1. Geometric interpolation for mismatched patch sizes - 2. Handling of relative position bias tables - 3. Removal of specific keys from the checkpoint model - """ - - def setUp(self): - self.model = Mock() - self.checkpoint_model = {} - self.logger = Mock() - - @patch('numpy.arange') - @patch('scipy.interpolate.interp2d') - def test_remap_pretrained_keys_swin(self, mock_interp2d, mock_arange): - # Setup mock model state dict - self.model.state_dict.return_value = { - "layers.0.blocks.0.attn.relative_position_bias_table": torch.randn(49, 3) - } - - # Setup mock checkpoint model - self.checkpoint_model = { - "layers.0.blocks.0.attn.relative_position_bias_table": torch.randn(25, 3), - "layers.0.blocks.0.attn.relative_position_index": torch.randn(49), - "layers.0.blocks.0.attn.relative_coords_table": torch.randn(49, 2), - "layers.0.blocks.0.attn.attn_mask": torch.randn(1, 1, 49, 49) - } - - # Mock interpolation - mock_interp2d.return_value = lambda x, y: np.random.rand(7, 7) - mock_arange.return_value = np.array([-3, -2, -1, 0, 1, 2, 3]) - - # Call the function - result = remap_pretrained_keys_swin(self.model, self.checkpoint_model, self.logger) - - # Assertions - self.assertIn("layers.0.blocks.0.attn.relative_position_bias_table", result) - self.assertEqual(result["layers.0.blocks.0.attn.relative_position_bias_table"].shape, (49, 3)) - - # Check if specific keys are removed - self.assertNotIn("layers.0.blocks.0.attn.relative_position_index", result) - self.assertNotIn("layers.0.blocks.0.attn.relative_coords_table", result) - self.assertNotIn("layers.0.blocks.0.attn.attn_mask", result) - - # Verify logger calls - self.logger.info.assert_called() - - def test_mismatched_heads(self): - # Setup for mismatched number of heads - self.model.state_dict.return_value = { - "layers.0.blocks.0.attn.relative_position_bias_table": torch.randn(49, 4) - } - self.checkpoint_model = { - "layers.0.blocks.0.attn.relative_position_bias_table": torch.randn(49, 3) - } - - result = remap_pretrained_keys_swin(self.model, self.checkpoint_model, self.logger) - - # The original tensor should remain unchanged - self.assertTrue(torch.equal(result["layers.0.blocks.0.attn.relative_position_bias_table"], - self.checkpoint_model["layers.0.blocks.0.attn.relative_position_bias_table"])) - - # Verify logger calls - self.logger.info.assert_called_with("Error in loading layers.0.blocks.0.attn.relative_position_bias_table, passing......") - - -class TestRemapPretrainedKeysVit(unittest.TestCase): - """ - Test suite for the remap_pretrained_keys_vit function. - - This test covers: - 1. Handling of relative position bias - 2. Geometric interpolation for mismatched patch sizes - 3. Proper key remapping in the checkpoint model - """ - - def setUp(self): - self.model = Mock() - self.checkpoint_model = {} - self.logger = Mock() - - @patch('torch.Tensor') - @patch('numpy.arange') - @patch('scipy.interpolate.interp2d') - def test_remap_pretrained_keys(self, mock_interp2d, mock_arange, mock_tensor): - # Setup mock model - self.model.use_rel_pos_bias = True - self.model.get_num_layers.return_value = 2 - self.model.patch_embed.patch_shape = [16, 16] - self.model.state_dict.return_value = { - "blocks.0.attn.relative_position_bias_table": torch.randn(49, 3), - "blocks.1.attn.relative_position_bias_table": torch.randn(49, 3) - } - - # Setup mock checkpoint model - self.checkpoint_model = { - "rel_pos_bias.relative_position_bias_table": torch.randn(49, 3), - "blocks.0.attn.relative_position_bias_table": torch.randn(25, 3), - "blocks.1.attn.relative_position_bias_table": torch.randn(25, 3), - "blocks.0.attn.relative_position_index": torch.randn(49), - "blocks.1.attn.relative_position_index": torch.randn(49) - } - - # Mock interpolation - mock_interp2d.return_value = lambda x, y: np.random.rand(7, 7) - mock_arange.return_value = np.array([-3, -2, -1, 0, 1, 2, 3]) - mock_tensor.return_value = torch.randn(49, 1) - - # Call the function - result = remap_pretrained_keys_vit(self.model, self.checkpoint_model, self.logger) - - # Assertions - self.assertNotIn("rel_pos_bias.relative_position_bias_table", result) - self.assertNotIn("blocks.0.attn.relative_position_index", result) - self.assertNotIn("blocks.1.attn.relative_position_index", result) - self.assertIn("blocks.0.attn.relative_position_bias_table", result) - self.assertIn("blocks.1.attn.relative_position_bias_table", result) - self.assertEqual(result["blocks.0.attn.relative_position_bias_table"].shape, (49, 3)) - self.assertEqual(result["blocks.1.attn.relative_position_bias_table"].shape, (49, 3)) - - # Verify logger calls - self.logger.info.assert_called() diff --git a/pytorch_caney/tests/test_models_simmim_simmim.py b/pytorch_caney/tests/test_models_simmim_simmim.py deleted file mode 100644 index ddef369..0000000 --- a/pytorch_caney/tests/test_models_simmim_simmim.py +++ /dev/null @@ -1,22 +0,0 @@ -import unittest -import argparse - -from pytorch_caney.config import get_config -from pytorch_caney.models.simmim.simmim import build_mim_model - - -class TestSimmim(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - config_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - args = argparse.Namespace(cfg=config_path) - self.config = get_config(args) - - def test_build_model(self): - build_mim_model(self.config) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/tests/test_transforms.py b/pytorch_caney/tests/test_transforms.py deleted file mode 100644 index 6aa2001..0000000 --- a/pytorch_caney/tests/test_transforms.py +++ /dev/null @@ -1,70 +0,0 @@ -from pytorch_caney.config import get_config -from pytorch_caney.data.transforms import SimmimTransform -from pytorch_caney.data.transforms import TensorResizeTransform - -import argparse -import unittest -import torch -import numpy as np - - -class TestTransforms(unittest.TestCase): - - def setUp(self): - # Initialize any required configuration here - config_path = 'pytorch_caney/' + \ - 'tests/config/test_config.yaml' - args = argparse.Namespace(cfg=config_path) - self.config = get_config(args) - - def test_simmim_transform(self): - - # Create an instance of SimmimTransform - transform = SimmimTransform(self.config) - - # Create a sample ndarray - img = np.random.randn(self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE, - 14) - - # Apply the transform - img_transformed, mask = transform(img) - - # Assertions - self.assertIsInstance(img_transformed, torch.Tensor) - self.assertEqual(img_transformed.shape, (14, - self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE)) - self.assertIsInstance(mask, np.ndarray) - - def test_tensor_resize_transform(self): - # Create an instance of TensorResizeTransform - transform = TensorResizeTransform(self.config) - - # Create a sample image tensor - img = np.random.randn(self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE, - 14) - - target = np.random.randint(0, 5, - size=((self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE))) - - # Apply the transform - img_transformed = transform(img) - target_transformed = transform(target) - - # Assertions - self.assertIsInstance(img_transformed, torch.Tensor) - self.assertEqual(img_transformed.shape, - (14, self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE)) - - self.assertIsInstance(target_transformed, torch.Tensor) - self.assertEqual(target_transformed.shape, - (1, self.config.DATA.IMG_SIZE, - self.config.DATA.IMG_SIZE)) - - -if __name__ == '__main__': - unittest.main() diff --git a/pytorch_caney/training/fine_tuning.py b/pytorch_caney/training/fine_tuning.py deleted file mode 100644 index e69de29..0000000 diff --git a/pytorch_caney/training/mim_utils.py b/pytorch_caney/training/mim_utils.py deleted file mode 100644 index 949f307..0000000 --- a/pytorch_caney/training/mim_utils.py +++ /dev/null @@ -1,706 +0,0 @@ -from functools import partial -from torch import optim as optim - -import os -import torch -import torch.distributed as dist -import numpy as np -from scipy import interpolate - - -def build_optimizer(config, model, is_pretrain=False, logger=None): - """ - Build optimizer, set weight decay of normalization to 0 by default. - AdamW only. - """ - logger.info('>>>>>>>>>> Build Optimizer') - - skip = {} - - skip_keywords = {} - - if hasattr(model, 'no_weight_decay'): - skip = model.no_weight_decay() - - if hasattr(model, 'no_weight_decay_keywords'): - skip_keywords = model.no_weight_decay_keywords() - - if is_pretrain: - parameters = get_pretrain_param_groups(model, skip, skip_keywords) - - else: - - depths = config.MODEL.SWIN.DEPTHS if config.MODEL.TYPE == 'swin' \ - else config.MODEL.SWINV2.DEPTHS - - num_layers = sum(depths) - - get_layer_func = partial(get_swin_layer, - num_layers=num_layers + 2, - depths=depths) - - scales = list(config.TRAIN.LAYER_DECAY ** i for i in - reversed(range(num_layers + 2))) - - parameters = get_finetune_param_groups(model, - config.TRAIN.BASE_LR, - config.TRAIN.WEIGHT_DECAY, - get_layer_func, - scales, - skip, - skip_keywords) - - optimizer = None - - optimizer = optim.AdamW(parameters, - eps=config.TRAIN.OPTIMIZER.EPS, - betas=config.TRAIN.OPTIMIZER.BETAS, - lr=config.TRAIN.BASE_LR, - weight_decay=config.TRAIN.WEIGHT_DECAY) - - logger.info(optimizer) - - return optimizer - - -def set_weight_decay(model, skip_list=(), skip_keywords=()): - """ - - Args: - model (_type_): _description_ - skip_list (tuple, optional): _description_. Defaults to (). - skip_keywords (tuple, optional): _description_. Defaults to (). - - Returns: - _type_: _description_ - """ - - has_decay = [] - - no_decay = [] - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue # frozen weights - - if len(param.shape) == 1 or name.endswith(".bias") \ - or (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - no_decay.append(param) - - else: - - has_decay.append(param) - - return [{'params': has_decay}, - {'params': no_decay, 'weight_decay': 0.}] - - -def check_keywords_in_name(name, keywords=()): - - isin = False - - for keyword in keywords: - - if keyword in name: - - isin = True - - return isin - - -def get_pretrain_param_groups(model, skip_list=(), skip_keywords=()): - - has_decay = [] - - no_decay = [] - - has_decay_name = [] - - no_decay_name = [] - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") or \ - (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - no_decay.append(param) - - no_decay_name.append(name) - - else: - - has_decay.append(param) - - has_decay_name.append(name) - - return [{'params': has_decay}, - {'params': no_decay, 'weight_decay': 0.}] - - -def get_swin_layer(name, num_layers, depths): - - if name in ("mask_token"): - - return 0 - - elif name.startswith("patch_embed"): - - return 0 - - elif name.startswith("layers"): - - layer_id = int(name.split('.')[1]) - - block_id = name.split('.')[3] - - if block_id == 'reduction' or block_id == 'norm': - - return sum(depths[:layer_id + 1]) - - layer_id = sum(depths[:layer_id]) + int(block_id) - - return layer_id + 1 - - else: - - return num_layers - 1 - - -def get_finetune_param_groups(model, - lr, - weight_decay, - get_layer_func, - scales, - skip_list=(), - skip_keywords=()): - - parameter_group_names = {} - - parameter_group_vars = {} - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") \ - or (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - group_name = "no_decay" - - this_weight_decay = 0. - - else: - - group_name = "decay" - - this_weight_decay = weight_decay - - if get_layer_func is not None: - - layer_id = get_layer_func(name) - - group_name = "layer_%d_%s" % (layer_id, group_name) - - else: - - layer_id = None - - if group_name not in parameter_group_names: - - if scales is not None: - - scale = scales[layer_id] - - else: - - scale = 1. - - parameter_group_names[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale, - } - - parameter_group_vars[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale - } - - parameter_group_vars[group_name]["params"].append(param) - - parameter_group_names[group_name]["params"].append(name) - - return list(parameter_group_vars.values()) - - -def load_checkpoint(config, model, optimizer, lr_scheduler, scaler, logger): - - logger.info(f">>>>>>>>>> Resuming from {config.MODEL.RESUME} ..........") - - if config.MODEL.RESUME.startswith('https'): - - checkpoint = torch.hub.load_state_dict_from_url( - config.MODEL.RESUME, map_location='cpu', check_hash=True) - - else: - - checkpoint = torch.load(config.MODEL.RESUME, map_location='cpu') - - # re-map keys due to name change (only for loading provided models) - rpe_mlp_keys = [k for k in checkpoint['model'].keys() if "rpe_mlp" in k] - - for k in rpe_mlp_keys: - - checkpoint['model'][k.replace( - 'rpe_mlp', 'cpb_mlp')] = checkpoint['model'].pop(k) - - msg = model.load_state_dict(checkpoint['model'], strict=False) - - logger.info(msg) - - max_accuracy = 0.0 - - if not config.EVAL_MODE and 'optimizer' in checkpoint \ - and 'lr_scheduler' in checkpoint \ - and 'scaler' in checkpoint \ - and 'epoch' in checkpoint: - - optimizer.load_state_dict(checkpoint['optimizer']) - - lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) - - scaler.load_state_dict(checkpoint['scaler']) - - config.defrost() - config.TRAIN.START_EPOCH = checkpoint['epoch'] + 1 - config.freeze() - - logger.info( - f"=> loaded successfully '{config.MODEL.RESUME}' " + - f"(epoch {checkpoint['epoch']})") - - if 'max_accuracy' in checkpoint: - max_accuracy = checkpoint['max_accuracy'] - - else: - max_accuracy = 0.0 - - del checkpoint - - torch.cuda.empty_cache() - - return max_accuracy - - -def save_checkpoint(config, epoch, model, max_accuracy, - optimizer, lr_scheduler, scaler, logger): - - save_state = {'model': model.state_dict(), - 'optimizer': optimizer.state_dict(), - 'lr_scheduler': lr_scheduler.state_dict(), - 'scaler': scaler.state_dict(), - 'max_accuracy': max_accuracy, - 'epoch': epoch, - 'config': config} - - save_path = os.path.join(config.OUTPUT, f'ckpt_epoch_{epoch}.pth') - - logger.info(f"{save_path} saving......") - - torch.save(save_state, save_path) - - logger.info(f"{save_path} saved !!!") - - -def get_grad_norm(parameters, norm_type=2): - - if isinstance(parameters, torch.Tensor): - - parameters = [parameters] - - parameters = list(filter(lambda p: p.grad is not None, parameters)) - - norm_type = float(norm_type) - - total_norm = 0 - - for p in parameters: - - param_norm = p.grad.data.norm(norm_type) - - total_norm += param_norm.item() ** norm_type - - total_norm = total_norm ** (1. / norm_type) - - return total_norm - - -def auto_resume_helper(output_dir, logger): - - checkpoints = os.listdir(output_dir) - - checkpoints = [ckpt for ckpt in checkpoints if ckpt.endswith('pth')] - - logger.info(f"All checkpoints founded in {output_dir}: {checkpoints}") - - if len(checkpoints) > 0: - - latest_checkpoint = max([os.path.join(output_dir, d) - for d in checkpoints], key=os.path.getmtime) - - logger.info(f"The latest checkpoint founded: {latest_checkpoint}") - - resume_file = latest_checkpoint - - else: - - resume_file = None - - return resume_file - - -def reduce_tensor(tensor): - - rt = tensor.clone() - - dist.all_reduce(rt, op=dist.ReduceOp.SUM) - - rt /= dist.get_world_size() - - return rt - - -def load_pretrained(config, model, logger): - - logger.info( - f">>>>>>>>>> Fine-tuned from {config.MODEL.PRETRAINED} ..........") - - checkpoint = torch.load(config.MODEL.PRETRAINED, map_location='cpu') - - checkpoint_model = checkpoint['model'] - - if any([True if 'encoder.' in k else - False for k in checkpoint_model.keys()]): - - checkpoint_model = {k.replace( - 'encoder.', ''): v for k, v in checkpoint_model.items() - if k.startswith('encoder.')} - - logger.info('Detect pre-trained model, remove [encoder.] prefix.') - - else: - - logger.info( - 'Detect non-pre-trained model, pass without doing anything.') - - if config.MODEL.TYPE in ['swin', 'swinv2']: - - logger.info( - ">>>>>>>>>> Remapping pre-trained keys for SWIN ..........") - - checkpoint = remap_pretrained_keys_swin( - model, checkpoint_model, logger) - - else: - - raise NotImplementedError - - msg = model.load_state_dict(checkpoint_model, strict=False) - - logger.info(msg) - - del checkpoint - - torch.cuda.empty_cache() - - logger.info(f">>>>>>>>>> loaded successfully '{config.MODEL.PRETRAINED}'") - - -def remap_pretrained_keys_swin(model, checkpoint_model, logger): - - state_dict = model.state_dict() - - # Geometric interpolation when pre-trained patch size mismatch - # with fine-tuned patch size - all_keys = list(checkpoint_model.keys()) - - for key in all_keys: - - if "relative_position_bias_table" in key: - - logger.info(f"Key: {key}") - - rel_position_bias_table_pretrained = checkpoint_model[key] - - rel_position_bias_table_current = state_dict[key] - - L1, nH1 = rel_position_bias_table_pretrained.size() - - L2, nH2 = rel_position_bias_table_current.size() - - if nH1 != nH2: - logger.info(f"Error in loading {key}, passing......") - - else: - - if L1 != L2: - - logger.info( - f"{key}: Interpolate " + - "relative_position_bias_table using geo.") - - src_size = int(L1 ** 0.5) - - dst_size = int(L2 ** 0.5) - - def geometric_progression(a, r, n): - return a * (1.0 - r ** n) / (1.0 - r) - - left, right = 1.01, 1.5 - - while right - left > 1e-6: - - q = (left + right) / 2.0 - - gp = geometric_progression(1, q, src_size // 2) - - if gp > dst_size // 2: - - right = q - - else: - - left = q - - # if q > 1.090307: - # q = 1.090307 - - dis = [] - - cur = 1 - - for i in range(src_size // 2): - - dis.append(cur) - - cur += q ** (i + 1) - - r_ids = [-_ for _ in reversed(dis)] - - x = r_ids + [0] + dis - - y = r_ids + [0] + dis - - t = dst_size // 2.0 - - dx = np.arange(-t, t + 0.1, 1.0) - - dy = np.arange(-t, t + 0.1, 1.0) - - logger.info("Original positions = %s" % str(x)) - - logger.info("Target positions = %s" % str(dx)) - - all_rel_pos_bias = [] - - for i in range(nH1): - - z = rel_position_bias_table_pretrained[:, i].view( - src_size, src_size).float().numpy() - - f_cubic = interpolate.interp2d(x, y, z, kind='cubic') - - all_rel_pos_bias_host = \ - torch.Tensor(f_cubic(dx, dy) - ).contiguous().view(-1, 1) - - all_rel_pos_bias.append( - all_rel_pos_bias_host.to( - rel_position_bias_table_pretrained.device)) - - new_rel_pos_bias = torch.cat(all_rel_pos_bias, dim=-1) - - checkpoint_model[key] = new_rel_pos_bias - - # delete relative_position_index since we always re-init it - relative_position_index_keys = [ - k for k in checkpoint_model.keys() if "relative_position_index" in k] - - for k in relative_position_index_keys: - - del checkpoint_model[k] - - # delete relative_coords_table since we always re-init it - relative_coords_table_keys = [ - k for k in checkpoint_model.keys() if "relative_coords_table" in k] - - for k in relative_coords_table_keys: - - del checkpoint_model[k] - - # delete attn_mask since we always re-init it - attn_mask_keys = [k for k in checkpoint_model.keys() if "attn_mask" in k] - - for k in attn_mask_keys: - - del checkpoint_model[k] - - return checkpoint_model - - -def remap_pretrained_keys_vit(model, checkpoint_model, logger): - - # Duplicate shared rel_pos_bias to each layer - if getattr(model, 'use_rel_pos_bias', False) and \ - "rel_pos_bias.relative_position_bias_table" in checkpoint_model: - - logger.info( - "Expand the shared relative position " + - "embedding to each transformer block.") - - num_layers = model.get_num_layers() - - rel_pos_bias = \ - checkpoint_model["rel_pos_bias.relative_position_bias_table"] - - for i in range(num_layers): - - checkpoint_model["blocks.%d.attn.relative_position_bias_table" % - i] = rel_pos_bias.clone() - - checkpoint_model.pop("rel_pos_bias.relative_position_bias_table") - - # Geometric interpolation when pre-trained patch - # size mismatch with fine-tuned patch size - all_keys = list(checkpoint_model.keys()) - - for key in all_keys: - - if "relative_position_index" in key: - - checkpoint_model.pop(key) - - if "relative_position_bias_table" in key: - - rel_pos_bias = checkpoint_model[key] - - src_num_pos, num_attn_heads = rel_pos_bias.size() - - dst_num_pos, _ = model.state_dict()[key].size() - - dst_patch_shape = model.patch_embed.patch_shape - - if dst_patch_shape[0] != dst_patch_shape[1]: - - raise NotImplementedError() - - num_extra_tokens = dst_num_pos - \ - (dst_patch_shape[0] * 2 - 1) * (dst_patch_shape[1] * 2 - 1) - - src_size = int((src_num_pos - num_extra_tokens) ** 0.5) - - dst_size = int((dst_num_pos - num_extra_tokens) ** 0.5) - - if src_size != dst_size: - - logger.info("Position interpolate for " + - "%s from %dx%d to %dx%d" % ( - key, - src_size, - src_size, - dst_size, - dst_size)) - - extra_tokens = rel_pos_bias[-num_extra_tokens:, :] - - rel_pos_bias = rel_pos_bias[:-num_extra_tokens, :] - - def geometric_progression(a, r, n): - - return a * (1.0 - r ** n) / (1.0 - r) - - left, right = 1.01, 1.5 - - while right - left > 1e-6: - - q = (left + right) / 2.0 - - gp = geometric_progression(1, q, src_size // 2) - - if gp > dst_size // 2: - - right = q - - else: - - left = q - - # if q > 1.090307: - # q = 1.090307 - - dis = [] - - cur = 1 - - for i in range(src_size // 2): - - dis.append(cur) - - cur += q ** (i + 1) - - r_ids = [-_ for _ in reversed(dis)] - - x = r_ids + [0] + dis - - y = r_ids + [0] + dis - - t = dst_size // 2.0 - - dx = np.arange(-t, t + 0.1, 1.0) - - dy = np.arange(-t, t + 0.1, 1.0) - - logger.info("Original positions = %s" % str(x)) - - logger.info("Target positions = %s" % str(dx)) - - all_rel_pos_bias = [] - - for i in range(num_attn_heads): - - z = rel_pos_bias[:, i].view( - src_size, src_size).float().numpy() - - f = interpolate.interp2d(x, y, z, kind='cubic') - - all_rel_pos_bias_host = \ - torch.Tensor(f(dx, dy)).contiguous().view(-1, 1) - - all_rel_pos_bias.append( - all_rel_pos_bias_host.to(rel_pos_bias.device)) - - rel_pos_bias = torch.cat(all_rel_pos_bias, dim=-1) - - new_rel_pos_bias = torch.cat( - (rel_pos_bias, extra_tokens), dim=0) - - checkpoint_model[key] = new_rel_pos_bias - - return checkpoint_model diff --git a/pytorch_caney/training/pre_training.py b/pytorch_caney/training/pre_training.py deleted file mode 100644 index e69de29..0000000 diff --git a/pytorch_caney/training/simmim_utils.py b/pytorch_caney/training/simmim_utils.py deleted file mode 100644 index 949f307..0000000 --- a/pytorch_caney/training/simmim_utils.py +++ /dev/null @@ -1,706 +0,0 @@ -from functools import partial -from torch import optim as optim - -import os -import torch -import torch.distributed as dist -import numpy as np -from scipy import interpolate - - -def build_optimizer(config, model, is_pretrain=False, logger=None): - """ - Build optimizer, set weight decay of normalization to 0 by default. - AdamW only. - """ - logger.info('>>>>>>>>>> Build Optimizer') - - skip = {} - - skip_keywords = {} - - if hasattr(model, 'no_weight_decay'): - skip = model.no_weight_decay() - - if hasattr(model, 'no_weight_decay_keywords'): - skip_keywords = model.no_weight_decay_keywords() - - if is_pretrain: - parameters = get_pretrain_param_groups(model, skip, skip_keywords) - - else: - - depths = config.MODEL.SWIN.DEPTHS if config.MODEL.TYPE == 'swin' \ - else config.MODEL.SWINV2.DEPTHS - - num_layers = sum(depths) - - get_layer_func = partial(get_swin_layer, - num_layers=num_layers + 2, - depths=depths) - - scales = list(config.TRAIN.LAYER_DECAY ** i for i in - reversed(range(num_layers + 2))) - - parameters = get_finetune_param_groups(model, - config.TRAIN.BASE_LR, - config.TRAIN.WEIGHT_DECAY, - get_layer_func, - scales, - skip, - skip_keywords) - - optimizer = None - - optimizer = optim.AdamW(parameters, - eps=config.TRAIN.OPTIMIZER.EPS, - betas=config.TRAIN.OPTIMIZER.BETAS, - lr=config.TRAIN.BASE_LR, - weight_decay=config.TRAIN.WEIGHT_DECAY) - - logger.info(optimizer) - - return optimizer - - -def set_weight_decay(model, skip_list=(), skip_keywords=()): - """ - - Args: - model (_type_): _description_ - skip_list (tuple, optional): _description_. Defaults to (). - skip_keywords (tuple, optional): _description_. Defaults to (). - - Returns: - _type_: _description_ - """ - - has_decay = [] - - no_decay = [] - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue # frozen weights - - if len(param.shape) == 1 or name.endswith(".bias") \ - or (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - no_decay.append(param) - - else: - - has_decay.append(param) - - return [{'params': has_decay}, - {'params': no_decay, 'weight_decay': 0.}] - - -def check_keywords_in_name(name, keywords=()): - - isin = False - - for keyword in keywords: - - if keyword in name: - - isin = True - - return isin - - -def get_pretrain_param_groups(model, skip_list=(), skip_keywords=()): - - has_decay = [] - - no_decay = [] - - has_decay_name = [] - - no_decay_name = [] - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") or \ - (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - no_decay.append(param) - - no_decay_name.append(name) - - else: - - has_decay.append(param) - - has_decay_name.append(name) - - return [{'params': has_decay}, - {'params': no_decay, 'weight_decay': 0.}] - - -def get_swin_layer(name, num_layers, depths): - - if name in ("mask_token"): - - return 0 - - elif name.startswith("patch_embed"): - - return 0 - - elif name.startswith("layers"): - - layer_id = int(name.split('.')[1]) - - block_id = name.split('.')[3] - - if block_id == 'reduction' or block_id == 'norm': - - return sum(depths[:layer_id + 1]) - - layer_id = sum(depths[:layer_id]) + int(block_id) - - return layer_id + 1 - - else: - - return num_layers - 1 - - -def get_finetune_param_groups(model, - lr, - weight_decay, - get_layer_func, - scales, - skip_list=(), - skip_keywords=()): - - parameter_group_names = {} - - parameter_group_vars = {} - - for name, param in model.named_parameters(): - - if not param.requires_grad: - - continue - - if len(param.shape) == 1 or name.endswith(".bias") \ - or (name in skip_list) or \ - check_keywords_in_name(name, skip_keywords): - - group_name = "no_decay" - - this_weight_decay = 0. - - else: - - group_name = "decay" - - this_weight_decay = weight_decay - - if get_layer_func is not None: - - layer_id = get_layer_func(name) - - group_name = "layer_%d_%s" % (layer_id, group_name) - - else: - - layer_id = None - - if group_name not in parameter_group_names: - - if scales is not None: - - scale = scales[layer_id] - - else: - - scale = 1. - - parameter_group_names[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale, - } - - parameter_group_vars[group_name] = { - "group_name": group_name, - "weight_decay": this_weight_decay, - "params": [], - "lr": lr * scale, - "lr_scale": scale - } - - parameter_group_vars[group_name]["params"].append(param) - - parameter_group_names[group_name]["params"].append(name) - - return list(parameter_group_vars.values()) - - -def load_checkpoint(config, model, optimizer, lr_scheduler, scaler, logger): - - logger.info(f">>>>>>>>>> Resuming from {config.MODEL.RESUME} ..........") - - if config.MODEL.RESUME.startswith('https'): - - checkpoint = torch.hub.load_state_dict_from_url( - config.MODEL.RESUME, map_location='cpu', check_hash=True) - - else: - - checkpoint = torch.load(config.MODEL.RESUME, map_location='cpu') - - # re-map keys due to name change (only for loading provided models) - rpe_mlp_keys = [k for k in checkpoint['model'].keys() if "rpe_mlp" in k] - - for k in rpe_mlp_keys: - - checkpoint['model'][k.replace( - 'rpe_mlp', 'cpb_mlp')] = checkpoint['model'].pop(k) - - msg = model.load_state_dict(checkpoint['model'], strict=False) - - logger.info(msg) - - max_accuracy = 0.0 - - if not config.EVAL_MODE and 'optimizer' in checkpoint \ - and 'lr_scheduler' in checkpoint \ - and 'scaler' in checkpoint \ - and 'epoch' in checkpoint: - - optimizer.load_state_dict(checkpoint['optimizer']) - - lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) - - scaler.load_state_dict(checkpoint['scaler']) - - config.defrost() - config.TRAIN.START_EPOCH = checkpoint['epoch'] + 1 - config.freeze() - - logger.info( - f"=> loaded successfully '{config.MODEL.RESUME}' " + - f"(epoch {checkpoint['epoch']})") - - if 'max_accuracy' in checkpoint: - max_accuracy = checkpoint['max_accuracy'] - - else: - max_accuracy = 0.0 - - del checkpoint - - torch.cuda.empty_cache() - - return max_accuracy - - -def save_checkpoint(config, epoch, model, max_accuracy, - optimizer, lr_scheduler, scaler, logger): - - save_state = {'model': model.state_dict(), - 'optimizer': optimizer.state_dict(), - 'lr_scheduler': lr_scheduler.state_dict(), - 'scaler': scaler.state_dict(), - 'max_accuracy': max_accuracy, - 'epoch': epoch, - 'config': config} - - save_path = os.path.join(config.OUTPUT, f'ckpt_epoch_{epoch}.pth') - - logger.info(f"{save_path} saving......") - - torch.save(save_state, save_path) - - logger.info(f"{save_path} saved !!!") - - -def get_grad_norm(parameters, norm_type=2): - - if isinstance(parameters, torch.Tensor): - - parameters = [parameters] - - parameters = list(filter(lambda p: p.grad is not None, parameters)) - - norm_type = float(norm_type) - - total_norm = 0 - - for p in parameters: - - param_norm = p.grad.data.norm(norm_type) - - total_norm += param_norm.item() ** norm_type - - total_norm = total_norm ** (1. / norm_type) - - return total_norm - - -def auto_resume_helper(output_dir, logger): - - checkpoints = os.listdir(output_dir) - - checkpoints = [ckpt for ckpt in checkpoints if ckpt.endswith('pth')] - - logger.info(f"All checkpoints founded in {output_dir}: {checkpoints}") - - if len(checkpoints) > 0: - - latest_checkpoint = max([os.path.join(output_dir, d) - for d in checkpoints], key=os.path.getmtime) - - logger.info(f"The latest checkpoint founded: {latest_checkpoint}") - - resume_file = latest_checkpoint - - else: - - resume_file = None - - return resume_file - - -def reduce_tensor(tensor): - - rt = tensor.clone() - - dist.all_reduce(rt, op=dist.ReduceOp.SUM) - - rt /= dist.get_world_size() - - return rt - - -def load_pretrained(config, model, logger): - - logger.info( - f">>>>>>>>>> Fine-tuned from {config.MODEL.PRETRAINED} ..........") - - checkpoint = torch.load(config.MODEL.PRETRAINED, map_location='cpu') - - checkpoint_model = checkpoint['model'] - - if any([True if 'encoder.' in k else - False for k in checkpoint_model.keys()]): - - checkpoint_model = {k.replace( - 'encoder.', ''): v for k, v in checkpoint_model.items() - if k.startswith('encoder.')} - - logger.info('Detect pre-trained model, remove [encoder.] prefix.') - - else: - - logger.info( - 'Detect non-pre-trained model, pass without doing anything.') - - if config.MODEL.TYPE in ['swin', 'swinv2']: - - logger.info( - ">>>>>>>>>> Remapping pre-trained keys for SWIN ..........") - - checkpoint = remap_pretrained_keys_swin( - model, checkpoint_model, logger) - - else: - - raise NotImplementedError - - msg = model.load_state_dict(checkpoint_model, strict=False) - - logger.info(msg) - - del checkpoint - - torch.cuda.empty_cache() - - logger.info(f">>>>>>>>>> loaded successfully '{config.MODEL.PRETRAINED}'") - - -def remap_pretrained_keys_swin(model, checkpoint_model, logger): - - state_dict = model.state_dict() - - # Geometric interpolation when pre-trained patch size mismatch - # with fine-tuned patch size - all_keys = list(checkpoint_model.keys()) - - for key in all_keys: - - if "relative_position_bias_table" in key: - - logger.info(f"Key: {key}") - - rel_position_bias_table_pretrained = checkpoint_model[key] - - rel_position_bias_table_current = state_dict[key] - - L1, nH1 = rel_position_bias_table_pretrained.size() - - L2, nH2 = rel_position_bias_table_current.size() - - if nH1 != nH2: - logger.info(f"Error in loading {key}, passing......") - - else: - - if L1 != L2: - - logger.info( - f"{key}: Interpolate " + - "relative_position_bias_table using geo.") - - src_size = int(L1 ** 0.5) - - dst_size = int(L2 ** 0.5) - - def geometric_progression(a, r, n): - return a * (1.0 - r ** n) / (1.0 - r) - - left, right = 1.01, 1.5 - - while right - left > 1e-6: - - q = (left + right) / 2.0 - - gp = geometric_progression(1, q, src_size // 2) - - if gp > dst_size // 2: - - right = q - - else: - - left = q - - # if q > 1.090307: - # q = 1.090307 - - dis = [] - - cur = 1 - - for i in range(src_size // 2): - - dis.append(cur) - - cur += q ** (i + 1) - - r_ids = [-_ for _ in reversed(dis)] - - x = r_ids + [0] + dis - - y = r_ids + [0] + dis - - t = dst_size // 2.0 - - dx = np.arange(-t, t + 0.1, 1.0) - - dy = np.arange(-t, t + 0.1, 1.0) - - logger.info("Original positions = %s" % str(x)) - - logger.info("Target positions = %s" % str(dx)) - - all_rel_pos_bias = [] - - for i in range(nH1): - - z = rel_position_bias_table_pretrained[:, i].view( - src_size, src_size).float().numpy() - - f_cubic = interpolate.interp2d(x, y, z, kind='cubic') - - all_rel_pos_bias_host = \ - torch.Tensor(f_cubic(dx, dy) - ).contiguous().view(-1, 1) - - all_rel_pos_bias.append( - all_rel_pos_bias_host.to( - rel_position_bias_table_pretrained.device)) - - new_rel_pos_bias = torch.cat(all_rel_pos_bias, dim=-1) - - checkpoint_model[key] = new_rel_pos_bias - - # delete relative_position_index since we always re-init it - relative_position_index_keys = [ - k for k in checkpoint_model.keys() if "relative_position_index" in k] - - for k in relative_position_index_keys: - - del checkpoint_model[k] - - # delete relative_coords_table since we always re-init it - relative_coords_table_keys = [ - k for k in checkpoint_model.keys() if "relative_coords_table" in k] - - for k in relative_coords_table_keys: - - del checkpoint_model[k] - - # delete attn_mask since we always re-init it - attn_mask_keys = [k for k in checkpoint_model.keys() if "attn_mask" in k] - - for k in attn_mask_keys: - - del checkpoint_model[k] - - return checkpoint_model - - -def remap_pretrained_keys_vit(model, checkpoint_model, logger): - - # Duplicate shared rel_pos_bias to each layer - if getattr(model, 'use_rel_pos_bias', False) and \ - "rel_pos_bias.relative_position_bias_table" in checkpoint_model: - - logger.info( - "Expand the shared relative position " + - "embedding to each transformer block.") - - num_layers = model.get_num_layers() - - rel_pos_bias = \ - checkpoint_model["rel_pos_bias.relative_position_bias_table"] - - for i in range(num_layers): - - checkpoint_model["blocks.%d.attn.relative_position_bias_table" % - i] = rel_pos_bias.clone() - - checkpoint_model.pop("rel_pos_bias.relative_position_bias_table") - - # Geometric interpolation when pre-trained patch - # size mismatch with fine-tuned patch size - all_keys = list(checkpoint_model.keys()) - - for key in all_keys: - - if "relative_position_index" in key: - - checkpoint_model.pop(key) - - if "relative_position_bias_table" in key: - - rel_pos_bias = checkpoint_model[key] - - src_num_pos, num_attn_heads = rel_pos_bias.size() - - dst_num_pos, _ = model.state_dict()[key].size() - - dst_patch_shape = model.patch_embed.patch_shape - - if dst_patch_shape[0] != dst_patch_shape[1]: - - raise NotImplementedError() - - num_extra_tokens = dst_num_pos - \ - (dst_patch_shape[0] * 2 - 1) * (dst_patch_shape[1] * 2 - 1) - - src_size = int((src_num_pos - num_extra_tokens) ** 0.5) - - dst_size = int((dst_num_pos - num_extra_tokens) ** 0.5) - - if src_size != dst_size: - - logger.info("Position interpolate for " + - "%s from %dx%d to %dx%d" % ( - key, - src_size, - src_size, - dst_size, - dst_size)) - - extra_tokens = rel_pos_bias[-num_extra_tokens:, :] - - rel_pos_bias = rel_pos_bias[:-num_extra_tokens, :] - - def geometric_progression(a, r, n): - - return a * (1.0 - r ** n) / (1.0 - r) - - left, right = 1.01, 1.5 - - while right - left > 1e-6: - - q = (left + right) / 2.0 - - gp = geometric_progression(1, q, src_size // 2) - - if gp > dst_size // 2: - - right = q - - else: - - left = q - - # if q > 1.090307: - # q = 1.090307 - - dis = [] - - cur = 1 - - for i in range(src_size // 2): - - dis.append(cur) - - cur += q ** (i + 1) - - r_ids = [-_ for _ in reversed(dis)] - - x = r_ids + [0] + dis - - y = r_ids + [0] + dis - - t = dst_size // 2.0 - - dx = np.arange(-t, t + 0.1, 1.0) - - dy = np.arange(-t, t + 0.1, 1.0) - - logger.info("Original positions = %s" % str(x)) - - logger.info("Target positions = %s" % str(dx)) - - all_rel_pos_bias = [] - - for i in range(num_attn_heads): - - z = rel_pos_bias[:, i].view( - src_size, src_size).float().numpy() - - f = interpolate.interp2d(x, y, z, kind='cubic') - - all_rel_pos_bias_host = \ - torch.Tensor(f(dx, dy)).contiguous().view(-1, 1) - - all_rel_pos_bias.append( - all_rel_pos_bias_host.to(rel_pos_bias.device)) - - rel_pos_bias = torch.cat(all_rel_pos_bias, dim=-1) - - new_rel_pos_bias = torch.cat( - (rel_pos_bias, extra_tokens), dim=0) - - checkpoint_model[key] = new_rel_pos_bias - - return checkpoint_model diff --git a/pytorch_caney/training/utils.py b/pytorch_caney/training/utils.py deleted file mode 100644 index e69de29..0000000 diff --git a/pytorch_caney/utils.py b/pytorch_caney/utils.py deleted file mode 100644 index af65b11..0000000 --- a/pytorch_caney/utils.py +++ /dev/null @@ -1,15 +0,0 @@ -import torch -import warnings - - -def check_gpus_available(ngpus: int) -> None: - ngpus_available = torch.cuda.device_count() - if ngpus < ngpus_available: - msg = 'Not using all available GPUS.' + \ - f' N GPUs available: {ngpus_available},' + \ - f' N GPUs selected: {ngpus}. ' - warnings.warn(msg) - elif ngpus > ngpus_available: - msg = 'Not enough GPUs to satisfy selected amount' + \ - f': {ngpus}. N GPUs available: {ngpus_available}' - warnings.warn(msg) From d1591c9ac6f6eed1ac32605afa091308af6f6e50 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Tue, 22 Oct 2024 10:46:37 -0400 Subject: [PATCH 32/50] init files for all subdirs --- pytorch_caney/configs/__init__.py | 0 pytorch_caney/datamodules/__init__.py | 0 pytorch_caney/datasets/__init__.py | 0 pytorch_caney/inference/__init__.py | 0 pytorch_caney/losses/__init__.py | 0 pytorch_caney/lr_schedulers/__init__.py | 0 pytorch_caney/models/__init__.py | 0 pytorch_caney/models/decoders/__init__.py | 0 pytorch_caney/models/encoders/__init__.py | 0 pytorch_caney/optimizers/__init__.py | 0 pytorch_caney/pipelines/__init__.py | 0 pytorch_caney/template/__init__.py | 0 pytorch_caney/transforms/__init__.py | 0 13 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 pytorch_caney/configs/__init__.py create mode 100644 pytorch_caney/datamodules/__init__.py create mode 100644 pytorch_caney/datasets/__init__.py create mode 100644 pytorch_caney/inference/__init__.py create mode 100644 pytorch_caney/losses/__init__.py create mode 100644 pytorch_caney/lr_schedulers/__init__.py create mode 100644 pytorch_caney/models/__init__.py create mode 100644 pytorch_caney/models/decoders/__init__.py create mode 100644 pytorch_caney/models/encoders/__init__.py create mode 100644 pytorch_caney/optimizers/__init__.py create mode 100644 pytorch_caney/pipelines/__init__.py create mode 100644 pytorch_caney/template/__init__.py create mode 100644 pytorch_caney/transforms/__init__.py diff --git a/pytorch_caney/configs/__init__.py b/pytorch_caney/configs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/datamodules/__init__.py b/pytorch_caney/datamodules/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/datasets/__init__.py b/pytorch_caney/datasets/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/inference/__init__.py b/pytorch_caney/inference/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/losses/__init__.py b/pytorch_caney/losses/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/lr_schedulers/__init__.py b/pytorch_caney/lr_schedulers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/models/__init__.py b/pytorch_caney/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/models/decoders/__init__.py b/pytorch_caney/models/decoders/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/models/encoders/__init__.py b/pytorch_caney/models/encoders/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/optimizers/__init__.py b/pytorch_caney/optimizers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/pipelines/__init__.py b/pytorch_caney/pipelines/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/template/__init__.py b/pytorch_caney/template/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/transforms/__init__.py b/pytorch_caney/transforms/__init__.py new file mode 100644 index 0000000..e69de29 From fa0aa6956d2c057fd7b766ec879547c1cbb7305f Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 23 Oct 2024 14:33:10 -0400 Subject: [PATCH 33/50] initial pretraining commit --- pytorch_caney/configs/config.py | 258 ++++++ pytorch_caney/datasets/sharded_dataset.py | 90 ++ pytorch_caney/models/encoders/swinv2.py | 847 ++++++++++++++++++ pytorch_caney/models/mim.py | 148 +++ pytorch_caney/optimizers/build.py | 249 +++++ pytorch_caney/optimizers/lamb.py | 214 +++++ pytorch_caney/pipelines/__init__.py | 8 + .../satvision_toa_pretrain_pipeline.py | 90 ++ pytorch_caney/ptc_cli.py | 53 ++ .../transforms/mim_mask_generator.py | 58 ++ pytorch_caney/transforms/mim_modis_toa.py | 48 + pytorch_caney/transforms/modis_toa_scale.py | 40 + .../transforms/random_resize_crop.py | 63 ++ pytorch_caney/utils.py | 41 + 14 files changed, 2207 insertions(+) create mode 100644 pytorch_caney/configs/config.py create mode 100644 pytorch_caney/datasets/sharded_dataset.py create mode 100644 pytorch_caney/models/encoders/swinv2.py create mode 100644 pytorch_caney/models/mim.py create mode 100644 pytorch_caney/optimizers/build.py create mode 100644 pytorch_caney/optimizers/lamb.py create mode 100644 pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py create mode 100644 pytorch_caney/transforms/mim_mask_generator.py create mode 100644 pytorch_caney/transforms/mim_modis_toa.py create mode 100644 pytorch_caney/transforms/modis_toa_scale.py create mode 100644 pytorch_caney/transforms/random_resize_crop.py create mode 100644 pytorch_caney/utils.py diff --git a/pytorch_caney/configs/config.py b/pytorch_caney/configs/config.py new file mode 100644 index 0000000..505285a --- /dev/null +++ b/pytorch_caney/configs/config.py @@ -0,0 +1,258 @@ +import os +import yaml +from yacs.config import CfgNode as CN + +_C = CN() + +# Base config files +_C.BASE = [''] + +# ----------------------------------------------------------------------------- +# Data settings +# ----------------------------------------------------------------------------- +_C.DATA = CN() +# Batch size for a single GPU, could be overwritten by command line argument +_C.DATA.BATCH_SIZE = 128 +# Path(s) to dataset, could be overwritten by command line argument +_C.DATA.DATA_PATHS = [''] +# Path to validation numpy dataset +_C.DATA.VALIDATION_PATH = '' +# Dataset name +_C.DATA.DATASET = 'MODIS' +# Input image size +_C.DATA.IMG_SIZE = 224 +# Dataset length (for datasets where len cannot be used) +_C.DATA.LENGTH = 1920000 +# Interpolation to resize image (random, bilinear, bicubic) +_C.DATA.INTERPOLATION = 'bicubic' +# Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU. +_C.DATA.PIN_MEMORY = True +# Number of data loading threads +_C.DATA.NUM_WORKERS = 8 +# [SimMIM] Mask patch size for MaskGenerator +_C.DATA.MASK_PATCH_SIZE = 32 +# [SimMIM] Mask ratio for MaskGenerator +_C.DATA.MASK_RATIO = 0.6 + +# ----------------------------------------------------------------------------- +# Model settings +# ----------------------------------------------------------------------------- +_C.MODEL = CN() +# Model type +_C.MODEL.TYPE = 'swinv2' +# Decoder type +_C.MODEL.DECODER = None +# Model name +_C.MODEL.NAME = 'swinv2_base_patch4_window7_224' +# Pretrained weight from checkpoint, could be from previous pre-training +# could be overwritten by command line argument +_C.MODEL.PRETRAINED = '' +# Checkpoint to resume, could be overwritten by command line argument +_C.MODEL.RESUME = '' +# Number of classes, overwritten in data preparation +_C.MODEL.NUM_CLASSES = 17 +# Dropout rate +_C.MODEL.DROP_RATE = 0.0 +# Drop path rate +_C.MODEL.DROP_PATH_RATE = 0.1 + +# Swin Transformer V2 parameters +_C.MODEL.SWINV2 = CN() +_C.MODEL.SWINV2.PATCH_SIZE = 4 +_C.MODEL.SWINV2.IN_CHANS = 3 +_C.MODEL.SWINV2.EMBED_DIM = 96 +_C.MODEL.SWINV2.DEPTHS = [2, 2, 6, 2] +_C.MODEL.SWINV2.NUM_HEADS = [3, 6, 12, 24] +_C.MODEL.SWINV2.WINDOW_SIZE = 7 +_C.MODEL.SWINV2.MLP_RATIO = 4. +_C.MODEL.SWINV2.QKV_BIAS = True +_C.MODEL.SWINV2.APE = False +_C.MODEL.SWINV2.PATCH_NORM = True +_C.MODEL.SWINV2.PRETRAINED_WINDOW_SIZES = [0, 0, 0, 0] +_C.MODEL.SWINV2.NORM_PERIOD = 0 +_C.MODEL.SWINV2.NORM_STAGE = False + +# ----------------------------------------------------------------------------- +# Training settings +# ----------------------------------------------------------------------------- +_C.LOSS = CN() +_C.LOSS.NAME = 'tversky' +_C.LOSS.MODE = 'multiclass' +_C.LOSS.CLASSES = None +_C.LOSS.LOG = False +_C.LOSS.LOGITS = True +_C.LOSS.SMOOTH = 0.0 +_C.LOSS.IGNORE_INDEX = None +_C.LOSS.EPS = 1e-7 +_C.LOSS.ALPHA = 0.5 +_C.LOSS.BETA = 0.5 +_C.LOSS.GAMMA = 1.0 + +# ----------------------------------------------------------------------------- +# Training settings +# ----------------------------------------------------------------------------- +_C.TRAIN = CN() +_C.TRAIN.STRATEGY = 'deepspeed' +_C.TRAIN.LIMIT_TRAIN_BATCHES = True +_C.TRAIN.NUM_TRAIN_BATCHES = None +_C.TRAIN.START_EPOCH = 0 +_C.TRAIN.EPOCHS = 300 +_C.TRAIN.WARMUP_EPOCHS = 20 +_C.TRAIN.WARMUP_STEPS = 200 +_C.TRAIN.WEIGHT_DECAY = 0.05 +_C.TRAIN.BASE_LR = 5e-4 +_C.TRAIN.WARMUP_LR = 5e-7 +_C.TRAIN.MIN_LR = 5e-6 +# Clip gradient norm +_C.TRAIN.CLIP_GRAD = 5.0 +# Auto resume from latest checkpoint +_C.TRAIN.AUTO_RESUME = True +# Gradient accumulation steps +# could be overwritten by command line argument +_C.TRAIN.ACCUMULATION_STEPS = 0 +# Whether to use gradient checkpointing to save memory +# could be overwritten by command line argument +_C.TRAIN.USE_CHECKPOINT = False + +# LR scheduler +_C.TRAIN.LR_SCHEDULER = CN() +_C.TRAIN.LR_SCHEDULER.NAME = 'cosine' +# Epoch interval to decay LR, used in StepLRScheduler +_C.TRAIN.LR_SCHEDULER.DECAY_EPOCHS = 30 +# LR decay rate, used in StepLRScheduler +_C.TRAIN.LR_SCHEDULER.DECAY_RATE = 0.1 +# Gamma / Multi steps value, used in MultiStepLRScheduler +_C.TRAIN.LR_SCHEDULER.GAMMA = 0.1 +_C.TRAIN.LR_SCHEDULER.MULTISTEPS = [] +# OneCycle LR Scheduler max LR percentage +_C.TRAIN.LR_SCHEDULER.CYCLE_PERCENTAGE = 0.3 + +# Optimizer +_C.TRAIN.OPTIMIZER = CN() +_C.TRAIN.OPTIMIZER.NAME = 'adamw' +# Optimizer Epsilon +_C.TRAIN.OPTIMIZER.EPS = 1e-8 +# Optimizer Betas +_C.TRAIN.OPTIMIZER.BETAS = (0.9, 0.999) +# SGD momentum +_C.TRAIN.OPTIMIZER.MOMENTUM = 0.9 + +# [SimMIM] Layer decay for fine-tuning +_C.TRAIN.LAYER_DECAY = 1.0 + +# Tensorboard settings +_C.TENSORBOARD = CN() +_C.TENSORBOARD.WRITER_DIR = '.' + +# DeepSpeed configuration settings +_C.DEEPSPEED = CN() +_C.DEEPSPEED.STAGE = 2 +_C.DEEPSPEED.REDUCE_BUCKET_SIZE = 5e8 +_C.DEEPSPEED.ALLGATHER_BUCKET_SIZE = 5e8 +_C.DEEPSPEED.CONTIGUOUS_GRADIENTS = True +_C.DEEPSPEED.OVERLAP_COMM = True + + +# ----------------------------------------------------------------------------- +# Testing settings +# ----------------------------------------------------------------------------- +_C.TEST = CN() +# Whether to use center crop when testing +_C.TEST.CROP = True + +# ----------------------------------------------------------------------------- +# Misc +# ----------------------------------------------------------------------------- +# Whether to enable pytorch amp, overwritten by command line argument +_C.ENABLE_AMP = False +# Enable Pytorch automatic mixed precision (amp). +_C.AMP_ENABLE = True +# Path to output folder, overwritten by command line argument +_C.OUTPUT = '' +# Tag of experiment, overwritten by command line argument +_C.TAG = 'pt-caney-default-tag' +# Frequency to save checkpoint +_C.SAVE_FREQ = 1 +# Frequency to logging info +_C.PRINT_FREQ = 10 +# Frequency for running validation step +_C.VALIDATION_FREQ = 1 +# Fixed random seed +_C.SEED = 42 +# Perform evaluation only, overwritten by command line argument +_C.EVAL_MODE = False +# Pipeline +_C.PIPELINE = 'satvisiontoapretrain' + + +def _update_config_from_file(config, cfg_file): + config.defrost() + with open(cfg_file, 'r') as f: + yaml_cfg = yaml.load(f, Loader=yaml.FullLoader) + + for cfg in yaml_cfg.setdefault('BASE', ['']): + if cfg: + _update_config_from_file( + config, os.path.join(os.path.dirname(cfg_file), cfg) + ) + print('=> merge config from {}'.format(cfg_file)) + config.merge_from_file(cfg_file) + config.freeze() + + +def update_config(config, args): + _update_config_from_file(config, args.cfg) + + config.defrost() + + def _check_args(name): + if hasattr(args, name) and eval(f'args.{name}'): + return True + return False + + # merge from specific arguments + if _check_args('batch_size'): + config.DATA.BATCH_SIZE = args.batch_size + if _check_args('data_paths'): + config.DATA.DATA_PATHS = args.data_paths + if _check_args('validation_path'): + config.DATA.VALIDATION_PATH = args.validation_path + if _check_args('dataset'): + config.DATA.DATASET = args.dataset + if _check_args('resume'): + config.MODEL.RESUME = args.resume + if _check_args('pretrained'): + config.MODEL.PRETRAINED = args.pretrained + if _check_args('resume'): + config.MODEL.RESUME = args.resume + if _check_args('accumulation_steps'): + config.TRAIN.ACCUMULATION_STEPS = args.accumulation_steps + if _check_args('use_checkpoint'): + config.TRAIN.USE_CHECKPOINT = True + if _check_args('disable_amp'): + config.AMP_ENABLE = False + if _check_args('output'): + config.OUTPUT = args.output + if _check_args('tag'): + config.TAG = args.tag + if _check_args('eval'): + config.EVAL_MODE = True + if _check_args('enable_amp'): + config.ENABLE_AMP = args.enable_amp + if _check_args('tensorboard_dir'): + config.TENSORBOARD.WRITER_DIR = args.tensorboard_dir + + # output folder + config.OUTPUT = os.path.join(config.OUTPUT, config.MODEL.NAME, config.TAG) + + config.freeze() + + +def get_config(args): + """Get a yacs CfgNode object with default values.""" + # Return a clone so that the defaults will not be altered + # This is for the "local variable" use pattern + config = _C.clone() + update_config(config, args) + + return config diff --git a/pytorch_caney/datasets/sharded_dataset.py b/pytorch_caney/datasets/sharded_dataset.py new file mode 100644 index 0000000..185a3b8 --- /dev/null +++ b/pytorch_caney/datasets/sharded_dataset.py @@ -0,0 +1,90 @@ +import os +import numpy as np +import pathlib +import logging + +from io import BytesIO +import webdataset as wds +import torch.distributed as dist + + +# ----------------------------------------------------------------------------- +# nodesplitter +# ----------------------------------------------------------------------------- +def nodesplitter(src, group=None): + if dist.is_initialized(): + if group is None: + group = dist.group.WORLD + rank = dist.get_rank(group=group) + size = dist.get_world_size(group=group) + logging.info(f"nodesplitter: rank={rank} size={size}") + count = 0 + for i, item in enumerate(src): + if i % size == rank: + yield item + count += 1 + logging.info(f"nodesplitter: rank={rank} size={size} " + \ + f"count={count} DONE") + else: + yield from src + + +# ----------------------------------------------------------------------------- +# ShardedDataset +# ----------------------------------------------------------------------------- +class ShardedDataset(object): + """ + Base pre-training webdataset + """ + + SHARD_PATH = os.path.join("shards") + INPUT_KEY: str = 'input.npy' + OUTPUT_KEY: str = 'output.npy' + REPEAT: int = 2 + + def __init__( + self, + config, + data_paths: list, + split: str, + length: int, + img_size: tuple = (192, 192), + transform=None, + batch_size=64, + ): + + self.random_state = 1000 + self.config = config + self.img_size = img_size + self.transform = transform + self.split = split + self.length = length + + self.shard_path = pathlib.Path(data_paths[0]) + shards = self.shard_path.glob('*.tar') + self.shards = list(map(str, shards)) + + self.batch_size = batch_size + + # ------------------------------------------------------------------------- + # dataset + # ------------------------------------------------------------------------- + def dataset(self): + + dataset = ( + wds.WebDataset(self.shards, + shardshuffle=True, + repeat=True, + handler=wds.ignore_and_continue, + nodesplitter=nodesplitter) + .shuffle(self.random_state) + .to_tuple(self.INPUT_KEY, handler=wds.ignore_and_continue) + .map_tuple(BytesIO) + .map_tuple(np.load) + .map_tuple(self.transform) + .batched(self.batch_size, partial=False) + .repeat(self.REPEAT) + .with_length(self.length) + ) + + return dataset \ No newline at end of file diff --git a/pytorch_caney/models/encoders/swinv2.py b/pytorch_caney/models/encoders/swinv2.py new file mode 100644 index 0000000..9d3f26e --- /dev/null +++ b/pytorch_caney/models/encoders/swinv2.py @@ -0,0 +1,847 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.checkpoint as checkpoint + +from timm.models.layers import DropPath, to_2tuple, trunc_normal_ + +import numpy as np + + +# ----------------------------------------------------------------------------- +# WindowAttention +# ----------------------------------------------------------------------------- +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 + attn_drop (float, optional): Dropout ratio of attention weight. + Default: 0.0 + proj_drop (float, optional): Dropout ratio of output. Default: 0.0 + pretrained_window_size (tuple[int]): The height and width of the + window in pre-training. + """ + + def __init__(self, + dim, + window_size, + num_heads, + qkv_bias=True, + attn_drop=0., + proj_drop=0., + pretrained_window_size=[0, 0]): + + super().__init__() + + self.dim = dim + + self.window_size = window_size # Wh, Ww + + self.pretrained_window_size = pretrained_window_size + + self.num_heads = num_heads + + self.logit_scale = nn.Parameter( + torch.log(10 * torch.ones((num_heads, 1, 1))), requires_grad=True) + + # mlp to generate continuous relative position bias + self.cpb_mlp = nn.Sequential(nn.Linear(2, 512, bias=True), + nn.ReLU(inplace=True), + nn.Linear(512, num_heads, bias=False)) + + # get relative_coords_table + relative_coords_h = torch.arange( + -(self.window_size[0] - 1), + self.window_size[0], + dtype=torch.float32) + relative_coords_w = torch.arange( + -(self.window_size[1] - 1), + self.window_size[1], + dtype=torch.float32) + + # 1, 2*Wh-1, 2*Ww-1, 2 + relative_coords_table = torch.stack( + torch.meshgrid( + [relative_coords_h, + relative_coords_w])).permute(1, + 2, + 0).contiguous().unsqueeze(0) + + if pretrained_window_size[0] > 0: + + relative_coords_table[:, :, :, + 0] /= (pretrained_window_size[0] - 1) + + relative_coords_table[:, :, :, + 1] /= (pretrained_window_size[1] - 1) + + else: + + relative_coords_table[:, :, :, 0] /= (self.window_size[0] - 1) + + relative_coords_table[:, :, :, 1] /= (self.window_size[1] - 1) + + relative_coords_table *= 8 # normalize to -8, 8 + + relative_coords_table = torch.sign(relative_coords_table) * torch.log2( + torch.abs(relative_coords_table) + 1.0) / np.log2(8) + + self.register_buffer("relative_coords_table", relative_coords_table) + + # 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])) # 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=False) + + if qkv_bias: + + self.q_bias = nn.Parameter(torch.zeros(dim)) + self.v_bias = nn.Parameter(torch.zeros(dim)) + + else: + + self.q_bias = None + self.v_bias = None + + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + self.softmax = nn.Softmax(dim=-1) + + def forward(self, x, mask=None): + """ + 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_bias = None + if self.q_bias is not None: + qkv_bias = torch.cat((self.q_bias, torch.zeros_like( + self.v_bias, requires_grad=False), self.v_bias)) + qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) + qkv = qkv.reshape(B_, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + # make torchscript happy (cannot use tensor as tuple) + q, k, v = qkv[0], qkv[1], qkv[2] + + # cosine attention + attn = (F.normalize(q, dim=-1) @ + F.normalize(k, dim=-1).transpose(-2, -1)) + # logit_scale = torch.clamp( + # self.logit_scale, max=torch.log(torch.tensor(1. / 0.01))).exp() + logit_scale = torch.clamp(self.logit_scale, max=torch.log( + torch.tensor(1. / 0.01)).to(self.logit_scale.get_device())).exp() + attn = attn * logit_scale + + relative_position_bias_table = self.cpb_mlp( + self.relative_coords_table).view(-1, self.num_heads) + relative_position_bias = \ + 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 + + relative_position_bias = 16 * torch.sigmoid(relative_position_bias) + 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 + + def extra_repr(self) -> str: + return f'dim={self.dim}, window_size={self.window_size}, ' \ + f'pretrained_window_size={self.pretrained_window_size}, ' \ + f'num_heads={self.num_heads}' + + def flops(self, N): + # calculate flops for 1 window with token length of N + flops = 0 + # qkv = self.qkv(x) + flops += N * self.dim * 3 * self.dim + # attn = (q @ k.transpose(-2, -1)) + flops += self.num_heads * N * (self.dim // self.num_heads) * N + # x = (attn @ v) + flops += self.num_heads * N * N * (self.dim // self.num_heads) + # x = self.proj(x) + flops += N * self.dim * self.dim + return flops + + +# ----------------------------------------------------------------------------- +# Mlp +# ----------------------------------------------------------------------------- +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.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 + + +# ----------------------------------------------------------------------------- +# window_partition +# ----------------------------------------------------------------------------- +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 + + +# ----------------------------------------------------------------------------- +# window_reverse +# ----------------------------------------------------------------------------- +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 + + +# ----------------------------------------------------------------------------- +# SwinTransformerBlock +# ----------------------------------------------------------------------------- +class SwinTransformerBlock(nn.Module): + r""" Swin Transformer Block. + + Args: + dim (int): Number of input channels. + input_resolution (tuple[int]): Input resulotion. + 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 + 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 + pretrained_window_size (int): Window size in pre-training. + """ + + def __init__(self, dim, input_resolution, num_heads, + window_size=7, shift_size=0, mlp_ratio=4., + qkv_bias=True, drop=0., attn_drop=0., drop_path=0., + act_layer=nn.GELU, norm_layer=nn.LayerNorm, + pretrained_window_size=0, extra_norm=False): + super().__init__() + self.dim = dim + self.input_resolution = input_resolution + self.num_heads = num_heads + self.window_size = window_size + self.shift_size = shift_size + self.mlp_ratio = mlp_ratio + if min(self.input_resolution) <= self.window_size: + # if window size is larger than input resolution, + # we don't partition windows + self.shift_size = 0 + self.window_size = min(self.input_resolution) + + 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, attn_drop=attn_drop, proj_drop=drop, + pretrained_window_size=to_2tuple(pretrained_window_size)) + + self.drop_path = DropPath( + drop_path) if drop_path > 0. else nn.Identity() + self.norm2 = norm_layer(dim) + + self.norm3 = norm_layer(dim) if extra_norm else nn.Identity() + mlp_hidden_dim = int(dim * mlp_ratio) + self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, + act_layer=act_layer, drop=drop) + + if self.shift_size > 0: + # calculate attention mask for SW-MSA + H, W = self.input_resolution + img_mask = torch.zeros((1, H, W, 1)) # 1 H W 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 + + # nW, window_size, window_size, 1 + mask_windows = window_partition(img_mask, self.window_size) + 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)) + else: + attn_mask = None + + self.register_buffer("attn_mask", attn_mask) + + def forward(self, x): + H, W = self.input_resolution + B, L, C = x.shape + assert L == H * W, "input feature has wrong size" + + shortcut = x + x = x.view(B, H, W, C) + + # cyclic shift + if self.shift_size > 0: + shifted_x = torch.roll( + x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) + else: + shifted_x = x + + # partition windows + # nW*B, window_size, window_size, C + 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) + + # W-MSA/SW-MSA + # nW*B, window_size*window_size, C + attn_windows = self.attn(x_windows, mask=self.attn_mask) + + # merge windows + attn_windows = attn_windows.view(-1, + self.window_size, self.window_size, C) + shifted_x = window_reverse( + attn_windows, self.window_size, H, W) # 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 + x = x.view(B, H * W, C) + x = shortcut + self.drop_path(self.norm1(x)) + + # FFN + x = x + self.drop_path(self.norm2(self.mlp(x))) + + x = self.norm3(x) + + return x + + def extra_repr(self) -> str: + return f"dim={self.dim}, input_resolution={self.input_resolution}," \ + f"num_heads={self.num_heads}, " \ + f"window_size={self.window_size}, " \ + f"shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}" + + def flops(self): + flops = 0 + H, W = self.input_resolution + # norm1 + flops += self.dim * H * W + # W-MSA/SW-MSA + nW = H * W / self.window_size / self.window_size + flops += nW * self.attn.flops(self.window_size * self.window_size) + # mlp + flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio + # norm2 + flops += self.dim * H * W + return flops + + +# ----------------------------------------------------------------------------- +# PatchMerging +# ----------------------------------------------------------------------------- +class PatchMerging(nn.Module): + r""" Patch Merging Layer. + + Args: + input_resolution (tuple[int]): Resolution of input feature. + dim (int): Number of input channels. + norm_layer (nn.Module, optional): Normalization layer. + Default: nn.LayerNorm + """ + + def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm): + super().__init__() + self.input_resolution = input_resolution + self.dim = dim + self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False) + self.norm = norm_layer(2 * dim) + + def forward(self, x): + """ + x: B, H*W, C + """ + H, W = self.input_resolution + B, L, C = x.shape + assert L == H * W, "input feature has wrong size" + assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even." + + x = x.view(B, H, W, C) + + 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.reduction(x) + x = self.norm(x) + + return x + + def extra_repr(self) -> str: + return f"input_resolution={self.input_resolution}, dim={self.dim}" + + def flops(self): + H, W = self.input_resolution + flops = (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim + flops += H * W * self.dim // 2 + return flops + + +# ----------------------------------------------------------------------------- +# BasicLayer +# ----------------------------------------------------------------------------- +class BasicLayer(nn.Module): + """ A basic Swin Transformer layer for one stage. + + Args: + dim (int): Number of input channels. + input_resolution (tuple[int]): Input resolution. + depth (int): Number of blocks. + num_heads (int): Number of attention heads. + window_size (int): Local window size. + 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 + 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. + pretrained_window_size (int): Local window size in pre-training. + """ + + def __init__(self, dim, input_resolution, depth, num_heads, window_size, + mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0., + drop_path=0., norm_layer=nn.LayerNorm, downsample=None, + use_checkpoint=False, pretrained_window_size=0, + extra_norm_period: int = 0, extra_norm_stage: bool = False,): + + super().__init__() + self.dim = dim + self.input_resolution = input_resolution + self.depth = depth + self.use_checkpoint = use_checkpoint + + def _extra_norm(index): + i = index + 1 + if extra_norm_period and i % extra_norm_period == 0: + return True + return i == depth if extra_norm_stage else False + + # build blocks + self.blocks = nn.ModuleList([ + SwinTransformerBlock(dim=dim, input_resolution=input_resolution, + 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, + drop=drop, attn_drop=attn_drop, + drop_path=drop_path[i] if isinstance( + drop_path, list) else drop_path, + norm_layer=norm_layer, + pretrained_window_size=pretrained_window_size, + extra_norm=_extra_norm(i)) + for i in range(depth)]) + + # patch merging layer + if downsample is not None: + self.downsample = downsample( + input_resolution, dim=dim, norm_layer=norm_layer) + else: + self.downsample = None + + def forward(self, x): + for blk in self.blocks: + if self.use_checkpoint: + x = checkpoint.checkpoint(blk, x, use_reentrant=False) + else: + x = blk(x) + if self.downsample is not None: + x = self.downsample(x) + return x + + def extra_repr(self) -> str: + return f"dim={self.dim}, " \ + f"input_resolution={self.input_resolution}," \ + f" depth={self.depth}" + + def flops(self): + flops = 0 + for blk in self.blocks: + flops += blk.flops() + if self.downsample is not None: + flops += self.downsample.flops() + return flops + + def _init_respostnorm(self): + for blk in self.blocks: + nn.init.constant_(blk.norm1.bias, 0) + nn.init.constant_(blk.norm1.weight, 0) + nn.init.constant_(blk.norm2.bias, 0) + nn.init.constant_(blk.norm2.weight, 0) + + +# ----------------------------------------------------------------------------- +# PatchEmbed +# ----------------------------------------------------------------------------- +class PatchEmbed(nn.Module): + r""" Image to Patch Embedding + + Args: + img_size (int): Image size. Default: 224. + patch_size (int): Patch token size. Default: 4. + in_chans (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, + img_size=224, + patch_size=4, + in_chans=3, + embed_dim=96, + norm_layer=None): + super().__init__() + img_size = to_2tuple(img_size) + patch_size = to_2tuple(patch_size) + patches_resolution = [img_size[0] // + patch_size[0], img_size[1] // patch_size[1]] + self.img_size = img_size + self.patch_size = patch_size + self.patches_resolution = patches_resolution + self.num_patches = patches_resolution[0] * patches_resolution[1] + + self.in_chans = in_chans + self.embed_dim = embed_dim + + self.proj = nn.Conv2d(in_chans, 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): + B, C, H, W = x.shape + # FIXME look at relaxing size constraints + assert H == self.img_size[0] and W == self.img_size[1], \ + f"Input image size ({H}*{W})" \ + f"doesn't match model ({self.img_size[0]}*{self.img_size[1]})." + x = self.proj(x).flatten(2).transpose(1, 2) # B Ph*Pw C + if self.norm is not None: + x = self.norm(x) + return x + + def flops(self): + 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 + + +# ----------------------------------------------------------------------------- +# SwinTransformerV2 +# ----------------------------------------------------------------------------- +class SwinTransformerV2(nn.Module): + r""" Swin Transformer + A PyTorch impl of : `Swin Transformer: Hierarchical + Vision Transformer using Shifted Windows` - + https://arxiv.org/pdf/2103.14030 + + Args: + img_size (int | tuple(int)): Input image size. Default 224 + patch_size (int | tuple(int)): Patch size. Default: 4 + in_chans (int): Number of input image channels. + Default: 3 + num_classes (int): Number of classes for classification head. + Default: 1000 + embed_dim (int): Patch embedding dimension. Default: 96 + depths (tuple(int)): Depth of each Swin Transformer layer. + num_heads (tuple(int)): Number of attention heads in different layers. + 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 + drop_rate (float): Dropout rate. Default: 0 + attn_drop_rate (float): Attention dropout rate. Default: 0 + drop_path_rate (float): Stochastic depth rate. Default: 0.1 + 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 + use_checkpoint (bool): Whether to use checkpointing to save memory. + Default: False + pretrained_window_sizes (tuple(int)): Pretrained window sizes of + each layer. + """ + + def __init__(self, img_size=224, patch_size=4, in_chans=3, + num_classes=1000, embed_dim=96, depths=[2, 2, 6, 2], + num_heads=[3, 6, 12, 24], window_size=7, mlp_ratio=4., + qkv_bias=True, drop_rate=0., attn_drop_rate=0., + drop_path_rate=0.1, norm_layer=nn.LayerNorm, + ape=False, patch_norm=True, use_checkpoint=False, + pretrained_window_sizes=[0, 0, 0, 0], + extra_norm_period: int = 0, extra_norm_stage: bool = False, + **kwargs): + super().__init__() + + self.num_classes = num_classes + self.num_layers = len(depths) + self.embed_dim = embed_dim + self.ape = ape + self.patch_norm = patch_norm + self.num_features = int(embed_dim * 2 ** (self.num_layers - 1)) + self.mlp_ratio = mlp_ratio + + # split image into non-overlapping patches + self.patch_embed = PatchEmbed( + img_size=img_size, patch_size=patch_size, + in_chans=in_chans, embed_dim=embed_dim, + norm_layer=norm_layer if self.patch_norm else None) + num_patches = self.patch_embed.num_patches + patches_resolution = self.patch_embed.patches_resolution + self.patches_resolution = patches_resolution + + # absolute position embedding + if self.ape: + self.absolute_pos_embed = nn.Parameter( + torch.zeros(1, num_patches, embed_dim)) + 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), + input_resolution=(patches_resolution[0] // (2 ** i_layer), + patches_resolution[1] // (2 ** i_layer)), + depth=depths[i_layer], + num_heads=num_heads[i_layer], + window_size=window_size, + mlp_ratio=self.mlp_ratio, + qkv_bias=qkv_bias, + 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, + pretrained_window_size=pretrained_window_sizes[i_layer], + extra_norm_period=extra_norm_period, + extra_norm_stage=extra_norm_stage) + self.layers.append(layer) + + self.norm = norm_layer(self.num_features) + self.avgpool = nn.AdaptiveAvgPool1d(1) + self.head = nn.Linear( + self.num_features, num_classes) if \ + num_classes > 0 else nn.Identity() + + self.apply(self._init_weights) + for bly in self.layers: + bly._init_respostnorm() + + 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) + + @torch.jit.ignore + def no_weight_decay(self): + return {'absolute_pos_embed'} + + @torch.jit.ignore + def no_weight_decay_keywords(self): + return {"cpb_mlp", "logit_scale", 'relative_position_bias_table'} + + def forward_features(self, x): + x = self.patch_embed(x) + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + + for layer in self.layers: + x = layer(x) + + x = self.norm(x) # B L C + x = self.avgpool(x.transpose(1, 2)) # B C 1 + x = torch.flatten(x, 1) + return x + + def extra_features(self, x): + x = self.patch_embed(x) + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + feature = [] + + for layer in self.layers: + x = layer(x) + bs, n, f = x.shape + h = int(n**0.5) + + feature.append( + x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()) + return feature + + def get_unet_feature(self, x): + x = self.patch_embed(x) + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + bs, n, f = x.shape + h = int(n**0.5) + feature = [x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()] + + for layer in self.layers: + x = layer(x) + bs, n, f = x.shape + h = int(n**0.5) + + feature.append( + x.view(-1, h, h, f).permute(0, 3, 1, 2).contiguous()) + return feature + + def forward(self, x): + x = self.forward_features(x) + x = self.head(x) + return x + + def flops(self): + flops = 0 + flops += self.patch_embed.flops() + for i, layer in enumerate(self.layers): + flops += layer.flops() + flops += self.num_features * \ + self.patches_resolution[0] * \ + self.patches_resolution[1] // (2 ** self.num_layers) + flops += self.num_features * self.num_classes + return flops diff --git a/pytorch_caney/models/mim.py b/pytorch_caney/models/mim.py new file mode 100644 index 0000000..6e41647 --- /dev/null +++ b/pytorch_caney/models/mim.py @@ -0,0 +1,148 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import trunc_normal_ + +from .encoders.swinv2 import SwinTransformerV2 + + +# ----------------------------------------------------------------------------- +# SwinTransformerV2ForMiM +# ----------------------------------------------------------------------------- +class SwinTransformerV2ForSimMIM(SwinTransformerV2): + def __init__(self, **kwargs): + super().__init__(**kwargs) + + assert self.num_classes == 0 + + self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim)) + trunc_normal_(self.mask_token, mean=0., std=.02) + + def forward(self, x, mask): + x = self.patch_embed(x) + + assert mask is not None + B, L, _ = x.shape + + mask_tokens = self.mask_token.expand(B, L, -1) + w = mask.flatten(1).unsqueeze(-1).type_as(mask_tokens) + x = x * (1. - w) + mask_tokens * w + + if self.ape: + x = x + self.absolute_pos_embed + x = self.pos_drop(x) + + for layer in self.layers: + x = layer(x) + x = self.norm(x) + + x = x.transpose(1, 2) + B, C, L = x.shape + H = W = int(L ** 0.5) + x = x.reshape(B, C, H, W) + return x + + @torch.jit.ignore + def no_weight_decay(self): + return super().no_weight_decay() | {'mask_token'} + + +# ----------------------------------------------------------------------------- +# MiMModel +# ----------------------------------------------------------------------------- +class MiMModel(nn.Module): + """ + Masked-Image-Modeling model + + Given an encoder, makes a model that incorporates + the encoder and attaches a simple linear layer that + produces the raw-pixel predictions of the masked + inputs. + """ + def __init__(self, encoder, encoder_stride, in_chans, patch_size): + super().__init__() + self.encoder = encoder + self.encoder_stride = encoder_stride + self.in_chans = in_chans + self.patch_size = patch_size + self.decoder = nn.Sequential( + nn.Conv2d( + in_channels=self.encoder.num_features, + out_channels=self.encoder_stride ** 2 * self.in_chans, + kernel_size=1), + nn.PixelShuffle(self.encoder_stride), + ) + + # self.in_chans = self.encoder.in_chans + # self.patch_size = self.encoder.patch_size + + def forward(self, x, mask): + z = self.encoder(x, mask) + x_rec = self.decoder(z) + + mask = mask.repeat_interleave(self.patch_size, 1).repeat_interleave( + self.patch_size, 2).unsqueeze(1).contiguous() + loss_recon = F.l1_loss(x, x_rec, reduction='none') + loss = (loss_recon * mask).sum() / (mask.sum() + 1e-5) / self.in_chans + return loss + + @torch.jit.ignore + def no_weight_decay(self): + if hasattr(self.encoder, 'no_weight_decay'): + return {'encoder.' + i for i in self.encoder.no_weight_decay()} + return {} + + @torch.jit.ignore + def no_weight_decay_keywords(self): + if hasattr(self.encoder, 'no_weight_decay_keywords'): + return {'encoder.' + i for i in + self.encoder.no_weight_decay_keywords()} + return {} + + +# ----------------------------------------------------------------------------- +# build_mim_model +# ----------------------------------------------------------------------------- +def build_mim_model(config): + """Builds the masked-image-modeling model. + + Args: + config: config object + + Raises: + NotImplementedError: if the model is + not swinv2, then this will be thrown. + + Returns: + MiMModel: masked-image-modeling model + """ + model_type = config.MODEL.TYPE + if model_type == 'swinv2': + encoder = SwinTransformerV2ForSimMIM( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.SWINV2.PATCH_SIZE, + in_chans=config.MODEL.SWINV2.IN_CHANS, + num_classes=0, + embed_dim=config.MODEL.SWINV2.EMBED_DIM, + depths=config.MODEL.SWINV2.DEPTHS, + num_heads=config.MODEL.SWINV2.NUM_HEADS, + window_size=config.MODEL.SWINV2.WINDOW_SIZE, + mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, + qkv_bias=config.MODEL.SWINV2.QKV_BIAS, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + ape=config.MODEL.SWINV2.APE, + patch_norm=config.MODEL.SWINV2.PATCH_NORM, + use_checkpoint=config.TRAIN.USE_CHECKPOINT, + extra_norm_period=config.MODEL.SWINV2.NORM_PERIOD, + extra_norm_stage=config.MODEL.SWINV2.NORM_STAGE) + encoder_stride = 32 + in_chans = config.MODEL.SWINV2.IN_CHANS + patch_size = config.MODEL.SWINV2.PATCH_SIZE + else: + raise NotImplementedError(f"Unknown pre-train model: {model_type}") + + model = MiMModel(encoder=encoder, encoder_stride=encoder_stride, + in_chans=in_chans, patch_size=patch_size) + + return model diff --git a/pytorch_caney/optimizers/build.py b/pytorch_caney/optimizers/build.py new file mode 100644 index 0000000..e2be339 --- /dev/null +++ b/pytorch_caney/optimizers/build.py @@ -0,0 +1,249 @@ +from functools import partial + +import torch +import deepspeed + +from pytorch_caney.optimizers.lamb import Lamb + + +OPTIMIZERS = { + 'adamw': torch.optim.AdamW, + 'lamb': Lamb, + 'fusedlamb': deepspeed.ops.lamb.FusedLamb, + 'fusedadamw': deepspeed.ops.adam.FusedAdam, +} + + +# ----------------------------------------------------------------------------- +# get_optimizer_from_dict +# ----------------------------------------------------------------------------- +def get_optimizer_from_dict(optimizer_name, config): + """Gets the proper optimizer given an optimizer name. + + Args: + optimizer_name (str): name of the optimizer + config: config object + + Raises: + KeyError: thrown if loss key is not present in dict + + Returns: + loss: pytorch optimizer + """ + + try: + + optimizer_to_use = OPTIMIZERS[optimizer_name.lower()] + + except KeyError: + + error_msg = f"{optimizer_name} is not an implemented optimizer" + + error_msg = f"{error_msg}. Available optimizer functions: {OPTIMIZERS.keys()}" + + raise KeyError(error_msg) + + return optimizer_to_use + + +# ----------------------------------------------------------------------------- +# build_optimizer +# ----------------------------------------------------------------------------- +def build_optimizer(config, model, is_pretrain=False, logger=None): + """ + Build optimizer, set weight decay of normalization to 0 by default. + AdamW only. + """ + if logger: + logger.info('>>>>>>>>>> Build Optimizer') + + skip = {} + skip_keywords = {} + optimizer_name = config.TRAIN.OPTIMIZER.NAME + + if logger: + logger.info(f'Building {optimizer_name}') + + optimizer_to_use = get_optimizer_from_dict(optimizer_name, config) + + if hasattr(model, 'no_weight_decay'): + skip = model.no_weight_decay() + + if hasattr(model, 'no_weight_decay_keywords'): + skip_keywords = model.no_weight_decay_keywords() + + if is_pretrain: + parameters = get_pretrain_param_groups(model, skip, skip_keywords) + + else: + depths = config.MODEL.SWIN.DEPTHS if config.MODEL.TYPE == 'swin' \ + else config.MODEL.SWINV2.DEPTHS + + num_layers = sum(depths) + + get_layer_func = partial(get_swin_layer, + num_layers=num_layers + 2, + depths=depths) + + scales = list(config.TRAIN.LAYER_DECAY ** i for i in + reversed(range(num_layers + 2))) + + parameters = get_finetune_param_groups(model, + config.TRAIN.BASE_LR, + config.TRAIN.WEIGHT_DECAY, + get_layer_func, + scales, + skip, + skip_keywords) + + optimizer = None + optimizer = optimizer_to_use(parameters, + eps=config.TRAIN.OPTIMIZER.EPS, + betas=config.TRAIN.OPTIMIZER.BETAS, + lr=config.TRAIN.BASE_LR, + weight_decay=config.TRAIN.WEIGHT_DECAY) + if logger: + logger.info(optimizer) + + return optimizer + + +# ----------------------------------------------------------------------------- +# get_finetune_param_groups +# ----------------------------------------------------------------------------- +def get_finetune_param_groups(model, + lr, + weight_decay, + get_layer_func, + scales, + skip_list=(), + skip_keywords=()): + + parameter_group_names = {} + parameter_group_vars = {} + + for name, param in model.named_parameters(): + + if not param.requires_grad: + continue + + if len(param.shape) == 1 or name.endswith(".bias") \ + or (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + group_name = "no_decay" + this_weight_decay = 0. + + else: + group_name = "decay" + this_weight_decay = weight_decay + + if get_layer_func is not None: + layer_id = get_layer_func(name) + group_name = "layer_%d_%s" % (layer_id, group_name) + + else: + layer_id = None + + if group_name not in parameter_group_names: + if scales is not None: + scale = scales[layer_id] + else: + scale = 1. + + parameter_group_names[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale, + } + + parameter_group_vars[group_name] = { + "group_name": group_name, + "weight_decay": this_weight_decay, + "params": [], + "lr": lr * scale, + "lr_scale": scale + } + + parameter_group_vars[group_name]["params"].append(param) + parameter_group_names[group_name]["params"].append(name) + return list(parameter_group_vars.values()) + + +# ----------------------------------------------------------------------------- +# check_keywords_in_name +# ----------------------------------------------------------------------------- +def check_keywords_in_name(name, keywords=()): + isin = False + for keyword in keywords: + if keyword in name: + isin = True + return isin + + +# ----------------------------------------------------------------------------- +# get_pretrain_param_groups +# ----------------------------------------------------------------------------- +def get_pretrain_param_groups(model, skip_list=(), skip_keywords=()): + + has_decay = [] + no_decay = [] + has_decay_name = [] + no_decay_name = [] + + for name, param in model.named_parameters(): + + if not param.requires_grad: + + continue + + if len(param.shape) == 1 or name.endswith(".bias") or \ + (name in skip_list) or \ + check_keywords_in_name(name, skip_keywords): + + no_decay.append(param) + + no_decay_name.append(name) + + else: + + has_decay.append(param) + + has_decay_name.append(name) + + return [{'params': has_decay}, + {'params': no_decay, 'weight_decay': 0.}] + + +# ----------------------------------------------------------------------------- +# get_swin_layer +# ----------------------------------------------------------------------------- +def get_swin_layer(name, num_layers, depths): + + if name in ("mask_token"): + + return 0 + + elif name.startswith("patch_embed"): + + return 0 + + elif name.startswith("layers"): + + layer_id = int(name.split('.')[1]) + + block_id = name.split('.')[3] + + if block_id == 'reduction' or block_id == 'norm': + + return sum(depths[:layer_id + 1]) + + layer_id = sum(depths[:layer_id]) + int(block_id) + + return layer_id + 1 + + else: + + return num_layers - 1 + diff --git a/pytorch_caney/optimizers/lamb.py b/pytorch_caney/optimizers/lamb.py new file mode 100644 index 0000000..de6aebb --- /dev/null +++ b/pytorch_caney/optimizers/lamb.py @@ -0,0 +1,214 @@ +""" PyTorch Lamb optimizer w/ behaviour similar to NVIDIA FusedLamb + +This optimizer code was adapted from the following (starting with latest) +* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py +* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py +* https://github.com/cybertronai/pytorch-lamb + +Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is +similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX. + +In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU. + +Original copyrights for above sources are below. + +Modifications Copyright 2021 Ross Wightman +""" +# Copyright (c) 2021, Habana Labs Ltd. All rights reserved. + +# Copyright (c) 2019-2020, NVIDIA CORPORATION. All rights reserved. +# +# 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. + +# MIT License +# +# Copyright (c) 2019 cybertronai +# +# 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 collections +import math + +import torch +from torch.optim import Optimizer + +from torch.utils.tensorboard import SummaryWriter + + +def log_lamb_rs(optimizer: Optimizer, event_writer: SummaryWriter, token_count: int): + """Log a histogram of trust ratio scalars in across layers.""" + results = collections.defaultdict(list) + for group in optimizer.param_groups: + for p in group['params']: + state = optimizer.state[p] + for i in ('weight_norm', 'adam_norm', 'trust_ratio'): + if i in state: + results[i].append(state[i]) + + for k, v in results.items(): + event_writer.add_histogram(f'lamb/{k}', torch.tensor(v), token_count) + + +class Lamb(Optimizer): + """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB + reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py + + LAMB was proposed in `Large Batch Optimization for Deep Learning: Training BERT in 76 minutes`_. + + Arguments: + params (iterable): iterable of parameters to optimize or dicts defining parameter groups. + lr (float, optional): learning rate. (default: 1e-3) + betas (Tuple[float, float], optional): coefficients used for computing + running averages of gradient and its norm. (default: (0.9, 0.999)) + eps (float, optional): term added to the denominator to improve + numerical stability. (default: 1e-8) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + grad_averaging (bool, optional): whether apply (1-beta2) to grad when + calculating running averages of gradient. (default: True) + max_grad_norm (float, optional): value used to clip global grad norm (default: 1.0) + trust_clip (bool): enable LAMBC trust ratio clipping (default: False) + always_adapt (boolean, optional): Apply adaptive learning rate to 0.0 + weight decay parameter (default: False) + + .. _Large Batch Optimization for Deep Learning - Training BERT in 76 minutes: + https://arxiv.org/abs/1904.00962 + .. _On the Convergence of Adam and Beyond: + https://openreview.net/forum?id=ryQu7f-RZ + """ + + def __init__( + self, params, lr=1e-3, bias_correction=True, betas=(0.9, 0.999), eps=1e-6, + weight_decay=0.01, grad_averaging=True, max_grad_norm=1.0, trust_clip=False, always_adapt=False): + defaults = dict( + lr=lr, bias_correction=bias_correction, betas=betas, eps=eps, weight_decay=weight_decay, + grad_averaging=grad_averaging, max_grad_norm=max_grad_norm, + trust_clip=trust_clip, always_adapt=always_adapt) + super().__init__(params, defaults) + + @torch.no_grad() + def step(self, closure=None): + """Performs a single optimization step. + Arguments: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + device = self.param_groups[0]['params'][0].device + one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly + global_grad_norm = torch.zeros(1, device=device) + for group in self.param_groups: + for p in group['params']: + if p.grad is None: + continue + grad = p.grad + if grad.is_sparse: + raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.') + global_grad_norm.add_(grad.pow(2).sum()) + + global_grad_norm = torch.sqrt(global_grad_norm) + # FIXME it'd be nice to remove explicit tensor conversion of scalars when torch.where promotes + # scalar types properly https://github.com/pytorch/pytorch/issues/9190 + max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], device=device) + clip_global_grad_norm = torch.where( + global_grad_norm > max_grad_norm, + global_grad_norm / max_grad_norm, + one_tensor) + + for group in self.param_groups: + bias_correction = 1 if group['bias_correction'] else 0 + beta1, beta2 = group['betas'] + grad_averaging = 1 if group['grad_averaging'] else 0 + beta3 = 1 - beta1 if grad_averaging else 1.0 + + # assume same step across group now to simplify things + # per parameter step can be easily support by making it tensor, or pass list into kernel + if 'step' in group: + group['step'] += 1 + else: + group['step'] = 1 + + if bias_correction: + bias_correction1 = 1 - beta1 ** group['step'] + bias_correction2 = 1 - beta2 ** group['step'] + else: + bias_correction1, bias_correction2 = 1.0, 1.0 + + for p in group['params']: + if p.grad is None: + continue + grad = p.grad.div_(clip_global_grad_norm) + state = self.state[p] + + # State initialization + if len(state) == 0: + # Exponential moving average of gradient valuesa + state['exp_avg'] = torch.zeros_like(p) + # Exponential moving average of squared gradient values + state['exp_avg_sq'] = torch.zeros_like(p) + + exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq'] + + # Decay the first and second moment running average coefficient + exp_avg.mul_(beta1).add_(grad, alpha=beta3) # m_t + exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) # v_t + + denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps']) + update = (exp_avg / bias_correction1).div_(denom) + + weight_decay = group['weight_decay'] + if weight_decay != 0: + update.add_(p, alpha=weight_decay) + + if weight_decay != 0 or group['always_adapt']: + # Layer-wise LR adaptation. By default, skip adaptation on parameters that are + # excluded from weight decay, unless always_adapt == True, then always enabled. + w_norm = p.norm(2.0) + g_norm = update.norm(2.0) + # FIXME nested where required since logical and/or not working in PT XLA + trust_ratio = torch.where( + w_norm > 0, + torch.where(g_norm > 0, w_norm / g_norm, one_tensor), + one_tensor, + ) + if group['trust_clip']: + # LAMBC trust clipping, upper bound fixed at one + trust_ratio = torch.minimum(trust_ratio, one_tensor) + + state['weight_norm'] = w_norm + state['adam_norm'] = g_norm + state['trust_ratio'] = trust_ratio + + update.mul_(trust_ratio) + + p.add_(update, alpha=-group['lr']) + + return loss diff --git a/pytorch_caney/pipelines/__init__.py b/pytorch_caney/pipelines/__init__.py index e69de29..642c3d9 100644 --- a/pytorch_caney/pipelines/__init__.py +++ b/pytorch_caney/pipelines/__init__.py @@ -0,0 +1,8 @@ +from .satvision_toa_pretrain_pipeline import SatVisionToaPretrain + +PIPELINES = { + 'satvisiontoapretrain': SatVisionToaPretrain, +} + +def get_available_pipelines(): + return {name: cls for name, cls in PIPELINES.items()} diff --git a/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py new file mode 100644 index 0000000..e292d42 --- /dev/null +++ b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py @@ -0,0 +1,90 @@ +import torch + +import pytorch_lightning as pl +import torchmetrics + +from torch.utils.data import DataLoader +from pytorch_caney.datasets.sharded_dataset import ShardedDataset +from pytorch_caney.models.mim import build_mim_model +from pytorch_caney.optimizers.build import build_optimizer +from pytorch_caney.transforms.mim_modis_toa import MimTransform + + +# ----------------------------------------------------------------------------- +# SatVisionToaPretrain +# ----------------------------------------------------------------------------- +class SatVisionToaPretrain(pl.LightningModule): + + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- + def __init__(self, config): + super(SatVisionToaPretrain, self).__init__() + self.save_hyperparameters(ignore=['model']) + + self.model = build_mim_model(config) + self.config = config + self.transform = MimTransform(self.config) + self.batch_size = config.DATA.BATCH_SIZE + self.num_workers = config.DATA.NUM_WORKERS + self.img_size = config.DATA.IMG_SIZE + self.train_data_paths = config.DATA.DATA_PATHS + self.train_data_length = config.DATA.LENGTH + self.pin_memory = config.DATA.PIN_MEMORY + + self.train_loss_avg = torchmetrics.MeanMetric() + self.trainset = ShardedDataset( + self.config, + self.train_data_paths, + split='train', + length=self.train_data_length, + img_size=self.img_size, + transform=self.transform, + batch_size=self.batch_size).dataset() + + # ------------------------------------------------------------------------- + # forward + # ------------------------------------------------------------------------- + def forward(self, x, x_mask): + return self.model(x, x_mask) + + # ------------------------------------------------------------------------- + # training_step + # ------------------------------------------------------------------------- + def training_step(self, batch, batch_idx): + image_imagemask = batch[0] + image = torch.stack([pair[0] for pair in image_imagemask]) + mask = torch.stack([pair[1] for pair in image_imagemask]) + loss = self.forward(image, mask) + self.train_loss_avg.update(loss) + self.log('train_loss', + self.train_loss_avg.compute(), + rank_zero_only=True, + batch_size=self.batch_size, + prog_bar=True + ) + + return loss + + # ------------------------------------------------------------------------- + # configure_optimizers + # ------------------------------------------------------------------------- + def configure_optimizers(self): + optimizer = build_optimizer(self.config, self.model, is_pretrain=True) + return optimizer + + # ------------------------------------------------------------------------- + # on_train_epoch_start + # ------------------------------------------------------------------------- + def on_train_epoch_start(self): + self.train_loss_avg.reset() + + # ------------------------------------------------------------------------- + # train_dataloader + # ------------------------------------------------------------------------- + def train_dataloader(self): + return DataLoader(self.trainset, + batch_size=None, + shuffle=False, + pin_memory=self.pin_memory, + num_workers=self.num_workers) diff --git a/pytorch_caney/ptc_cli.py b/pytorch_caney/ptc_cli.py index e69de29..fd61df2 100644 --- a/pytorch_caney/ptc_cli.py +++ b/pytorch_caney/ptc_cli.py @@ -0,0 +1,53 @@ +import argparse + +from pytorch_lightning import Trainer + +from pytorch_caney.configs.config import _C, _update_config_from_file +from pytorch_caney.utils import get_strategy, get_distributed_train_batches +from pytorch_caney.pipelines import PIPELINES, get_available_pipelines + + +# ----------------------------------------------------------------------------- +# main +# ----------------------------------------------------------------------------- +def main(config): + + print('Training') + + # Get the proper pipeline + available_pipelines = get_available_pipelines() + print("Available pipelines:", available_pipelines) + pipeline = PIPELINES[config.PIPELINE] + print(f'Using {pipeline}') + ptlPipeline = pipeline(config) + + strategy = get_strategy(config) + + trainer = Trainer( + accelerator="gpu", + devices=-1, + strategy=strategy, + max_epochs=config.TRAIN.EPOCHS, + log_every_n_steps=config.PRINT_FREQ, + ) + + if config.TRAIN.LIMIT_TRAIN_BATCHES: + trainer.limit_train_batches = get_distributed_train_batches(config, trainer) + + trainer.fit(model=ptlPipeline) + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser() + + parser.add_argument( + '--config-path', type=str, help='Path to pretrained model config' + ) + + hparams = parser.parse_args() + + config = _C.clone() + _update_config_from_file(config, hparams.config_path) + + main(config) diff --git a/pytorch_caney/transforms/mim_mask_generator.py b/pytorch_caney/transforms/mim_mask_generator.py new file mode 100644 index 0000000..c101d3c --- /dev/null +++ b/pytorch_caney/transforms/mim_mask_generator.py @@ -0,0 +1,58 @@ +import numpy as np +from numba import njit + + +# ----------------------------------------------------------------------------- +# MimMaskGenerator +# ----------------------------------------------------------------------------- +class MimMaskGenerator: + """ + Generates the masks for masked-image-modeling + """ + def __init__(self, + input_size=192, + mask_patch_size=32, + model_patch_size=4, + mask_ratio=0.6): + self.input_size = input_size + self.mask_patch_size = mask_patch_size + self.model_patch_size = model_patch_size + self.mask_ratio = mask_ratio + + assert self.input_size % self.mask_patch_size == 0 + assert self.mask_patch_size % self.model_patch_size == 0 + + self.rand_size = self.input_size // self.mask_patch_size + self.scale = self.mask_patch_size // self.model_patch_size + + self.token_count = self.rand_size ** 2 + self.mask_count = int(np.ceil(self.token_count * self.mask_ratio)) + + def __call__(self): + mask = make_mim_mask(self.token_count, self.mask_count, + self.rand_size, self.scale) + mask = mask.repeat(self.scale, axis=0).repeat(self.scale, axis=1) + return mask + + +# ----------------------------------------------------------------------------- +# make_mim_mask +# ----------------------------------------------------------------------------- +@njit() +def make_mim_mask(token_count, mask_count, rand_size, scale): + """JIT-compiled random mask generation + + Args: + token_count + mask_count + rand_size + scale + + Returns: + mask + """ + mask_idx = np.random.permutation(token_count)[:mask_count] + mask = np.zeros(token_count, dtype=np.int64) + mask[mask_idx] = 1 + mask = mask.reshape((rand_size, rand_size)) + return mask diff --git a/pytorch_caney/transforms/mim_modis_toa.py b/pytorch_caney/transforms/mim_modis_toa.py new file mode 100644 index 0000000..c111600 --- /dev/null +++ b/pytorch_caney/transforms/mim_modis_toa.py @@ -0,0 +1,48 @@ +import torchvision.transforms as T + +from .random_resize_crop import RandomResizedCropNP +from .mim_mask_generator import MimMaskGenerator +from .modis_toa_scale import MinMaxEmissiveScaleReflectance + + +# ----------------------------------------------------------------------------- +# MimTransform +# ----------------------------------------------------------------------------- +class MimTransform: + """ + torchvision transform which transforms the input imagery into + addition to generating a MiM mask + """ + + def __init__(self, config): + + self.transform_img = \ + T.Compose([ + MinMaxEmissiveScaleReflectance(), # New transform for MinMax + RandomResizedCropNP(scale=(0.67, 1.), + ratio=(3. / 4., 4. / 3.)), + T.ToTensor(), + T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), + ]) + + if config.MODEL.TYPE in ['swin', 'swinv2']: + + model_patch_size = config.MODEL.SWINV2.PATCH_SIZE + + else: + + raise NotImplementedError + + self.mask_generator = MimMaskGenerator( + input_size=config.DATA.IMG_SIZE, + mask_patch_size=config.DATA.MASK_PATCH_SIZE, + model_patch_size=model_patch_size, + mask_ratio=config.DATA.MASK_RATIO, + ) + + def __call__(self, img): + + img = self.transform_img(img) + mask = self.mask_generator() + + return img, mask diff --git a/pytorch_caney/transforms/modis_toa_scale.py b/pytorch_caney/transforms/modis_toa_scale.py new file mode 100644 index 0000000..b256a79 --- /dev/null +++ b/pytorch_caney/transforms/modis_toa_scale.py @@ -0,0 +1,40 @@ +import numpy as np + + +# ----------------------------------------------------------------------------- +# MinMaxEmissiveScaleReflectance +# ----------------------------------------------------------------------------- +class MinMaxEmissiveScaleReflectance(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emissive_mins = np.array( + [223.1222, 178.9174, 204.3739, 204.7677, + 194.8686, 202.1759, 201.3823, 203.3537], + dtype=np.float32) + + self.emissive_maxs = np.array( + [352.7182, 261.2920, 282.5529, 319.0373, + 295.0209, 324.0677, 321.5254, 285.9848], + dtype=np.float32) + + def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img diff --git a/pytorch_caney/transforms/random_resize_crop.py b/pytorch_caney/transforms/random_resize_crop.py new file mode 100644 index 0000000..8eab062 --- /dev/null +++ b/pytorch_caney/transforms/random_resize_crop.py @@ -0,0 +1,63 @@ +import torch +import numpy as np + + +# ----------------------------------------------------------------------------- +# RandomResizedCropNP +# ----------------------------------------------------------------------------- +class RandomResizedCropNP(object): + """ + Numpy implementation of RandomResizedCrop + """ + + def __init__(self, + scale=(0.08, 1.0), + ratio=(3.0/4.0, 4.0/3.0)): + + self.scale = scale + self.ratio = ratio + + def __call__(self, img): + + height, width = img.shape[:2] + area = height * width + + for _ in range(10): + target_area = np.random.uniform(*self.scale) * area + aspect_ratio = np.random.uniform(*self.ratio) + + w = int(round(np.sqrt(target_area * aspect_ratio))) + h = int(round(np.sqrt(target_area / aspect_ratio))) + + if np.random.random() < 0.5: + w, h = h, w + + if w <= width and h <= height: + x1 = np.random.randint(0, width - w + 1) + y1 = np.random.randint(0, height - h + 1) + cropped = img[y1:y1+h, x1:x1+w, :] + cropped = np.moveaxis(cropped, -1, 0) + cropped_resized = torch.nn.functional.interpolate( + torch.from_numpy(cropped).unsqueeze(0), + size=height, + mode='bicubic', + align_corners=False) + cropped_squeezed_numpy = cropped_resized.squeeze().numpy() + cropped_squeezed_numpy = np.moveaxis( + cropped_squeezed_numpy, 0, -1) + return cropped_squeezed_numpy + + # if crop was not successful after 10 attempts, use center crop + w = min(width, height) + x1 = (width - w) // 2 + y1 = (height - w) // 2 + cropped = img[y1:y1+w, x1:x1+w, :] + cropped = np.moveaxis(cropped, -1, 0) + cropped_resized = torch.nn.functional.interpolate(torch.from_numpy( + cropped).unsqueeze(0), + size=height, + mode='bicubic', + align_corners=False) + cropped_squeezed_numpy = cropped_resized.squeeze().numpy() + cropped_squeezed_numpy = np.moveaxis(cropped_squeezed_numpy, 0, -1) + return cropped_squeezed_numpy \ No newline at end of file diff --git a/pytorch_caney/utils.py b/pytorch_caney/utils.py new file mode 100644 index 0000000..4f05ccf --- /dev/null +++ b/pytorch_caney/utils.py @@ -0,0 +1,41 @@ +from pytorch_lightning.strategies import DeepSpeedStrategy + + +# ----------------------------------------------------------------------------- +# get_strategy +# ----------------------------------------------------------------------------- +def get_strategy(config): + + strategy = config.TRAIN.STRATEGY + + if strategy == 'deepspeed': + deepspeed_config = { + "train_micro_batch_size_per_gpu": config.DATA.BATCH_SIZE, + "steps_per_print": config.PRINT_FREQ, + "zero_allow_untested_optimizer": True, + "zero_optimization": { + "stage": config.DEEPSPEED.STAGE, + "contiguous_gradients": config.DEEPSPEED.CONTIGUOUS_GRADIENTS, + "overlap_comm": config.DEEPSPEED.OVERLAP_COMM, + "reduce_bucket_size": config.DEEPSPEED.REDUCE_BUCKET_SIZE, + "allgather_bucket_size": config.DEEPSPEED.ALLGATHER_BUCKET_SIZE, + }, + "activation_checkpointing": { + "partition_activations": config.TRAIN.USE_CHECKPOINT, + }, + } + + return DeepSpeedStrategy(config=deepspeed_config) + + elif strategy == 'ddp' or strategy == 'fsdp': + # These may be return as strings + return strategy + +# ----------------------------------------------------------------------------- +# get_distributed_train_batches +# ----------------------------------------------------------------------------- +def get_distributed_train_batches(config, trainer): + if config.TRAIN.NUM_TRAIN_BATCHES: + return config.TRAIN.NUM_TRAIN_BATCHES + else: + return config.DATA.LENGTH // (config.DATA.BATCH_SIZE * trainer.world_size) From 7e6430ecd74c9301dd888816a04efa460d927611 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 30 Oct 2024 17:22:03 -0400 Subject: [PATCH 34/50] added model handling and 3dcloud task --- pytorch_caney/configs/config.py | 16 +- pytorch_caney/datamodules/__init__.py | 8 + .../datamodules/abi_3dcloud_datamodule.py | 51 +++++++ pytorch_caney/datasets/abi_3dcloud_dataset.py | 59 ++++++++ pytorch_caney/models/__init__.py | 2 + pytorch_caney/models/decoders/__init__.py | 1 + pytorch_caney/models/decoders/fcn_decoder.py | 25 ++++ pytorch_caney/models/encoders/__init__.py | 3 + pytorch_caney/models/encoders/fcn_encoder.py | 26 ++++ pytorch_caney/models/encoders/satvision.py | 45 ++++++ pytorch_caney/models/encoders/swinv2.py | 6 +- pytorch_caney/models/heads/__init__.py | 1 + .../models/heads/segmentation_head.py | 16 ++ pytorch_caney/models/model_factory.py | 87 +++++++++++ pytorch_caney/pipelines/__init__.py | 2 + .../pipelines/three_d_cloud_pipeline.py | 141 ++++++++++++++++++ pytorch_caney/ptc_cli.py | 13 +- pytorch_caney/ptc_logging.py | 49 ++++++ .../transforms/abi_radiance_conversion.py | 58 +++++++ pytorch_caney/transforms/abi_toa.py | 30 ++++ pytorch_caney/transforms/abi_toa_scale.py | 37 +++++ pytorch_caney/transforms/modis_toa.py | 27 ++++ pytorch_caney/utils.py | 2 +- 23 files changed, 697 insertions(+), 8 deletions(-) create mode 100644 pytorch_caney/datamodules/abi_3dcloud_datamodule.py create mode 100644 pytorch_caney/datasets/abi_3dcloud_dataset.py create mode 100644 pytorch_caney/models/decoders/fcn_decoder.py create mode 100644 pytorch_caney/models/encoders/fcn_encoder.py create mode 100644 pytorch_caney/models/encoders/satvision.py create mode 100644 pytorch_caney/models/heads/__init__.py create mode 100644 pytorch_caney/models/heads/segmentation_head.py create mode 100644 pytorch_caney/models/model_factory.py create mode 100644 pytorch_caney/pipelines/three_d_cloud_pipeline.py create mode 100644 pytorch_caney/ptc_logging.py create mode 100644 pytorch_caney/transforms/abi_radiance_conversion.py create mode 100644 pytorch_caney/transforms/abi_toa.py create mode 100644 pytorch_caney/transforms/abi_toa_scale.py create mode 100644 pytorch_caney/transforms/modis_toa.py diff --git a/pytorch_caney/configs/config.py b/pytorch_caney/configs/config.py index 505285a..adf237a 100644 --- a/pytorch_caney/configs/config.py +++ b/pytorch_caney/configs/config.py @@ -15,6 +15,10 @@ _C.DATA.BATCH_SIZE = 128 # Path(s) to dataset, could be overwritten by command line argument _C.DATA.DATA_PATHS = [''] +# Path(s) to the validation/test dataset +_C.DATA.TEST_DATA_PATHS = [''] +# Path(s) to dataset masks +_C.DATA.MASK_PATHS = [''] # Path to validation numpy dataset _C.DATA.VALIDATION_PATH = '' # Dataset name @@ -40,8 +44,10 @@ _C.MODEL = CN() # Model type _C.MODEL.TYPE = 'swinv2' -# Decoder type -_C.MODEL.DECODER = None +# Encoder type for fine-tuning +_C.MODEL.ENCODER = '' +# Decoder type for fine-tuning +_C.MODEL.DECODER = '' # Model name _C.MODEL.NAME = 'swinv2_base_patch4_window7_224' # Pretrained weight from checkpoint, could be from previous pre-training @@ -51,6 +57,8 @@ _C.MODEL.RESUME = '' # Number of classes, overwritten in data preparation _C.MODEL.NUM_CLASSES = 17 +# Number of channels the input image has +_C.MODEL.IN_CHANS = 3 # Dropout rate _C.MODEL.DROP_RATE = 0.0 # Drop path rate @@ -168,7 +176,7 @@ # Enable Pytorch automatic mixed precision (amp). _C.AMP_ENABLE = True # Path to output folder, overwritten by command line argument -_C.OUTPUT = '' +_C.OUTPUT = '.' # Tag of experiment, overwritten by command line argument _C.TAG = 'pt-caney-default-tag' # Frequency to save checkpoint @@ -183,6 +191,8 @@ _C.EVAL_MODE = False # Pipeline _C.PIPELINE = 'satvisiontoapretrain' +# Data module +_C.DATAMODULE = 'abitoa3dcloud' def _update_config_from_file(config, cfg_file): diff --git a/pytorch_caney/datamodules/__init__.py b/pytorch_caney/datamodules/__init__.py index e69de29..c428d84 100644 --- a/pytorch_caney/datamodules/__init__.py +++ b/pytorch_caney/datamodules/__init__.py @@ -0,0 +1,8 @@ +from .abi_3dcloud_datamodule import AbiToa3DCloudDataModule + +DATAMODULES = { + 'abitoa3dcloud': AbiToa3DCloudDataModule, +} + +def get_available_datamodules(): + return {name: cls for name, cls in DATAMODULES.items()} \ No newline at end of file diff --git a/pytorch_caney/datamodules/abi_3dcloud_datamodule.py b/pytorch_caney/datamodules/abi_3dcloud_datamodule.py new file mode 100644 index 0000000..c44c342 --- /dev/null +++ b/pytorch_caney/datamodules/abi_3dcloud_datamodule.py @@ -0,0 +1,51 @@ +from torch.utils.data import DataLoader +import lightning as L + +from pytorch_caney.datasets.abi_3dcloud_dataset import AbiToa3DCloudDataset +from pytorch_caney.transforms.abi_toa import AbiToaTransform + + +class AbiToa3DCloudDataModule(L.LightningDataModule): + """NonGeo ABI TOA 3D cloud data module implementation""" + + def __init__( + self, + config, + ) -> None: + super().__init__() + self.config = config + self.transform = AbiToaTransform(config.DATA.IMG_SIZE) + print(self.transform) + self.train_data_paths = config.DATA.DATA_PATHS + self.test_data_paths = config.DATA.TEST_DATA_PATHS + self.batch_size = config.DATA.BATCH_SIZE + self.num_workers = config.DATA.NUM_WORKERS + + def setup(self, stage: str) -> None: + if stage in ["fit"]: + self.train_dataset = AbiToa3DCloudDataset( + self.config, + self.train_data_paths, + self.transform, + ) + if stage in ["fit", "validate"]: + self.val_dataset = AbiToa3DCloudDataset( + self.config, + self.test_data_paths, + self.transform, + ) + if stage in ["test"]: + self.test_dataset = AbiToa3DCloudDataset( + self.config, + self.test_data_paths, + self.transform, + ) + + def train_dataloader(self): + return DataLoader(self.train_dataset, batch_size=self.batch_size, num_workers=self.num_workers) + + def val_dataloader(self): + return DataLoader(self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers) + + def test_dataloader(self): + return DataLoader(self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers) diff --git a/pytorch_caney/datasets/abi_3dcloud_dataset.py b/pytorch_caney/datasets/abi_3dcloud_dataset.py new file mode 100644 index 0000000..3f37eae --- /dev/null +++ b/pytorch_caney/datasets/abi_3dcloud_dataset.py @@ -0,0 +1,59 @@ +import os +from pathlib import Path +from typing import Any, Dict + +import numpy as np +import rioxarray as rxr + +from torchgeo.datasets import NonGeoDataset + + +class AbiToa3DCloudDataset(NonGeoDataset): + + def __init__(self, config, data_paths: list, transform=None) -> None: + + super().__init__() + + self.config = config + self.data_paths = data_paths + self.transform = transform + self.img_size = config.DATA.IMG_SIZE + + self.image_list = [] + self.mask_list = [] + + for image_mask_path in self.data_paths: + self.image_list.extend(self.get_filenames(image_mask_path)) + + self.rgb_indices = [0, 1, 2] + + def __len__(self) -> int: + return len(self.image_list) + + def __getitem__(self, index: int) -> Dict[str, Any]: + + npz_array = self._load_file(self.image_list[index]) + image = npz_array['chip'] + mask = npz_array['data'].item()['Cloud_mask'] + + if self.transform is not None: + image = self.transform(image) + + return image, mask + + def _load_file(self, path: Path): + if Path(path).suffix == '.npy' or Path(path).suffix == '.npz': + return np.load(path, allow_pickle=True) + elif Path(path).suffix == '.tif': + return rxr.open_rasterio(path) + else: + raise RuntimeError('Non-recognized dataset format. Expects npy or tif.') + + def get_filenames(self, path): + """ + Returns a list of absolute paths to images inside given `path` + """ + files_list = [] + for filename in sorted(os.listdir(path)): + files_list.append(os.path.join(path, filename)) + return files_list diff --git a/pytorch_caney/models/__init__.py b/pytorch_caney/models/__init__.py index e69de29..32eb253 100644 --- a/pytorch_caney/models/__init__.py +++ b/pytorch_caney/models/__init__.py @@ -0,0 +1,2 @@ +from .model_factory import ModelFactory +from .mim import MiMModel \ No newline at end of file diff --git a/pytorch_caney/models/decoders/__init__.py b/pytorch_caney/models/decoders/__init__.py index e69de29..fafea15 100644 --- a/pytorch_caney/models/decoders/__init__.py +++ b/pytorch_caney/models/decoders/__init__.py @@ -0,0 +1 @@ +from .fcn_decoder import FcnDecoder \ No newline at end of file diff --git a/pytorch_caney/models/decoders/fcn_decoder.py b/pytorch_caney/models/decoders/fcn_decoder.py new file mode 100644 index 0000000..232147d --- /dev/null +++ b/pytorch_caney/models/decoders/fcn_decoder.py @@ -0,0 +1,25 @@ +import torch.nn as nn + +from ..model_factory import ModelFactory + + +@ModelFactory.decoder("fcn") +class FcnDecoder(nn.Module): + def __init__(self, num_features: int = 1024): + super(FcnDecoder, self).__init__() + self.output_channels = 64 + self.decoder = nn.Sequential( + nn.ConvTranspose2d(num_features, 2048, kernel_size=3, stride=2, padding=1, output_padding=1), # 16x16x512 + nn.ReLU(), + nn.ConvTranspose2d(2048, 512, kernel_size=3, stride=2, padding=1, output_padding=1), # 32x32x256 + nn.ReLU(), + nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 + nn.ReLU(), + nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 + nn.ReLU(), + nn.ConvTranspose2d(128, self.output_channels, kernel_size=3, stride=2, padding=1, output_padding=1), # 128x128x64 + nn.ReLU() + ) + + def forward(self, x): + return self.decoder(x) \ No newline at end of file diff --git a/pytorch_caney/models/encoders/__init__.py b/pytorch_caney/models/encoders/__init__.py index e69de29..c699db0 100644 --- a/pytorch_caney/models/encoders/__init__.py +++ b/pytorch_caney/models/encoders/__init__.py @@ -0,0 +1,3 @@ +from .fcn_encoder import FcnEncoder +from .satvision import SatVision +from .swinv2 import SwinTransformerV2 \ No newline at end of file diff --git a/pytorch_caney/models/encoders/fcn_encoder.py b/pytorch_caney/models/encoders/fcn_encoder.py new file mode 100644 index 0000000..0c1e20f --- /dev/null +++ b/pytorch_caney/models/encoders/fcn_encoder.py @@ -0,0 +1,26 @@ +import torch.nn as nn + +from ..model_factory import ModelFactory + + +@ModelFactory.encoder("fcn") +class FcnEncoder(nn.Module): + def __init__(self, config): + super(FcnEncoder, self).__init__() + self.config = config + self.num_input_channels = self.config.MODEL.IN_CHANS + self.num_features = 1024 + self.encoder = nn.Sequential( + nn.Conv2d(self.num_input_channels, 64, kernel_size=3, stride=1, padding=1), # 128x128x64 + nn.ReLU(), + nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1), # 64x64x128 + nn.ReLU(), + nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1), # 32x32x256 + nn.ReLU(), + nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1), # 16x16x512 + nn.ReLU(), + nn.Conv2d(512, 1024, kernel_size=3, stride=2, padding=1) # 8x8x1024 + ) + + def forward(self, x): + return self.encoder(x) \ No newline at end of file diff --git a/pytorch_caney/models/encoders/satvision.py b/pytorch_caney/models/encoders/satvision.py new file mode 100644 index 0000000..d539550 --- /dev/null +++ b/pytorch_caney/models/encoders/satvision.py @@ -0,0 +1,45 @@ +from .swinv2 import SwinTransformerV2 +from ..model_factory import ModelFactory +import torch.nn as nn + + +@ModelFactory.encoder("satvision") +class SatVision(nn.Module): + def __init__(self, config): + super().__init__() + + self.config = config + + window_sizes = config.MODEL.SWINV2.PRETRAINED_WINDOW_SIZES + + self.model = SwinTransformerV2( + img_size=config.DATA.IMG_SIZE, + patch_size=config.MODEL.SWINV2.PATCH_SIZE, + in_chans=config.MODEL.SWINV2.IN_CHANS, + num_classes=config.MODEL.NUM_CLASSES, + embed_dim=config.MODEL.SWINV2.EMBED_DIM, + depths=config.MODEL.SWINV2.DEPTHS, + num_heads=config.MODEL.SWINV2.NUM_HEADS, + window_size=config.MODEL.SWINV2.WINDOW_SIZE, + mlp_ratio=config.MODEL.SWINV2.MLP_RATIO, + qkv_bias=config.MODEL.SWINV2.QKV_BIAS, + drop_rate=config.MODEL.DROP_RATE, + drop_path_rate=config.MODEL.DROP_PATH_RATE, + ape=config.MODEL.SWINV2.APE, + patch_norm=config.MODEL.SWINV2.PATCH_NORM, + use_checkpoint=config.TRAIN.USE_CHECKPOINT, + pretrained_window_sizes=window_sizes, + ) + + self.num_classes = self.model.num_classes + self.num_layers = self.model.num_layers + self.num_features = self.model.num_features + + def forward(self, x): + return self.model.forward(x) + + def forward_features(self, x): + return self.model.forward_features(x) + + def extra_features(self, x): + return self.model.extra_features(x) diff --git a/pytorch_caney/models/encoders/swinv2.py b/pytorch_caney/models/encoders/swinv2.py index 9d3f26e..1ceb257 100644 --- a/pytorch_caney/models/encoders/swinv2.py +++ b/pytorch_caney/models/encoders/swinv2.py @@ -7,6 +7,8 @@ import numpy as np +from ..model_factory import ModelFactory + # ----------------------------------------------------------------------------- # WindowAttention @@ -656,6 +658,7 @@ def flops(self): # ----------------------------------------------------------------------------- # SwinTransformerV2 # ----------------------------------------------------------------------------- +@ModelFactory.encoder("swinv2") class SwinTransformerV2(nn.Module): r""" Swin Transformer A PyTorch impl of : `Swin Transformer: Hierarchical @@ -831,8 +834,7 @@ def get_unet_feature(self, x): return feature def forward(self, x): - x = self.forward_features(x) - x = self.head(x) + x = self.extra_features(x)[-1] return x def flops(self): diff --git a/pytorch_caney/models/heads/__init__.py b/pytorch_caney/models/heads/__init__.py new file mode 100644 index 0000000..df60bcd --- /dev/null +++ b/pytorch_caney/models/heads/__init__.py @@ -0,0 +1 @@ +from .segmentation_head import SegmentationHead \ No newline at end of file diff --git a/pytorch_caney/models/heads/segmentation_head.py b/pytorch_caney/models/heads/segmentation_head.py new file mode 100644 index 0000000..86308e6 --- /dev/null +++ b/pytorch_caney/models/heads/segmentation_head.py @@ -0,0 +1,16 @@ +import torch.nn as nn + +from ..model_factory import ModelFactory + +@ModelFactory.head("segmentation_head") +class SegmentationHead(nn.Module): + def __init__(self, decoder_channels=128, num_classes=4, head_dropout=0.2, output_shape=(91, 40)): + super(SegmentationHead, self).__init__() + self.head = nn.Sequential( + nn.Conv2d(decoder_channels, num_classes, kernel_size=3, stride=1, padding=1), + nn.Dropout(head_dropout), + nn.Upsample(size=output_shape, mode='bilinear', align_corners=False) + ) + + def forward(self, x): + return self.head(x) \ No newline at end of file diff --git a/pytorch_caney/models/model_factory.py b/pytorch_caney/models/model_factory.py new file mode 100644 index 0000000..f12b3fd --- /dev/null +++ b/pytorch_caney/models/model_factory.py @@ -0,0 +1,87 @@ +import torch.nn as nn + +# ----------------------------------------------------------------------------- +# ModelFactory +# ----------------------------------------------------------------------------- +class ModelFactory: + # Class-level registries + backbones = {} + decoders = {} + heads = {} + + # ------------------------------------------------------------------------- + # register_backbone + # ------------------------------------------------------------------------- + @classmethod + def register_backbone(cls, name: str, backbone_cls): + """Register a new backbone in the factory.""" + cls.backbones[name] = backbone_cls + + # ------------------------------------------------------------------------- + # register_decoder + # ------------------------------------------------------------------------- + @classmethod + def register_decoder(cls, name: str, decoder_cls): + """Register a new decoder in the factory.""" + cls.decoders[name] = decoder_cls + + # ------------------------------------------------------------------------- + # register_head + # ------------------------------------------------------------------------- + @classmethod + def register_head(cls, name: str, head_cls): + """Register a new head in the factory.""" + cls.heads[name] = head_cls + + # ------------------------------------------------------------------------- + # get_component + # ------------------------------------------------------------------------- + @classmethod + def get_component(cls, component_type: str, name: str, **kwargs): + """Public method to retrieve and instantiate a component by type and name.""" + print(cls.backbones) + print(cls.decoders) + print(cls.heads) + registry = { + "encoder": cls.backbones, + "decoder": cls.decoders, + "head": cls.heads, + }.get(component_type) + + if registry is None or name not in registry: + raise ValueError(f"{component_type.capitalize()} '{name}' not found in registry.") + + return registry[name](**kwargs) + + # ------------------------------------------------------------------------- + # encoder + # ------------------------------------------------------------------------- + @classmethod + def encoder(cls, name): + """Class decorator for registering an encoder.""" + def decorator(encoder_cls): + cls.register_backbone(name, encoder_cls) + return encoder_cls + return decorator + + # ------------------------------------------------------------------------- + # decoder + # ------------------------------------------------------------------------- + @classmethod + def decoder(cls, name): + """Class decorator for registering a decoder.""" + def decorator(decoder_cls): + cls.register_decoder(name, decoder_cls) + return decoder_cls + return decorator + + # ------------------------------------------------------------------------- + # head + # ------------------------------------------------------------------------- + @classmethod + def head(cls, name): + """Class decorator for registering a head.""" + def decorator(head_cls): + cls.register_head(name, head_cls) + return head_cls + return decorator \ No newline at end of file diff --git a/pytorch_caney/pipelines/__init__.py b/pytorch_caney/pipelines/__init__.py index 642c3d9..f008267 100644 --- a/pytorch_caney/pipelines/__init__.py +++ b/pytorch_caney/pipelines/__init__.py @@ -1,7 +1,9 @@ from .satvision_toa_pretrain_pipeline import SatVisionToaPretrain +from .three_d_cloud_pipeline import ThreeDCloudTask PIPELINES = { 'satvisiontoapretrain': SatVisionToaPretrain, + '3dcloud': ThreeDCloudTask } def get_available_pipelines(): diff --git a/pytorch_caney/pipelines/three_d_cloud_pipeline.py b/pytorch_caney/pipelines/three_d_cloud_pipeline.py new file mode 100644 index 0000000..19a94f4 --- /dev/null +++ b/pytorch_caney/pipelines/three_d_cloud_pipeline.py @@ -0,0 +1,141 @@ +import torch +import torch.nn as nn +import torchmetrics +from torchgeo.trainers import BaseTask + +import lightning.pytorch as pl +from pytorch_caney.models.mim import build_mim_model +from pytorch_caney.optimizers.build import build_optimizer +from pytorch_caney.transforms.abi_toa import AbiToaTransform +from pytorch_caney.models import ModelFactory +from pytorch_caney.models.decoders import FcnDecoder +from pytorch_caney.models.heads import SegmentationHead +from typing import Any, Tuple + +# ----------------------------------------------------------------------------- +# ThreeDCloudTask +# ----------------------------------------------------------------------------- +class ThreeDCloudTask(pl.LightningModule): + + NUM_CLASSES: int = 1 + OUTPUT_SHAPE: Tuple[int, int] = (91, 40) + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- + def __init__(self, config): + super(ThreeDCloudTask, self).__init__() + self.save_hyperparameters(ignore=['model']) + self.config = config + self.configure_models() + self.configure_losses() + self.configure_metrics() + self.transform = AbiToaTransform(self.config) + + # ------------------------------------------------------------------------- + # configure_models + # ------------------------------------------------------------------------- + def configure_models(self): + factory = ModelFactory() + + self.encoder = factory.get_component(component_type="encoder", + name=self.config.MODEL.ENCODER, + config=self.config) + + self.decoder = factory.get_component(component_type="decoder", + name=self.config.MODEL.DECODER, + num_features=self.encoder.num_features) + + self.segmentation_head = factory.get_component(component_type="head", + name="segmentation_head", + decoder_channels=self.decoder.output_channels, + num_classes=self.NUM_CLASSES, + output_shape=self.OUTPUT_SHAPE) + + self.model = nn.Sequential(self.encoder, self.decoder, self.segmentation_head) + print(self.model) + + # ------------------------------------------------------------------------- + # configure_losses + # ------------------------------------------------------------------------- + def configure_losses(self): + loss: str = self.config.LOSS.NAME + if loss == 'bce': + self.criterion = nn.BCEWithLogitsLoss() + else: + raise ValueError( + f'Loss type "{loss}" is not valid. ' + 'Currecntly supports "ce".' + ) + + # ------------------------------------------------------------------------- + # configure_metrics + # ------------------------------------------------------------------------- + def configure_metrics(self): + num_classes = 2 + self.train_iou = torchmetrics.JaccardIndex(num_classes=num_classes, task="binary") + self.val_iou = torchmetrics.JaccardIndex(num_classes=num_classes, task="binary") + self.train_loss_avg = torchmetrics.MeanMetric() + self.val_loss_avg = torchmetrics.MeanMetric() + + self.train_iou_avg = torchmetrics.MeanMetric() + self.val_iou_avg = torchmetrics.MeanMetric() + + # ------------------------------------------------------------------------- + # forward + # ------------------------------------------------------------------------- + def forward(self, x): + return self.model(x) + + # ------------------------------------------------------------------------- + # training_step + # ------------------------------------------------------------------------- + def training_step(self, batch, batch_idx): + inputs, targets = batch + targets = targets.unsqueeze(1) + logits = self.forward(inputs) + loss = self.criterion(logits, targets.float()) + preds = torch.sigmoid(logits) + iou = self.train_iou(preds, targets.int()) + + self.train_loss_avg.update(loss) + self.train_iou_avg.update(iou) + self.log('train_loss', self.train_loss_avg.compute(), on_step=True, on_epoch=True, prog_bar=True) + self.log('train_iou', self.train_iou_avg.compute(), on_step=True, on_epoch=True, prog_bar=True) + return loss + + # ------------------------------------------------------------------------- + # validation_step + # ------------------------------------------------------------------------- + def validation_step(self, batch, batch_idx): + inputs, targets = batch + targets = targets.unsqueeze(1) + logits = self.forward(inputs) + val_loss = self.criterion(logits, targets.float()) + preds = torch.sigmoid(logits) + val_iou = self.val_iou(preds, targets.int()) + self.val_loss_avg.update(val_loss) + self.val_iou_avg.update(val_iou) + self.log('val_loss', self.val_loss_avg.compute(), on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) + self.log('val_iou', self.val_iou_avg.compute(), on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) + + return val_loss + + # ------------------------------------------------------------------------- + # configure_optimizers + # ------------------------------------------------------------------------- + def configure_optimizers(self): + optimizer = build_optimizer(self.config, self.model, is_pretrain=True) + return optimizer + + # ------------------------------------------------------------------------- + # on_train_epoch_start + # ------------------------------------------------------------------------- + def on_train_epoch_start(self): + self.train_loss_avg.reset() + self.train_iou_avg.reset() + + # ------------------------------------------------------------------------- + # on_validation_epoch_start + # ------------------------------------------------------------------------- + def on_validation_epoch_start(self): + self.val_loss_avg.reset() diff --git a/pytorch_caney/ptc_cli.py b/pytorch_caney/ptc_cli.py index fd61df2..ea31b92 100644 --- a/pytorch_caney/ptc_cli.py +++ b/pytorch_caney/ptc_cli.py @@ -1,10 +1,12 @@ import argparse -from pytorch_lightning import Trainer +from lightning.pytorch import Trainer from pytorch_caney.configs.config import _C, _update_config_from_file from pytorch_caney.utils import get_strategy, get_distributed_train_batches from pytorch_caney.pipelines import PIPELINES, get_available_pipelines +from pytorch_caney.datamodules import DATAMODULES, get_available_datamodules +from pytorch_caney.ptc_logging import create_logger # ----------------------------------------------------------------------------- @@ -21,6 +23,12 @@ def main(config): print(f'Using {pipeline}') ptlPipeline = pipeline(config) + available_datamodules = get_available_datamodules() + print(f"Available data modules: {available_datamodules}") + datamoduleClass = DATAMODULES[config.DATAMODULE] + print(f'Using {datamoduleClass}') + datamodule = datamoduleClass(config) + strategy = get_strategy(config) trainer = Trainer( @@ -34,11 +42,12 @@ def main(config): if config.TRAIN.LIMIT_TRAIN_BATCHES: trainer.limit_train_batches = get_distributed_train_batches(config, trainer) - trainer.fit(model=ptlPipeline) + trainer.fit(model=ptlPipeline, datamodule=datamodule) if __name__ == "__main__": + parser = argparse.ArgumentParser() parser.add_argument( diff --git a/pytorch_caney/ptc_logging.py b/pytorch_caney/ptc_logging.py new file mode 100644 index 0000000..3b76462 --- /dev/null +++ b/pytorch_caney/ptc_logging.py @@ -0,0 +1,49 @@ +import os +import sys +import logging +import functools +from termcolor import colored + + +@functools.lru_cache() +def create_logger(output_dir, dist_rank=0, name=''): + # create logger + logger = logging.getLogger(name) + + logger.setLevel(logging.DEBUG) + + logger.propagate = False + + # create formatter + fmt = '[%(asctime)s %(name)s] ' + \ + '(%(filename)s %(lineno)d): ' + \ + '%(levelname)s %(message)s' + + color_fmt = colored('[%(asctime)s %(name)s]', 'green') + \ + colored('(%(filename)s %(lineno)d)', 'yellow') + \ + ': %(levelname)s %(message)s' + + # create console handlers for master process + if dist_rank == 0: + + console_handler = logging.StreamHandler(sys.stdout) + + console_handler.setLevel(logging.DEBUG) + + console_handler.setFormatter( + logging.Formatter(fmt=color_fmt, datefmt='%Y-%m-%d %H:%M:%S')) + + logger.addHandler(console_handler) + + # create file handlers + file_handler = logging.FileHandler(os.path.join( + output_dir, f'log_rank{dist_rank}.txt'), mode='a') + + file_handler.setLevel(logging.DEBUG) + + file_handler.setFormatter(logging.Formatter( + fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')) + + logger.addHandler(file_handler) + + return logger diff --git a/pytorch_caney/transforms/abi_radiance_conversion.py b/pytorch_caney/transforms/abi_radiance_conversion.py new file mode 100644 index 0000000..71b5e3d --- /dev/null +++ b/pytorch_caney/transforms/abi_radiance_conversion.py @@ -0,0 +1,58 @@ +import numpy as np + + +# ----------------------------------------------------------------------------- +# vis_calibrate +# ----------------------------------------------------------------------------- +def vis_calibrate(data): + """Calibrate visible channels to reflectance.""" + solar_irradiance = np.array(2017) + esd = np.array(0.99) + factor = np.pi * esd * esd / solar_irradiance + + return data * np.float32(factor) * 100 + + +# ----------------------------------------------------------------------------- +# ir_calibrate +# ----------------------------------------------------------------------------- +def ir_calibrate(data): + """Calibrate IR channels to BT.""" + fk1 = np.array(13432.1), + fk2 = np.array(1497.61), + bc1 = np.array(0.09102), + bc2 = np.array(0.99971), + + # if self.clip_negative_radiances: + # min_rad = self._get_minimum_radiance(data) + # data = data.clip(min=data.dtype.type(min_rad)) + + res = (fk2 / np.log(fk1 / data + 1) - bc1) / bc2 + return res + + +# ----------------------------------------------------------------------------- +# ConvertABIToReflectanceBT +# ----------------------------------------------------------------------------- +class ConvertABIToReflectanceBT(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + vis_calibrate(img[:, :, self.reflectance_indices]) + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = ir_calibrate(img[:, :, self.emissive_indices]) + + return img \ No newline at end of file diff --git a/pytorch_caney/transforms/abi_toa.py b/pytorch_caney/transforms/abi_toa.py new file mode 100644 index 0000000..f762b25 --- /dev/null +++ b/pytorch_caney/transforms/abi_toa.py @@ -0,0 +1,30 @@ +import torchvision.transforms as T + +from .abi_toa_scale import MinMaxEmissiveScaleReflectance +from .abi_radiance_conversion import ConvertABIToReflectanceBT + + +# ----------------------------------------------------------------------------- +# AbiToaTransform +# ----------------------------------------------------------------------------- +class AbiToaTransform: + """ + torchvision transform which transforms the input imagery into + addition to generating a MiM mask + """ + + def __init__(self, img_size): + + self.transform_img = \ + T.Compose([ + ConvertABIToReflectanceBT(), # New transform for MinMax + MinMaxEmissiveScaleReflectance(), + T.ToTensor(), + T.Resize((img_size, img_size), antialias=True), + ]) + + def __call__(self, img): + + img = self.transform_img(img) + + return img diff --git a/pytorch_caney/transforms/abi_toa_scale.py b/pytorch_caney/transforms/abi_toa_scale.py new file mode 100644 index 0000000..0d4cf1e --- /dev/null +++ b/pytorch_caney/transforms/abi_toa_scale.py @@ -0,0 +1,37 @@ +import numpy as np + + +class MinMaxEmissiveScaleReflectance(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emissive_mins = np.array( + [117.04327, 152.00592, 157.96591, 176.15349, + 210.60493, 210.52264, 218.10147, 225.9894], + dtype=np.float32) + + self.emissive_maxs = np.array( + [221.07022, 224.44113, 242.3326, 307.42004, + 290.8879, 343.72617, 345.72894, 323.5239], + dtype=np.float32) + + def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img \ No newline at end of file diff --git a/pytorch_caney/transforms/modis_toa.py b/pytorch_caney/transforms/modis_toa.py new file mode 100644 index 0000000..fd52805 --- /dev/null +++ b/pytorch_caney/transforms/modis_toa.py @@ -0,0 +1,27 @@ +import torchvision.transforms as T + +from .modis_toa_scale import MinMaxEmissiveScaleReflectance + + +# ----------------------------------------------------------------------------- +# ModisToaTransform +# ----------------------------------------------------------------------------- +class ModisToaTransform: + """ + torchvision transform which transforms the input imagery + """ + + def __init__(self, config): + + self.transform_img = \ + T.Compose([ + MinMaxEmissiveScaleReflectance(), # New transform for MinMax + T.ToTensor(), + T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), + ]) + + def __call__(self, img): + + img = self.transform_img(img) + + return img \ No newline at end of file diff --git a/pytorch_caney/utils.py b/pytorch_caney/utils.py index 4f05ccf..5e4a9b0 100644 --- a/pytorch_caney/utils.py +++ b/pytorch_caney/utils.py @@ -1,4 +1,4 @@ -from pytorch_lightning.strategies import DeepSpeedStrategy +from lightning.pytorch.strategies import DeepSpeedStrategy # ----------------------------------------------------------------------------- From 8f8d9b1e3b61d34e327891470a5da235606407bf Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 6 Nov 2024 11:54:35 -0500 Subject: [PATCH 35/50] updated pipelines --- configs/3dcloudtask_fcn_baseline_test.yaml | 32 +++++++++++ ...cloudtask_swinv2_satvision_giant_test.yaml | 41 ++++++++++++++ ...v2_satvision_giant_128_onecycle_100ep.yaml | 48 +++++++++++++++++ ...ision_giant_128_onecycle_100ep_resume.yaml | 49 +++++++++++++++++ notebooks/README.md | 0 pytorch_caney/configs/config.py | 7 ++- pytorch_caney/datamodules/__init__.py | 2 + .../datamodules/modis_toa_mim_datamodule.py | 48 +++++++++++++++++ pytorch_caney/models/encoders/satvision.py | 53 +++++++++++++++++++ .../satvision_toa_pretrain_pipeline.py | 22 ++++++-- .../pipelines/three_d_cloud_pipeline.py | 39 +++++++++----- pytorch_caney/ptc_cli.py | 45 ++++++++++++---- pytorch_caney/ptc_logging.py | 49 ----------------- pytorch_caney/utils.py | 2 +- 14 files changed, 357 insertions(+), 80 deletions(-) create mode 100644 configs/3dcloudtask_fcn_baseline_test.yaml create mode 100644 configs/3dcloudtask_swinv2_satvision_giant_test.yaml create mode 100644 configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep.yaml create mode 100644 configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep_resume.yaml create mode 100644 notebooks/README.md create mode 100644 pytorch_caney/datamodules/modis_toa_mim_datamodule.py delete mode 100644 pytorch_caney/ptc_logging.py diff --git a/configs/3dcloudtask_fcn_baseline_test.yaml b/configs/3dcloudtask_fcn_baseline_test.yaml new file mode 100644 index 0000000..19d4ed7 --- /dev/null +++ b/configs/3dcloudtask_fcn_baseline_test.yaml @@ -0,0 +1,32 @@ +PIPELINE: '3dcloud' +DATAMODULE: 'abitoa3dcloud' +MODEL: + ENCODER: 'fcn' + DECODER: 'fcn' + NAME: 3dcloud-fcn-baseline + IN_CHANS: 14 + DROP_PATH_RATE: 0.1 +DATA: + BATCH_SIZE: 32 + DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + TEST_DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + IMG_SIZE: 128 +TRAIN: + ACCELERATOR: 'gpu' + STRATEGY: 'auto' + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +LOSS: + NAME: 'bce' +PRINT_FREQ: 10 +SAVE_FREQ: 50 +VALIDATION_FREQ: 20 +TAG: 3dcloud_task_fcn_baseline_128_scaled_bt_minmax diff --git a/configs/3dcloudtask_swinv2_satvision_giant_test.yaml b/configs/3dcloudtask_swinv2_satvision_giant_test.yaml new file mode 100644 index 0000000..2d67c57 --- /dev/null +++ b/configs/3dcloudtask_swinv2_satvision_giant_test.yaml @@ -0,0 +1,41 @@ +PIPELINE: '3dcloud' +DATAMODULE: 'abitoa3dcloud' +MODEL: + ENCODER: 'satvision' + DECODER: 'fcn' + PRETRAINED: /panfs/ccds02/nobackup/projects/ilab/projects/3DClouds/models/SV-TOA/3B_2M/mp_rank_00_model_states.pt + TYPE: swinv2 + NAME: 3dcloud-svtoa-finetune-giant + IN_CHANS: 14 + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + BATCH_SIZE: 32 + DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + TEST_DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + IMG_SIZE: 128 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +LOSS: + NAME: 'bce' +PRECISION: 'bf16' +PRINT_FREQ: 10 +SAVE_FREQ: 50 +VALIDATION_FREQ: 20 +TAG: 3dcloud_task_swinv2_g_satvision_128_scaled_bt_minmax diff --git a/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep.yaml b/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep.yaml new file mode 100644 index 0000000..cfa75d6 --- /dev/null +++ b/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep.yaml @@ -0,0 +1,48 @@ +PIPELINE: 'satvisiontoapretrain' + +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 + +DATA: + DATAMODULE: False + BATCH_SIZE: 64 + LENGTH: 1_920_000 + PIN_MEMORY: True + NUM_WORKERS: 4 + DATA_PATHS: [/explore/nobackup/projects/ilab/projects/3DClouds/data/mosaic-v3/webdatasets/shards] + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 + +TRAIN: + ACCELERATOR: 'gpu' + STRATEGY: 'deepspeed' + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] + +DEEPSPEED: + STAGE: 2 + +PRECISION: 'bf16' + +PRINT_FREQ: 10 +SAVE_FREQ: 50 +TAG: mim_pretrain_giant_satvision_128_scaled_bt_minmax_50ep diff --git a/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep_resume.yaml b/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep_resume.yaml new file mode 100644 index 0000000..a338624 --- /dev/null +++ b/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep_resume.yaml @@ -0,0 +1,49 @@ +PIPELINE: 'satvisiontoapretrain' + +MODEL: + TYPE: swinv2 + NAME: mim_satvision_pretrain-giant + DROP_PATH_RATE: 0.1 + PRETRAINED: /panfs/ccds02/nobackup/projects/ilab/projects/3DClouds/models/SV-TOA/3B_2M/mp_rank_00_model_states.pt + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 + +DATA: + DATAMODULE: False + BATCH_SIZE: 64 + LENGTH: 1_920_000 + PIN_MEMORY: True + NUM_WORKERS: 4 + DATA_PATHS: [/explore/nobackup/projects/ilab/projects/3DClouds/data/mosaic-v3/webdatasets/shards] + IMG_SIZE: 128 + MASK_PATCH_SIZE: 8 + MASK_RATIO: 0.6 + +TRAIN: + ACCELERATOR: 'gpu' + STRATEGY: 'deepspeed' + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] + +DEEPSPEED: + STAGE: 2 + +PRECISION: 'bf16' + +PRINT_FREQ: 10 +SAVE_FREQ: 50 +TAG: mim_pretrain_giant_satvision_128_scaled_bt_minmax_50ep_resume diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/configs/config.py b/pytorch_caney/configs/config.py index adf237a..4bbfea9 100644 --- a/pytorch_caney/configs/config.py +++ b/pytorch_caney/configs/config.py @@ -11,6 +11,8 @@ # Data settings # ----------------------------------------------------------------------------- _C.DATA = CN() +# Use a PL data module +_C.DATA.DATAMODULE = True # Batch size for a single GPU, could be overwritten by command line argument _C.DATA.BATCH_SIZE = 128 # Path(s) to dataset, could be overwritten by command line argument @@ -100,6 +102,7 @@ # Training settings # ----------------------------------------------------------------------------- _C.TRAIN = CN() +_C.TRAIN.ACCELERATOR = 'gpu' _C.TRAIN.STRATEGY = 'deepspeed' _C.TRAIN.LIMIT_TRAIN_BATCHES = True _C.TRAIN.NUM_TRAIN_BATCHES = None @@ -172,7 +175,7 @@ # Misc # ----------------------------------------------------------------------------- # Whether to enable pytorch amp, overwritten by command line argument -_C.ENABLE_AMP = False +_C.PRECISION = '32' # Enable Pytorch automatic mixed precision (amp). _C.AMP_ENABLE = True # Path to output folder, overwritten by command line argument @@ -193,6 +196,8 @@ _C.PIPELINE = 'satvisiontoapretrain' # Data module _C.DATAMODULE = 'abitoa3dcloud' +# Fast dev run +_C.FAST_DEV_RUN = False def _update_config_from_file(config, cfg_file): diff --git a/pytorch_caney/datamodules/__init__.py b/pytorch_caney/datamodules/__init__.py index c428d84..ad540c3 100644 --- a/pytorch_caney/datamodules/__init__.py +++ b/pytorch_caney/datamodules/__init__.py @@ -1,7 +1,9 @@ from .abi_3dcloud_datamodule import AbiToa3DCloudDataModule +from .modis_toa_mim_datamodule import ModisToaMimDataModule DATAMODULES = { 'abitoa3dcloud': AbiToa3DCloudDataModule, + 'modistoamimpretrain': ModisToaMimDataModule, } def get_available_datamodules(): diff --git a/pytorch_caney/datamodules/modis_toa_mim_datamodule.py b/pytorch_caney/datamodules/modis_toa_mim_datamodule.py new file mode 100644 index 0000000..b52b8e2 --- /dev/null +++ b/pytorch_caney/datamodules/modis_toa_mim_datamodule.py @@ -0,0 +1,48 @@ +import lightning as L +from torch.utils.data import DataLoader + +from pytorch_caney.datasets.sharded_dataset import ShardedDataset +from pytorch_caney.transforms.mim_modis_toa import MimTransform + + +# ----------------------------------------------------------------------------- +# SatVisionToaPretrain +# ----------------------------------------------------------------------------- +class ModisToaMimDataModule(L.LightningDataModule): + """NonGeo MODIS TOA Masked-Image-Modeling data module implementation""" + + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- + def __init__(self, config,) -> None: + super().__init__() + self.config = config + self.transform = MimTransform(config) + self.batch_size = config.DATA.BATCH_SIZE + self.num_workers = config.DATA.NUM_WORKERS + self.img_size = config.DATA.IMG_SIZE + self.train_data_paths = config.DATA.DATA_PATHS + self.train_data_length = config.DATA.LENGTH + self.pin_memory = config.DATA.PIN_MEMORY + + # ------------------------------------------------------------------------- + # setup + # ------------------------------------------------------------------------- + def setup(self, stage: str) -> None: + if stage in ["fit"]: + self.train_dataset = ShardedDataset( + self.config, + self.train_data_paths, + split='train', + length=self.train_data_length, + img_size=self.img_size, + transform=self.transform, + batch_size=self.batch_size).dataset() + + # ------------------------------------------------------------------------- + # train_dataloader + # ------------------------------------------------------------------------- + def train_dataloader(self) -> DataLoader: + return DataLoader(self.train_dataset, + batch_size=self.batch_size, + num_workers=self.num_workers) diff --git a/pytorch_caney/models/encoders/satvision.py b/pytorch_caney/models/encoders/satvision.py index d539550..f19247d 100644 --- a/pytorch_caney/models/encoders/satvision.py +++ b/pytorch_caney/models/encoders/satvision.py @@ -1,10 +1,18 @@ from .swinv2 import SwinTransformerV2 from ..model_factory import ModelFactory import torch.nn as nn +import torch +# ----------------------------------------------------------------------------- +# SatVision +# ----------------------------------------------------------------------------- @ModelFactory.encoder("satvision") class SatVision(nn.Module): + + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- def __init__(self, config): super().__init__() @@ -31,15 +39,60 @@ def __init__(self, config): pretrained_window_sizes=window_sizes, ) + if self.config.MODEL.PRETRAINED: + self.load_pretrained() + self.num_classes = self.model.num_classes self.num_layers = self.model.num_layers self.num_features = self.model.num_features + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- + def load_pretrained(self): + + checkpoint = torch.load(self.config.MODEL.PRETRAINED, map_location='cpu') + + checkpoint_model = checkpoint['module'] + + if any([True if 'encoder.' in k else + False for k in checkpoint_model.keys()]): + + checkpoint_model = {k.replace( + 'encoder.', ''): v for k, v in checkpoint_model.items() + if k.startswith('encoder.')} + + print('Detect pre-trained model, remove [encoder.] prefix.') + + else: + + print( + 'Detect non-pre-trained model, pass without doing anything.') + + msg = self.model.load_state_dict(checkpoint_model, strict=False) + + print(msg) + + del checkpoint + + torch.cuda.empty_cache() + + print(f">>>>>>>>>> loaded successfully '{self.config.MODEL.PRETRAINED}'") + + # ------------------------------------------------------------------------- + # forward + # ------------------------------------------------------------------------- def forward(self, x): return self.model.forward(x) + # ------------------------------------------------------------------------- + # forward_features + # ------------------------------------------------------------------------- def forward_features(self, x): return self.model.forward_features(x) + # ------------------------------------------------------------------------- + # extra_features + # ------------------------------------------------------------------------- def extra_features(self, x): return self.model.extra_features(x) diff --git a/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py index e292d42..07e3bb5 100644 --- a/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py +++ b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py @@ -1,9 +1,9 @@ import torch - -import pytorch_lightning as pl import torchmetrics - from torch.utils.data import DataLoader + +import lightning.pytorch as pl + from pytorch_caney.datasets.sharded_dataset import ShardedDataset from pytorch_caney.models.mim import build_mim_model from pytorch_caney.optimizers.build import build_optimizer @@ -21,9 +21,12 @@ class SatVisionToaPretrain(pl.LightningModule): def __init__(self, config): super(SatVisionToaPretrain, self).__init__() self.save_hyperparameters(ignore=['model']) - - self.model = build_mim_model(config) self.config = config + + self.model = build_mim_model(self.config) + if self.config.MODEL.PRETRAINED: + self.load_checkpoint() + self.transform = MimTransform(self.config) self.batch_size = config.DATA.BATCH_SIZE self.num_workers = config.DATA.NUM_WORKERS @@ -42,6 +45,15 @@ def __init__(self, config): transform=self.transform, batch_size=self.batch_size).dataset() + # ------------------------------------------------------------------------- + # load_checkpoint + # ------------------------------------------------------------------------- + def load_checkpoint(self): + print(f'Attempting to load checkpoint from {self.config.MODEL.PRETRAINED}') + checkpoint = torch.load(self.config.MODEL.PRETRAINED) + self.model.load_state_dict(checkpoint['module']) + print(f'Successfully applied checkpoint') + # ------------------------------------------------------------------------- # forward # ------------------------------------------------------------------------- diff --git a/pytorch_caney/pipelines/three_d_cloud_pipeline.py b/pytorch_caney/pipelines/three_d_cloud_pipeline.py index 19a94f4..492db5b 100644 --- a/pytorch_caney/pipelines/three_d_cloud_pipeline.py +++ b/pytorch_caney/pipelines/three_d_cloud_pipeline.py @@ -1,9 +1,9 @@ import torch import torch.nn as nn import torchmetrics -from torchgeo.trainers import BaseTask import lightning.pytorch as pl + from pytorch_caney.models.mim import build_mim_model from pytorch_caney.optimizers.build import build_optimizer from pytorch_caney.transforms.abi_toa import AbiToaTransform @@ -45,13 +45,17 @@ def configure_models(self): name=self.config.MODEL.DECODER, num_features=self.encoder.num_features) - self.segmentation_head = factory.get_component(component_type="head", - name="segmentation_head", - decoder_channels=self.decoder.output_channels, - num_classes=self.NUM_CLASSES, - output_shape=self.OUTPUT_SHAPE) - - self.model = nn.Sequential(self.encoder, self.decoder, self.segmentation_head) + self.segmentation_head = factory.get_component( + component_type="head", + name="segmentation_head", + decoder_channels=self.decoder.output_channels, + num_classes=self.NUM_CLASSES, + output_shape=self.OUTPUT_SHAPE + ) + + self.model = nn.Sequential(self.encoder, + self.decoder, + self.segmentation_head) print(self.model) # ------------------------------------------------------------------------- @@ -72,8 +76,10 @@ def configure_losses(self): # ------------------------------------------------------------------------- def configure_metrics(self): num_classes = 2 - self.train_iou = torchmetrics.JaccardIndex(num_classes=num_classes, task="binary") - self.val_iou = torchmetrics.JaccardIndex(num_classes=num_classes, task="binary") + self.train_iou = torchmetrics.JaccardIndex(num_classes=num_classes, + task="binary") + self.val_iou = torchmetrics.JaccardIndex(num_classes=num_classes, + task="binary") self.train_loss_avg = torchmetrics.MeanMetric() self.val_loss_avg = torchmetrics.MeanMetric() @@ -99,8 +105,10 @@ def training_step(self, batch, batch_idx): self.train_loss_avg.update(loss) self.train_iou_avg.update(iou) - self.log('train_loss', self.train_loss_avg.compute(), on_step=True, on_epoch=True, prog_bar=True) - self.log('train_iou', self.train_iou_avg.compute(), on_step=True, on_epoch=True, prog_bar=True) + self.log('train_loss', self.train_loss_avg.compute(), + on_step=True, on_epoch=True, prog_bar=True) + self.log('train_iou', self.train_iou_avg.compute(), + on_step=True, on_epoch=True, prog_bar=True) return loss # ------------------------------------------------------------------------- @@ -115,8 +123,10 @@ def validation_step(self, batch, batch_idx): val_iou = self.val_iou(preds, targets.int()) self.val_loss_avg.update(val_loss) self.val_iou_avg.update(val_iou) - self.log('val_loss', self.val_loss_avg.compute(), on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) - self.log('val_iou', self.val_iou_avg.compute(), on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) + self.log('val_loss', self.val_loss_avg.compute(), + on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) + self.log('val_iou', self.val_iou_avg.compute(), + on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) return val_loss @@ -125,6 +135,7 @@ def validation_step(self, batch, batch_idx): # ------------------------------------------------------------------------- def configure_optimizers(self): optimizer = build_optimizer(self.config, self.model, is_pretrain=True) + print(f'Using optimizer: {optimizer}') return optimizer # ------------------------------------------------------------------------- diff --git a/pytorch_caney/ptc_cli.py b/pytorch_caney/ptc_cli.py index ea31b92..424623b 100644 --- a/pytorch_caney/ptc_cli.py +++ b/pytorch_caney/ptc_cli.py @@ -1,4 +1,5 @@ import argparse +import os from lightning.pytorch import Trainer @@ -6,13 +7,12 @@ from pytorch_caney.utils import get_strategy, get_distributed_train_batches from pytorch_caney.pipelines import PIPELINES, get_available_pipelines from pytorch_caney.datamodules import DATAMODULES, get_available_datamodules -from pytorch_caney.ptc_logging import create_logger # ----------------------------------------------------------------------------- # main # ----------------------------------------------------------------------------- -def main(config): +def main(config, output_dir): print('Training') @@ -23,26 +23,38 @@ def main(config): print(f'Using {pipeline}') ptlPipeline = pipeline(config) - available_datamodules = get_available_datamodules() - print(f"Available data modules: {available_datamodules}") - datamoduleClass = DATAMODULES[config.DATAMODULE] - print(f'Using {datamoduleClass}') - datamodule = datamoduleClass(config) + # Resume from checkpoint + if config.MODEL.RESUME: + print(f'Attempting to resume from checkpoint {config.MODEL.RESUME}') + ptlPipeline = pipeline.load_from_checkpoint(config.MODEL.RESUME) + # Determine training strategy strategy = get_strategy(config) trainer = Trainer( - accelerator="gpu", + accelerator=config.TRAIN.ACCELERATOR, devices=-1, strategy=strategy, + precision=config.PRECISION, max_epochs=config.TRAIN.EPOCHS, log_every_n_steps=config.PRINT_FREQ, + default_root_dir=output_dir, ) if config.TRAIN.LIMIT_TRAIN_BATCHES: trainer.limit_train_batches = get_distributed_train_batches(config, trainer) - trainer.fit(model=ptlPipeline, datamodule=datamodule) + if config.DATA.DATAMODULE: + available_datamodules = get_available_datamodules() + print(f"Available data modules: {available_datamodules}") + datamoduleClass = DATAMODULES[config.DATAMODULE] + datamodule = datamoduleClass(config) + print(f'Training using datamodule: {datamodule}') + trainer.fit(model=ptlPipeline, datamodule=datamodule) + + else: + print(f'Training without datamodule, assuming data is set in pipeline: {ptlPipeline}') + trainer.fit(model=ptlPipeline) if __name__ == "__main__": @@ -59,4 +71,17 @@ def main(config): config = _C.clone() _update_config_from_file(config, hparams.config_path) - main(config) + output_dir = os.path.join(config.OUTPUT, config.MODEL.NAME, config.TAG) + print(f'Output directory: {output_dir}') + os.makedirs(output_dir, exist_ok=True) + + path = os.path.join(output_dir, + f"{config.TAG}.config.json") + + with open(path, "w") as f: + f.write(config.dump()) + + print(f"Full config saved to {path}") + print(config.dump()) + + main(config, output_dir) diff --git a/pytorch_caney/ptc_logging.py b/pytorch_caney/ptc_logging.py deleted file mode 100644 index 3b76462..0000000 --- a/pytorch_caney/ptc_logging.py +++ /dev/null @@ -1,49 +0,0 @@ -import os -import sys -import logging -import functools -from termcolor import colored - - -@functools.lru_cache() -def create_logger(output_dir, dist_rank=0, name=''): - # create logger - logger = logging.getLogger(name) - - logger.setLevel(logging.DEBUG) - - logger.propagate = False - - # create formatter - fmt = '[%(asctime)s %(name)s] ' + \ - '(%(filename)s %(lineno)d): ' + \ - '%(levelname)s %(message)s' - - color_fmt = colored('[%(asctime)s %(name)s]', 'green') + \ - colored('(%(filename)s %(lineno)d)', 'yellow') + \ - ': %(levelname)s %(message)s' - - # create console handlers for master process - if dist_rank == 0: - - console_handler = logging.StreamHandler(sys.stdout) - - console_handler.setLevel(logging.DEBUG) - - console_handler.setFormatter( - logging.Formatter(fmt=color_fmt, datefmt='%Y-%m-%d %H:%M:%S')) - - logger.addHandler(console_handler) - - # create file handlers - file_handler = logging.FileHandler(os.path.join( - output_dir, f'log_rank{dist_rank}.txt'), mode='a') - - file_handler.setLevel(logging.DEBUG) - - file_handler.setFormatter(logging.Formatter( - fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')) - - logger.addHandler(file_handler) - - return logger diff --git a/pytorch_caney/utils.py b/pytorch_caney/utils.py index 5e4a9b0..9cde7cf 100644 --- a/pytorch_caney/utils.py +++ b/pytorch_caney/utils.py @@ -27,7 +27,7 @@ def get_strategy(config): return DeepSpeedStrategy(config=deepspeed_config) - elif strategy == 'ddp' or strategy == 'fsdp': + else: # These may be return as strings return strategy From 72f0197c36980b9d853a7ad4e381490a834aa86e Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 6 Nov 2024 11:55:50 -0500 Subject: [PATCH 36/50] deleted other examples --- .../deepspeed/multinode_deepspeed_launcher.sh | 62 ---------- .../frontier_satvision_giant_runner.sh | 104 ----------------- ...v2_satvision_giant_192_window12_200ep.yaml | 30 ----- ...se_landcover5class_192_window12_100ep.yaml | 33 ------ ...se_landcover9class_192_window12_100ep.yaml | 33 ------ ...nv2_satvision_base_192_window12_800ep.yaml | 27 ----- .../run_satvision_finetune_lc_fiveclass.sh | 20 ---- .../run_satvision_finetune_lc_nineclass.sh | 20 ---- .../satvision-base/run_satvision_pretrain.sh | 19 --- examples/satvision-giant/README.md | 3 - ...v2_satvision_giant_192_window12_200ep.yaml | 29 ----- .../satvision-giant/run_satvision_pretrain.sh | 24 ---- examples/satvision-huge/README.md | 3 - ...nv2_satvision_huge_192_window12_200ep.yaml | 29 ----- .../satvision-huge/run_satvision_pretrain.sh | 22 ---- ...nv2_satvision_giant_128_window08_50ep.yaml | 31 ----- ...atvision_huge_128_window08_50ep_adamw.yaml | 33 ------ ...satvision_huge_128_window08_50ep_lamb.yaml | 33 ------ ...nt_128_window08_patch8_onecycle_100ep.yaml | 31 ----- ...uge_128_window8_patch8_onecycle_100ep.yaml | 33 ------ runs/runners/README.md | 29 ----- .../discover_svtoa_pretraining_runner.sh | 65 ----------- ...iscover_svtoa_pretraining_runner_resume.sh | 65 ----------- .../frontier_svtoa_pretraining_runner.sh | 105 ----------------- ...rontier_svtoa_pretraining_runner_resume.sh | 108 ------------------ 25 files changed, 991 deletions(-) delete mode 100644 examples/deepspeed/multinode_deepspeed_launcher.sh delete mode 100644 examples/frontier/frontier_satvision_giant_runner.sh delete mode 100644 examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml delete mode 100644 examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml delete mode 100644 examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml delete mode 100644 examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml delete mode 100755 examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh delete mode 100755 examples/satvision-base/run_satvision_finetune_lc_nineclass.sh delete mode 100755 examples/satvision-base/run_satvision_pretrain.sh delete mode 100644 examples/satvision-giant/README.md delete mode 100644 examples/satvision-giant/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml delete mode 100755 examples/satvision-giant/run_satvision_pretrain.sh delete mode 100644 examples/satvision-huge/README.md delete mode 100644 examples/satvision-huge/mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml delete mode 100755 examples/satvision-huge/run_satvision_pretrain.sh delete mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml delete mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml delete mode 100644 runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml delete mode 100644 runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml delete mode 100644 runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml delete mode 100644 runs/runners/README.md delete mode 100644 runs/runners/discover_svtoa_pretraining_runner.sh delete mode 100644 runs/runners/discover_svtoa_pretraining_runner_resume.sh delete mode 100644 runs/runners/frontier_svtoa_pretraining_runner.sh delete mode 100644 runs/runners/frontier_svtoa_pretraining_runner_resume.sh diff --git a/examples/deepspeed/multinode_deepspeed_launcher.sh b/examples/deepspeed/multinode_deepspeed_launcher.sh deleted file mode 100644 index 9d47225..0000000 --- a/examples/deepspeed/multinode_deepspeed_launcher.sh +++ /dev/null @@ -1,62 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=sv-huge-deepspeed # create a short name for your job -#SBATCH --nodes=5 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) -#SBATCH --mem=300G # total memory per node (4 GB per cpu-core is default) -#SBATCH --gres=gpu:4 # number of allocated gpus per node -#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --partition=gpu_a100 -#SBATCH --reservation=jcv -#SBATCH --constraint=rome -#SBATCH --qos=8n_a100 -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES - -launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 40" -echo $cmd - -srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -echo "END TIME: $(date)" diff --git a/examples/frontier/frontier_satvision_giant_runner.sh b/examples/frontier/frontier_satvision_giant_runner.sh deleted file mode 100644 index dd37dcd..0000000 --- a/examples/frontier/frontier_satvision_giant_runner.sh +++ /dev/null @@ -1,104 +0,0 @@ -#!/bin/bash -#SBATCH -A geo160 -#SBATCH --job-name=satvision-giant-pretraining-100-epoch-test # create a short name for your job -#SBATCH --nodes=46 # node count -#SBATCH --qos=debug -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --gres=gpu:8 # number of allocated gpus per node -#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) -#SBATCH --cpus-per-task=56 -#SBATCH -C nvme -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - -##### Setup modules -module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 -module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 -module load PrgEnv-gnu/8.4.0 -export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich -module load amd-mixed/5.7.1 -module load craype-accel-amd-gfx90a -module load miniforge3/23.11.0 -export MPICH_GPU_SUPPORT_ENABLED=1 -export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" -export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} -rm -rf ${MIOPEN_USER_DB_PATH} -mkdir -p ${MIOPEN_USER_DB_PATH} - -##### sbcast env to local nvme -echo "copying torch_env to each node in the job" -conda_env_name='rocm-torch-test-full-0.1.0' - -sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz -echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz -echo /mnt/bb/${USER}/${conda_env_name}.tar.gz -ls -l /mnt/bb/${USER} -ls -l $MEMBERWORK/geo160 - -if [ ! "$?" == "0" ]; then - # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, - # your application may pick up partially complete shared library files, which would give you confusing errors. - echo "SBCAST failed!" - exit 1 -fi - -srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} -echo "untaring torchenv" -srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} -echo "Done untarring torchenv" - -source activate /mnt/bb/${USER}/${conda_env_name} -echo "Activated ${conda_env_name}" - -srun --ntasks-per-node 1 conda-unpack - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -# export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/02m -batchsize=416 -nprocpernode=8 - -launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize}" -echo $cmd - -srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -echo "END TIME: $(date)" - diff --git a/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml b/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml deleted file mode 100644 index 5ed2538..0000000 --- a/examples/frontier/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml +++ /dev/null @@ -1,30 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-giant - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 12 - NORM_PERIOD: 6 - -DATA: - IMG_SIZE: 192 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 100 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 1 -SAVE_FREQ: 1 -TAG: mim_pretrain_swinv2_g_satvision_192_window12__100ep diff --git a/examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml b/examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml deleted file mode 100644 index 5f41c64..0000000 --- a/examples/satvision-base/finetune_satvision_base_landcover5class_192_window12_100ep.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - DECODER: unet - NAME: satvision_finetune_lc5class - DROP_PATH_RATE: 0.1 - NUM_CLASSES: 5 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 128 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 14 - PRETRAINED_WINDOW_SIZES: [ 12, 12, 12, 6 ] -DATA: - IMG_SIZE: 224 - DATASET: MODISLC5 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -LOSS: - NAME: 'tversky' - MODE: 'multiclass' - ALPHA: 0.4 - BETA: 0.6 -TRAIN: - EPOCHS: 100 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.01 - LAYER_DECAY: 0.8 -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: satvision_finetune_land_cover_5class_swinv2_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml b/examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml deleted file mode 100644 index 2e96121..0000000 --- a/examples/satvision-base/finetune_satvision_base_landcover9class_192_window12_100ep.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - DECODER: unet - NAME: satvision_finetune_lc9class - DROP_PATH_RATE: 0.1 - NUM_CLASSES: 9 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 128 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 14 - PRETRAINED_WINDOW_SIZES: [ 12, 12, 12, 6 ] -DATA: - IMG_SIZE: 224 - DATASET: MODISLC5 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -LOSS: - NAME: 'tversky' - MODE: 'multiclass' - ALPHA: 0.4 - BETA: 0.6 -TRAIN: - EPOCHS: 100 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.01 - LAYER_DECAY: 0.8 -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: satvision_finetune_land_cover_9class_swinv2_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml b/examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml deleted file mode 100644 index 4c188bf..0000000 --- a/examples/satvision-base/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml +++ /dev/null @@ -1,27 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 128 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 12 -DATA: - IMG_SIZE: 192 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -TRAIN: - EPOCHS: 800 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: mim_pretrain_swinv2_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh b/examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh deleted file mode 100755 index 155abf6..0000000 --- a/examples/satvision-base/run_satvision_finetune_lc_fiveclass.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -#SBATCH -J finetune_satvision_lc5 -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - - -export PYTHONPATH=$PWD:../../../:../../../pytorch-caney -export NGPUS=8 - -torchrun --nproc_per_node $NGPUS \ - ../../../pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py \ - --cfg finetune_satvision_base_landcover5class_192_window12_100ep.yaml \ - --pretrained /explore/nobackup/people/cssprad1/projects/satnet/code/development/masked_image_modeling/development/models/simmim_satnet_pretrain_pretrain/simmim_pretrain__satnet_swinv2_base__img192_window12__800ep_v3_no_norm/ckpt_epoch_800.pth \ - --dataset MODISLC9 \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/finetuning/h18v04/labels_9classes_224 \ - --batch-size 4 \ - --output /explore/nobackup/people/cssprad1/projects/satnet/code/development/cleanup/finetune/models \ - --enable-amp \ No newline at end of file diff --git a/examples/satvision-base/run_satvision_finetune_lc_nineclass.sh b/examples/satvision-base/run_satvision_finetune_lc_nineclass.sh deleted file mode 100755 index 7008967..0000000 --- a/examples/satvision-base/run_satvision_finetune_lc_nineclass.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -#SBATCH -J finetune_satvision_lc9 -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - - -export PYTHONPATH=$PWD:../../../:../../../pytorch-caney -export NGPUS=8 - -torchrun --nproc_per_node $NGPUS \ - ../../../pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py \ - --cfg finetune_satvision_base_landcover5class_192_window12_100ep.yaml \ - --pretrained /explore/nobackup/people/cssprad1/projects/satnet/code/development/masked_image_modeling/development/models/simmim_satnet_pretrain_pretrain/simmim_pretrain__satnet_swinv2_base__img192_window12__800ep_v3_no_norm/ckpt_epoch_800.pth \ - --dataset MODISLC9 \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/finetuning/h18v04/labels_5classes_224 \ - --batch-size 4 \ - --output /explore/nobackup/people/cssprad1/projects/satnet/code/development/cleanup/finetune/models \ - --enable-amp \ No newline at end of file diff --git a/examples/satvision-base/run_satvision_pretrain.sh b/examples/satvision-base/run_satvision_pretrain.sh deleted file mode 100755 index 0ff9598..0000000 --- a/examples/satvision-base/run_satvision_pretrain.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/bash - -#SBATCH -J pretrain_satvision_swinv2 -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - - -export PYTHONPATH=$PWD:../../../:../../../pytorch-caney -export NGPUS=4 - -torchrun --nproc_per_node $NGPUS \ - ../../../pytorch-caney/pytorch_caney/pipelines/pretraining/mim.py \ - --cfg mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml \ - --dataset MODIS \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/pretraining/training_* \ - --batch-size 128 \ - --output /explore/nobackup/people/cssprad1/projects/satnet/code/development/cleanup/trf/transformer/models \ - --enable-amp \ No newline at end of file diff --git a/examples/satvision-giant/README.md b/examples/satvision-giant/README.md deleted file mode 100644 index 7fe3149..0000000 --- a/examples/satvision-giant/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# SatVision-Giant (SwinV2-Giant) - -`sbatch run_satvision_pretrain ` \ No newline at end of file diff --git a/examples/satvision-giant/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml b/examples/satvision-giant/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml deleted file mode 100644 index 0872262..0000000 --- a/examples/satvision-giant/mim_pretrain_swinv2_satvision_giant_192_window12_200ep.yaml +++ /dev/null @@ -1,29 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-giant - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 12 - NORM_PERIOD: 6 - -DATA: - IMG_SIZE: 192 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -TRAIN: - EPOCHS: 200 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: mim_pretrain_swinv2_g_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-giant/run_satvision_pretrain.sh b/examples/satvision-giant/run_satvision_pretrain.sh deleted file mode 100755 index 770c7b7..0000000 --- a/examples/satvision-giant/run_satvision_pretrain.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash - -#SBATCH -J deepspeed-satvision-giant -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - -module load singularity - -srun -n 1 singularity exec \ - --env PYTHONPATH="$PWD:$PWD/pytorch-caney" \ - --nv -B /lscratch,/explore,/panfs \ - $1 \ - deepspeed \ - pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py \ - --cfg $2 \ - --dataset MODIS \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/pretraining/training_* \ - --batch-size 32 \ - --output . \ - --enable-amp - - - diff --git a/examples/satvision-huge/README.md b/examples/satvision-huge/README.md deleted file mode 100644 index 6c607d5..0000000 --- a/examples/satvision-huge/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# SatVision-Huge (SwinV2-Huge) - -`sbatch run_satvision_pretrain ` diff --git a/examples/satvision-huge/mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml b/examples/satvision-huge/mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml deleted file mode 100644 index 9e31f10..0000000 --- a/examples/satvision-huge/mim_pretrain_swinv2_satvision_huge_192_window12_200ep.yaml +++ /dev/null @@ -1,29 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-huge - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 352 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 12 - NORM_PERIOD: 6 - -DATA: - IMG_SIZE: 192 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -TRAIN: - EPOCHS: 200 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: mim_pretrain_swinv2_h_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-huge/run_satvision_pretrain.sh b/examples/satvision-huge/run_satvision_pretrain.sh deleted file mode 100755 index e91edbe..0000000 --- a/examples/satvision-huge/run_satvision_pretrain.sh +++ /dev/null @@ -1,22 +0,0 @@ -#!/bin/bash - -#SBATCH -J deepspeed-satvision-giant -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - -module load singularity - -srun -n 1 singularity exec \ - --env PYTHONPATH="$PWD:$PWD/pytorch-caney" \ - --nv -B /lscratch,/explore,/panfs \ - $1 \ - deepspeed \ - pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py \ - --cfg $2 \ - --dataset MODIS \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/pretraining/training_* \ - --batch-size 32 \ - --output . \ - --enable-amp - diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml deleted file mode 100644 index a323994..0000000 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml +++ /dev/null @@ -1,31 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-giant - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] - NUM_HEADS: [ 16, 32, 64, 128 ] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 50 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - MIN_LR: 2e-4 - WARMUP_LR: 1e-4 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 100 -SAVE_FREQ: 1000 -VALIDATION_FREQ: 200 -TAG: mim_pretrain_3b_2m_128_window8_onecycle_50ep_hackathon diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml deleted file mode 100644 index 131dc94..0000000 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_adamw.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-huge - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 352 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 50 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - MIN_LR: 2e-4 - WARMUP_LR: 1e-4 - WEIGHT_DECAY: 0.05 - OPTIMIZER: - NAME: adamw - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 1000 -VALIDATION_FREQ: 20 -TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_adamw diff --git a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml b/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml deleted file mode 100644 index 0c28c49..0000000 --- a/runs/configs/frontier_mim_pretrain_swinv2_satvision_huge_128_window08_50ep_lamb.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-huge - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 352 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 50 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - MIN_LR: 2e-4 - WARMUP_LR: 1e-4 - WEIGHT_DECAY: 0.05 - OPTIMIZER: - NAME: lamb - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 1000 -VALIDATION_FREQ: 20 -TAG: mim_pretrain_675m_2m_128_window8_onecycle_hackathon_lamb_debug diff --git a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml deleted file mode 100644 index 513870a..0000000 --- a/runs/configs/mim_pretrain_swinv2_satvision_giant_128_window08_patch8_onecycle_100ep.yaml +++ /dev/null @@ -1,31 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-giant - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 512 - DEPTHS: [ 2, 2, 42, 2 ] - NUM_HEADS: [ 16, 32, 64, 128 ] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 100 - WARMUP_EPOCHS: 1 - BASE_LR: 3e-4 - WARMUP_LR: 1e-4 - MIN_LR: 2e-4 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 1 -VALIDATION_FREQ: 20 -TAG: mim_pretrain_swinv2_g_satvision_128_window08_mpatch8_scaled_bt_minmax_100ep diff --git a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml b/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml deleted file mode 100644 index 77c71ef..0000000 --- a/runs/configs/mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - NAME: mim_satvision_pretrain-huge - DROP_PATH_RATE: 0.1 - SWINV2: - IN_CHANS: 14 - PATCH_SIZE: 4 - EMBED_DIM: 352 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 8 - NORM_PERIOD: 6 - -DATA: - IMG_SIZE: 128 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -TRAIN: - USE_CHECKPOINT: True - EPOCHS: 100 - WARMUP_EPOCHS: 10 - BASE_LR: 3e-4 - MIN_LR: 2e-4 - WARMUP_LR: 1e-4 - WEIGHT_DECAY: 0.05 - LR_SCHEDULER: - NAME: 'multistep' - GAMMA: 0.1 - MULTISTEPS: [700,] -PRINT_FREQ: 10 -SAVE_FREQ: 50 -VALIDATION_FREQ: 20 -TAG: mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_scaled_bt_minmax_100ep diff --git a/runs/runners/README.md b/runs/runners/README.md deleted file mode 100644 index 81308f3..0000000 --- a/runs/runners/README.md +++ /dev/null @@ -1,29 +0,0 @@ -# Runners - -softlink these to cwd with pytorch-caney - -## Discover - -For starting a model from scratch -```bash -$ sbatch discover_svtoa_pretraining_runner.sh mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml -``` - -For starting resuming a model - -```bash -$ sbatch discover_svtoa_pretraining_runner_resume.sh mim_pretrain_swinv2_satvision_huge_128_window8_patch8_onecycle_100ep.yaml mim_satvision_pretrain-huge/mim_pretrain_swinv2_h_satvision_128_window8_mpatch8_100ep/ckpt_epoch_60 -``` - -- !! Deepspeed does not allow resuming training with a different world size (n gpus). You must use the same number of gpus (/nodes) when resuming. -- The 2nd arg should be the path to the checkpoint directory without a trailing `/`. I haven't edited to code to handle this obvious bug. - - -## Frontier - -For starting model from scratch -- same as above commands just switch out the discover runner script for the frontier runner script. -- If needed, switch out the cast command to copy from here: /lustre/orion/geo160/proj-shared/envs/rocm-torch-test-full-0.1.0.tar.gz instead of where it currently is. - -## !! Note -For 26m and 100m dataset, make sure to increase NUM_SAMPLES in the mim_deepspeed.py script, that reflects dataset length. diff --git a/runs/runners/discover_svtoa_pretraining_runner.sh b/runs/runners/discover_svtoa_pretraining_runner.sh deleted file mode 100644 index 6946f84..0000000 --- a/runs/runners/discover_svtoa_pretraining_runner.sh +++ /dev/null @@ -1,65 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=sv-toa-deepspeed # create a short name for your job -#SBATCH --nodes=5 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) -#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) -#SBATCH --gres=gpu:4 # number of allocated gpus per node -#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --partition=gpu_a100 -#SBATCH --constraint=rome -#SBATCH --qos=8n_a100 -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -export NCCL_NET_GDR_LEVEL=PHB -export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/validation_test/data/sv_toa_128_chip_validation_04_24.npy" - -launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 32 --validation-path ${validation_path}" -echo $cmd - -srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -pkill -9 python - -echo "END TIME: $(date)" diff --git a/runs/runners/discover_svtoa_pretraining_runner_resume.sh b/runs/runners/discover_svtoa_pretraining_runner_resume.sh deleted file mode 100644 index ce59268..0000000 --- a/runs/runners/discover_svtoa_pretraining_runner_resume.sh +++ /dev/null @@ -1,65 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=sv-toa-deepspeed # create a short name for your job -#SBATCH --nodes=5 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --cpus-per-task=40 # cpu-cores per task (>1 if multi-threaded tasks) -#SBATCH --mem=400G # total memory per node (4 GB per cpu-core is default) -#SBATCH --gres=gpu:4 # number of allocated gpus per node -#SBATCH --time=12:00:00 # total run time limit (HH:MM:SS) -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --partition=gpu_a100 -#SBATCH --constraint=rome -#SBATCH --qos=8n_a100 -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov - - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -export NCCL_NET_GDR_LEVEL=PHB -export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -validation_path="/discover/nobackup/projects/calebtest/3dclouds.runs/validation_test/data/sv_toa_128_chip_validation_04_24.npy" - -launcher="/discover/nobackup/jacaraba/spack/opt/spack/linux-sles15-zen/gcc-7.5.0/singularityce-3.11.3-o5pnooghlq7cgiv5zh5qnmyhmbltcynu/bin/singularity exec --nv -B /discover,/gpfsm /discover/nobackup/projects/akmosaic/container/nvpt-24.01 python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=4" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths /discover/nobackup/projects/calebtest/3dclouds/v3 --output . --batch-size 32 --validation-path ${validation_path} --resume $2" -echo $cmd - -srun --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -pkill -9 python - -echo "END TIME: $(date)" diff --git a/runs/runners/frontier_svtoa_pretraining_runner.sh b/runs/runners/frontier_svtoa_pretraining_runner.sh deleted file mode 100644 index 4828798..0000000 --- a/runs/runners/frontier_svtoa_pretraining_runner.sh +++ /dev/null @@ -1,105 +0,0 @@ -#!/bin/bash -#SBATCH -A geo160 -#SBATCH --job-name=hackathon-675m-batch-size-test # create a short name for your job -#SBATCH --nodes=1 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --gres=gpu:8 # number of allocated gpus per node -#SBATCH -q debug -#SBATCH --time=00:30:00 # total run time limit (HH:MM:SS) -#SBATCH --cpus-per-task=56 -#SBATCH -C nvme - -##### Setup modules -module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 -module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 -module load PrgEnv-gnu/8.4.0 -export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich -export LD_LIBRARY_PATH=/lustre/orion/geo160/proj-shared/testing/aws-olf-rccl-plugin/aws-ofi-rccl/lib:$LD_LIBRARY_PATH -module load amd-mixed/5.7.1 -module load craype-accel-amd-gfx90a -module load miniforge3/23.11.0 -export MPICH_GPU_SUPPORT_ENABLED=1 -export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" -export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} -rm -rf ${MIOPEN_USER_DB_PATH} -mkdir -p ${MIOPEN_USER_DB_PATH} - -##### sbcast env to local nvme -echo "copying torch_env to each node in the job" -conda_env_name='rocm-torch-test-full-0.1.0' - -sbcast -pf /lustre/orion/geo160/proj-shared/envs/${conda_env_name}.tar.gz.hackathon /mnt/bb/${USER}/${conda_env_name}.tar.gz -echo /lustre/orion/geo160/proj-shared/envs/${conda_env_name}.tar.gz.hackathon -echo /mnt/bb/${USER}/${conda_env_name}.tar.gz -ls -l /mnt/bb/${USER} -ls -l /lustre/orion/geo160/proj-shared/envs - -if [ ! "$?" == "0" ]; then - # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, - # your application may pick up partially complete shared library files, which would give you confusing errors. - echo "SBCAST failed!" - exit 1 -fi - -srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} -echo "untaring torchenv" -srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} -echo "Done untarring torchenv" - -source activate /mnt/bb/${USER}/${conda_env_name} -echo "Activated ${conda_env_name}" - -srun --ntasks-per-node 1 conda-unpack - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -# export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m -validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -tensorboard_dir=/lustre/orion/geo160/proj-shared/data/tensorboard/hackathon_2024 -batchsize=256 -nprocpernode=8 - -launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --validation-path ${validationpath} --tensorboard-dir ${tensorboard_dir}" -echo $cmd - -srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -echo "END TIME: $(date)" - diff --git a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh b/runs/runners/frontier_svtoa_pretraining_runner_resume.sh deleted file mode 100644 index 6a914fe..0000000 --- a/runs/runners/frontier_svtoa_pretraining_runner_resume.sh +++ /dev/null @@ -1,108 +0,0 @@ -#!/bin/bash -#SBATCH -A geo160 -#SBATCH --qos=debug -#SBATCH --job-name=satvision-giant-pretraining-15-epoch-test # create a short name for your job -#SBATCH --nodes=32 # node count -#SBATCH --ntasks-per-node=1 # total number of tasks per node -#SBATCH --gres=gpu:8 # number of allocated gpus per node -#SBATCH --time=02:00:00 # total run time limit (HH:MM:SS) -#SBATCH --cpus-per-task=56 -#SBATCH -C nvme -#SBATCH --mail-type=ALL # send email when job begins -#SBATCH --mail-user=caleb.s.spradlin@nasa.gov -#SBATCH --mail-user=cspradlindev@gmail.com - -##### Setup modules -module load cpe/23.05 # recommended cpe version with cray-mpich/8.1.26 -module load cray-mpich/8.1.26 # for better GPU-aware MPI w/ ROCm 5.7.1 -module load PrgEnv-gnu/8.4.0 -export LD_LIBRARY_PATH=$CRAY_LD_LIBRARY_PATH:$LD_LIBRARY_PATH # because using a non-default cray-mpich -export LD_LIBRARY_PATH=/lustre/orion/geo160/proj-shared/testing/aws-olf-rccl-plugin/aws-ofi-rccl/lib:$LD_LIBRARY_PATH -module load amd-mixed/5.7.1 -module load craype-accel-amd-gfx90a -module load miniforge3/23.11.0 -export MPICH_GPU_SUPPORT_ENABLED=1 -export MIOPEN_USER_DB_PATH="/mnt/bb/${USER}/my-miopen-cache" -export MIOPEN_CUSTOM_CACHE_DIR=${MIOPEN_USER_DB_PATH} -rm -rf ${MIOPEN_USER_DB_PATH} -mkdir -p ${MIOPEN_USER_DB_PATH} - -##### sbcast env to local nvme -echo "copying torch_env to each node in the job" -conda_env_name='rocm-torch-test-full-0.1.0' - -sbcast -pf $MEMBERWORK/geo160/${conda_env_name}.tar.gz /mnt/bb/${USER}/${conda_env_name}.tar.gz -echo $MEMBERWORK/geo160/${conda_env_name}.tar.gz -echo /mnt/bb/${USER}/${conda_env_name}.tar.gz -ls -l /mnt/bb/${USER} -ls -l $MEMBERWORK/geo160 - -if [ ! "$?" == "0" ]; then - # CHECK EXIT CODE. When SBCAST fails, it may leave partial files on the compute nodes, and if you continue to launch srun, - # your application may pick up partially complete shared library files, which would give you confusing errors. - echo "SBCAST failed!" - exit 1 -fi - -srun --ntasks-per-node 1 mkdir /mnt/bb/${USER}/${conda_env_name} -echo "untaring torchenv" -srun --ntasks-per-node 1 tar -xzf /mnt/bb/${USER}/${conda_env_name}.tar.gz -C /mnt/bb/${USER}/${conda_env_name} -echo "Done untarring torchenv" - -source activate /mnt/bb/${USER}/${conda_env_name} -echo "Activated ${conda_env_name}" - -srun --ntasks-per-node 1 conda-unpack - -# export MASTER_PORT=$(expr 10000 + $(echo -n $SLURM_JOBID | tail -c 4)) -export MASTER_PORT=6000 -export WORLD_SIZE=$(($SLURM_NNODES * $SLURM_NTASKS_PER_NODE)) -echo "WORLD_SIZE="$WORLD_SIZE - -# export NCCL_SOCKET_IFNAME=ib - -export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1) -echo "MASTER_ADDR="$MASTER_ADDR - - -echo "$MASTER_ADDR:$MASTER_PORT" - -export PYTHONPATH=$PWD:pytorch-caney -export NCCL_DEBUG=INFO - -# do not remove or the training will hang and nodes will be lost w/o this workaround -#export CUDA_LAUNCH_BLOCKING=1 - -# hide duplicated errors using this hack - will be properly fixed in pt-1.12 -#export TORCHELASTIC_ERROR_FILE=torch-elastic-error.json - -# force crashing on nccl issues like hanging broadcast -#export NCCL_ASYNC_ERROR_HANDLING=1 - -#export NCCL_P2P_DISABLE=1 - -# cublas bug solve? -# export DISABLE_ADDMM_CUDA_LT=1 - -echo $SLURM_JOB_NUM_NODES -echo $SLURM_PROCID -echo $MASTER_ADDR -echo $MASTER_PORT - -nnodes=$SLURM_JOB_NUM_NODES -datapaths=/lustre/orion/geo160/proj-shared/data/satvision-toa/50m -validationpath=/lustre/orion/geo160/proj-shared/data/satvision-toa/validation/sv_toa_128_chip_validation_04_24.npy -batchsize=64 -nprocpernode=8 -latest_ckpt=$(find mim_satvision_pretrain-giant/* -name "ckpt_epoch_*" | sort -n | tail -1) - -launcher="python -u -m torch.distributed.run --nnodes=${nnodes} --master_addr ${MASTER_ADDR} --master_port ${MASTER_PORT} --nproc_per_node=${nprocpernode}" -echo $launcher - -cmd=" pytorch-caney/pytorch_caney/pipelines/pretraining/mim_deepspeed.py --cfg $1 --dataset MODIS --data-paths ${datapaths} --output . --batch-size ${batchsize} --resume ${latest_ckpt} --validation-path ${validationpath}" -echo $cmd - -srun -l -c56 --gpus-per-task=${nprocpernode} --gpu-bind=closest --jobid $SLURM_JOBID bash -c "$launcher --node_rank \$SLURM_PROCID $cmd" - -echo "END TIME: $(date)" - From 9a7cd6f03f5c15c12d50d43b880b1349c2cd79a2 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Fri, 8 Nov 2024 14:07:47 -0500 Subject: [PATCH 37/50] merge conflicts --- ...se_landcover5class_192_window12_100ep.yaml | 33 ------------------- ...se_landcover9class_192_window12_100ep.yaml | 33 ------------------- .../run_satvision_finetune_lc_fiveclass.sh | 20 ----------- .../run_satvision_finetune_lc_nineclass.sh | 19 ----------- 4 files changed, 105 deletions(-) delete mode 100644 examples/satvision-toa-finetune/finetune_satvision_base_landcover5class_192_window12_100ep.yaml delete mode 100644 examples/satvision-toa-finetune/finetune_satvision_base_landcover9class_192_window12_100ep.yaml delete mode 100755 examples/satvision-toa-finetune/run_satvision_finetune_lc_fiveclass.sh delete mode 100755 examples/satvision-toa-finetune/run_satvision_finetune_lc_nineclass.sh diff --git a/examples/satvision-toa-finetune/finetune_satvision_base_landcover5class_192_window12_100ep.yaml b/examples/satvision-toa-finetune/finetune_satvision_base_landcover5class_192_window12_100ep.yaml deleted file mode 100644 index 5f41c64..0000000 --- a/examples/satvision-toa-finetune/finetune_satvision_base_landcover5class_192_window12_100ep.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - DECODER: unet - NAME: satvision_finetune_lc5class - DROP_PATH_RATE: 0.1 - NUM_CLASSES: 5 - SWINV2: - IN_CHANS: 7 - EMBED_DIM: 128 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 14 - PRETRAINED_WINDOW_SIZES: [ 12, 12, 12, 6 ] -DATA: - IMG_SIZE: 224 - DATASET: MODISLC5 - MASK_PATCH_SIZE: 32 - MASK_RATIO: 0.6 -LOSS: - NAME: 'tversky' - MODE: 'multiclass' - ALPHA: 0.4 - BETA: 0.6 -TRAIN: - EPOCHS: 100 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.01 - LAYER_DECAY: 0.8 -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: satvision_finetune_land_cover_5class_swinv2_satvision_192_window12__800ep \ No newline at end of file diff --git a/examples/satvision-toa-finetune/finetune_satvision_base_landcover9class_192_window12_100ep.yaml b/examples/satvision-toa-finetune/finetune_satvision_base_landcover9class_192_window12_100ep.yaml deleted file mode 100644 index f55651a..0000000 --- a/examples/satvision-toa-finetune/finetune_satvision_base_landcover9class_192_window12_100ep.yaml +++ /dev/null @@ -1,33 +0,0 @@ -MODEL: - TYPE: swinv2 - DECODER: unet - NAME: satvision_toa_finetune_lc9class - DROP_PATH_RATE: 0.1 - NUM_CLASSES: 9 - SWINV2: - IN_CHANS: 14 - EMBED_DIM: 352 - DEPTHS: [ 2, 2, 18, 2 ] - NUM_HEADS: [ 4, 8, 16, 32 ] - WINDOW_SIZE: 14 - NORM_PERIOD: 6 -DATA: - IMG_SIZE: 224 - DATASET: MODISLC9 - MASK_PATCH_SIZE: 8 - MASK_RATIO: 0.6 -LOSS: - NAME: 'tversky' - MODE: 'multiclass' - ALPHA: 0.4 - BETA: 0.6 -TRAIN: - EPOCHS: 100 - WARMUP_EPOCHS: 10 - BASE_LR: 1e-4 - WARMUP_LR: 5e-7 - WEIGHT_DECAY: 0.01 - LAYER_DECAY: 0.8 -PRINT_FREQ: 100 -SAVE_FREQ: 5 -TAG: satvision_toa_finetune_land_cover_9class_swinv2_satvision_224_window12__100ep diff --git a/examples/satvision-toa-finetune/run_satvision_finetune_lc_fiveclass.sh b/examples/satvision-toa-finetune/run_satvision_finetune_lc_fiveclass.sh deleted file mode 100755 index 155abf6..0000000 --- a/examples/satvision-toa-finetune/run_satvision_finetune_lc_fiveclass.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -#SBATCH -J finetune_satvision_lc5 -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - - -export PYTHONPATH=$PWD:../../../:../../../pytorch-caney -export NGPUS=8 - -torchrun --nproc_per_node $NGPUS \ - ../../../pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py \ - --cfg finetune_satvision_base_landcover5class_192_window12_100ep.yaml \ - --pretrained /explore/nobackup/people/cssprad1/projects/satnet/code/development/masked_image_modeling/development/models/simmim_satnet_pretrain_pretrain/simmim_pretrain__satnet_swinv2_base__img192_window12__800ep_v3_no_norm/ckpt_epoch_800.pth \ - --dataset MODISLC9 \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/finetuning/h18v04/labels_9classes_224 \ - --batch-size 4 \ - --output /explore/nobackup/people/cssprad1/projects/satnet/code/development/cleanup/finetune/models \ - --enable-amp \ No newline at end of file diff --git a/examples/satvision-toa-finetune/run_satvision_finetune_lc_nineclass.sh b/examples/satvision-toa-finetune/run_satvision_finetune_lc_nineclass.sh deleted file mode 100755 index 618dcab..0000000 --- a/examples/satvision-toa-finetune/run_satvision_finetune_lc_nineclass.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/bash - -#SBATCH -J finetune_satvision_lc9 -#SBATCH -t 3-00:00:00 -#SBATCH -G 4 -#SBATCH -N 1 - -export PYTHONPATH=$PWD:$PWD/pytorch-caney -export NGPUS=4 - -torchrun --nproc_per_node $NGPUS \ - pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py \ - --cfg $1 \ - --pretrained $2 \ - --dataset MODISLC9 \ - --data-paths /explore/nobackup/projects/ilab/data/satvision/finetuning/h18v04/labels_5classes_224 \ - --batch-size 4 \ - --output . \ - --enable-amp From 45a3c2a54c9fadd38c600c2b43446f415b692855 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Wed, 13 Nov 2024 11:50:06 -0500 Subject: [PATCH 38/50] Update requirements.txt --- requirements/requirements.txt | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index a680b1c..b89597c 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,22 +1,12 @@ torch>=2.0.0 torchvision>=0.15 -pytorch-lightning -omegaconf +lightning rasterio rioxarray xarray -geopandas -opencv-python -opencv-python-headless -opencv-contrib-python -opencv-contrib-python-headless tifffile webcolors -Pillow -seaborn -xgboost tiler -segmentation-models pytest coveralls rtree From a9e567227d3a85762e10d0a40bf26c123e6c4f34 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Wed, 13 Nov 2024 11:51:00 -0500 Subject: [PATCH 39/50] Update Dockerfile.dev --- requirements/Dockerfile.dev | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/requirements/Dockerfile.dev b/requirements/Dockerfile.dev index 92be52b..8bbaf20 100644 --- a/requirements/Dockerfile.dev +++ b/requirements/Dockerfile.dev @@ -75,7 +75,7 @@ RUN git clone --single-branch --branch master https://github.com/pkolano/shift.g rm -rf /app # Pip -RUN pip --no-cache-dir install omegaconf \ +RUN pip --no-cache-dir install \ pytorch-lightning \ Lightning \ transformers \ @@ -95,9 +95,6 @@ RUN pip --no-cache-dir install omegaconf \ opencv-contrib-python-headless \ tifffile \ webcolors \ - Pillow \ - seaborn \ - xgboost \ tiler \ segmentation-models \ timm \ From d596fbcbbb4fe613f58b92a8516439f2b375e735 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Wed, 13 Nov 2024 16:04:46 -0500 Subject: [PATCH 40/50] added single recon example notebook, routine pep8 work --- ...odis_reconstruction_example_notebook.ipynb | 368 ++++++++++++++++++ pytorch_caney/models/__init__.py | 9 +- pytorch_caney/models/decoders/__init__.py | 5 +- pytorch_caney/models/decoders/fcn_decoder.py | 12 +- pytorch_caney/models/encoders/__init__.py | 5 +- pytorch_caney/models/encoders/fcn_encoder.py | 12 +- pytorch_caney/models/encoders/satvision.py | 15 +- pytorch_caney/models/encoders/swinv2.py | 14 +- pytorch_caney/models/heads/__init__.py | 5 +- .../models/heads/segmentation_head.py | 13 +- pytorch_caney/models/mim.py | 6 +- pytorch_caney/optimizers/build.py | 11 +- pytorch_caney/optimizers/lamb.py | 61 +-- pytorch_caney/pipelines/__init__.py | 4 +- .../satvision_toa_pretrain_pipeline.py | 13 +- .../pipelines/three_d_cloud_pipeline.py | 30 +- pytorch_caney/plotting/__init__.py | 0 pytorch_caney/plotting/modis_toa.py | 152 ++++++++ .../transforms/abi_radiance_conversion.py | 15 +- pytorch_caney/transforms/abi_toa.py | 2 +- pytorch_caney/transforms/abi_toa_scale.py | 12 +- .../transforms/mim_mask_generator.py | 2 +- pytorch_caney/transforms/mim_modis_toa.py | 4 +- pytorch_caney/transforms/modis_toa.py | 4 +- pytorch_caney/transforms/modis_toa_scale.py | 10 +- .../transforms/random_resize_crop.py | 2 +- pytorch_caney/utils.py | 16 +- 27 files changed, 680 insertions(+), 122 deletions(-) create mode 100644 notebooks/satvision_toa_modis_reconstruction_example_notebook.ipynb create mode 100644 pytorch_caney/plotting/__init__.py create mode 100644 pytorch_caney/plotting/modis_toa.py diff --git a/notebooks/satvision_toa_modis_reconstruction_example_notebook.ipynb b/notebooks/satvision_toa_modis_reconstruction_example_notebook.ipynb new file mode 100644 index 0000000..853d0db --- /dev/null +++ b/notebooks/satvision_toa_modis_reconstruction_example_notebook.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5facdc34-efbd-4082-91ef-e70a4f34c441", + "metadata": {}, + "source": [ + "# SatVision-TOA Reconstruction Example Notebook\n", + "\n", + "This notebook demonstrates the reconstruction capabilities of the SatVision-TOA model, designed to process and reconstruct MODIS TOA (Top of Atmosphere) imagery using Masked Image Modeling (MIM) for Earth observation tasks.\n", + "\n", + "Follow this step-by-step guide to install necessary dependencies, load model weights, transform data, make predictions, and visualize the results.\n", + "\n", + "## 1. Setup and Install Dependencies\n", + "\n", + "The following packages are required to run the notebook:\n", + "- `yacs` – for handling configuration\n", + "- `timm` – for Transformer and Image Models in PyTorch\n", + "- `segmentation-models-pytorch` – for segmentation utilities\n", + "- `termcolor` – for colored terminal text\n", + "- `webdataset==0.2.86` – for handling datasets from web sources" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5e08cd1-d8df-4dd8-b884-d452ef90943b", + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install yacs timm segmentation-models-pytorch termcolor webdataset==0.2.86" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4506576-5e30-417d-96de-8953d71c76c2", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import time\n", + "import random\n", + "import datetime\n", + "from tqdm import tqdm\n", + "import numpy as np\n", + "import logging\n", + "\n", + "import torch\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.backends.backend_pdf import PdfPages\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore') " + ] + }, + { + "cell_type": "markdown", + "id": "775cb720-5151-49fa-a7d5-7291ef663d45", + "metadata": {}, + "source": [ + "## 2. Model and Configuration Imports\n", + "\n", + "We load necessary modules from the pytorch-caney library, including the model, transformations, and plotting utilities." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "edf47149-f489-497b-8601-89a7e8dbd9b9", + "metadata": {}, + "outputs": [], + "source": [ + "sys.path.append('../../pytorch-caney')\n", + "\n", + "from pytorch_caney.models.mim import build_mim_model\n", + "from pytorch_caney.transforms.mim_modis_toa import MimTransform\n", + "from pytorch_caney.configs.config import _C, _update_config_from_file\n", + "from pytorch_caney.plotting.modis_toa import plot_export_pdf" + ] + }, + { + "cell_type": "markdown", + "id": "fe00e78e-fca3-4221-86dd-da205fed4192", + "metadata": {}, + "source": [ + "## 2. Fetching the model\n", + "\n", + "### 2.1 Clone model ckpt from huggingface\n", + "\n", + "Model repo: https://huggingface.co/nasa-cisto-data-science-group/satvision-toa-giant-patch8-window8-128\n", + "\n", + "```bash\n", + "# On prism/explore system\n", + "module load git-lfs\n", + "\n", + "git lfs install\n", + "\n", + "git clone git@hf.co:nasa-cisto-data-science-group/satvision-toa-giant-patch8-window8-128\n", + "```\n", + "\n", + "Note: If using git w/ ssh, make sure you have ssh keys enabled to clone using ssh auth.\n", + "https://huggingface.co/docs/hub/security-git-ssh\n", + "\n", + "```bash\n", + "# If this outputs as anon, follow the next steps.\n", + "ssh -T git@hf.co\n", + "```\n", + "\n", + "\n", + "```bash\n", + "eval $(ssh-agent)\n", + "\n", + "# Check if ssh-agent is using the proper key\n", + "ssh-add -l\n", + "\n", + "# If not\n", + "ssh-add ~/.ssh/your-key\n", + "\n", + "# Or if you want to use the default id_* key, just do\n", + "ssh-add\n", + "\n", + "```\n", + "\n", + "## 3. Fetching the validation dataset\n", + "\n", + "### 3.1 Clone dataset repo from huggingface\n", + "\n", + "Dataset repo: https://huggingface.co/datasets/nasa-cisto-data-science-group/modis_toa_cloud_reconstruction_validation\n", + "\n", + "\n", + "```bash\n", + "# On prims/explore system\n", + "module load git-lfs\n", + "\n", + "git lfs install\n", + "\n", + "git clone git@hf.co:datasets/nasa-cisto-data-science-group/modis_toa_cloud_reconstruction_validation\n", + "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "abb754ff-1753-4a4c-804e-8e3e5461fd0a", + "metadata": {}, + "source": [ + "## 4. Define Model and Data Paths\n", + "\n", + "Specify paths to model checkpoint, configuration file, and the validation dataset. Customize these paths as needed for your environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ec267ce-ded1-40e6-8443-e1037297f710", + "metadata": {}, + "outputs": [], + "source": [ + "MODEL_PATH: str = '../../satvision-toa-giant-patch8-window8-128/mp_rank_00_model_states.pt'\n", + "CONFIG_PATH: str = '../../satvision-toa-giant-patch8-window8-128/mim_pretrain_swinv2_satvision_giant_128_window08_50ep.yaml'\n", + "\n", + "OUTPUT: str = '.'\n", + "DATA_PATH: str = '../../modis_toa_cloud_reconstruction_validation/sv_toa_128_chip_validation_04_24.npy'" + ] + }, + { + "cell_type": "markdown", + "id": "bd7d0b93-7fd3-49cb-ab9e-7536820ec5f2", + "metadata": {}, + "source": [ + "## 5. Configure Model\n", + "\n", + "Load and update the configuration for the SatVision-TOA model, specifying model and data paths." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aac43f0e-dc4b-49ba-a482-933b5bab4b79", + "metadata": {}, + "outputs": [], + "source": [ + "# Update config given configurations\n", + "\n", + "config = _C.clone()\n", + "_update_config_from_file(config, CONFIG_PATH)\n", + "\n", + "config.defrost()\n", + "config.MODEL.PRETRAINED = MODEL_PATH\n", + "config.DATA.DATA_PATHS = [DATA_PATH]\n", + "config.OUTPUT = OUTPUT\n", + "config.freeze()" + ] + }, + { + "cell_type": "markdown", + "id": "1d596904-d1df-4f6d-8e88-4c647ac26924", + "metadata": {}, + "source": [ + "## 6. Load Model Weights from Checkpoint\n", + "\n", + "Build and initialize the model from the checkpoint to prepare for evaluation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfe245f7-589e-4b02-9990-15cb1733f6cb", + "metadata": {}, + "outputs": [], + "source": [ + "print('Building un-initialized model')\n", + "model = build_mim_model(config)\n", + "print('Successfully built uninitialized model')\n", + "\n", + "print(f'Attempting to load checkpoint from {config.MODEL.PRETRAINED}')\n", + "checkpoint = torch.load(config.MODEL.PRETRAINED)\n", + "model.load_state_dict(checkpoint['module'])\n", + "print('Successfully applied checkpoint')\n", + "model.cuda()\n", + "model.eval()" + ] + }, + { + "cell_type": "markdown", + "id": "20c26d1e-125a-4b4c-a21e-ab07d6977222", + "metadata": {}, + "source": [ + "## 7. Transform Validation Data\n", + "\n", + "The MODIS TOA dataset is loaded and transformed using MimTransform, generating a masked dataset for reconstruction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b3b47b1-0690-4ef9-bed6-ec243b5d42cb", + "metadata": {}, + "outputs": [], + "source": [ + "# Use the Masked-Image-Modeling transform specific to MODIS TOA data\n", + "transform = MimTransform(config)\n", + "\n", + "# The reconstruction evaluation set is a single numpy file\n", + "validation_dataset_path = config.DATA.DATA_PATHS[0]\n", + "validation_dataset = np.load(validation_dataset_path)\n", + "len_batch = range(validation_dataset.shape[0])\n", + "\n", + "# Apply transform to each image in the batch\n", + "# A mask is auto-generated in the transform\n", + "imgMasks = [transform(validation_dataset[idx]) for idx \\\n", + " in len_batch]\n", + "\n", + "# Seperate img and masks, cast masks to torch tensor\n", + "img = torch.stack([imgMask[0] for imgMask in imgMasks])\n", + "mask = torch.stack([torch.from_numpy(imgMask[1]) for \\\n", + " imgMask in imgMasks])" + ] + }, + { + "cell_type": "markdown", + "id": "8b2148e4-da6d-4ae0-a194-c7adb62728a0", + "metadata": { + "tags": [] + }, + "source": [ + "## 8. Prediction\n", + "\n", + "Run predictions on each sample and calculate reconstruction losses. Each image is processed individually to track individual losses." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3814751-f352-456e-850c-fe1d289b1d6b", + "metadata": {}, + "outputs": [], + "source": [ + "inputs = []\n", + "outputs = []\n", + "masks = []\n", + "losses = []\n", + "\n", + "# We could do this in a single batch however we\n", + "# want to report the loss per-image, in place of\n", + "# loss per-batch.\n", + "for i in tqdm(range(img.shape[0])):\n", + " single_img = img[i].unsqueeze(0)\n", + " single_mask = mask[i].unsqueeze(0)\n", + " single_img = single_img.cuda(non_blocking=True)\n", + " single_mask = single_mask.cuda(non_blocking=True)\n", + "\n", + " with torch.no_grad():\n", + " z = model.encoder(single_img, single_mask)\n", + " img_recon = model.decoder(z)\n", + " loss = model(single_img, single_mask)\n", + "\n", + " inputs.extend(single_img.cpu())\n", + " masks.extend(single_mask.cpu())\n", + " outputs.extend(img_recon.cpu())\n", + " losses.append(loss.cpu()) " + ] + }, + { + "cell_type": "markdown", + "id": "22329bb4-5c6e-42dc-a492-8863fc2bf672", + "metadata": {}, + "source": [ + "## 9. Export Reconstruction Results to PDF\n", + "\n", + "Save and visualize the reconstruction results. The output PDF will contain reconstructed images with original and masked versions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ac6a09d-5fe2-4aa9-ac37-f235d5a8020a", + "metadata": {}, + "outputs": [], + "source": [ + "pdfPath = '../../satvision-toa-reconstruction-validation-giant-example.pdf'\n", + "rgbIndex = [0, 2, 1] # Indices of [Red band, Blue band, Green band]\n", + "plot_export_pdf(pdfPath, inputs, outputs, masks, rgbIndex)" + ] + }, + { + "cell_type": "markdown", + "id": "1e0eb426-c7b4-47d4-aefa-2199ecfce2ab", + "metadata": {}, + "source": [ + "This notebook provides an end-to-end example for reconstructing satellite images with the SatVision-TOA model, from setup through prediction and output visualization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62065e24-ddf2-4bf1-8362-90dc0c9bf49e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ILAB Kernel (Pytorch)", + "language": "python", + "name": "pytorch-kernel" + }, + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pytorch_caney/models/__init__.py b/pytorch_caney/models/__init__.py index 32eb253..e381289 100644 --- a/pytorch_caney/models/__init__.py +++ b/pytorch_caney/models/__init__.py @@ -1,2 +1,9 @@ from .model_factory import ModelFactory -from .mim import MiMModel \ No newline at end of file +from .mim import MiMModel +from .heads import SegmentationHead +from .decoders import FcnDecoder +from .encoders import SatVision, SwinTransformerV2, FcnEncoder + + +__all__ = [ModelFactory, MiMModel, SegmentationHead, + FcnDecoder, SatVision, SwinTransformerV2, FcnEncoder] diff --git a/pytorch_caney/models/decoders/__init__.py b/pytorch_caney/models/decoders/__init__.py index fafea15..303682d 100644 --- a/pytorch_caney/models/decoders/__init__.py +++ b/pytorch_caney/models/decoders/__init__.py @@ -1 +1,4 @@ -from .fcn_decoder import FcnDecoder \ No newline at end of file +from .fcn_decoder import FcnDecoder + + +__all__ = [FcnDecoder] diff --git a/pytorch_caney/models/decoders/fcn_decoder.py b/pytorch_caney/models/decoders/fcn_decoder.py index 232147d..cdb3d04 100644 --- a/pytorch_caney/models/decoders/fcn_decoder.py +++ b/pytorch_caney/models/decoders/fcn_decoder.py @@ -9,17 +9,17 @@ def __init__(self, num_features: int = 1024): super(FcnDecoder, self).__init__() self.output_channels = 64 self.decoder = nn.Sequential( - nn.ConvTranspose2d(num_features, 2048, kernel_size=3, stride=2, padding=1, output_padding=1), # 16x16x512 + nn.ConvTranspose2d(num_features, 2048, kernel_size=3, stride=2, padding=1, output_padding=1), # 16x16x512 # noqa: E501 nn.ReLU(), - nn.ConvTranspose2d(2048, 512, kernel_size=3, stride=2, padding=1, output_padding=1), # 32x32x256 + nn.ConvTranspose2d(2048, 512, kernel_size=3, stride=2, padding=1, output_padding=1), # 32x32x256 # noqa: E501 nn.ReLU(), - nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 + nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 # noqa: E501 nn.ReLU(), - nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 + nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1), # 64x64x128 # noqa: E501 nn.ReLU(), - nn.ConvTranspose2d(128, self.output_channels, kernel_size=3, stride=2, padding=1, output_padding=1), # 128x128x64 + nn.ConvTranspose2d(128, self.output_channels, kernel_size=3, stride=2, padding=1, output_padding=1), # 128x128x64 # noqa: E501 nn.ReLU() ) def forward(self, x): - return self.decoder(x) \ No newline at end of file + return self.decoder(x) diff --git a/pytorch_caney/models/encoders/__init__.py b/pytorch_caney/models/encoders/__init__.py index c699db0..ac897ad 100644 --- a/pytorch_caney/models/encoders/__init__.py +++ b/pytorch_caney/models/encoders/__init__.py @@ -1,3 +1,6 @@ from .fcn_encoder import FcnEncoder from .satvision import SatVision -from .swinv2 import SwinTransformerV2 \ No newline at end of file +from .swinv2 import SwinTransformerV2 + + +__all__ = [FcnEncoder, SatVision, SwinTransformerV2] diff --git a/pytorch_caney/models/encoders/fcn_encoder.py b/pytorch_caney/models/encoders/fcn_encoder.py index 0c1e20f..3f77cc0 100644 --- a/pytorch_caney/models/encoders/fcn_encoder.py +++ b/pytorch_caney/models/encoders/fcn_encoder.py @@ -11,16 +11,16 @@ def __init__(self, config): self.num_input_channels = self.config.MODEL.IN_CHANS self.num_features = 1024 self.encoder = nn.Sequential( - nn.Conv2d(self.num_input_channels, 64, kernel_size=3, stride=1, padding=1), # 128x128x64 + nn.Conv2d(self.num_input_channels, 64, kernel_size=3, stride=1, padding=1), # 128x128x64 # noqa: E501 nn.ReLU(), - nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1), # 64x64x128 + nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1), # 64x64x128 # noqa: E501 nn.ReLU(), - nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1), # 32x32x256 + nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1), # 32x32x256 # noqa: E501 nn.ReLU(), - nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1), # 16x16x512 + nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1), # 16x16x512 # noqa: E501 nn.ReLU(), - nn.Conv2d(512, 1024, kernel_size=3, stride=2, padding=1) # 8x8x1024 + nn.Conv2d(512, 1024, kernel_size=3, stride=2, padding=1) # 8x8x1024 # noqa: E501 ) def forward(self, x): - return self.encoder(x) \ No newline at end of file + return self.encoder(x) diff --git a/pytorch_caney/models/encoders/satvision.py b/pytorch_caney/models/encoders/satvision.py index f19247d..06141d0 100644 --- a/pytorch_caney/models/encoders/satvision.py +++ b/pytorch_caney/models/encoders/satvision.py @@ -5,7 +5,7 @@ # ----------------------------------------------------------------------------- -# SatVision +# SatVision # ----------------------------------------------------------------------------- @ModelFactory.encoder("satvision") class SatVision(nn.Module): @@ -42,16 +42,17 @@ def __init__(self, config): if self.config.MODEL.PRETRAINED: self.load_pretrained() - self.num_classes = self.model.num_classes - self.num_layers = self.model.num_layers - self.num_features = self.model.num_features + self.num_classes = self.model.num_classes + self.num_layers = self.model.num_layers + self.num_features = self.model.num_features # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def load_pretrained(self): - checkpoint = torch.load(self.config.MODEL.PRETRAINED, map_location='cpu') + checkpoint = torch.load( + self.config.MODEL.PRETRAINED, map_location='cpu') checkpoint_model = checkpoint['module'] @@ -77,14 +78,14 @@ def load_pretrained(self): torch.cuda.empty_cache() - print(f">>>>>>>>>> loaded successfully '{self.config.MODEL.PRETRAINED}'") + print(f">>>>>>> loaded successfully '{self.config.MODEL.PRETRAINED}'") # ------------------------------------------------------------------------- # forward # ------------------------------------------------------------------------- def forward(self, x): return self.model.forward(x) - + # ------------------------------------------------------------------------- # forward_features # ------------------------------------------------------------------------- diff --git a/pytorch_caney/models/encoders/swinv2.py b/pytorch_caney/models/encoders/swinv2.py index 1ceb257..fd4ed8f 100644 --- a/pytorch_caney/models/encoders/swinv2.py +++ b/pytorch_caney/models/encoders/swinv2.py @@ -219,7 +219,7 @@ def flops(self, N): # ----------------------------------------------------------------------------- -# Mlp +# Mlp # ----------------------------------------------------------------------------- class Mlp(nn.Module): def __init__(self, in_features, hidden_features=None, @@ -242,7 +242,7 @@ def forward(self, x): # ----------------------------------------------------------------------------- -# window_partition +# window_partition # ----------------------------------------------------------------------------- def window_partition(x, window_size): """ @@ -262,7 +262,7 @@ def window_partition(x, window_size): # ----------------------------------------------------------------------------- -# window_reverse +# window_reverse # ----------------------------------------------------------------------------- def window_reverse(windows, window_size, H, W): """ @@ -283,7 +283,7 @@ def window_reverse(windows, window_size, H, W): # ----------------------------------------------------------------------------- -# SwinTransformerBlock +# SwinTransformerBlock # ----------------------------------------------------------------------------- class SwinTransformerBlock(nn.Module): r""" Swin Transformer Block. @@ -494,7 +494,7 @@ def flops(self): # ----------------------------------------------------------------------------- -# BasicLayer +# BasicLayer # ----------------------------------------------------------------------------- class BasicLayer(nn.Module): """ A basic Swin Transformer layer for one stage. @@ -595,7 +595,7 @@ def _init_respostnorm(self): # ----------------------------------------------------------------------------- -# PatchEmbed +# PatchEmbed # ----------------------------------------------------------------------------- class PatchEmbed(nn.Module): r""" Image to Patch Embedding @@ -656,7 +656,7 @@ def flops(self): # ----------------------------------------------------------------------------- -# SwinTransformerV2 +# SwinTransformerV2 # ----------------------------------------------------------------------------- @ModelFactory.encoder("swinv2") class SwinTransformerV2(nn.Module): diff --git a/pytorch_caney/models/heads/__init__.py b/pytorch_caney/models/heads/__init__.py index df60bcd..fcf4565 100644 --- a/pytorch_caney/models/heads/__init__.py +++ b/pytorch_caney/models/heads/__init__.py @@ -1 +1,4 @@ -from .segmentation_head import SegmentationHead \ No newline at end of file +from .segmentation_head import SegmentationHead + + +__all__ = [SegmentationHead] diff --git a/pytorch_caney/models/heads/segmentation_head.py b/pytorch_caney/models/heads/segmentation_head.py index 86308e6..5561bac 100644 --- a/pytorch_caney/models/heads/segmentation_head.py +++ b/pytorch_caney/models/heads/segmentation_head.py @@ -2,15 +2,20 @@ from ..model_factory import ModelFactory + @ModelFactory.head("segmentation_head") class SegmentationHead(nn.Module): - def __init__(self, decoder_channels=128, num_classes=4, head_dropout=0.2, output_shape=(91, 40)): + def __init__(self, decoder_channels=128, num_classes=4, + head_dropout=0.2, output_shape=(91, 40)): super(SegmentationHead, self).__init__() self.head = nn.Sequential( - nn.Conv2d(decoder_channels, num_classes, kernel_size=3, stride=1, padding=1), + nn.Conv2d(decoder_channels, num_classes, + kernel_size=3, stride=1, padding=1), nn.Dropout(head_dropout), - nn.Upsample(size=output_shape, mode='bilinear', align_corners=False) + nn.Upsample(size=output_shape, + mode='bilinear', + align_corners=False) ) def forward(self, x): - return self.head(x) \ No newline at end of file + return self.head(x) diff --git a/pytorch_caney/models/mim.py b/pytorch_caney/models/mim.py index 6e41647..2d421cf 100644 --- a/pytorch_caney/models/mim.py +++ b/pytorch_caney/models/mim.py @@ -7,7 +7,7 @@ # ----------------------------------------------------------------------------- -# SwinTransformerV2ForMiM +# SwinTransformerV2ForMiM # ----------------------------------------------------------------------------- class SwinTransformerV2ForSimMIM(SwinTransformerV2): def __init__(self, **kwargs): @@ -48,7 +48,7 @@ def no_weight_decay(self): # ----------------------------------------------------------------------------- -# MiMModel +# MiMModel # ----------------------------------------------------------------------------- class MiMModel(nn.Module): """ @@ -101,7 +101,7 @@ def no_weight_decay_keywords(self): # ----------------------------------------------------------------------------- -# build_mim_model +# build_mim_model # ----------------------------------------------------------------------------- def build_mim_model(config): """Builds the masked-image-modeling model. diff --git a/pytorch_caney/optimizers/build.py b/pytorch_caney/optimizers/build.py index e2be339..c5d6c17 100644 --- a/pytorch_caney/optimizers/build.py +++ b/pytorch_caney/optimizers/build.py @@ -39,7 +39,7 @@ def get_optimizer_from_dict(optimizer_name, config): error_msg = f"{optimizer_name} is not an implemented optimizer" - error_msg = f"{error_msg}. Available optimizer functions: {OPTIMIZERS.keys()}" + error_msg = f"{error_msg}. Available optimizer functions: {OPTIMIZERS.keys()}" # noqa: E501 raise KeyError(error_msg) @@ -98,10 +98,10 @@ def build_optimizer(config, model, is_pretrain=False, logger=None): optimizer = None optimizer = optimizer_to_use(parameters, - eps=config.TRAIN.OPTIMIZER.EPS, - betas=config.TRAIN.OPTIMIZER.BETAS, - lr=config.TRAIN.BASE_LR, - weight_decay=config.TRAIN.WEIGHT_DECAY) + eps=config.TRAIN.OPTIMIZER.EPS, + betas=config.TRAIN.OPTIMIZER.BETAS, + lr=config.TRAIN.BASE_LR, + weight_decay=config.TRAIN.WEIGHT_DECAY) if logger: logger.info(optimizer) @@ -246,4 +246,3 @@ def get_swin_layer(name, num_layers, depths): else: return num_layers - 1 - diff --git a/pytorch_caney/optimizers/lamb.py b/pytorch_caney/optimizers/lamb.py index de6aebb..e51466d 100644 --- a/pytorch_caney/optimizers/lamb.py +++ b/pytorch_caney/optimizers/lamb.py @@ -1,14 +1,14 @@ """ PyTorch Lamb optimizer w/ behaviour similar to NVIDIA FusedLamb This optimizer code was adapted from the following (starting with latest) -* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py -* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py +* https://github.com/HabanaAI/Model-References/blob/2b435114fe8e31f159b1d3063b8280ae37af7423/PyTorch/nlp/bert/pretraining/lamb.py # noqa: E501 +* https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py # noqa: E501 * https://github.com/cybertronai/pytorch-lamb -Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is -similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX. +Use FusedLamb if you can (GPU). The reason for including this variant of Lamb is to have a version that is # noqa: E501 +similar in behaviour to APEX FusedLamb if you aren't using NVIDIA GPUs or cannot install/use APEX. # noqa: E501 -In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU. +In addition to some cleanup, this Lamb impl has been modified to support PyTorch XLA and has been tested on TPU. # noqa: E501 Original copyrights for above sources are below. @@ -41,7 +41,7 @@ # 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 +# The above copyright notice and this permission notice shall be included in all # noqa: E501 # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR @@ -60,7 +60,9 @@ from torch.utils.tensorboard import SummaryWriter -def log_lamb_rs(optimizer: Optimizer, event_writer: SummaryWriter, token_count: int): +def log_lamb_rs(optimizer: Optimizer, + event_writer: SummaryWriter, + token_count: int): """Log a histogram of trust ratio scalars in across layers.""" results = collections.defaultdict(list) for group in optimizer.param_groups: @@ -75,13 +77,13 @@ def log_lamb_rs(optimizer: Optimizer, event_writer: SummaryWriter, token_count: class Lamb(Optimizer): - """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB - reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py + """Implements a pure pytorch variant of FuseLAMB (NvLamb variant) optimizer from apex.optimizers.FusedLAMB # noqa: E501 + reference: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py # noqa: E501 - LAMB was proposed in `Large Batch Optimization for Deep Learning: Training BERT in 76 minutes`_. + LAMB was proposed in `Large Batch Optimization for Deep Learning: Training BERT in 76 minutes`_. # noqa: E501 Arguments: - params (iterable): iterable of parameters to optimize or dicts defining parameter groups. + params (iterable): iterable of parameters to optimize or dicts defining parameter groups. # noqa: E501 lr (float, optional): learning rate. (default: 1e-3) betas (Tuple[float, float], optional): coefficients used for computing running averages of gradient and its norm. (default: (0.9, 0.999)) @@ -102,12 +104,17 @@ class Lamb(Optimizer): """ def __init__( - self, params, lr=1e-3, bias_correction=True, betas=(0.9, 0.999), eps=1e-6, - weight_decay=0.01, grad_averaging=True, max_grad_norm=1.0, trust_clip=False, always_adapt=False): + self, params, lr=1e-3, bias_correction=True, + betas=(0.9, 0.999), eps=1e-6, weight_decay=0.01, + grad_averaging=True, max_grad_norm=1.0, + trust_clip=False, always_adapt=False): + defaults = dict( - lr=lr, bias_correction=bias_correction, betas=betas, eps=eps, weight_decay=weight_decay, + lr=lr, bias_correction=bias_correction, + betas=betas, eps=eps, weight_decay=weight_decay, grad_averaging=grad_averaging, max_grad_norm=max_grad_norm, trust_clip=trust_clip, always_adapt=always_adapt) + super().__init__(params, defaults) @torch.no_grad() @@ -123,7 +130,8 @@ def step(self, closure=None): loss = closure() device = self.param_groups[0]['params'][0].device - one_tensor = torch.tensor(1.0, device=device) # because torch.where doesn't handle scalars correctly + # because torch.where doesn't handle scalars correctly + one_tensor = torch.tensor(1.0, device=device) global_grad_norm = torch.zeros(1, device=device) for group in self.param_groups: for p in group['params']: @@ -131,13 +139,15 @@ def step(self, closure=None): continue grad = p.grad if grad.is_sparse: - raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.') + raise RuntimeError( + 'Lamb does not support sparse gradients, consider SparseAdam instad.') # noqa: E501 global_grad_norm.add_(grad.pow(2).sum()) global_grad_norm = torch.sqrt(global_grad_norm) - # FIXME it'd be nice to remove explicit tensor conversion of scalars when torch.where promotes - # scalar types properly https://github.com/pytorch/pytorch/issues/9190 - max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], device=device) + # FIXME it'd be nice to remove explicit tensor conversion of scalars when torch.where promotes # noqa: E501 + # scalar types properly https://github.com/pytorch/pytorch/issues/9190 # noqa: E501 + max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], + device=device) clip_global_grad_norm = torch.where( global_grad_norm > max_grad_norm, global_grad_norm / max_grad_norm, @@ -150,7 +160,7 @@ def step(self, closure=None): beta3 = 1 - beta1 if grad_averaging else 1.0 # assume same step across group now to simplify things - # per parameter step can be easily support by making it tensor, or pass list into kernel + # per parameter step can be easily support by making it tensor, or pass list into kernel # noqa: E501 if 'step' in group: group['step'] += 1 else: @@ -179,9 +189,10 @@ def step(self, closure=None): # Decay the first and second moment running average coefficient exp_avg.mul_(beta1).add_(grad, alpha=beta3) # m_t - exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) # v_t + exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) # v_t # noqa: E501 - denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps']) + denom = (exp_avg_sq.sqrt() / + math.sqrt(bias_correction2)).add_(group['eps']) update = (exp_avg / bias_correction1).div_(denom) weight_decay = group['weight_decay'] @@ -189,11 +200,11 @@ def step(self, closure=None): update.add_(p, alpha=weight_decay) if weight_decay != 0 or group['always_adapt']: - # Layer-wise LR adaptation. By default, skip adaptation on parameters that are - # excluded from weight decay, unless always_adapt == True, then always enabled. + # Layer-wise LR adaptation. By default, skip adaptation on parameters that are # noqa: E501 + # excluded from weight decay, unless always_adapt == True, then always enabled. # noqa: E501 w_norm = p.norm(2.0) g_norm = update.norm(2.0) - # FIXME nested where required since logical and/or not working in PT XLA + # FIXME nested where required since logical and/or not working in PT XLA # noqa: E501 trust_ratio = torch.where( w_norm > 0, torch.where(g_norm > 0, w_norm / g_norm, one_tensor), diff --git a/pytorch_caney/pipelines/__init__.py b/pytorch_caney/pipelines/__init__.py index f008267..911c274 100644 --- a/pytorch_caney/pipelines/__init__.py +++ b/pytorch_caney/pipelines/__init__.py @@ -1,10 +1,12 @@ from .satvision_toa_pretrain_pipeline import SatVisionToaPretrain -from .three_d_cloud_pipeline import ThreeDCloudTask +from .three_d_cloud_pipeline import ThreeDCloudTask + PIPELINES = { 'satvisiontoapretrain': SatVisionToaPretrain, '3dcloud': ThreeDCloudTask } + def get_available_pipelines(): return {name: cls for name, cls in PIPELINES.items()} diff --git a/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py index 07e3bb5..c5461fe 100644 --- a/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py +++ b/pytorch_caney/pipelines/satvision_toa_pretrain_pipeline.py @@ -46,13 +46,13 @@ def __init__(self, config): batch_size=self.batch_size).dataset() # ------------------------------------------------------------------------- - # load_checkpoint + # load_checkpoint # ------------------------------------------------------------------------- def load_checkpoint(self): - print(f'Attempting to load checkpoint from {self.config.MODEL.PRETRAINED}') + print('Loading checkpoint from {self.config.MODEL.PRETRAINED}') checkpoint = torch.load(self.config.MODEL.PRETRAINED) self.model.load_state_dict(checkpoint['module']) - print(f'Successfully applied checkpoint') + print('Successfully applied checkpoint') # ------------------------------------------------------------------------- # forward @@ -73,16 +73,15 @@ def training_step(self, batch, batch_idx): self.train_loss_avg.compute(), rank_zero_only=True, batch_size=self.batch_size, - prog_bar=True - ) - + prog_bar=True) + return loss # ------------------------------------------------------------------------- # configure_optimizers # ------------------------------------------------------------------------- def configure_optimizers(self): - optimizer = build_optimizer(self.config, self.model, is_pretrain=True) + optimizer = build_optimizer(self.config, self.model, is_pretrain=True) return optimizer # ------------------------------------------------------------------------- diff --git a/pytorch_caney/pipelines/three_d_cloud_pipeline.py b/pytorch_caney/pipelines/three_d_cloud_pipeline.py index 492db5b..717c705 100644 --- a/pytorch_caney/pipelines/three_d_cloud_pipeline.py +++ b/pytorch_caney/pipelines/three_d_cloud_pipeline.py @@ -4,21 +4,20 @@ import lightning.pytorch as pl -from pytorch_caney.models.mim import build_mim_model from pytorch_caney.optimizers.build import build_optimizer from pytorch_caney.transforms.abi_toa import AbiToaTransform from pytorch_caney.models import ModelFactory -from pytorch_caney.models.decoders import FcnDecoder -from pytorch_caney.models.heads import SegmentationHead -from typing import Any, Tuple +from typing import Tuple + # ----------------------------------------------------------------------------- # ThreeDCloudTask # ----------------------------------------------------------------------------- class ThreeDCloudTask(pl.LightningModule): - NUM_CLASSES: int = 1 + NUM_CLASSES: int = 1 OUTPUT_SHAPE: Tuple[int, int] = (91, 40) + # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- @@ -32,7 +31,7 @@ def __init__(self, config): self.transform = AbiToaTransform(self.config) # ------------------------------------------------------------------------- - # configure_models + # configure_models # ------------------------------------------------------------------------- def configure_models(self): factory = ModelFactory() @@ -41,9 +40,10 @@ def configure_models(self): name=self.config.MODEL.ENCODER, config=self.config) - self.decoder = factory.get_component(component_type="decoder", - name=self.config.MODEL.DECODER, - num_features=self.encoder.num_features) + self.decoder = factory.get_component( + component_type="decoder", + name=self.config.MODEL.DECODER, + num_features=self.encoder.num_features) self.segmentation_head = factory.get_component( component_type="head", @@ -59,7 +59,7 @@ def configure_models(self): print(self.model) # ------------------------------------------------------------------------- - # configure_losses + # configure_losses # ------------------------------------------------------------------------- def configure_losses(self): loss: str = self.config.LOSS.NAME @@ -72,7 +72,7 @@ def configure_losses(self): ) # ------------------------------------------------------------------------- - # configure_metrics + # configure_metrics # ------------------------------------------------------------------------- def configure_metrics(self): num_classes = 2 @@ -90,7 +90,7 @@ def configure_metrics(self): # forward # ------------------------------------------------------------------------- def forward(self, x): - return self.model(x) + return self.model(x) # ------------------------------------------------------------------------- # training_step @@ -108,7 +108,7 @@ def training_step(self, batch, batch_idx): self.log('train_loss', self.train_loss_avg.compute(), on_step=True, on_epoch=True, prog_bar=True) self.log('train_iou', self.train_iou_avg.compute(), - on_step=True, on_epoch=True, prog_bar=True) + on_step=True, on_epoch=True, prog_bar=True) return loss # ------------------------------------------------------------------------- @@ -127,14 +127,14 @@ def validation_step(self, batch, batch_idx): on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) self.log('val_iou', self.val_iou_avg.compute(), on_step=True, on_epoch=True, prog_bar=True, sync_dist=True) - + return val_loss # ------------------------------------------------------------------------- # configure_optimizers # ------------------------------------------------------------------------- def configure_optimizers(self): - optimizer = build_optimizer(self.config, self.model, is_pretrain=True) + optimizer = build_optimizer(self.config, self.model, is_pretrain=True) print(f'Using optimizer: {optimizer}') return optimizer diff --git a/pytorch_caney/plotting/__init__.py b/pytorch_caney/plotting/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pytorch_caney/plotting/modis_toa.py b/pytorch_caney/plotting/modis_toa.py new file mode 100644 index 0000000..37671b6 --- /dev/null +++ b/pytorch_caney/plotting/modis_toa.py @@ -0,0 +1,152 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.backends.backend_pdf import PdfPages + +from ..transforms.modis_toa_scale import MinMaxEmissiveScaleReflectance + + +# ----------------------------------------------------------------------------- +# MODIS Reconstruction Visualization Pipeline +# ----------------------------------------------------------------------------- +# This script processes MODIS TOA images and model reconstructions, generating +# comparison visualizations in a PDF format. It contains several functions that +# interact to prepare, transform, and visualize MODIS image data, applying +# necessary transformations for reflective and emissive band scaling, masking, +# and normalization. The flow is as follows: +# +# 1. `plot_export_pdf`: Main function that generates PDF visualizations. +# It uses other functions to process and organize data. +# 2. `process_reconstruction_prediction`: Prepares images and masks for +# visualization, applying transformations and normalization. +# 3. `minmax_norm`: Scales image arrays to 0-255 range for display. +# 4. `process_mask`: Prepares mask images to match the input image dimensions. +# 5. `reverse_transform`: Applies band-specific scaling to MODIS data. +# +# ASCII Diagram: +# +# plot_export_pdf +# └── process_reconstruction_prediction +# ├── minmax_norm +# ├── process_mask +# └── reverse_transform +# +# ----------------------------------------------------------------------------- + + +# ----------------------------------------------------------------------------- +# plot_export_pdf +# ----------------------------------------------------------------------------- +# Generates a multi-page PDF with visualizations of original, reconstructed, +# and masked MODIS images. Uses the `process_reconstruction_prediction` funct +# to prepare data for display and organizes subplots for easy comparison. +# ----------------------------------------------------------------------------- +def plot_export_pdf(path, inputs, outputs, masks, rgb_index): + pdf_plot_obj = PdfPages(path) + + for idx in range(len(inputs)): + # prediction processing + image = inputs[idx] + img_recon = outputs[idx] + mask = masks[idx] + rgb_image, rgb_image_masked, rgb_recon_masked, mask = \ + process_reconstruction_prediction( + image, img_recon, mask, rgb_index) + + # matplotlib code + fig, (ax01, ax23) = plt.subplots(2, 2, figsize=(40, 30)) + ax0, ax1 = ax01 + ax2, ax3 = ax23 + ax2.imshow(rgb_image) + ax2.set_title(f"Idx: {idx} MOD021KM v6.1 Bands: {rgb_index}") + + ax0.imshow(rgb_recon_masked) + ax0.set_title(f"Idx: {idx} Model reconstruction") + + ax1.imshow(rgb_image_masked) + ax1.set_title(f"Idx: {idx} MOD021KM Bands: {rgb_index}, masked") + + ax3.matshow(mask[:, :, 0]) + ax3.set_title(f"Idx: {idx} Reconstruction Mask") + pdf_plot_obj.savefig() + + pdf_plot_obj.close() + + +# ----------------------------------------------------------------------------- +# process_reconstruction_prediction +# ----------------------------------------------------------------------------- +# Prepares RGB images, reconstructions, and masked versions by extracting and +# normalizing specific bands based on the provided RGB indices. Returns masked +# images and the processed mask for visualization in the PDF. +# ----------------------------------------------------------------------------- +def process_reconstruction_prediction(image, img_recon, mask, rgb_index): + + mask = process_mask(mask) + + red_idx = rgb_index[0] + blue_idx = rgb_index[1] + green_idx = rgb_index[2] + + image = reverse_transform(image.numpy()) + + img_recon = reverse_transform(img_recon.numpy()) + + rgb_image = np.stack((image[red_idx, :, :], + image[blue_idx, :, :], + image[green_idx, :, :]), axis=-1) + rgb_image = minmax_norm(rgb_image) + + rgb_image_recon = np.stack((img_recon[red_idx, :, :], + img_recon[blue_idx, :, :], + img_recon[green_idx, :, :]), axis=-1) + rgb_image_recon = minmax_norm(rgb_image_recon) + + rgb_masked = np.where(mask == 0, rgb_image, rgb_image_recon) + rgb_image_masked = np.where(mask == 1, 0, rgb_image) + rgb_recon_masked = rgb_masked + + return rgb_image, rgb_image_masked, rgb_recon_masked, mask + + +# ----------------------------------------------------------------------------- +# minmax_norm +# ----------------------------------------------------------------------------- +# Normalizes an image array to a range of 0-255 for consistent display. +# ----------------------------------------------------------------------------- +def minmax_norm(img_arr): + arr_min = img_arr.min() + arr_max = img_arr.max() + img_arr_scaled = (img_arr - arr_min) / (arr_max - arr_min) + img_arr_scaled = img_arr_scaled * 255 + img_arr_scaled = img_arr_scaled.astype(np.uint8) + return img_arr_scaled + + +# ----------------------------------------------------------------------------- +# process_mask +# ----------------------------------------------------------------------------- +# Adjusts the dimensions of a binary mask to match the input image shape, +# replicating mask values across the image. +# ----------------------------------------------------------------------------- +def process_mask(mask): + mask_img = mask.unsqueeze(0) + mask_img = mask_img.repeat_interleave(4, 1).repeat_interleave(4, 2) + mask_img = mask_img.unsqueeze(1).contiguous()[0, 0] + return np.stack([mask_img] * 3, axis=-1) + + +# ----------------------------------------------------------------------------- +# reverse_transform +# ----------------------------------------------------------------------------- +# Reverses scaling transformations applied to the original MODIS data to +# prepare the image for RGB visualization. +# ----------------------------------------------------------------------------- +def reverse_transform(image): + minMaxTransform = MinMaxEmissiveScaleReflectance() + image = image.transpose((1, 2, 0)) + image[:, :, minMaxTransform.reflectance_indices] *= 100 + emis_min, emis_max = \ + minMaxTransform.emissive_mins, minMaxTransform.emissive_maxs + image[:, :, minMaxTransform.emissive_indices] *= (emis_max - emis_min) + image[:, :, minMaxTransform.emissive_indices] += emis_min + return image.transpose((2, 0, 1)) diff --git a/pytorch_caney/transforms/abi_radiance_conversion.py b/pytorch_caney/transforms/abi_radiance_conversion.py index 71b5e3d..4470b75 100644 --- a/pytorch_caney/transforms/abi_radiance_conversion.py +++ b/pytorch_caney/transforms/abi_radiance_conversion.py @@ -11,7 +11,7 @@ def vis_calibrate(data): factor = np.pi * esd * esd / solar_irradiance return data * np.float32(factor) * 100 - + # ----------------------------------------------------------------------------- # ir_calibrate @@ -42,17 +42,18 @@ class ConvertABIToReflectanceBT(object): """ def __init__(self): - + self.reflectance_indices = [0, 1, 2, 3, 4, 6] self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] def __call__(self, img): - + # Reflectance % to reflectance units img[:, :, self.reflectance_indices] = \ vis_calibrate(img[:, :, self.reflectance_indices]) - + # Brightness temp scaled to (0,1) range - img[:, :, self.emissive_indices] = ir_calibrate(img[:, :, self.emissive_indices]) - - return img \ No newline at end of file + img[:, :, self.emissive_indices] = ir_calibrate( + img[:, :, self.emissive_indices]) + + return img diff --git a/pytorch_caney/transforms/abi_toa.py b/pytorch_caney/transforms/abi_toa.py index f762b25..30afb9c 100644 --- a/pytorch_caney/transforms/abi_toa.py +++ b/pytorch_caney/transforms/abi_toa.py @@ -17,7 +17,7 @@ def __init__(self, img_size): self.transform_img = \ T.Compose([ - ConvertABIToReflectanceBT(), # New transform for MinMax + ConvertABIToReflectanceBT(), MinMaxEmissiveScaleReflectance(), T.ToTensor(), T.Resize((img_size, img_size), antialias=True), diff --git a/pytorch_caney/transforms/abi_toa_scale.py b/pytorch_caney/transforms/abi_toa_scale.py index 0d4cf1e..852aafd 100644 --- a/pytorch_caney/transforms/abi_toa_scale.py +++ b/pytorch_caney/transforms/abi_toa_scale.py @@ -9,7 +9,7 @@ class MinMaxEmissiveScaleReflectance(object): """ def __init__(self): - + self.reflectance_indices = [0, 1, 2, 3, 4, 6] self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] @@ -24,14 +24,14 @@ def __init__(self): dtype=np.float32) def __call__(self, img): - + # Reflectance % to reflectance units img[:, :, self.reflectance_indices] = \ img[:, :, self.reflectance_indices] * 0.01 - + # Brightness temp scaled to (0,1) range img[:, :, self.emissive_indices] = \ (img[:, :, self.emissive_indices] - self.emissive_mins) / \ - (self.emissive_maxs - self.emissive_mins) - - return img \ No newline at end of file + (self.emissive_maxs - self.emissive_mins) + + return img diff --git a/pytorch_caney/transforms/mim_mask_generator.py b/pytorch_caney/transforms/mim_mask_generator.py index c101d3c..530b1ca 100644 --- a/pytorch_caney/transforms/mim_mask_generator.py +++ b/pytorch_caney/transforms/mim_mask_generator.py @@ -30,7 +30,7 @@ def __init__(self, def __call__(self): mask = make_mim_mask(self.token_count, self.mask_count, - self.rand_size, self.scale) + self.rand_size, self.scale) mask = mask.repeat(self.scale, axis=0).repeat(self.scale, axis=1) return mask diff --git a/pytorch_caney/transforms/mim_modis_toa.py b/pytorch_caney/transforms/mim_modis_toa.py index c111600..1d168d9 100644 --- a/pytorch_caney/transforms/mim_modis_toa.py +++ b/pytorch_caney/transforms/mim_modis_toa.py @@ -1,7 +1,7 @@ import torchvision.transforms as T from .random_resize_crop import RandomResizedCropNP -from .mim_mask_generator import MimMaskGenerator +from .mim_mask_generator import MimMaskGenerator from .modis_toa_scale import MinMaxEmissiveScaleReflectance @@ -18,7 +18,7 @@ def __init__(self, config): self.transform_img = \ T.Compose([ - MinMaxEmissiveScaleReflectance(), # New transform for MinMax + MinMaxEmissiveScaleReflectance(), RandomResizedCropNP(scale=(0.67, 1.), ratio=(3. / 4., 4. / 3.)), T.ToTensor(), diff --git a/pytorch_caney/transforms/modis_toa.py b/pytorch_caney/transforms/modis_toa.py index fd52805..24fdb1f 100644 --- a/pytorch_caney/transforms/modis_toa.py +++ b/pytorch_caney/transforms/modis_toa.py @@ -15,7 +15,7 @@ def __init__(self, config): self.transform_img = \ T.Compose([ - MinMaxEmissiveScaleReflectance(), # New transform for MinMax + MinMaxEmissiveScaleReflectance(), T.ToTensor(), T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), ]) @@ -24,4 +24,4 @@ def __call__(self, img): img = self.transform_img(img) - return img \ No newline at end of file + return img diff --git a/pytorch_caney/transforms/modis_toa_scale.py b/pytorch_caney/transforms/modis_toa_scale.py index b256a79..1eb5a30 100644 --- a/pytorch_caney/transforms/modis_toa_scale.py +++ b/pytorch_caney/transforms/modis_toa_scale.py @@ -12,7 +12,7 @@ class MinMaxEmissiveScaleReflectance(object): """ def __init__(self): - + self.reflectance_indices = [0, 1, 2, 3, 4, 6] self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] @@ -27,14 +27,14 @@ def __init__(self): dtype=np.float32) def __call__(self, img): - + # Reflectance % to reflectance units img[:, :, self.reflectance_indices] = \ img[:, :, self.reflectance_indices] * 0.01 - + # Brightness temp scaled to (0,1) range img[:, :, self.emissive_indices] = \ (img[:, :, self.emissive_indices] - self.emissive_mins) / \ - (self.emissive_maxs - self.emissive_mins) - + (self.emissive_maxs - self.emissive_mins) + return img diff --git a/pytorch_caney/transforms/random_resize_crop.py b/pytorch_caney/transforms/random_resize_crop.py index 8eab062..06609ec 100644 --- a/pytorch_caney/transforms/random_resize_crop.py +++ b/pytorch_caney/transforms/random_resize_crop.py @@ -60,4 +60,4 @@ def __call__(self, img): align_corners=False) cropped_squeezed_numpy = cropped_resized.squeeze().numpy() cropped_squeezed_numpy = np.moveaxis(cropped_squeezed_numpy, 0, -1) - return cropped_squeezed_numpy \ No newline at end of file + return cropped_squeezed_numpy diff --git a/pytorch_caney/utils.py b/pytorch_caney/utils.py index 9cde7cf..fc7e46d 100644 --- a/pytorch_caney/utils.py +++ b/pytorch_caney/utils.py @@ -15,21 +15,24 @@ def get_strategy(config): "zero_allow_untested_optimizer": True, "zero_optimization": { "stage": config.DEEPSPEED.STAGE, - "contiguous_gradients": config.DEEPSPEED.CONTIGUOUS_GRADIENTS, + "contiguous_gradients": + config.DEEPSPEED.CONTIGUOUS_GRADIENTS, "overlap_comm": config.DEEPSPEED.OVERLAP_COMM, "reduce_bucket_size": config.DEEPSPEED.REDUCE_BUCKET_SIZE, - "allgather_bucket_size": config.DEEPSPEED.ALLGATHER_BUCKET_SIZE, + "allgather_bucket_size": + config.DEEPSPEED.ALLGATHER_BUCKET_SIZE, }, "activation_checkpointing": { - "partition_activations": config.TRAIN.USE_CHECKPOINT, + "partition_activations": config.TRAIN.USE_CHECKPOINT, }, } - + return DeepSpeedStrategy(config=deepspeed_config) else: # These may be return as strings - return strategy + return strategy + # ----------------------------------------------------------------------------- # get_distributed_train_batches @@ -38,4 +41,5 @@ def get_distributed_train_batches(config, trainer): if config.TRAIN.NUM_TRAIN_BATCHES: return config.TRAIN.NUM_TRAIN_BATCHES else: - return config.DATA.LENGTH // (config.DATA.BATCH_SIZE * trainer.world_size) + return config.DATA.LENGTH // \ + (config.DATA.BATCH_SIZE * trainer.world_size) From 7a00a4c565a086c535e4ec1d7a9a4873b6e15b60 Mon Sep 17 00:00:00 2001 From: cssprad1 Date: Mon, 18 Nov 2024 13:33:48 -0500 Subject: [PATCH 41/50] pep8 formatting --- pytorch_caney/configs/config.py | 16 +++++----- pytorch_caney/datamodules/__init__.py | 4 ++- .../datamodules/abi_3dcloud_datamodule.py | 32 ++++++++++++++++--- .../datamodules/modis_toa_mim_datamodule.py | 4 +-- pytorch_caney/datasets/abi_3dcloud_dataset.py | 26 ++++++++++++--- pytorch_caney/datasets/sharded_dataset.py | 8 ++--- pytorch_caney/models/model_factory.py | 10 +++--- pytorch_caney/ptc_cli.py | 8 ++--- 8 files changed, 75 insertions(+), 33 deletions(-) diff --git a/pytorch_caney/configs/config.py b/pytorch_caney/configs/config.py index 6beecb9..f633293 100644 --- a/pytorch_caney/configs/config.py +++ b/pytorch_caney/configs/config.py @@ -49,7 +49,7 @@ # Encoder type for fine-tuning _C.MODEL.ENCODER = '' # Decoder type for fine-tuning -_C.MODEL.DECODER = '' +_C.MODEL.DECODER = '' # Model name _C.MODEL.NAME = 'swinv2_base_patch4_window7_224' # Pretrained weight from checkpoint, could be from previous pre-training @@ -104,8 +104,8 @@ _C.TRAIN = CN() _C.TRAIN.ACCELERATOR = 'gpu' _C.TRAIN.STRATEGY = 'deepspeed' -_C.TRAIN.LIMIT_TRAIN_BATCHES = True -_C.TRAIN.NUM_TRAIN_BATCHES = None +_C.TRAIN.LIMIT_TRAIN_BATCHES = True +_C.TRAIN.NUM_TRAIN_BATCHES = None _C.TRAIN.START_EPOCH = 0 _C.TRAIN.EPOCHS = 300 _C.TRAIN.WARMUP_EPOCHS = 20 @@ -120,7 +120,7 @@ _C.TRAIN.AUTO_RESUME = True # Gradient accumulation steps # could be overwritten by command line argument -_C.TRAIN.ACCUMULATION_STEPS = 1 +_C.TRAIN.ACCUMULATION_STEPS = 1 # Whether to use gradient checkpointing to save memory # could be overwritten by command line argument _C.TRAIN.USE_CHECKPOINT = False @@ -160,8 +160,8 @@ _C.DEEPSPEED.STAGE = 2 _C.DEEPSPEED.REDUCE_BUCKET_SIZE = 5e8 _C.DEEPSPEED.ALLGATHER_BUCKET_SIZE = 5e8 -_C.DEEPSPEED.CONTIGUOUS_GRADIENTS = True -_C.DEEPSPEED.OVERLAP_COMM = True +_C.DEEPSPEED.CONTIGUOUS_GRADIENTS = True +_C.DEEPSPEED.OVERLAP_COMM = True # ----------------------------------------------------------------------------- @@ -175,7 +175,7 @@ # Misc # ----------------------------------------------------------------------------- # Whether to enable pytorch amp, overwritten by command line argument -_C.PRECISION = '32' +_C.PRECISION = '32' # Enable Pytorch automatic mixed precision (amp). _C.AMP_ENABLE = True # Path to output folder, overwritten by command line argument @@ -196,7 +196,7 @@ _C.PIPELINE = 'satvisiontoapretrain' # Data module _C.DATAMODULE = 'abitoa3dcloud' -# Fast dev run +# Fast dev run _C.FAST_DEV_RUN = False diff --git a/pytorch_caney/datamodules/__init__.py b/pytorch_caney/datamodules/__init__.py index ad540c3..b5633d2 100644 --- a/pytorch_caney/datamodules/__init__.py +++ b/pytorch_caney/datamodules/__init__.py @@ -1,10 +1,12 @@ from .abi_3dcloud_datamodule import AbiToa3DCloudDataModule from .modis_toa_mim_datamodule import ModisToaMimDataModule + DATAMODULES = { 'abitoa3dcloud': AbiToa3DCloudDataModule, 'modistoamimpretrain': ModisToaMimDataModule, } + def get_available_datamodules(): - return {name: cls for name, cls in DATAMODULES.items()} \ No newline at end of file + return {name: cls for name, cls in DATAMODULES.items()} diff --git a/pytorch_caney/datamodules/abi_3dcloud_datamodule.py b/pytorch_caney/datamodules/abi_3dcloud_datamodule.py index c44c342..2b23f03 100644 --- a/pytorch_caney/datamodules/abi_3dcloud_datamodule.py +++ b/pytorch_caney/datamodules/abi_3dcloud_datamodule.py @@ -5,9 +5,15 @@ from pytorch_caney.transforms.abi_toa import AbiToaTransform +# ----------------------------------------------------------------------------- +# AbiToa3DCloudDataModule +# ----------------------------------------------------------------------------- class AbiToa3DCloudDataModule(L.LightningDataModule): """NonGeo ABI TOA 3D cloud data module implementation""" + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- def __init__( self, config, @@ -21,6 +27,9 @@ def __init__( self.batch_size = config.DATA.BATCH_SIZE self.num_workers = config.DATA.NUM_WORKERS + # ------------------------------------------------------------------------- + # setup + # ------------------------------------------------------------------------- def setup(self, stage: str) -> None: if stage in ["fit"]: self.train_dataset = AbiToa3DCloudDataset( @@ -40,12 +49,27 @@ def setup(self, stage: str) -> None: self.test_data_paths, self.transform, ) - + + # ------------------------------------------------------------------------- + # train_dataloader + # ------------------------------------------------------------------------- def train_dataloader(self): - return DataLoader(self.train_dataset, batch_size=self.batch_size, num_workers=self.num_workers) + return DataLoader(self.train_dataset, + batch_size=self.batch_size, + num_workers=self.num_workers) + # ------------------------------------------------------------------------- + # val_dataloader + # ------------------------------------------------------------------------- def val_dataloader(self): - return DataLoader(self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers) + return DataLoader(self.val_dataset, + batch_size=self.batch_size, + num_workers=self.num_workers) + # ------------------------------------------------------------------------- + # test_dataloader + # ------------------------------------------------------------------------- def test_dataloader(self): - return DataLoader(self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers) + return DataLoader(self.val_dataset, + batch_size=self.batch_size, + num_workers=self.num_workers) diff --git a/pytorch_caney/datamodules/modis_toa_mim_datamodule.py b/pytorch_caney/datamodules/modis_toa_mim_datamodule.py index b52b8e2..e77064e 100644 --- a/pytorch_caney/datamodules/modis_toa_mim_datamodule.py +++ b/pytorch_caney/datamodules/modis_toa_mim_datamodule.py @@ -26,7 +26,7 @@ def __init__(self, config,) -> None: self.pin_memory = config.DATA.PIN_MEMORY # ------------------------------------------------------------------------- - # setup + # setup # ------------------------------------------------------------------------- def setup(self, stage: str) -> None: if stage in ["fit"]: @@ -40,7 +40,7 @@ def setup(self, stage: str) -> None: batch_size=self.batch_size).dataset() # ------------------------------------------------------------------------- - # train_dataloader + # train_dataloader # ------------------------------------------------------------------------- def train_dataloader(self) -> DataLoader: return DataLoader(self.train_dataset, diff --git a/pytorch_caney/datasets/abi_3dcloud_dataset.py b/pytorch_caney/datasets/abi_3dcloud_dataset.py index 3f37eae..85056fc 100644 --- a/pytorch_caney/datasets/abi_3dcloud_dataset.py +++ b/pytorch_caney/datasets/abi_3dcloud_dataset.py @@ -8,14 +8,20 @@ from torchgeo.datasets import NonGeoDataset +# ----------------------------------------------------------------------------- +# AbiToa3DCloudDataModule +# ----------------------------------------------------------------------------- class AbiToa3DCloudDataset(NonGeoDataset): - + + # ------------------------------------------------------------------------- + # __init__ + # ------------------------------------------------------------------------- def __init__(self, config, data_paths: list, transform=None) -> None: super().__init__() self.config = config - self.data_paths = data_paths + self.data_paths = data_paths self.transform = transform self.img_size = config.DATA.IMG_SIZE @@ -27,9 +33,15 @@ def __init__(self, config, data_paths: list, transform=None) -> None: self.rgb_indices = [0, 1, 2] + # ------------------------------------------------------------------------- + # __len__ + # ------------------------------------------------------------------------- def __len__(self) -> int: return len(self.image_list) + # ------------------------------------------------------------------------- + # __getitem__ + # ------------------------------------------------------------------------- def __getitem__(self, index: int) -> Dict[str, Any]: npz_array = self._load_file(self.image_list[index]) @@ -39,16 +51,22 @@ def __getitem__(self, index: int) -> Dict[str, Any]: if self.transform is not None: image = self.transform(image) - return image, mask + return image, mask + # ------------------------------------------------------------------------- + # _load_file + # ------------------------------------------------------------------------- def _load_file(self, path: Path): if Path(path).suffix == '.npy' or Path(path).suffix == '.npz': return np.load(path, allow_pickle=True) elif Path(path).suffix == '.tif': return rxr.open_rasterio(path) else: - raise RuntimeError('Non-recognized dataset format. Expects npy or tif.') + raise RuntimeError('Non-recognized dataset format. Expects npy or tif.') # noqa: E501 + # ------------------------------------------------------------------------- + # get_filenames + # ------------------------------------------------------------------------- def get_filenames(self, path): """ Returns a list of absolute paths to images inside given `path` diff --git a/pytorch_caney/datasets/sharded_dataset.py b/pytorch_caney/datasets/sharded_dataset.py index 185a3b8..8cec063 100644 --- a/pytorch_caney/datasets/sharded_dataset.py +++ b/pytorch_caney/datasets/sharded_dataset.py @@ -23,7 +23,7 @@ def nodesplitter(src, group=None): if i % size == rank: yield item count += 1 - logging.info(f"nodesplitter: rank={rank} size={size} " + \ + logging.info(f"nodesplitter: rank={rank} size={size} " + f"count={count} DONE") else: yield from src @@ -34,7 +34,7 @@ def nodesplitter(src, group=None): # ----------------------------------------------------------------------------- class ShardedDataset(object): """ - Base pre-training webdataset + Base pre-training webdataset """ SHARD_PATH = os.path.join("shards") @@ -53,7 +53,7 @@ def __init__( batch_size=64, ): - self.random_state = 1000 + self.random_state = 1000 self.config = config self.img_size = img_size self.transform = transform @@ -87,4 +87,4 @@ def dataset(self): .with_length(self.length) ) - return dataset \ No newline at end of file + return dataset diff --git a/pytorch_caney/models/model_factory.py b/pytorch_caney/models/model_factory.py index f12b3fd..e888ae4 100644 --- a/pytorch_caney/models/model_factory.py +++ b/pytorch_caney/models/model_factory.py @@ -1,5 +1,3 @@ -import torch.nn as nn - # ----------------------------------------------------------------------------- # ModelFactory # ----------------------------------------------------------------------------- @@ -38,7 +36,7 @@ def register_head(cls, name: str, head_cls): # ------------------------------------------------------------------------- @classmethod def get_component(cls, component_type: str, name: str, **kwargs): - """Public method to retrieve and instantiate a component by type and name.""" + """Public method to retrieve and instantiate a component by type and name.""" # noqa: E501 print(cls.backbones) print(cls.decoders) print(cls.heads) @@ -49,8 +47,8 @@ def get_component(cls, component_type: str, name: str, **kwargs): }.get(component_type) if registry is None or name not in registry: - raise ValueError(f"{component_type.capitalize()} '{name}' not found in registry.") - + raise ValueError(f"{component_type.capitalize()} '{name}' not found in registry.") # noqa: E501 + return registry[name](**kwargs) # ------------------------------------------------------------------------- @@ -84,4 +82,4 @@ def head(cls, name): def decorator(head_cls): cls.register_head(name, head_cls) return head_cls - return decorator \ No newline at end of file + return decorator diff --git a/pytorch_caney/ptc_cli.py b/pytorch_caney/ptc_cli.py index 424623b..d41ed96 100644 --- a/pytorch_caney/ptc_cli.py +++ b/pytorch_caney/ptc_cli.py @@ -1,7 +1,7 @@ import argparse import os -from lightning.pytorch import Trainer +from lightning.pytorch import Trainer from pytorch_caney.configs.config import _C, _update_config_from_file from pytorch_caney.utils import get_strategy, get_distributed_train_batches @@ -42,7 +42,8 @@ def main(config, output_dir): ) if config.TRAIN.LIMIT_TRAIN_BATCHES: - trainer.limit_train_batches = get_distributed_train_batches(config, trainer) + trainer.limit_train_batches = get_distributed_train_batches( + config, trainer) if config.DATA.DATAMODULE: available_datamodules = get_available_datamodules() @@ -53,13 +54,12 @@ def main(config, output_dir): trainer.fit(model=ptlPipeline, datamodule=datamodule) else: - print(f'Training without datamodule, assuming data is set in pipeline: {ptlPipeline}') + print(f'Training without datamodule, assuming data is set in pipeline: {ptlPipeline}') # noqa: E501 trainer.fit(model=ptlPipeline) if __name__ == "__main__": - parser = argparse.ArgumentParser() parser.add_argument( From 9ead3a48d58aa3e02ddaa8c6934565333a674af7 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Mon, 18 Nov 2024 13:58:16 -0500 Subject: [PATCH 42/50] Update README.md --- README.md | 713 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 645 insertions(+), 68 deletions(-) diff --git a/README.md b/README.md index cd8a5a0..5a69557 100644 --- a/README.md +++ b/README.md @@ -13,23 +13,24 @@ Python package for lots of Pytorch tools. - Latest: https://nasa-nccs-hpda.github.io/pytorch-caney/latest -## Objectives +# pytorch-caney + +Python package for a variety of PyTorch tools for geospatial science problems. + +[![DOI](https://zenodo.org/badge/472450059.svg)](https://zenodo.org/badge/latestdoi/472450059) +## Objectives - Library to process remote sensing imagery using GPU and CPU parallelization. - Machine Learning and Deep Learning image classification and regression. - Agnostic array and vector-like data structures. -- User interface environments via Notebooks for easy to use AI/ML projects. -- Example notebooks for quick AI/ML start with your own data. +- User interface environments via Notebooks for easy-to-use AI/ML projects. +- Example notebooks for a quick AI/ML start with your own data. ## Installation -The following library is intended to be used to accelerate the development of data science products -for remote sensing satellite imagery, or any other applications. pytorch-caney can be installed -by itself, but instructions for installing the full environments are listed under the requirements -directory so projects, examples, and notebooks can be run. +The following library is intended to be used to accelerate the development of data science products for remote sensing satellite imagery, or other applications. `pytorch-caney` can be installed by itself, but instructions for installing the full environments are listed under the `requirements` directory so projects, examples, and notebooks can be run. -Note: PIP installations do not include CUDA libraries for GPU support. Make sure NVIDIA libraries -are installed locally in the system if not using conda/mamba. +**Note:** PIP installations do not include CUDA libraries for GPU support. Make sure NVIDIA libraries are installed locally in the system if not using conda/mamba. ```bash module load singularity # if a module needs to be loaded @@ -42,103 +43,679 @@ singularity build --sandbox pytorch-caney-container docker://nasanccs/pytorch-ca ## Contributors -- Jordan Alexis Caraballo-Vega, jordan.a.caraballo-vega@nasa.gov -- Caleb Spradlin, caleb.s.spradlin@nasa.gov +- **Jordan Alexis Caraballo-Vega**: [jordan.a.caraballo-vega@nasa.gov](mailto:jordan.a.caraballo-vega@nasa.gov) +- **Caleb Spradlin**: [caleb.s.spradlin@nasa.gov](mailto:caleb.s.spradlin@nasa.gov) +- **Jian Li**: [jian.li@nasa.gov](mailto:jian.li@nasa.gov) ## Contributing -Please see our [guide for contributing to pytorch-caney](CONTRIBUTING.md). +Please see our [guide for contributing to pytorch-caney](CONTRIBUTING.md). -## SatVision +# User Guide +--- -| name | pretrain | resolution | #params | -| :---: | :---: | :---: | :---: | -| SatVision-B | MODIS-1.9-M | 192x192 | 84.5M | +## 1. SatVision-TOA -## SatVision Datasets +|Name|Pretrain|Resolution|Channels | Parameters| +|---|---|---|---|---| +|SatVision-TOA-GIANT|MODIS-TOA-100-M|128x128|14|3B| -| name | bands | resolution | #chips | -| :---: | :---: | :---: | :---: | -| MODIS-Small | 7 | 128x128 | 1,994,131 | +### Accessing the Model -## MODIS Surface Reflectance (MOD09GA) Band Details +Model Repository: [HuggingFace](https://huggingface.co/nasa-cisto-data-science-group/satvision-toa-giant-patch8-window8-128) -| Band Name | Bandwidth | -| :------------: | :-----------: | -| sur_refl_b01_1 | 0.620 - 0.670 | -| sur_refl_b02_1 | 0.841 - 0.876 | -| sur_refl_b03_1 | 0.459 - 0.479 | -| sur_refl_b04_1 | 0.545 - 0.565 | -| sur_refl_b05_1 | 1.230 - 1.250 | -| sur_refl_b06_1 | 1.628 - 1.652 | -| sur_refl_b07_1 | 2.105 - 2.155 | +#### **Clone the Model Checkpoint** -## Pre-training with Masked Image Modeling +1. Load `git-lfs`: +```bash + module load git-lfs +``` +```bash + git lfs install +``` -To pre-train the swinv2 base model with masked image modeling pre-training, run: +2. Clone the repository: ```bash -torchrun --nproc_per_node pytorch-caney/pytorch_caney/pipelines/pretraining/mim.py --cfg --dataset --data-paths --batch-size --output --enable-amp + git clone git@hf.co:nasa-cisto-data-science-group/satvision-toa-giant-patch8-window8-128 ``` -For example to run on a compute node with 4 GPUs and a batch size of 128 on the MODIS SatVision pre-training dataset with a base swinv2 model, run: + Note: Using SSH authentication +Ensure SSH keys are configured. Troubleshooting steps: +- Check SSH connection: ```bash -singularity shell --nv -B /path/to/container/pytorch-caney-container -Singularity> export PYTHONPATH=$PWD:$PWD/pytorch-caney -Singularity> torchrun --nproc_per_node 4 pytorch-caney/pytorch_caney/pipelines/pretraining/mim.py --cfg pytorch-caney/examples/satvision/mim_pretrain_swinv2_satvision_base_192_window12_800ep.yaml --dataset MODIS --data-paths /explore/nobackup/projects/ilab/data/satvision/pretraining/training_* --batch-size 128 --output . --enable-amp + ssh -T git@hf.co # If reports back as anonymous follow the next steps ``` - -This example script runs the exact configuration used to make the SatVision-base model pre-training with MiM and the MODIS pre-training dataset. +- Add your SSH key: ```bash -singularity shell --nv -B /path/to/container/pytorch-caney-container -Singularity> cd pytorch-caney/examples/satvision -Singularity> ./run_satvision_pretrain.sh + eval $(ssh-agent) + ssh-add ~/.ssh/your-key # Path to your SSH key ``` -## Fine-tuning Satvision-base -To fine-tune the satvision-base pre-trained model, run: +## Running SatVision-TOA Pipelines + +### Command-Line Interface (CLI) + +To run tasks with **PyTorch-Caney**, use the following command: + ```bash -torchrun --nproc_per_node pytorch-caney/pytorch_caney/pipelines/finetuning/finetune.py --cfg --pretrained --dataset --data-paths --batch-size --output --enable-amp +$ python pytorch-caney/pytorch_caney/ptc_cli.py --config-path ``` -See example config files pytorch-caney/examples/satvision/finetune_satvision_base_*.yaml to see how to structure your config file for fine-tuning. +### Common CLI Arguments +| Command-line-argument | Description |Required/Optional/Flag | Default | Example | +| --------------------- |:----------------------------------------------------|:---------|:---------|:--------------------------------------| +| `-config-path` | Path to training config | Required | N/A |`--config-path pytorch-caney/configs/3dcloudtask_swinv2_satvision_gaint_test.yaml` | +| `-h, --help` | show this help message and exit | Optional | N/a |`--help`, `-h` | -## Testing -For unittests, run this bash command to run linting and unit test runs. This will execute unit tests and linting in a temporary venv environment only used for testing. -```bash -git clone git@github.com:nasa-nccs-hpda/pytorch-caney.git -cd pytorch-caney; bash test.sh +### Examples + +**Run 3D Cloud Task with Pretrained Model**: +```shell +$ python pytorch-caney/pytorch_caney/ptc_cli.py --config-path pytorch-caney/configs/3dcloudtask_swinv2_satvision_giant_test.yaml +``` +**Run 3D Cloud Task with baseline model**: +```shell +$ python pytorch-caney/pytorch_caney/ptc_cli.py --config-path pytorch-caney/configs/3dcloudtask_fcn_baseline_test.yaml +``` + +**Run SatVision-TOA Pretraining from Scratch**: +```shell +$ python pytorch-caney/pytorch_caney/ptc_cli.py --config-path pytorch-caney/configs/mim_pretrain_swinv2_satvision_giant_128_onecycle_100ep.yaml ``` -or run unit tests directly with container or anaconda env + +## **3. Using Singularity for Containerized Execution** + +**Shell Access** ```bash -git clone git@github.com:nasa-nccs-hpda/pytorch-caney.git -singularity build --sandbox pytorch-caney-container docker://nasanccs/pytorch-caney:latest -singularity shell --nv -B /path/to/container/pytorch-caney-container -cd pytorch-caney; python -m unittest discover pytorch_caney/tests +$ singularity shell --nv -B +Singularity> export PYTHONPATH=$PWD:$PWD/pytorch-caney ``` +**Command Execution** ```bash -git clone git@github.com:nasa-nccs-hpda/pytorch-caney.git -cd pytorch-caney; conda env create -f requirements/environment_gpu.yml; -conda activate pytorch-caney -python -m unittest discover pytorch_caney/tests +$ singularity exec --nv -B , --env PYTHONPATH=$PWD:$PWD/pytorch-caney COMMAND ``` -Another example using the singularity exec command from the Explore system: +### **Example** + +Running the 3D Cloud Task inside the container: ```bash -singularity exec --env PYTHONPATH="$NOBACKUP/development/pytorch-caney" --nv -B /path/to/mount /path/to/container/pytorch-caney-container coverage run -m unittest discover pytorch_caney/tests +$ singularity shell --nv -B +Singularity> export PYTHONPATH=$PWD:$PWD/pytorch-caney +Singularity> python pytorch-caney/pytorch_caney/ptc_cli.py --config-path pytorch-caney/configs/3dcloudtask_swinv2_satvision_giant_test.yaml +``` + +--- + +## 4. ThreeDCloudTask Pipeline + +This document describes how to run the `ThreeDCloudTask` pipeline using the provided configuration files and PyTorch Lightning setup. This requires downloading the 3D Cloud dataset from HuggingFace. + +## Pipeline Overview + +The `ThreeDCloudTask` is a PyTorch Lightning module designed for regression tasks predicting a 3D cloud vertical structure. The pipeline is configurable through YAML files and leverages custom components for the encoder, decoder, loss functions, and metrics. -This command would output the report per file: +## Running the Pipeline +Follow the steps below to train or validate the `ThreeDCloudTask` pipeline. + +### Prepare Configuration + +Two example configuration files are provided: + +- `3dcloudtask_swinv2_satvision_gaint_test.yaml`: Configures a pipeline using the SwinV2-based SatVision encoder. +- `3dcloudtask_fcn_baseline_test.yaml`: Configures a baseline pipeline with a fully convolutional network (FCN). + +Modify the configuration file to suit your dataset and training parameters. + +### Run the Training Script + +Example: ```bash -singularity exec --env PYTHONPATH="$NOBACKUP/development/pytorch-caney" --nv -B /path/to/mount /path/to/container/pytorch-caney-container coverage report +$ singularity shell --nv -B +Singularity> export PYTHONPATH=$PWD:$PWD/pytorch-caney +Singularity> python python pytorch-caney/pytorch_caney/ptc_cli.py --config-path pytorch-caney/configs/3dcloudtask_swinv2_satvision_giant_test.yaml +``` + +### Script Behavior + +- **Pipeline Initialization**: The script initializes the pipeline using the `PIPELINES` registry, based on the `PIPELINE`value in the configuration file. +- **Model and Data Module Setup**: The script automatically detects and uses the appropriate `DATAMODULE` and `MODEL` components specified in the configuration. +- **Training Strategy**: The `get_strategy` function selects the optimal training strategy, including distributed training if applicable. +- **Checkpoints**: If a checkpoint path is provided in the configuration (`MODEL.RESUME`), training resumes from that checkpoint. +### Output + +The results, logs, and model checkpoints are saved in a directory specified by: +`///` + +Example: + +`./outputs/3dcloud-svtoa-finetune-giant/3dcloud_task_swinv2_g_satvision_128_scaled_bt_minmax/` + +### Configuration Details + +#### 3D Cloud Task Example Configurations + +```yaml +PIPELINE: '3dcloud' +DATAMODULE: 'abitoa3dcloud' +MODEL: + ENCODER: 'satvision' + DECODER: 'fcn' + PRETRAINED: satvision-toa-giant-patch8-window8-128/mp_rank_00_model_states.pt + TYPE: swinv2 + NAME: 3dcloud-svtoa-finetune-giant + IN_CHANS: 14 + DROP_PATH_RATE: 0.1 + SWINV2: + IN_CHANS: 14 + EMBED_DIM: 512 + DEPTHS: [ 2, 2, 42, 2 ] + NUM_HEADS: [ 16, 32, 64, 128 ] + WINDOW_SIZE: 8 + NORM_PERIOD: 6 +DATA: + BATCH_SIZE: 32 + DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + TEST_DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + IMG_SIZE: 128 +TRAIN: + USE_CHECKPOINT: True + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +LOSS: + NAME: 'bce' +PRECISION: 'bf16' +PRINT_FREQ: 10 +SAVE_FREQ: 50 +VALIDATION_FREQ: 20 +TAG: 3dcloud_task_swinv2_g_satvision_128_scaled_bt_minmax +``` + +#### FCN Baseline Configuration + +```yaml +PIPELINE: '3dcloud' +DATAMODULE: 'abitoa3dcloud' +MODEL: + ENCODER: 'fcn' + DECODER: 'fcn' + NAME: 3dcloud-fcn-baseline + IN_CHANS: 14 + DROP_PATH_RATE: 0.1 +DATA: + BATCH_SIZE: 32 + DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + TEST_DATA_PATHS: [/explore/nobackup/projects/ilab/data/satvision-toa/3dcloud.data/abiChipsNew/] + IMG_SIZE: 128 +TRAIN: + ACCELERATOR: 'gpu' + STRATEGY: 'auto' + EPOCHS: 50 + WARMUP_EPOCHS: 10 + BASE_LR: 3e-4 + MIN_LR: 2e-4 + WARMUP_LR: 1e-4 + WEIGHT_DECAY: 0.05 + LR_SCHEDULER: + NAME: 'multistep' + GAMMA: 0.1 + MULTISTEPS: [700,] +LOSS: + NAME: 'bce' +PRINT_FREQ: 10 +SAVE_FREQ: 50 +VALIDATION_FREQ: 20 +TAG: 3dcloud_task_fcn_baseline_128_scaled_bt_minmax ``` -## References +### Key Components + +#### Model Components + +- **Encoder**: Handles feature extraction from input data. +- **Decoder**: Processes features into an intermediate representation. +- **Segmentation Head**: Produces the final output with a specific shape (91x40). + +#### Loss Function + +- **Binary Cross-Entropy Loss (`bce`)** is used for training. + +#### Metrics + +- **Jaccard Index (IoU)**: Evaluates model accuracy. +- **Mean Loss**: Tracks average loss during training and validation. + +#### Optimizer + +- Custom optimizer configurations are handled by `build_optimizer`. + +### Additional Notes + +- Customize your `DATAMODULE` and `MODEL` definitions as per the dataset and task requirements. +- To run the pipeline with GPUs, ensure your system has compatible hardware and CUDA installed. + +--- + +## Masked-Image-Modeling Pre-Training Pipeline + +--- + +For an example of how MiM pre-trained models work, see the example inference notebook in `pytorch-caney/notebooks/` + +# SatVision-TOA Model Input Data Generation and Pre-processing + +--- + +## Overview  + +- For expected model input see "Expected Model Input" section +- For steps taken for generating the MODIS-TOA pre-training dataset see "MODIS-TOA Dataset Generation" section + +![MODIS TOA Bands](modis_toa_bands.png) + +## MODIS-TOA Dataset Generation -- [Pytorch Lightning](https://github.com/Lightning-AI/lightning) -- [Swin Transformer](https://github.com/microsoft/Swin-Transformer) -- [SimMIM](https://github.com/microsoft/SimMIM) +The MODIS TOA dataset is derived from MODIS MOD02 Level 1B swaths, which provide calibrated and geolocated irradiances across 36 spectral bands. The data processing pipeline involves compositing, calibration, and normalization steps to convert raw data into a format suitable for deep learning model ingestion.  + +MODIS data comes in three spatial resolutions 250 m, 500 m and 1 km where bands 1 and 2 are natively 250 m, bands 3 – 7 are natively 500 m and bands 8 – 36 are natively 1 km.  For this work all bands need to be at the same spatial resolution so the finer resolution bands 1 – 7 have been aggregated to 1 km. + +The initial step involves compositing MODIS 5-minute swaths into daily global composites at 1 km spatial resolution. This step consolidates continuous swath data into a consistent daily global grid.  + +The SatVision TOA model is pre-trained on 14 MODIS band L1B Top-Of-Atmosphere (TOA) irradiance imageries. Bands were selected based on which ones were most similar to spectral profiles of other instruments such as GOES ABI. See Table 1 for mapping each band to one of the 14 indices and the central wavelength for each band. + +## Conversion to TOA Reflectance and Brightness Temperature + +After generating daily composites, digital numbers (DNs) from the MODIS bands are converted into Top-of-Atmosphere (TOA) reflectance for visible and Near-Infrared (NIR) bands, and brightness temperature (BT) for Thermal Infrared (TIR) bands. The conversion is guided by the MODIS Level 1B product user guide and implemented through the `SatPy` Python package. These transformations give the data physical units (reflectance and temperature).  + +## Expected Model Input + +The pre-processed data should closely match the bands listed in the table provided in the model documentation, ensuring that each input channel accurately corresponds to a specific MODIS band and spectral range. The exact bands required depend on the task; however, the general expectation is for consistency with the MODIS TOA reflectance and BT band specifications. + +## Equations for MODIS DN Conversion + +Radiance and reflectance scales and offsets are found in the MOD021KM metadata, specifically within each subdataset. + +Radiance: `radianceScales` and `radianceOffsets` + +Reflectance: `reflectanceScales` and `reflectanceOffsets` + +### Reflectance Calibration +The formula for converting MODIS DN values to TOA reflectance is: + +$$\text{Reflectance} = (DN - \text{reflectanceOffsets}) \times \text{reflectanceScales} \times 100$$ + +This formula scales and converts the values into percentage reflectance. + +### Brightness Temperature Calibration + +For TIR bands, the calibration to Brightness Temperature ($BT$) is more involved and relies on physical constants and the effective central wavenumber ($WN$). + +The equation for converting MODIS DN to BT is: + +$$\text{Radiance} = (DN - \text{radianceOffsets}) \times \text{radianceScales}$$ + + +$$BT = \frac{c_2}{\text{WN} \times \ln\left(\frac{c_1}{\text{Radiance} \times \text{WN}^5} + 1\right)}$$ + + +$$BT = \frac{(BT - tci)}{tcs}$$ + +Where:  + +- $c_1$ and $c_2$ are derived constants based on the Planck constant $h$, the speed of light $c$, and the Boltzmann constant $k$. +- $tcs$ is the temperature correction slope, and $tci$ is the temperature correction intercept. + +### Scaling for Machine Learning Compatibility + +Both TOA reflectance and BT values are scaled to a range of 0-1 to ensure compatibility with neural networks, aiding model convergence and training stability:  + + **TOA Reflectance Scaling** + +Reflectance values are scaled by a factor of 0.01, transforming the original 0-100 range to 0-1.  + +$$\text{TOA Reflectance (scaled)} = \text{TOA Reflectance} \times 0.01$$ + +**Brightness Temperature Scaling** + +Brightness temperatures are min-max scaled to a range of 0-1, based on global minimum and maximum values for each of the 8 TIR channels in the dataset. + +$$\text{Scaled Value} = \frac{\text{Original Value} - \text{Min}}{\text{Max} - \text{Min}}$$ + +This normalization process aligns the dynamic range of both feature types, contributing to more stable model performance.  + +## Example Python Code + +### MODIS L1B + +- https://github.com/pytroll/satpy/blob/main/satpy/readers/modis_l1b.py + +Below is an example of the Python code used in SatPy for calibrating radiance, reflectance, and BT for MODIS L1B products: + +```python + +def calibrate_radiance(array, attributes, index): + """Calibration for radiance channels.""" + offset = np.float32(attributes["radiance_offsets"][index]) + scale = np.float32(attributes["radiance_scales"][index]) + array = (array - offset) * scale + return array + + +def calibrate_refl(array, attributes, index): + """Calibration for reflective channels.""" + offset = np.float32(attributes["reflectance_offsets"][index]) + scale = np.float32(attributes["reflectance_scales"][index]) + # convert to reflectance and convert from 1 to % + array = (array - offset) * scale * 100 + return array + + +def calibrate_bt(array, attributes, index, band_name): + """Calibration for the emissive channels.""" + offset = np.float32(attributes["radiance_offsets"][index]) + scale = np.float32(attributes["radiance_scales"][index]) + + array = (array - offset) * scale + + # Planck constant (Joule second) + h__ = np.float32(6.6260755e-34) + + # Speed of light in vacuum (meters per second) + c__ = np.float32(2.9979246e+8) + + # Boltzmann constant (Joules per Kelvin) + k__ = np.float32(1.380658e-23) + + # Derived constants + c_1 = 2 * h__ * c__ * c__ + c_2 = (h__ * c__) / k__ + + # Effective central wavenumber (inverse centimeters) + cwn = np.array([ + 2.641775E+3, 2.505277E+3, 2.518028E+3, 2.465428E+3, + 2.235815E+3, 2.200346E+3, 1.477967E+3, 1.362737E+3, + 1.173190E+3, 1.027715E+3, 9.080884E+2, 8.315399E+2, + 7.483394E+2, 7.308963E+2, 7.188681E+2, 7.045367E+2], + dtype=np.float32) + + # Temperature correction slope (no units) + tcs = np.array([ + 9.993411E-1, 9.998646E-1, 9.998584E-1, 9.998682E-1, + 9.998819E-1, 9.998845E-1, 9.994877E-1, 9.994918E-1, + 9.995495E-1, 9.997398E-1, 9.995608E-1, 9.997256E-1, + 9.999160E-1, 9.999167E-1, 9.999191E-1, 9.999281E-1], + dtype=np.float32) + + # Temperature correction intercept (Kelvin) + tci = np.array([ + 4.770532E-1, 9.262664E-2, 9.757996E-2, 8.929242E-2, + 7.310901E-2, 7.060415E-2, 2.204921E-1, 2.046087E-1, + 1.599191E-1, 8.253401E-2, 1.302699E-1, 7.181833E-2, + 1.972608E-2, 1.913568E-2, 1.817817E-2, 1.583042E-2], + dtype=np.float32) + + # Transfer wavenumber [cm^(-1)] to wavelength [m] + cwn = 1. / (cwn * 100) + + # Some versions of the modis files do not contain all the bands. + emmissive_channels = ["20", "21", "22", "23", "24", "25", "27", "28", "29", + "30", "31", "32", "33", "34", "35", "36"] + global_index = emmissive_channels.index(band_name) + + cwn = cwn[global_index] + tcs = tcs[global_index] + tci = tci[global_index] + array = c_2 / (cwn * np.log(c_1 / (1000000 * array * cwn ** 5) + 1)) + array = (array - tci) / tcs + return array +``` + +### ABI L1B + +- https://github.com/pytroll/satpy/blob/main/satpy/readers/abi_l1b.py + +Below is an example of the Python code used in SatPy for calibrating radiance, reflectance, and BT for ABI L1B products: + +```python + def _rad_calibrate(self, data): + """Calibrate any channel to radiances. + + This no-op method is just to keep the flow consistent - + each valid cal type results in a calibration method call + """ + res = data + res.attrs = data.attrs + return res + + def _raw_calibrate(self, data): + """Calibrate any channel to raw counts. + + Useful for cases where a copy requires no calibration. + """ + res = data + res.attrs = data.attrs + res.attrs["units"] = "1" + res.attrs["long_name"] = "Raw Counts" + res.attrs["standard_name"] = "counts" + return res + + def _vis_calibrate(self, data): + """Calibrate visible channels to reflectance.""" + solar_irradiance = self["esun"] + esd = self["earth_sun_distance_anomaly_in_AU"] + + factor = np.pi * esd * esd / solar_irradiance + + res = data * np.float32(factor) + res.attrs = data.attrs + res.attrs["units"] = "1" + res.attrs["long_name"] = "Bidirectional Reflectance" + res.attrs["standard_name"] = "toa_bidirectional_reflectance" + return res + + def _get_minimum_radiance(self, data): + """Estimate minimum radiance from Rad DataArray.""" + attrs = data.attrs + scale_factor = attrs["scale_factor"] + add_offset = attrs["add_offset"] + count_zero_rad = - add_offset / scale_factor + count_pos = np.ceil(count_zero_rad) + min_rad = count_pos * scale_factor + add_offset + return min_rad + + def _ir_calibrate(self, data): + """Calibrate IR channels to BT.""" + fk1 = float(self["planck_fk1"]) + fk2 = float(self["planck_fk2"]) + bc1 = float(self["planck_bc1"]) + bc2 = float(self["planck_bc2"]) + + if self.clip_negative_radiances: + min_rad = self._get_minimum_radiance(data) + data = data.clip(min=data.dtype.type(min_rad)) + + res = (fk2 / np.log(fk1 / data + 1) - bc1) / bc2 + res.attrs = data.attrs + res.attrs["units"] = "K" + res.attrs["long_name"] = "Brightness Temperature" + res.attrs["standard_name"] = "toa_brightness_temperature" + return res +``` + +### Performing scaling as a torch transform + +For MODIS-TOA data: + +```python +import numpy as np + + +# ----------------------------------------------------------------------- +# MinMaxEmissiveScaleReflectance +# ----------------------------------------------------------------------- +class MinMaxEmissiveScaleReflectance(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emissive_mins = np.array( + [223.1222, 178.9174, 204.3739, 204.7677, + 194.8686, 202.1759, 201.3823, 203.3537], + dtype=np.float32) + + self.emissive_maxs = np.array( + [352.7182, 261.2920, 282.5529, 319.0373, + 295.0209, 324.0677, 321.5254, 285.9848], + dtype=np.float32) + + def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img + + +# ------------------------------------------------------------------------ +# ModisToaTransform +# ------------------------------------------------------------------------ +class ModisToaTransform: + """ + torchvision transform which transforms the input imagery + """ + + def __init__(self, config): + + self.transform_img = \ + T.Compose([ + MinMaxEmissiveScaleReflectance(), + T.ToTensor(), + T.Resize((config.DATA.IMG_SIZE, config.DATA.IMG_SIZE)), + ]) + + def __call__(self, img): + + img = self.transform_img(img) + + return img +``` + +For ABI data + +```python +# ----------------------------------------------------------------------- +# ConvertABIToReflectanceBT +# ----------------------------------------------------------------------- +class ConvertABIToReflectanceBT(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + def __call__(self, img): + + # Digital Numbers to TOA reflectance units + img[:, :, self.reflectance_indices] = \ + vis_calibrate(img[:, :, self.reflectance_indices]) + + # Digital Numbers -> Radiance -> Brightness Temp (K) + img[:, :, self.emissive_indices] = ir_calibrate(img[:, :, self.emissive_indices]) + + return img + +# ------------------------------------------------------------------------ +# MinMaxEmissiveScaleReflectance +# ------------------------------------------------------------------------ +class MinMaxEmissiveScaleReflectance(object): + """ + Performs scaling of MODIS TOA data + - Scales reflectance percentages to reflectance units (% -> (0,1)) + - Performs per-channel minmax scaling for emissive bands (k -> (0,1)) + """ + + def __init__(self): + + self.reflectance_indices = [0, 1, 2, 3, 4, 6] + self.emissive_indices = [5, 7, 8, 9, 10, 11, 12, 13] + + self.emissive_mins = np.array( + [117.04327, 152.00592, 157.96591, 176.15349, + 210.60493, 210.52264, 218.10147, 225.9894], + dtype=np.float32) + + self.emissive_maxs = np.array( + [221.07022, 224.44113, 242.3326, 307.42004, + 290.8879, 343.72617, 345.72894, 323.5239], + dtype=np.float32) + + def __call__(self, img): + + # Reflectance % to reflectance units + img[:, :, self.reflectance_indices] = \ + img[:, :, self.reflectance_indices] * 0.01 + + # Brightness temp scaled to (0,1) range + img[:, :, self.emissive_indices] = \ + (img[:, :, self.emissive_indices] - self.emissive_mins) / \ + (self.emissive_maxs - self.emissive_mins) + + return img + +# ------------------------------------------------------------------------ +# AbiToaTransform +# ------------------------------------------------------------------------ +class AbiToaTransform: + """ + torchvision transform which transforms the input imagery into + addition to generating a MiM mask + """ + + def __init__(self, img_size): + + self.transform_img = \ + T.Compose([ + ConvertABIToReflectanceBT(), + MinMaxEmissiveScaleReflectance(), + T.ToTensor(), + T.Resize((img_size, img_size)), + ]) + + def __call__(self, img): + + img = self.transform_img(img) + + return img + +``` From b129f5de23ab9844bc43b320cc64b8f9a057197c Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Mon, 18 Nov 2024 14:06:06 -0500 Subject: [PATCH 43/50] Add files via upload --- docs/static/modis_toa_bands.png | Bin 0 -> 126698 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/static/modis_toa_bands.png diff --git a/docs/static/modis_toa_bands.png b/docs/static/modis_toa_bands.png new file mode 100644 index 0000000000000000000000000000000000000000..cee5f717109c082da0e8b36efb601d4b6330eeb6 GIT binary patch literal 126698 zcmeFZg;!foyZ4QR5Q>h77Br41xj%X z_N4cH?&mz~oZnyYt~Xg(vy++3zGmjyGn4E4*@@H9QpUrk#703u!BbUH&_zK(uR=jV zLjgWPev%R(OM^^My>*r4P#UJ5?IGVl?2J_HH8oM#k;gz33{)Z%^uI-rPZU&26pViz zqoAmvQvKg!T~yZpDuafC661sd_^&drkm=t?D)NQ=_J5`5#i;*XV=>x)N~2d5qyOg^ zSq<_5sn-udCRndkjJ;7%NSXe=P*rsqk5N!$P*fFU_5D$Q7hrXV>Rmi`(3M3HMP<;9 z>PM$S>1|bZ&O1o`eJlK#P!}1^tgi!yZtPKQWy$jQLNw z0JLNoVAU+>AM-wTq5((Qls%iog4 z93UWS8;6v=!mbPUbLv8kG5u z*+A46%m3JN8ADnSnzLbWbd|zCHUv3@PyTU?{{JET|N0PC{80qDcWy+Vk6S$OYw~>| z>A4O((fS9sY*j3-sX71S2NOT++AVZDdvg#~NTLJ3>b)x8&N68*;Y$g`_}@OnTME>W zzCUMp^`P=pDoS-}QRON1_CNa?8oFXJi=hrC;`Ac85%v%mxb;qXfAr=mM(Vsoa8X}x z8=fBMbvnvYDKIS|VCMVXZjZ|&V7!cU>FJg9_4?cDf~n0zkFcOzyDa06f6R`MMxLh^ z-3@Be?iBc~HT3bZ^L+&Vo%Z%<9~seUzjA5%zc=^1(7VC*<<`?GGBPh&~y@UxG0Le)B0#4yzil z+ts6BDa7(pZHKhc%aj-gSI_yJ)0F7$@2~p=o#uXP0hM7Z_3g{-TrCs)ZbxsI z%3&Gj@W%(?kn7JhT4A><@Hus!o&|@*3W7<=s~-WJVRt9P^R;3L&QzYfNG@vkG2kN|?Y1puK zyLQ!FlmEDr>(by{;PbWm;r=L$07u{A5wYa`o#wg^ll@@*v#z@^N%PH4p5aj9&K0_{ z08iD#liu9G{c6ekdXEs7wpHI1gD|9_%r2RY-KS$?%r&Ms?W4VH|gwEc_TMc50vVX*eCJ znBRbvX+qxEMcR+Q@Ly~Uy{KJ$ybXKgA^WtMEDlaQ`7sVh!{JPAOxnTfzG+`^&pVI} z3)@T*R%*eP5B;jjQlJn0DYmql0g&geU2?Z=4sg)h-!D)N zjQTV9E&Ew%ukQ~m9%~B29&W~3<+1h{bVc?f;69B>KI675$ySZ&oC==`g!Qv=;L=&ib@dD#bf=M(oH60 zqVp2_HQOl#ethvY2oU-f5W?#;s4xdEz3co{not3IxM;+xbem9549Ic4*rA#hoY&ZU ze&j!FTPrWo`3Yp?SQ6zGwRTo`<-byVAG)V*p_UUNTk%cB9(Cqxh9sFK%e z^ppX*EfY}9GR?R70w?3ny`4T|`hcZ9cca3W%B}U~z3v@8fEf#Qx!Cx(KSfTq!0ucM zpLX~8oO%nz&xTKbauchI${g^PCKCxhJB0=#Yh@ztL+Bsf!XJB6%nll1p+zn|8OL9E zLT5D%G-Y!h&MT$6x&*K1xN~kdRFfqyzqO8Yf4X)N&`Nm{f|xJ56t(Is`eNh~X>7el z$vP`6wBjl-jjvQOeS|Dpr@$F53{@l92O<`wj6+C6^ZOn0M(fw}+ zck4!z4Z?{?73oc*zk3SQXf1W=rgzT2D@JBE15bhSv^6je;*)49_g~pZJy+&-d7R4o z;6}J@wTeV52dFPbN#BEv_YJT33_5{Cs)l@RohK(KwXr(+OL>;wkns?f)v^~~C;%-z zTt+lz>6Y(HL+hMc*E!N96P{8NFF!!{EX+gle$BQVWF^&l9{+R z5fV}!JcWne9;SDNyva=2`19%L&thw4x9!dhmw`}6cG;IFyl$l-SF6GsJga#6m$&X! z+CBJ77GXU&l}CX~pZ2qV`k|u{GFGEzJfuC`?MmOS$Lz%6%N`R))^YY;|8%Nv`|8|X z5JaBy=i@;`>i{-K*?0TAdcGne&z!$5dxZOgMfygSMy6}XcAUDg4pA*oD*BnC5Ebf8 z?$G*WwRhF*>B`6zB^#5%d<%n{D+6yO#;oOwg^4&XlqZM>w#xjpUgYvqvEl)fgnkcv zf^;y_Y2V9NnvKEHR6a2Bzx zRQa^7`0MG~hL2+_M3F6Zd!5+^W6yoR^&8$8LlxNK7bzgy_-7-3w;Yd?SJByJYdjbSkAL{{Bh)Z;Nu!g7>B?aB zp=X5&KA7N)+iLi9=mFySURb~u7-;QYL_=`gWZeQeVaOvPB9R_gkZ@k!~ zdF*^_A8q2_;odEJ#v-z=Cv20oy4PFxR#AQO$OGLZV00Rbw7BANU|Q_@|#V{4`x^0 zKX1_vA<{z_HtXy*L|zXu)Pby5hNs^YUQy`fG_C-)x1n?8U$oObzcACn3=fwyrdMN> zwpVNm$4h>saaxyHFdT#Wxe^JF;Q+2kSGl^-lLQM}IOBfr#aENvQ?Q9!n{%F9`zQ?S zS@a_nsuJzpC6IGKobT(ovc>fPnM5Ps>k$v1p4G;6q4Evo>C#OT0FnglOfCwJf-46MGf;vv6vYX7K6?x~FQ;LR zg+5~IK_F9FvC2St|;GNNw(DU~<0oM>|Z zrV2Rd6*1H37kV(SN$omHZ5B*StQ1A0i1p8_Y#yD@YhS_7>DpWniUk^2TX52~G*L2` zLuS8-Jk^%Tv6}(D7y6NW_miq~410}rsGYcVFLes!lBp_MMjSP>kCj&gS5Q!f^4(3j zLA&$I!`6ANLM3$0QLv$8ffkE(Uq4*||2`UfdR+Y=tBYc#u1&{>W6@O&42c3UM>KoO z$dbb+Y2j)tHqF9^H3HKLuWT%L3dnJRwmNA}(0fXeSdEomPH%kQIgxpvOO8cC?f7{o z8+V!N2lH?HD7#(TRKDnEn|i5E(V#g;+x;laKx0qTQf;5hS;0=scWN=A#~dIp^j&tE z%J)o0OOR4GDO**QX*1{_10z~=zWC%kFI1*tO}P@QCT;L;{I$otFwDw#m8FXIV<90X)PRW}J_zk+8>zsaQ1)jzAn zvIbbli`g^-BXlCR$@2)mty4J(AVQD1*RdPf=DeA%-%07CK3xNE^L?#-UIJlyUXG(o z^2lnc0Q|cB6Kf3nG!ut_RZ)cjr6g7ndqcHvM(mx1EcBPK<;zp=_Qsh^m3YEEht=c{R;994&jh;^r%Ng8at48v|7Mn#z$?lN_m z?OO%~0cM>_n!9yObNt{|W2-bD)0e<1yrNG9;c8%VIXC&wYO%m4x=Ff8@A~sc<087L z`_m)x@5;kJB7e6BQchdSlu@UG6=rfX(eofOPq4&Lw|#J`-50Q;(^WH)D@SqMh*sP) zj^tOZj=P2@*iLKvP-2~?<9wUQdaPk^r@p1f!MF&M9pdt8wM-CW7;nDaw9;0m9st|BvOgBT(X({ zWg7XNrVdZ(Z)5zFC_!G!zL83%U9LAn5aa?U~w z27PSkxrG~!HFIns=1|PTxCqw#gb>b;ac9g|h~kq38Mfj%>OtJvkeMs@PlxSND0D{6 z16B3!98D&^0K2U1nLtMCf*u|$`LE^FMeBsrWEQi$?8UyP#n2FuRHqMN&)rPIWdQmR zt@>DJj7QmWl14#hubyk`Y+t+S0{_9tZTu`^u<}u}) zZ8cNlHI*WD+ERR=##<)(elMQQ7e+Hr`oLh5V;p)cwPTKLf1iby$^jJH@l?Sj0R3fs z)t{I*PqsxGBqr#L4(S}@7zGCe;-cA$y6`Gj$Wt`jJIKqDUdQOV)(f%rFEy*WC&0P$TTpB3`8)VihceI{cXAtTlxyqGGQ)YfvP43LzgYWf^xZ@R+ zA~EC23&s!Zqs*YkI1d0sJHqM9y(!_rUCjNac&@LO^d>pb7H}-zGz!0$Js#&nom#2a z)DhMG?(3>MxtE`#vk!~o{uY;bCZM{s@Ot-Wx~)d3^c)z{Y*B<3 zkVC{tA+Wt!R!_^KcN}0IJVWmH77Z0d>s*i4f1G!ja+J@vb>~WF^J?{o!h-*<9{Lt) zacm$!H+MF-M0>-KYoPN}+jb!ON-xx9jV}SkY)bitA8EIqCq~LEht4uAg}QFMH)099Oeaj7pS;xRNeZJ%uE|Vx<({ zj`ECPPO4~X4pz-J%ee7A`1Xg#<7>YXaV2>-JPUTE!nnRUO=eYLi_tI!BljMrB z3%LAV(RFh+M56DTjoLT<0Mq;qFPY7snaVp%i&f)unh6Ke6tBrU)oX-JBQs{8djMV| z1Vd8y9UsVv_C4pA9ZCc_?Rdlh@u#gKrw=_1yz_uO-uVFu6lk0qzrcv8-fKZUg|IMk zoF}e))uMWbWy$5tcp=2EZD_4axiGNftKlXbVxh@4fN$XFKE)jvbOJVlF3W29`SpOV z$J>i0xoO=XZVI|N;E0SgpI#stGPF)U;)|{^rfR#^RQt9l<}#7>m5yB+%epL(l-)7?tICQ=!T3#!jiiy9}pbgAIKN@>asmJ9;in~ z>J%h^1SXk|g};v00*wztiC?SQaGDJ9KK2W|OPΜznl68LOw#n0#?#OTNXb`cjIm zMg@=~WypdqJ zz#dMsuAp%dk7dM5h79AutG-(L!an{2qR!RS6QA?jvDH{QieFMAfd{z0k$=2$dY>629uZ;cW?r;ENw3a*7)S2m=J1d!n0b?ePSD=t; zVm_J^ZUD6tSHb`s+}tt-;T zQK?69_y<+MSlj4zZGKYhLw7bf>?}%zf&?jF;bS-S+kGw8ayZiF9SA1SlV(X4G)lJHmsxkFe$(1%$tFjH*8ge+-x#~IVgt577HK7GNHUTGvE$}9DfL07e|w_ z!iCo&Cl|_7(5PWmQyJ)F5}szoUeqsO^(Jyi7|ka-{U-CN?j**J$)6R64A!Q4z#yrE zCN_HpH$R!uFUU<>=M(qRS}D0A*?!&JeL73QcjU(<>>2wuPI!{k1`lzmU|g}JM8%G3!|#5xKhwo*Q*kTx@Ydq zmLXj#B;4B`LuMpVpjs#^|99PTM$<_nvo^=}QERr&(qiJrXi$QVMgR~V%mKyJb2pay z>Z{2poL}Km##h-yG?B&C34K8rLK+&#YRkv?BOWV(CZmP4YBM?8uX%;k zET@-pGGt|fN~}0|f&wHP+zVwtgDG#tN5gb)pd-g`-wkEH@gDSrgTS7{SLtwnW0!M z1EH@|!8&|&Z#hRao5Kx4%^yCWH^UZJ_`~wAsL{^5Dnf_ZGlIVwZ9t$IsX%N}qv?Jb z6`Ra9t=q#63wtl86<{eSl4?ww@A&ry&ZuBvCKxLqwEv-hMy|6@MdloW|L9-oWk-r? zYy%ce*;~zn{I2-fAJH4D6PX~Rn!z+gEq&1>L(HNzv1t3ER$7jCPJ}VcWTHK9LeH3q z%wx%-Yuo4bv)_Ijq01C-=!qFeei_4p?6%((MDoNOJHMfm$*_vgfI3H;jmCW$#HB|K>5Y^?nxYSxP>SS4#O z)uMHlzEv3(;8ds)Gf?u0Q9*9l>{%WCZ1MZ48KQ1lNwb_-NI49679eM!CSQ zXrXv5#}%tB)!MpS$3k`5U9+*N5f5M!t0Ek~Zc^J}sXY47nTJQ7%UzxNZe zQ{aX!QJ}UOxt8LUEYgo8X>`q8RyP1FWH}lfZtzY#OzC89iK>%+`OSOMx+(V4jfKh> zf9$XoQLQA9r&PWh&U@^vv=#fJVWfh9L}7qQ67kvl;$fCee%e|DgiD3&1Gdq}%N?az`#Ltlj_l?~ct0c5q}Eu%(~^{0a%!wTm2J6T(vZY`J)cf{j~Zp7tS5*u{%No)CR{ z=#!us*^@zn60@HzoF$}IL~C{2=kEdKYnHS{3(X(nUk;cKUCCIo=umjlf!LqMCI;o~ zUZbN=dM;!>b&PEaf6#=Lm!nN`Ni@2l4jkIJbT=DEtLMNbI^p zyR#)m7=uAXFh0f=qIVeUVt0ekEYRnf8^ZfOj2lRd>ax(g7&{PW!q698O3x^0Rb2ns zP-rBGa?jOaKoVr4%lf$N(pVte);^Up?^9qyVO{8E^zD&&j+D*LeCoTP$zVIl*BkZ$ zk8Im?htMo1TMnv`vGMm_Q)`;P8y(RN8WL{muWy^5D&3e1#kE2-D@!s z?7;Sqz*!D*6)+krn48Qge)Fpd5YNS+vOBHu^j_5NI?RlrOv)xTluCZX#F<=g+i8f=VCc(A-Cl1b)}C~^6y$& z2m}N4dz0G-Qai3kpqsWoX#0X)a3(Gw!XB@G{G@&~nE1<(CwR z>CFDucGu*Su=B8?#Zgt}e1r%`F!?RHa=+@WVeZWL7(@PkCRov0`g>^j?h+qrMROEj z+5s)gLvc`X$XQQk>-PKGSNf+R8JKIXA*D@eUh8~L+VnfnX8e3TKfS`%GQH$>dIo|+ z6S$%s-qy&a%#Ug6D$PM(zSha+Bo2!%!_NJ>6BC%Gzrkg2nZ@e@zk1@3Ws(%Gqnc(7 zQD{qx55euwer{Jn+k~gj@6728l`h=t;2mThQBQZ63LNwO#YCr?5!Xu(R$~|FnhcKG8cZ|ClS5~{_`0t z&uiwHY#pbLGFX3h&T2{t>L@VFX~mCPl4N}$|LUdov#2n~mOjOc^>>yrm&43hSC6u{ zv0=$zh5bb|4sgt9jPLl9EQlzry~s7=dZIfvs<7X?EZoUwy`7fW4-yHxY3{eiT{~%T z$FUi&2r_%k^|wNJMNeNVtvnZe0MRZp)Z*=brnMx7T!oZ|Wrb$SVd8ObLWZ!HpVuPh z$ZZ<5!VE0d#oRzH*vquJj>~KzZy(e?4cTViIl~+sjoU0G)#g~&lDP_sWn-aLpKj!#9O94lXS~!FYhY4-Sf*B$9|qAT!(go z`$J`GS4}F`Gs2;%bg;!}_H$&o6f1oor!2vC^1!wH^Cpnx)7aY&&GcT<_pzB&#Hl|9 zVy|>t4KkJCHU^o8f<|-zf;tGR#kW3rOHYHTFNtr@Io1;R!kaZWwrz;)HVL!@jmJu~ z7Sc~3QffEbolne7zNztj)8MxL0T5WjqQ=!Y*&H;?Y{GjejWfa$D9?d^_Cv!=is}}I z6LYq*$1{<^Awjg|I8@*^Cmv+5ZpxW4XJZIO3c3)cHj>ckMc*K$Y+&`t*CQOnAC?@2-CdNN0FFJNXLtFCk_b4(xLrs9T!c#qz0A7cIG8}J9 zjgcHzzA$zMr>nt)A@%cJJv2SsM2o%^}c%gUGy|h0FG5fF|3ftOy=IWfe-epB^eav#3c$^X zV%gjVPL)U%-8|zNB1Oi=?d1KR|SwgsAOn{lER| zUTR}k{U%eKNkN#a+Z=8xg!}^nNY05in3*$wDG+)-tBe_RU^@*@M`Nb}6tTM%@qT}q zjQxK*?!S%UjR$r=AP(MNw{8UKBhTT8^B1`o#NIz{OJ`;KU;N<^5RG$Tl7F1jrmVew zF_Bia-hZ(1|7p^HpJ5atquo%f#mspd!YQ=QQs{5}5vgv^W$0-^+t&gQTKk_+mF-m) z^}>S~9BJ%dCx)m));}5+2LML&AMsvqwY7028QLs zG+{sBo+VMFYJd5LSC$bNa~Nc%srE=XsTFBig+pP$&{=-)>F8c*0=HTil72B6qnxBc z5=QYyPQE8!$SRLQuRiS|!6?ll#6l%PKcc;BlsT`H;O?*7Dz%jP0okl_n-s~fa092F zz`^aG-yMoH!;o~uoagZK?9hj^BJJi|463sEWb>fI7c}Zo1wX{TF*|%UcF;sZv!7ya zi`+l%W!OzTD++rEfUEx%kNhU6k(`&phlCBrozhJ3D>k>5Nuj;#%@mrc(x6_>p-O=% zk|4-LkI4}6*e9eyPYi!Rc9#~i z>$I2cvd!kK6S%$_`7&NoqY+4+>xdzKy+@)Ts~JdOs^ccV`RgkeyZ~HU|6fRsEL}_T zV&Tp3bHB2`v=b5lvEl0btL>?0oB0~Eudv<$FD!r97irH*BN4YZm){*KIU2j?cK3LY z+NKlIX!WCj>7Wdz?gn?cQA6OuCdo=l$Q$kACmPKQ0{xwXzJWnyiFx*_HKYJ8+xus$$DHY?-SNXqy$wl?v}L$N!a4+2o~_O& zVb!{Bo{ypJYVI>A--jZe98!0?YWIvmPOTb0Bay9xZ7O-O-*#7C5kqx`0u#LQ>MNV# zd{R=#s7g{}?-x>&^U-O^#B8RM0t%Wg-vKNZedb~?QhUgItVk?gQ(mu>zON4R@PEET zq^Eya3jmwxGJwng&#sITp z0DF(3ikyqCWs-1H3<5MH4j2f1 zw)+A=Ue#)pz_gczVe@yOMNdfI(A|yQU z@&3vXNlCJ>n_y97UhPH2d{fhZffQ1~<6Ir4b{x75uI6rSi^0hbg&hVJ*cfW6_H>(S zPlkN|%+tUo*{ddAL48s?zJH|83Ub`FX?ot#ZF%=Aw(nxe;s{QGp`wZeKT|3jkrJPs z*RXfXT{S6^4uhox#E8~BheoMKmBt4<7d>-ZTq84hLt|5yAwU|eJo@xZ!iG0wGmfQj zWY3cbi2F2RW1A%URRT5a2uaH}6M!rbbJ>XQYVtMdyA6Vn2E~C#5Xi>f1XDD*hrPJ8 zyi76}IjQ_v)+X3wvMP4M$TW~`XlZ5|Pzx7?%vTnLz8Vclwnsa<=|%R+u8TePZzmgB z8N0|`$yvD$hB_uow2@)Bzp)|)fq>og(JFpXN!c{t@H2DniI-i@+Qz(kKs?LI{YxW; zj6B|82BzZV7ZM*!dX0izdvA6^Y9g&Q??3j+`HZnu>f5`o?G^?O;P7;(j{9G4#F%jB zIaOGE#^$IJCbSHFVMz8kgn%*y9(^F%BrH~U|g zj*J@rD$I>X-Dgv7XB5PFQpoM z=^Fi+4V^#ZNnvw{p4Q>N((9jtyT1VS{Ygq#ox>=M4Ts-Ku+nqDh=aPLI;_<;nI@tS z1$0fLED@gg&dw3Y3yqz~SFXHqe8nowvW|-?9f=lELVJwll^MTdyV8?S)YLZY6YKRn zW9ATG(cbx#JuxhR`HP;G5S1V|HmDsrS=sh-gz`j?ip_3kTl^uWk4OP^1D%=pVUz{! zlJtXW{w{gdov(Kb{3`y=8KYpMbm-R#B$q_@on2uH_5Jl<<|yRA1b!OaO#q>F<2WrW zx}D76hrdt%%NrdcS9a=iR65L^5@JFTY{YK|>6M&GPSm*+B=ZU3k3YibuOkwvkw#nc z`D)D4gIr#&xLPNqyQaASi@fvB4wgW<3*@Xky&?yFcjS=kMWCWcOP7;V;kQeTrgyRi zphV+HxTqQvX#?nQ+w`zcR)O3~I()rMZnbehXZv24&^W}hnm0duC_nQ^ zBfPm{7bIwhoOj-QAwmrVVlODf(1dnoHz9Flv8;2mH%VX)Qvv2%!CDXv$5`&{B`1CiOF__|uI+NEU4YRi#D1;h^ZpiCpCT#x z=d-_@Z`{dr@O64u?fC}7I#roYdD3FFevJeYd%GBS3(IShF`+ICCBBC!7G)Zmf9D}Q zj=Llvcs)WF!)P*k@h0+=ug_jKhSuM}OKQ9YPk>RUT{r)E6MxxBaQUj=AqX z%O%PC7C|W$1b7vxv8VT4;qYd}MJ}r{@7UOwY)u5({LNx?SJJ)RnFd;E>r_dC|cNY%O*PF0_OPSbqMJS-4HXSP~H0j{NL&F?e zX41MhmVvV7zBTVWkwg~rebvlwH4~kb@EB{L5hMZWQEWPYV}d$rA1IM6c0BpZga2rV zvrB8=!_qA>9#d^I^g)f-LSv7&gkiN5_EGzaI_UQXEZfK$iziFs`tTrNg6CSiMq)n_ z%I@~c=>h>_h&X5!MF>4CZgGXI^HL3JC!tsehYe9CxF6o^Z(krhOcu|NaKCz~Zxm>L z*X47F==$*Wouxnh5W5Cv*HF%i!bgHfeZ+^Mz&R&rfYZR2zDvn-uj80uhfJYKa{5QV zQ|aSAbj_65*3np$d#J}}zb|2}T8Vn59+c8!-MKiU>a>Cr(N5?9p;9g)%LYb&wB-!8 zz3yP-!d$UUKNS4Kt+T>YXG!Gmtq)UIiy^h+!P}z2Xxn_r3vqnd>GlcXhuP%mFC3uO zQ@bW>qjfl^KU}eM<3%A?W}aW3dcT$*+WUy3avyN==@ZCto8)7yyW~r%98#Y*Xk`mn z%*h8DoV@k2hlI#Gv3P`>EqJR+)3v3(ujr4e4A`#hE4e3}dPJ%c5}PRDDfz!Q8_3U6 zI9Hn^l-ZZ6BJzEK1qxSmgM$HM)=z@hv}6ou2?6iZEPn?uAL&1_p-0f|DSRP`7)7pD zdwb=)3JV&ip?|!K^uW^W{uoP0o{KPEb@xUS(kJs=Z5taN6Ljq|%t>$C2g(@Zz%bmD z;^Sjw7xWb1JHtEPHds(D1*OBmOC~kSyey~Q_2)6$!jYb;3bWB{q^c@%GTc}@;kP#o zlr2>S;bR>&0xZ{D3?J|zjK#Y66XZE`=N#68M-H`xA@OrpbugCxOdT(sM`WCw4ITs1 zUPh9Lne!rq^NuEMTWbYlsk=?T7|QhI7@7Fd-{Ma;#PzOp{Vcz^k#FeWd+t>y=CjFx!C}Uh zVqHGZXXro;CmKOV0AXLN(!!QDV^QYZ8@U@KDsmnZ?({7`9_?I2nFf=adJMk{KV8jsN9Zx9iIsZ$ ztKaseYCI`9R92^>pm zw}zu{#CO~$ggetMKjK@ZttjN=co8uFY88FRd9UC+e6DDt8v@fZ8(vrh+hq9scm_Mo zZ0y`?G!|+Nap)y;BWy7xWX`0A($yTYn<*ni0Xra@dIaO`%iOtvdC~oqpHvB56|sDj zX?vgMHbrg-XUMPPkICbInT{yGnize2tH%f@bVN`1c|LeWJyKX^- z_C6JMF{dfI2+4l+G=djS+lAG3g@`WeR?A%TG&bYzB>vC@?Hw@~-A+t1w^#P&E72l; zb6v6>XcHwo(vLEQ1Z^J}<}?4W#WEwi&&XV;8p4aK)02NKDMi@l2iPEH#)Jt8GvxK+~ z_h3AVfBori{DL-)*D2Tjs>7=ED`Y$f$B&IhpI{mFp~Z4>D}nI|)Pb!N=OG$&v4RXE ztj6FY5i@4V)rrD;pnx6=M4pcdxy5S1NxYEQK6(l^>JR&glhnwoK^gfpua_X&a{oB0 z_0aW)cE**gQTxd3pB6@|Bz~vbvd?w1$@{jorGnX38nRIH zyO-1hB#AVM^isCG@0^FPdy-k?t{v_avC2cg?cJYrWJSgoizI3%j;~|K@l<8g73qd_ zoEj6k`w(D1iG46igXH^qVvcotN__;*bkGj{t`JQKkY8}8=2=PJAzQTpYpFKT{@TSJ zDLdFEWO^!#L$^b_h}oZYsYNx|2<=2=J+DeJHs7Yt-N_9;nIs-!huH7PwHa5m6yx5q+;u=`^R4S~nDtAs)+362(ON%Vn>vXX zPT_4{GBr-cW2)_T@`h3~qNL zaK}}o`XOYH(b=vzI16D5t?*tZ>6ZmPTQai2BXBKsN%vCVRs3eH2zEAC10UPv=DsNB@VMvzsB_Dc-wRqE9V!VA^A8 zABk!TJ!oMEhp%a`6bj!dq9icKo>V)z&--&Q$s^-HV^eJv{DRc{WUVd^>||fa4%0kM zv0WPoL8&Jh;Xwclg`4;^$^$N7s4cC6t7(n$icwD)>iz$%7B zfp_GJbD{gf%92;L50nyZD(g5HFf@#3$+Z$g=d6;9%Cu zhgek*vCPDht=EL4BUgEGM3ZL?`IrU`v-OO16AzSmpc2r;6GO4_;pILy&S{`{R_`!iJw6qolT9Mo%I+(%ivBN&-LpX zy0%39ZW<8BKYMo;LR~V=Fw;CB29moO7U%Olu1n+9jE)tPG!F{YM^2Htm{xqbzzlRg z^mMrD-kIvEBui{%EE&YMD`-{miORTK`fWs{yFmgk^mwbi!hB;!7X44tEpu$EwuC|MfKV+)MgQ* z-&n3n(e;m>SZyqQ5*#7n?uOP@*Y_B*uuwXz9o$n+etcSpd)Ee`v2yV=`91=+R17k(_Ti9pe%(6Blb zbr3hYb1J5_A};$%DoLzQdD6tzn9!Cm?55GYQVhR*F=FEAjkE@vTaw?x**09Y3-M%Y z3ETBPfW3CF%GcCf9<^*;9cX@$sk6)x)PGvvCl?PGLML&!&X8@*JYC6{CO_D(r0DtJU{Pd4Au99;9zm zWf>B~`FI0X(B?nxR6g zeG}CW!cab8(Jk?-9JVSC9QnMT(}3)FH(JhLDZ4LVGTJ;>FE(YFy8{Bd$`hR&C6m0q zkwyr)5?k33J0kCv7lx~+?|uj?!XgRT*NnvaKYYDqP#j^~rj1L2ySux)ySoL4!Civ8 z1Pc;;aJS$N!6mpPNYEg`2{2f2+2;9bcdMRv>#O`FquqB;-{)~1XP98OC`4iTQK*p? z)#x(;$auvni#-SGaF#oaw!+;K+p8`bIqaUuiw9x$R*c(*vm$4_^1zlE?}mlfV&ygx zTkk{@*r!L=TOYciQ$o}?Lam7(a9WZ6atj3TxZv=DteJh=qsZI+fJSSHkYPS%|MFVH zy%VRf;*V`NoRZ7!nw)gsIrZg?F0LS|rW++{bcegn>hZC5ol|7r*5wJQf}1N$6iXXN zi(^D36nADL31}Z*no1XM^;%;-3x>=%(eH|`w8=3cuTQa8sW=4G1%s-CS)HT#qzJ!) zf~u)OW0zuubZ+fwu1dI@8KJHWbKXd4w(&;RFbdy$OPC70M>8nRomGrRj2;)il4wKS zi?$KfmQLtxc?#MbpKgW+o0tC*%o7{uUitIMmMB6mtKo2M0<1-Q0Q$>#)4^+YJV79# zZd;82a=W_vI0!C&U`{BJJ)b&iah>3A?wNoQ@%z?Rz}ct#>RerM?>)jaVTHbJN((x9 zCMB$&I;h{9O;ZX^@Il1y#Wr%|%!r-hSsrEl99ml%XeDlX&iqJ(??-3dNM9dwqqwrm z-j2NU?Z(9Vi7mEAf82EIpDLnOS6V_@rPmOld`F$$% z5hL%KL(iXD_#ZluL(@Od>~X1No!oMdv``zF)T;dW7a0FZ#HSFBz2=sOR<(C}D%ex# zpT$cn?n+=@r_t@+Fu!`5i_&ahtdRZdrWz#0H72!A66#a|NU|g^C)$l*QZw z0z*IGTIEAyg8;;FHUg`oamga6(8Wy3$IL=ph(H0gZVxl6^r_a<2>GK$+%ro0NU~!1 zbH5WWbw#s!S?$#BW{V^@W{t|u@t~z&Uu~3iL(8ax-|ylZKS7Rjjzyc}gT9rJCUHx0 zBRH}2(P5kN)0r`C`rbyc9oU!;y&l~;AD#hJqRM*mNTsfcce-HWmA)zF-7=XdKcRkji@0Gk)oz9$3hyNFNl4Oq= zY;^pcdqQ-ZN3W8MgmG5Srd#0VcmZyT_lonYO2kI=hr;Re{9Q`%ps{dl-L`jYgGic{ z`S7r+CKzLy6oqh%$OBqaLh%?mJtYlLMwo*=tFaTZ=XgVPJgYg*7d!EtvNCnc6)mJ6 zFp}d$#q7nunaQt)&iIKFwD!aW2~BcY%;_20)6OPIK+z#toRlcNGK}j{8NzAhht0)5 z+Xx;6-|T@x%zKlLB_1tnq{2Y^Q-Y+{v02{_8SW=++n9iO;jtzpU5ClqQA8U&tyGKO4V|MB9Sti-<$a zKq3>*$$t^aRSlN}oA#}w^3#XHhciN|6va-EDJ`o{i@vu<75w>CA4tP4hYC%yKr?WD+L zcJqw?ooW84?_}olmNGQ6f6Y1Dam@rl=C0?Z@^3Xv%hhB~L zC-y|aBHPhQ!78Mj6>!>lAeT>q*fxG;S#;Jsi#?{UqScJ-OA}9EG|O*Ow|l~e!l|wl zx2ftfX_gzGw`A#bT1DjjkjjU>8SeTlo5pYX_QKh21+iG7kov*-#3kzo{uM%(&nlG{ z62f;Y+YlL@(aYyY96RLGiJF7cdXh^Jg1k|GDbePh+O7GegGx`1KCru16C}budRhKW z)28d=A|bb!ieSRgM{KJp*^B7fTl5J^2fF>>1XmNnCM7aKAEm2}Tq-UFsZ|D?is2qFbBdRaYLlP&tn5rw62 z*y^R-s-3p~ZuLHruJT;x{stJbgueNX&i}V@$2}G*P5@35XN%!(Vr*~+>x=J^92}K` z7Bx#U!T;uY{tx;w6br@NW?q>?ehrzx}r2 z-~NmLnAZ;wUwK__k*WW;P-_Gi2G41Ba|wnuvHCVKlavHzJ3>gHo66^ZATub?&@dF3 zB(ue-=-X!<*4=Zdb}yKF41uo z-*Bii=|cM}$XT`Z0s}zIjKIL0AQIvredLCT$hyi0EIBU0>6L2)lIF*pTC@38`ysE7 zn;(I^wBl`})g{V4z)r{NYFR99@o6O7FvB zec}SOeCzsK_;v(j433k*=8@(V&LsYaMJ0xrYUseSv^IBtP*5OX3g~12+s%Xa!xp0W z@<9fm3K+FtGVxKxH+GZ!Px9vR46FodZ%UG9qn9_51MrXt&jCK4tPE5Cqm~6NL`PiU7|ZobJ-Om+^53mH*CWt{ ziRlX5u6xeEg=KIEfD#B)@K>o2RUOPhISs_kO2;cZZ$6>m`$@BMfbqCJ0@N3tD2PKR zJkVEwUZ=t}aEDlo>_?Q0$a{alN0k3&MJWY<9gd*O)B=*!of9B~FR-)a-|z)}1B5eJ z&wGHk>9eVqK_Y!YpvNj;SeU05yNLY=04=D>SvzH4l-W9INCA&gY)t9Y-xl5nk<;2( z0EX#p0l0<=`-;4_z02WP?0LX)1I7cSAGt38=~D&)-sRB*bG=H7*BRxXBjE4zuZ9&} zso!F+QUExb9PQ9I^`our+|NFW7JstvhXia2Z{gdD30;m+W1k)YkEZYja;yTcW4^ub z`83h`OF`Ro;FO3sFa{>T-t2UaBdM>d$p7}o6$s*|2v(uQ+RW-IgI4(Ls7G3G^t*Nz z=&C1fSUsNr9^l~^AYeQ}-^;<4?`E}4-x6i5H>*>=ORCjBK&Vvx0DSvKzXPwP7vG?l zCsn^&V0yZktGq@CNNB2o!)ddArPLUY|M&p-Le*O*n5uXE+aAT}>;lNJ?bd$%BtV!Q z3P?iq2Nk`<8TT}gwskUl^z(}FNkc@YIDjXi2dwlMZ_NlpPCD#O=elQpMox_An*l}uqt((g z&Ve@CS0G#0e*@8QK{brF&)JNRPaE)f28Fb)Plu{-e1Hn;bwm8&XVMdVmbxALyb8DK zKLB7yJuFiVJGfo8RG8@-B@6If^#K%Hxq9NAfbvBIeRd5v430CeT(Pq~#agWswN-g_ zt)-l2@ae<)H82&VdpOUCNnrZ!zO#P?ID+zrarNLoc|vdtFBi?Yu;c(HVv}<`fJk0L z1{`H^1M@AOe&#K>SugL2s0C^IS-Vb}OiVy@Mcy!9Yp*-{8vy2P-=_mO_^xi7a2F@^ z2CjJXmfv}_0-_-Q-shV&_3`xDHviRKJPln+)nQc_rtoDz>}9wT=Vr~k^{s60?%{8} zKKbMFC>NQ^<<6%Wft~oLjiLLQ7TMNu;H;p=PmpK_kfB{$GVf)J`&9!$Nr^B&)uaV0IU|AR4brck?Wyk&Ajwt zTdg8ipYF%M?j}9^nL~5#K>XEDUHoDgdvaF*!U03yX3p%Ok0@8;|G2!yf0O5zMMXb?vWK$a%r*(`chBeIb?c zr3u)Il8%W^cP9o&-5 z_{dR0<+mtuUz}=R1C}tpK9};$pgOMrnDCM;pG0uz>M3M1;h*$Ci~dktcb4}4O@dS_ z&84SV$ThHZ?sFZ-iToq4Q3?mfCvYJcfO~e;NoB6K#-^D-Lsv6a!qezZcwa&r zKGQy(H`Q7&s@PW=7Cs(!(WmpFw;Y}YukZ_JW`Woe6(t4%8*oWY`8W2HhFhL^dNkq4 zc01>6JWEj%)8VK!B{L(pQ*S_L!zV1hBNA=A;SrmiK1b>x&lD2Gc*;7D56KgvV9> zJar!xWFeGcs|iqw0w}=2`6z=6`2l#>&Y+L?wmJK@r|? zVnz!NVnH}7RFB8|7rkTtmvem&_2!;BxnLOz5T)tAv4RgcfZlDgD~TL`N`>F-fQ(yI zy`>M(x%?jO@D6$bZhUVZZ2)P>e^h>%1IWP-Ki)1mks%%$5X$r2RCT(Sb3wMC6hH0# znK$C*Ks!)dIN2BZN#6ONm@V&n>|1+!XfdU0z>QZi&9^ocvN{pO<;Z5@Ad>GnBY5Vc z>V#n#whsKygnK!mM*LB5@`w{l`exP|iLxt}*C`_$fiD5v8ho-POmv2UWo*7bq^KJO z<-KHy(9<8>hhQsfh6DI!(q{0On@$-N>yfp#8}MiT&E22jwuQE$o63jtqCUL(bp z3byF;^}OlG5^xQ+VrI&RM+o1N%tJ!JmkWi$?WTs#c=K$*HAB1ekZ)SiwZsNnl#j%2 z;qKPnk{czf0T631V*8&50KdwuCvx)+3Vy<%+(f9)R0)JhKj;mj5f*oMwR+P%b zQ=#-DEDS2e2Sulra`8AmyWXYO2Y!!GNcSQ-793claC4;cBvvSRTtDdk9Ufcz@qStQ zF}y$3hyD)L3pQZvDW%8xKbo(P{{$Oo8gf2_(r{1z6O$}te?Z@(=J0gQLuvu-7uW-e zKQ*NCg-i(%RTTmy@&~#da!GB5%q?Sekqa5N3|DC=@~cc08~?L-_Moh822BR(umC6B zk@>4>@4-iG9MplB03C(d( zC>EUqMn4)e;AhD5Gs!>%l=~Ys7nmz>SQugWK)PuLlGH9NyX}Dlbxr{)Lmo_wcyF0a zzoo8?^eNz~&EGuie!>{hNLKtz8LA<^F`&Zf`N4fo6o~_!n`{oCz?J{3RiPGkLuB@= zPduqW_@@JUJED&O!1PysBr*k@DgzLY&P{g=VtmU=RVhY^09RA-THb?o_r(@0*vPDI z$c1)}2#vI;H)*7C%z#9A1Q$n5zSB4Y*vP`gIpsLf8tn#_t(gbK4pP-ZoQOOpZNK~B zQ<+CN|6rgpk1xp4jEsephN-!|`>TdK;N$;^V{|(Y0rbZarX*(-{6q6YTJHo;5pHmP z8Yn(l8U)*%sYnz;r{YTi8yKMa`Plw#F?j6n7$I`Jzju>i_`!X2{r=g=(X5ibcEk(m zfm`%fvY>bmUDd6de*HTh3lBL{?CTy8Q29DLyKNhG7K2tr3evD-aNvv|Ub*vbRY>Y( z{^dHAVnFb*5!R-GWE4Y^w^jw4KCP-VC13n*cUh*u)C4wwJXy=PLsW`s+iGT zhbQTFAB~$n1*TEwOeW5SUU(&&!ns5xd#sq${WU-Qbg|RiUBo!{%Ga8TMe0=MVjIRn zDwdMMA$-*Dv339cgLbYhf7AMoN}vl71%iILr>r@wyCR1nh(% zn#P_9NGEU)4piY$m>jWz@!UwW4CaVRHeoxrTx6M%gQT=)s8da5P#{hE-T(=J*ysBEQ%8+dG z%#oD}^b~3K)2F_{eZ}$`+yKfu)@bsAdlXt;os<( zhK$ld<0ddOYqo?vl*U3e0FFdo(hr?jt=Jl^FqCx3Pd1iEx0zCv6Wbi;UqI z;KJYFR{YW9$gH4yFYe^oBO%G<1!0ETywIp2+RMtV`D&752IZzBKZsY;IQSsV4#FX12PY1`3)ECe z57Tw(Q^VzVNi^5iKW+)|8_`8Z+d`pqa?s6TZOcZ24nHV72`6wZRiSiKRcyh$oa=Iv9v2$gI zt<806Pi|K2ef#G&79Hm$cY<2n;@$UGhmJ9DlZ*yp;Gg&^SH@p(S0pN>xznD&-ssX$h|wA#^9!&GIX(^{XuIN$M;fkekbXH*`<5H9lwRU<*^GuP zz5Ya_T*W*s#@<$k%j(ZiIrIn-eEN)IS3Tde$BUgN0)^WPhI`oR+8VMy!$E#Edn(nz zH~Ms4$ZKvtkF;>WG#>u~fsnBjInH(yPDBehM{=+7FK0SdW! zuyh*jT=V_SIzL8n{U3ESwmZJ+-CYa-0tF8!C;2RP<%b7NT! z1rF)*T2&wT<@1S>rCWjMlJ(m{GSILow) zBI*3|7ne11S}I0udQRpxt)CUwTIc(uYw!lgo;y%j$D8t}omF|>$004qa8hYH@v%s^ zTl`fr3+m_4u;)w{HJPZ|j{Bixg$a+9*aO8*v}>^Oi&wXQT*Gxadk38OgND2zDhp=k zpeacMp7%)T-ZC#*7>p4899jb15FJ`VVIG(5)oRIS#6ioMwLLZnnQr z#L!D{c$vRgJxV?bSctu_Jz*MSTIN@_6GoahmtX$PPI{6b5(h{m^GIz*EuyAY8qQ7d zUMTbO-<_$q9idrejlS(-wVfk3QR)doF}QM)-s0j?3G-bH2|KP35!=9QDw4$Y)UIYL zI^r0HoEn;vWd3H(0*VRTw4w#F0rWp(rHkZQAHKXNK%(9IN?1+EhB|;e*Q>`KU+}|uNbw@|laH^iEFa7tnzdyUG?)`C^*~@@i)8OcE zY^b5wrpjwKgC1|rM(XEXS4*o2A&v`2U^=EyZSP&No`NO|*fmAIn0M2%?~`2-l8*)< zX-8F${l6%m`R3=5s1OF2sZ7oRj-QE?RNUF(deUbD^q5C_rMgh7Q5)6B*d{x@m%-`W zx$>(R!%Tj8$0#Lr%`o9^N>=vVlsCKHeqOT@N!Nq~+N&nQQHi!kU02hUUH3fx!E-B0 z$h7kH*g*kr^gevrNZvp;@&x+eq*hC{7in}+o+Mit|7dUyK?P%%JzH{_VO7f&G4TuItOPzrgNGzR zd!cjC2oWAlWe(hK)Tpdh5;d@So)ofW>MPpf4h}7xu1BA$K|-}Ivu4>D%;0ny8i=$W zPz*HRbnSaaV2y7blBkxg5wO@;BDXJI`#W8$okkw@`BYPe>u~{6PMzAM=ay5KiXhEW zq%`H1r5`W07P5dmrSw&OEZcmXnpPsKFL=fq9i#f!=~$po;2!2kfq!NQl1EMVS5qW= zD&$+RUUo=9%2l#1eq`T^%0CRKGWSuE7PUazn1|T$5fVa6Wt2$stVsI;xvSQzzfar+ zqk(nU$0&^tYieVfrmg%OGK>`aIj62s5fh6HZB1e3W5d3@wQ7#=Q2T1ms$M_a=OBur zO3R~8JuXB`k)%?5MidrO;#Jk}RriK)=I|=jg(?9NRkYw8A zwIXOfey5f8y{YZ6e$!E9X<3V^?A}n1cZ#xRmzu$0o$bo;X(3m`w7OuP{_u5A#Bf&o z#pWcmWwgEyxCt0gFDq>!z#F&3I`kkJMFwn1iI>r2V{r=%`c>8B(NGf;BvK6fJ$CT_ zq9JJ5{vjy-`hDh_f>}h~m#hQ3bKy|;y`Pahk=QtIOQP*zfO&kR4o$(CV zg;S8u!6|;Ql)3P-_+F(*F+7a*$`UjFzPuH?5mE`CbCmX-_bZojQ^Qrzr6C2}ZTm2~ zCe1*#aTb&-@|Jbq!n^0$;2Z9O7F`6D3Wa!n!2HnkZBwTEy?~cL{d=^uAbZWh7z5qy zB!9y%^kzR7c){;g+&P!RI~l6jK2pRt7Q;8LGP8D{S-8rL!EiE;-*U2Uw$G4kWq#%J z@EFRETX@d|@6y`$^o3vDuHG_30g(R$MGiiQ?zz@Vr09kC=;clDMRyX*1S|%3wU~WC zy_0>cxGh7CS%^BXW<|!Mg3NmV;bRwO7V{lcfdqNl|961W=Ii z(yhzGi0b`h)1SagihhH{OT@vrQW`y7LPre>Oo&7zSA<_P4jb)x(ZUbovZpjy#qqF| zG;hRlsgaOn@iXi0p+7QGoOs$DpoQ3OhM5@B{_sJGLtv}+(#hfKo4n^c0}ZzQUc76K z%x42v$lmt{;lG9z0crG!CXu12mXakgp`0-++rC!3pk?`saS%jP#!K5ui^K7O8jI?F zgo_Y%`;qMUIsT&Fsi{hZpk~UokqV_7UgBb`bV6E~3z}D+sx@}{Ho?kFo;Xr;y{q=+ z?j?Y)BOp@Y27V{FEgyprlwR_bzUG|v6DHQ%0Xs=vmzPd31aaelSe4~lS9MbmPhh>q#yp(V>|`4;E#^vk_fuAAD*Hvw zDfU9J3J8K(6kEO?J2o2t#@MyKBz2OVZ8x=G*E+Tu>@=fBcmAe!;x%zKP;d~A{5-9P z8`wpLEpW-|)L8P+e9PjDeKJ=4u{RGnVT0`Y#9zj!Rq(2L+Pe8)%mjs!;3?Q{tt};M zzKYp-UQff5XbmBYtG_*h1A29S}#_))Mqj z)A?RQj)|_A|29oC>+dY-WS_lJ{Cirlf1c;zDiUM&F&)!li%*#LS&;9yRoIVuITBl# zLDTU4?ARvhH&%m@km#BKC)~9)irIR3TiaKqIaac;rpM&k3I$sdq+>O>Lr@^~D*ABu z@bcz$URIX^`>nby%fVxcnw4ilEuehym3?F#4ak?|vA^UN=Zcb)ai&kWz%1T$>;|cX zMO(A+!IvCpezc!mpB3LHo7h)hbG*nuDRFrxqkeE7FMG1hWNEwLM#D|iYHIym-P~j#X3K@_>2YzpGbRb?BBe&*PEH-o?e*aKmO$j##uSccT_oK z;GTL~+SK>^2*<9vyo-o#v~unY?6fZ{!HyU@$DVTYT%;EC5xaB@Bq8~$6eBH`HX|D6 zP3^AMADMpsXjr6Ei5*^_mEE?xm+ygYgoA=LsFR;nw(pFDL1Yo*l|T)lr<9ttDvnaz z7lNQfK$jz}S}LSvig1iCsKzH}E#0ojjp|J@y}$Wm9WIK(V`Lp#i$rHMn0h?sV@qzJ z@NfI^f@R}7&p}X|fR-PLGw$-0mVElk$H+ztY@eGkM=Cgnn}}W01}JPWb(%n%)QZRZ zsZ@9}d%t{HTpwE0+pAn48R(Sy5NcUmgN{Nb!aBZ;8kE>@_;De4(wsIb|EVQlmH!0S(*B|^D^BO zjQ5@qi%@m@N)uV284jl9xtHorURFo@LIG!@J1cMtYCe@ll>({1&$%yF!|FX=L*{I= z57BB%C?VMoXfu;W)~Cmz&n}n_r*ichUN=bmwDg;B>!>}=W7Rb2 zKFecDY6zcH!)hMUt|Y$dOBdW{=>ayJ+{sF5e8b2%(I$Gq|@NF zr%GbXS@ee*Rk-K0r@qONLwc1Yj-MlGU;K0Wc?tu@b?V9cI9;hI;QpP+zzsJl@;t^{ z^e!+W!QNNZb8eWj1p8e6r4;Gq^l>?+PaRX6B|B+-2)HCYM`eN4L~T>qt6%|T5O4Mb zvX$q8y@);Mf1cnqTQm%u5O_9(Va@)TC7|a|EuGFTOkG=&m?TULG`B=adi3^YLf=$T z;ZyCnb^>=3VlN(LBrYj+k1G^d{>2OY$w9d1ul-txw$Og!Q|exiJV;uwa%9;f)`s<0 z%>6Q!4Z{0LjgNJ21&(cqmbwxbx|!gDPx@7ZqVyNZbYFkk1#YTELf^C?bt^t*e`Epc zI@t60N*Gez>+nc>d*t&i3Y~F@5EP5$BxT;GVZk?LJn_p|b(laQhwpoAR{>9gy6SDZ zJ@{l0k;4YeHM1u847(xa#m`LR`nVu!_w*)rxqIBd82P{Yk^cxr`YWkJ|6t4Fg)<}v z(#sa{9j7NDCKACEWf1UI?nwUkAK%G_>T1IXThdzYAMW7C_+BNx^}1o^clz(+h6%y1aR&6|WlctSmKG=Uaw5YdYzsJ7Da ze;_7sFrx7iHHA0lqY3)|M~3r%i5YX2xA$rAV5qtDU%1QLBl!~mg>eCQJ0sQbFgwuD zQj3WHpP_~on4r6y{H>Kxq z%mIkQK@N_OzG_!BA5gqwDRfktItR>c=L3_SjV%DcR`E8O&Dy%4^;`F+Ma?weQ%g=1 zxg5I&g5yV%n`0Y@wp8A7@W7oj05A{&0y`&rpzliAv9?t&8;C;Yf#g2-W-}yY zbN2;E#8m)pAgMjJ?`eM`F(b zFL3if2w8@A-E9cy6nJ^%eI zTaRbL+q0hAjcb4qxHrgTUq%M)0Eo&Ch~zZ+J_JailmN{NC~JC_5a4k2Qi0a}NJzLlFW-$OAXBfX=Htd_&+lqEKL*lLce>0)EQkmsM4~ zh&P4`J_BwTXJY%z&PPYH$Lyqb={kvZ0;Cq{euR}mOu2r7#tATNhTp>zYvV9hI;s%0 zaYUoh)0^gEg3sN1y*$e%JHCLkARSo3Gs#BFH9eHQ*myv7UX4Z}8QCX(mTjD0} zleA%tU04keNEJ;zQ{DOHB9)Z^*j3M&ODg>}c!qXGPeFcW*f&hrTwitdK75}~$hz49 zuo^Q_0A5)HzEc2zSk%dH8>9N1_C4X@9;nCCd_yiwGktom@)q9)Vhy4JWa8Hqk7*#c z`|WR^TM>P;Ag>B1QO{GLgQhlK@z$r@89Zp8vN=ugIFW|Wx>F16*Z^bs-TX|~C> zFLwZ_q`cjOgmjp?o*TmuAMC=ffEvQ3MyIR#FLEN${PC#JNO|F9cf5W1k7~e>L-*?Z zE+USzr4#^f%DCW7zmwR)NLx>QIxdVryL>8dU~V3{7mzk@UDT^S94c?P?c4`^Ik(=8 z>mHM+gt0)&+x(cYQSohyI z;KJ&i0X4zBVSO$SqkzVB(K7UBjTp4q%(ns1YTyi8TEjkgSOahwBaU7G59{vX6iXXk zmLq;1lNZyX(~nOsbp@a<)+4RuH#q?7(FG`wf`ax_ZE<_|d3lb@@#&|(5wy+b7XkLJ zQ)OkL{s8&Z!GZD$kKP5aD+l66yk77V03ju^EHC#WVc!3S5Smv;^S~f{T0Z$3THn7wLEO-UxV0g3}6hW-XNTp-kJt4=Ef#vVF2i01KR3> zpMn0b8~sqljIACZ#{3w_%IVACEu)f=t&`5znRsn|Jf|k{8`$)CdeD?7U2Kc18P-Aw zv9Z+s4XlgKS2wGlfI_CF%>V&-opbE`x5^RnF%6i*oUAPGg1;c%fvM}Ko)L%VQKg;_ z&lS(+i$7xxOt`L;X9Kpv5O2mE%DaN6jY*yiI~~3&IVuuSX8_fJ0A)T34fCd-YR6t( ze|z}L5x_nB(E?MsbO2-U5MUR~fCirT#a_@}fGnkY%DAU-43GtlKnDDo7%&JJ|HF6O zCDR1Xt6XKhb>L-;Zc$rj2dXzKR_z%+-I2qTfAA*H6(XZ+@SA%po$Fgj?aO%*>^hYd zUc3O-LAOnd2PiQ&jNsw6uRFovcQ)QsmvulGGCs90WS!%*wEK6t4o2VD{nO+5$4hcy zz~_V=ECXO_j)V0FfO*Sa-?$VV76zdCk~5{&o&fNG7ll^sh3cG=yX;`MeoUZp0Qk_) z8lhtt-2pj5%Uw}My(`R{nJfJE6(~R~@7_I_Wbf-HzhI1X`m~mGj(De-S^DVuR`l2p zi=LMGr+XB$e~EBVd?9ioqkWJ6=&h!2y{~i6GMc=6*K1Q#d#h1nk)Hmg;&cT2kAj6nYiRFfBNlmE$ABBV) zY`9w}H4F`OrxQH)fmJx=A&g2!446(YUcd7cnsTpe%PN%M)@DF+ADu9x`(*%1*ay1)P;6!W zI;&gOJC6!J7gbcI4BBkkb1BWnS5vQal8Zg~J4l|`+XgJ-a>v)4W@98}2OGTtfVgX} zYgCgIVk*ozW6C8z!UrOW!jilKOgF1zGo29Ow?&8OH28aW^iDe#K%UhqSgJvri-oaO z@CSM#*ryINUcH}!*}<6|2y9-kHs;O{;lG$6i~x*>i1G=zbcnETCZLbr&;OPne|bDV z9dP7gB*Jiw+k;1E1rKs(coX?NTD-el(JvJLC`!|+2V;M)1L!*7SbfB5b*94rwM?mjXs)kmOKMdm`}pZTRr z0Pwp6VaB7YX*?kAXF&V}KGRmV%c{Fhpz{?Yv?BAL=5)l}1+6l1g(FK6^+Df9wOdVcU*YBHuvgj2!S52Hu`A`69ZTguV^@~2>`80mVFm8YwfTCHo`Vs2 z%Ucqtw(_(bd{vVK&@%C(|A6WkJ-h_RO~iFjYEoSJJVEBVEl}E-c&jM1PibjrNP@z( zbctp{W^0K{2MZhQx;*O>)(6pC?BlEt%YdPgiRIM%dguK+nrGoBp|r`>aiNe}1)17k zrE{S;ZvN2T@qm!^XhAut^SfULAx`-N>rBu#;CIQ1Lz+pak~8lnAAkM*lmJcBiMtOC z>w7ljNQ5n`2*~+;@Sa#He^7wIp){n4B@4xPfqnWd5%bm>r}qZJc~$R$ni|C|R@<|z zF$<1<=Jzne98jR`aj{z>7DemQ)Pjh?ei?uKh+}W#jTth9XhJX=IF=!gW_vHi+rq&k z)R&$VVLg$eg&0?@!)?&2JWogir93ZHA;Mk`30k35;JCkZ7Yfrd>YW@( zL(mSu8mHreYzETNn7F-^GA9Nv15rPq+)R~ez^tY;j)wN4xmQd&P@>7LQ zch!|>)^bS@fgo__2zeKdl*7J{A47J$t(tx*Kr=3B_-;H_--X(Fly+f2Zi*s(<~p&V z5z%~$F`BepQrNV1a7*Ufqk^evflnk9ycq(?z1pe9)al)rfG3#%$Fld6ve`pQ>K~&o z<wg#DO1DL!LKUhksF8Z?j)ct*P}tizc9LD}od5=ZRI_F7D= zCKIV$i>RGzIVbg#{4M}~u$PVc2u7?m zED$=EIyQSm^)o#gp3lK)*-c%zr`+D1_%MX9j;*77o4B401DMbT+Ds~92rt~sYA>ED z>)2q1D)KqIdNgEWEMYn(bu|)Ik)&S}yXo0%5y$7Gk?x#tHSb|vxnouywwkb+aR&#* z?mYR^Co4PT@lMDJSBz#{l_z4!Xt0hP(o+6vfx;naAmDg#jr(1QwY+%lsU*wQWbu`v zK^XzpvfE1IL;Q+$1o9`pu`p8H{4y&IcbfsxX_S4hKo^9cOC)8%_@_V1EsOU*xSzoj z)%W{er=c3Z&-WbJBqOzOvyUz)n|Jxr`2CF2kG9|Lk7SNWj7?}Bf1Te!9RLxfZBW5&wtAR>Oj9`6sWtdYAFM zK5Swg%fdF9AP1T8lJKctFESq_JlO~MaVYm%W|M`V0EEBAC|?|$(_|F}x^|ey6D0?uvBkVAF zWoYr_vz=Sx;bQwlbt~gjttj#A8@%^VZol^2_aRGrf!Aovo|xv8#Q*$W1v^gIx=vE) z+wrWn7dr>7%tK?~yLSRlX98TdMK>=wzL?mzq|QR`a8x46faT4>tSE%ueIm2jDxDm^ z?(w1?vZ)>M|8m1zYd!XFq9k*AG|1lxwRzU4oZW}uXxMiDZx;ad<#B>Om>9*pxdfTk zNw2g`ke@&Ayvv*&$^4bJxM$!D^GD=wh8n5drM_27s0!jIsMD0FX2z zcRS~1ra_s~Iw>c55zs^NSuDp9HN3~?B!JA@2N#&!#Itc9g2hWF&&e7r-vO?v_ZpYV4pZ=u^rjL?uOZ`0GRfgN7^lhnSPQ_K>`$i*2hKV zk%|6%b2Q$ABuNRB4z;aAexNEkGOIcJK(76bI|$CZhnA0FkiSr^TuJK_B4ZBGnGSaC zdWL(DDNmt`LB6UJU2!^Y1NV7C)+4O7Nbm$eY&e7Z>VUpo4Of3RYI0VT&r#Ll}W%>B)$opEq8^Klxtfo7h zzaV)w0b>!hKZc|}LYuN&jeNu7L*mM9-y)#9?LY~0v?Pq?ZpEAW?eqT;_R>u`F zXFg#-W1*!))jzBCEB)AvX1k{9y_*`mMOX3zcd%I2@vDA%#$R3GB33*SQ?V>Zq@yx*mW@Qkt4rrKRfpVu|gYK z3Qj^8V*rOr0>-Uv*Jm8FKDS#rkv1)e>5o9JqP^s6jF;myNSs zlHZ>fvjOkN(bDUK@|1dN8Fg ze(jYaU|2bjg&C&la*OBm?l)IsHFM`KY* zU!!%Eg_0sJoMsEXhy6xyQg`W>EsD^zqbcUNL?9DhO%S^s)V7{nVshO75mO9tA6;%h zJVx6);y0Tio>)a)*@#xqUK6&tSUHRc6Y;kV$zJR+1DNv@g%1Rxp}o!0CnhG{Suha< z8Zo|5^@G~brUiaz(OeQ9vx26|qhTaII}4s4dMS5uJGc2$| z9b%itXino~5~^+aK=Lb)XX>`V@p2$?S4 zW2zyT{~icvpK|eUVZ6Ngk!>MHvcJvG4)Kf({6WXDD#$9)n|mqC*<#G3gR)CdiQ{FFHCUY(r&I{zz`Br^pj!BB@fS#DUTK!aT7{ zIcRS3h(Wq^=dpd76r_t3SQ#*F1BOde$y769egGz!PXA|tsUn#8TU?O-y9R$>voK<; zZv;f#SuB@yOo)s0zlEPhBtPI4L2rr(=bhva?%qWk(hGAop~pLL6yGPt`A{Z{+oTQqhet?jp6Z(;0~iKRdO{A+1N~~lrCmjRI;#)6Z26IpRI9FprCX_ z5J)+o_jZ5YY80(`QQ0q2vnfK@mQ@;y9Z9)kn)Gm9bby3kyo5=14GlZxDXKPRrir^gsmTt|P;kcVT zD6kJxqW_7t?7=Wfjp-N&5j1Fw+3?+`a@Te9VKF&j6l#8wXnYckM9n6(dq?TpB*EtT z*)O#74`6qmPL&t3MMFdyPlFAzK&4JY*+ktT!_Iw&3u|7;Rq4rtwkyk{@kWwmv3l90c2 zZ*J%Lc2k@k?|?&hOGC}?Pj;|J!m)|VRXW7#0|tzz)!K)JLJxCW^g>|EFIj5-rZ5l9 zNqAtIqt)>Q23kkiQx3n?88+T?!^gX0EVEr7UvZQ~pGFD?ypq0?rZYpISY?YW4EY7U zLrE7Sh$x8$zTnxocLBnIKVy@xF@5qTmU3vY4-NzHkl5gCaJ%7d!-L>XegS&*PB)f1 z5}K2?^7<^+E;4`0?sECmakmX3?76^o*I+(bm=@ZJ9fo{6&B-N~7-Id4o+w=&|Dl~T z0yr4^E88Sk8Y!$0j>OP9?@?mP@W-(a#Q*d2nDJ8C;EYd<5|1ax*LWyTsEgvTy1bC; zQKQ4~`#5Kr+H{Qce+P{N2IglB1CWg)veEpZ+%wRJjiY}Z=NuC24(|_fxauk*-T~$7 z2bX)3sm_cLG8;T@u6d{_5Yo^Dxgl#jd}P?}y_hKfPx!7{iQXBxL8K6ma=fx1gJWU6 z&0TQ~iLReeN#36w&KGhz1e|#|b#*7*_Z;8DSxUfm4zhrt&|@FW|5PM#4D#Pqei!Th zipkt0#f}g&kDTvTRA*A1X75_-%VBaNF(t3ceDU`Zf!XHk+vYfR!53MoT*L0sxX@T0 zk&?Iu*F9spR_Q>cL1l$YA~L~N4q4MP%n#ThO!Yu#l?|s1Bk626RU~!k=f^R3U`W?7 z_V1V-YUmN-V7>Wu%3t+#-R zDr~&H$)Sc87+~m>oRO9R>25G+7^GWjkdTxvQ9xR0r3Fdpk}l~^K{_S<&b;sa-@Cqb z?|Rl^xxir^PCVzFXaDxz1FO)z_Ea#u@ZkY-eO~#G-D}_a3WE=M3?`?N42MOip-BO| zKZ($dBmodRqJyHyAS_@vR2!dE&JY<%f=%8`UNmuuV-7-wJ3f@3?m`7wns5~j5rgX1d27&~q3 z`r}A^_mHDE%3VXlA#`2!^v4EsyVgqW*?XQXmbp}nM^xK)Dx)-;1nWtm@-AdFB6uT1 zT{`7335Z3RCG=QR=m}ju0p(7-qvqp3kIcFsj=UBIzoei%CGn(QZz4+D&ZR$Ec~U;@ zvgN!*ecjP)V-XPA!e*MTkQBRZkA0ddtjC%oy(PmCsKD9RZuX7iL4Wd}t1u)+$(wM) zE(~|>J23BFWs!kkoE4-vgXY(Nl4!J#kX3x7`?61Xxo$Xf>?& z0tl*Bx7VAFBjf1O@sz-4z_+Ewre-aYpLq<8^}fn8A701TEzSDIJ<`PDgb$|lorBX~ zr~ej=iG~j4-~7CQFEYJNgK>h=*m@s(F|kXyFzCN~rN^b#-fRhrV)*%uytfAD+SVrf z!h(S z_%=#Q1)-`6_u0r{iF&}3j(>e&1&TqTD?vGksiKo{Hx=h`YO5qjFWLR(3rhr>$;yw9 zhPfomHp9Y2J%4_NbYXNzrHO7)Y`sR>2#u)al@_%=B2YavG!m5Z-NZf2scJL&x;XVn zvYgyZUy1HX)>S73d7}RGDSd}VSV@=~G7vemdSe;y?PNCP-y?ng_c#+Rg!0D4Q@2M? zNQ`q$3FEB$K6cCsALzV(eo8F>diL4zbqN&@h?*TFd>m%0Gb!W7ZdnmYRQ-*pR9{@7 zO_zLE7KHfznIx8GhYE8Kp(`uj{lHksiM>j-(~OjP0sn%Jbt$=j&fv0>lhVs)NyI_A z7`rUeifeL5@qM^_M2Qo&yImOJgLq#IXlpLdJZ|yY>E2AVo>^F6XaFe+L+8VL;imTN zSRK-D#Kl1&K9V*c5AG^Wd#w0AdFqt#2XEUn$WVa=3!2S4dcc0l#Toiq3jU}V{&}b; zv6k*SQUh+*J=o)?z~I~>EB66Xgv198E6dlq&nlr}Bsi#B8P^YG8 z%gv^fN>%yANr#`N){WzTpXr!xHccGZYbWhA-(-WRXK_Ujip5VCqblPYtlldtNHLr~ z*t_CD#JJkOkTPJ_%}d3wUwJ|QtaXcD3mjPj{`F=nO4d<=Q>s+Gz-ZqS7E;E23JYX> z!PSd7=!;LT1mWz!{rn|B=>V1!wK zo=QH`OvV1<`&;jab+-&K+A^&$SZXz#rx2tssD^LOt3{d#$R!4%_&YE5PEPDVyDGfhz2!aZqWg! zK~FpIk>2)a{Ko(Lm%}iyX9D|m0oNYaB>wjq03_&b6VJm=FZoG@jUJQ`a-^*?_ZIa0S9l$2wSr!&P2OIo9$KXTIm*~UH&rM7Jv+Mr51OLxg3o;N-=wo~# zkstqS3;xfK{`)TrEw~Qtq=cf+1X)ma?ly_PbZ?!xa2gaN ze6E1LiU1|XtP9Yc%?5~a4u3ttJp5y)%(VDAeJil;|JYTIaTz6%<3&~I-0vs7$D==y zA^?Ig3Dug_^Y_e|-=CyDOj48BH7JIpX@U(vUZPbQwL`tlfC?^38t_{_11LNh9tr@G zCAL0}_}iQU?7k51Q|+RTHnekii$l;?^&6m&3ZvnRZ_{Re{18s-FD(hlqn^U^$a-+~g-~IUE4F7-GwRd&KA#rkH?=njyfX&bU0< z$#j2|{eA0tO+V+_0BC)g7sg?3-FJ4KzXh`X|LkF9o4USA&H$fpUH>uv*JubdZ#@1Z z*wcmH1w)@A80Vb6&)N(Dp4~&#GVgUJI==xKAJDI#O|cAK9s(BVXG-gqULQ-rLFVUQ zo_D`68uQcCyF+_j$+uPod>YhGd!O99ziVuW?_P~}V>tfy z$Ue>7LWijkvIL*s05pMX_E|nx_uNgXt<=}6E-qZfHtE9qj#kVI(`>1M`l_Qo9{1VNnh)nX=_+Z7Q3GP z6Rm5|)Gk8vIdw>tJOStC1Fs6l3Lur_0!T4&=J2=koesPJ`jqN_0A)|})6H8VW%$i1 zZ)Q3frzVz6%>DPQm>dBPWAQi9$ORBaQuB=nfj#mFj8@z1wgLA(<1?qRjk^u5C-$U3 zMu#ws+TTZ3Bb-Vsar8YK04g(~R{3jbmBdG7hxNdy=MWiMet1Y^{#Ooh$@8^zoJaHz z(r?4pHyfR%V$bIrzgCP&D8q@B3YY^#^gKT06|^0NE(SPvo%64>Lo(91T)n;;*Um-7 zy@V6%GR?`xR>e%MQ*;J}rNI+?n^j?toxv(I%a52wrvT7r443A%(A$*jsM2p`5 z4l@N;&g%lZzj8$Srsmz-?`RczJga%7tyrxwYy6L@7^nuDg7RVS^6i$`VmP&>Lksg> z^?(4;1%c({iy9ET*wuHynDt*6rIyMF#>7haMI>AN@0U(*fLxxMx~9eb&kGUKXP*pw zmIE&1YOZW_b`lNr^8`a7ljw|@lL&ImIp4TPE9*d+PykbK2BSZDww;eeb^s@>K^QHg z@l{$Viz5D7GeFwB86&?{X7Dmt=1wZqx&iV;0DC21-oMH^e_BkSkHiS3lj8_0z@NLl zIZ16@2wlHy-j;$dF<$j4U(}SCR;r|KDULuUU7Ye$57Dm`F=s#k#gNqgWK2OY=2kg6 zZ)QKW<*XpZD?!4k5xjc?1npcXi8boh9HVEFmpBg7qPuQ~{kie6-;LbTA;ml`*W)(y z(sw)BVrV#uEy}Ku>Ptp3%we3Mw)?%V_BAZ%np?d2X7O+-*NpXTLB$|aOC}3Mwq9+) zpg|z6tFhJUF}U`e4Eh z`}GZdaN^59S4-go$U)}W?cAz^f-sn;@%Omxy6KjOGvgcWrWs3zDj-1tkFi#NS%uef zY~>74gS?9ff^a?!0Tr@j4u2)2sfR*Gjzj%7dCl#CN+;LuW)2o*K;wCn@Om<{e-swaeMLxo~-V)nz{bBUtft&6c_B#604hvh21!*8{!B-=uvC+$8Cf8Tnu6qgwCat>LG^{Mdtwkn$j6d(MA_~ILp;RovA2iiIsC?*aSWV9YTyb*` z%iZ|G_1QDkDpv;XZDq>Roxm!%MM*}6q4|s;Js$fw0+xQ}hSb+adoR=573M|`D5tei z9h7vl$_)*k@4vieqncN`m|TV67e@O$!gq7RO(xWjPG+AwbKzEi>}%lO9Jam@XHEYC zy%MLN0}{$ZU!*SjAc(+Gdq;Zb3H}>w#P(!o+JPs@8EAeoiR)&{O$m1uUp9&@2MS5v zvj}=#awd8S+zI6*Sp}1G^qID`Nc~r^>7kRJ?KA-4$o!ZTC<}ATRQh;2Ea}>xB{kP` zOh?j*GCvD%k$r$|XA2uqDG)hfadPKTGOQur=aGY-uSDiU zOc;qBw@JYHuQ;cYPTf8L>|~6WZ==NO@{c$NI%;B$<#PIL_Xcdl-8B8k;#X97JXhaG z-A^!D#hu)mUG+cre$klYM71hAU#Nm5>BrI@y4H3QK; ztvU$%OHXfV!6VTC09NQ}0&!&uNw-T#&PY^F5C&SO(#0>IAcn7OFoo&|KVWD%s;!vP zTj*Q`j`1N~UJm!HvaWZYVuH&iK6{vDKF)Ap0zdiHn z)>d#eo;w4(*uV0ql&!U*aXMGRoj+fFsfyz;vmdQXykH72ePgj{HEwg(nb8j&H$|$u zZRq^e#=9%e7W86X@M4K9g-3o%aU@^a`QbU6tENYPg`E7%U(#H7$x~aKeWCm#@p9UZ z(l`@ZlUR%7nQK})FJILm#Iv4RJm&NFIKhB+w-b=4K=fld;8;oV9+V{q1>5d90i@)g zlDK45#l`Znd+kz*dAvIpjAJS?eoKZ}!C^^Set}GSw0pdNaGVI;8+)24KFys7IDL%? zWnQrs^fRm$`m8zb`>ZZu9V#>Ek&iAv;s4ta6_3B9l3aBBQX6l$vT41k^ME>oyNAYk z>*9PyEcp4pfTF~l|MJb!w9j&V!@U`B?I@eshw=dAiR(81NWWiFwBbs+Z5Ck{B>%?# z`IjPb(Y>B_U{1`rNR%g0jc-)3HTxbwJ$=TI`^4l_!2K25ApmvUsZi#Tk3>@n*%Rhp zxTnc8wD9{DYV9CdUthDcsIE|Rar^6^Ofp!PuoZsW^nGUP^~+#6;FEKpcw%Qm+OptC zUqV&8U*ERY)_W-9WqogLtmBd-$qoC1SW(*4W~(5!^{`igmlXl~j_ZLdmJfp=!J*&CHLDJx*qNI4_AFM6d$wz$vqUzx^7Gx>uUFwAf)Aja zmQPGW!hXO5{~iS6J^9uN%8u%&U(n`wq6&D|HuiP`n?I|ZXM-5=h7@B<65khv~( zqe{nkuHnYVA0J?_@t;;h6|gIa44s~3JdD}imWZVTZ-YqzLqRn>5X{}I(m|O_YPMZ7 zG4}cqb_7`Jw=!NOCCeD&lZ!C&~<7f75rw{l0pY^M{ zhrM9?@lwZ9OJ$k_#Y1YTPWJ@Lp@|1P=Gb)X-;Fz~zsiKDLMbrG?orsov?bIYOl2Rz24%*`za;Fj% z?#V>7tikDm!B?57h6?3eQW zglzad!);(FhR^(A1@}{Zy*ms$_RK5mes&Q5KfCYUH)9U_j5JbsN+A0(qVxtnhqJ| z+3~O!8y~=5GT9Vg4@ZuR)e#3H7=9ylj!)E^_Rij8knb;+0tKqGNm7xr)-)wAb$m%- z-(XOi9)D7yRgO@?Q0&tuPN~3JsJTQNALL2c(L-5>>Lk)oo~I)gI^wUlV;W%w7=v%; zk+$M^K-J?%#Nzg4D7Ziu#8*g%A+lf$03BFxP%p`Zr;rI@tqKZ7LUV~Eig|Qi`Dxq)G~cf_h2cm zx{Z$SWy7>~i=W%`Py5Ft&Y3TYyPNp7iQQ~STbpgeL}4VE#z6*azhZIZnA_lAB%#rT*y~|A;qg}!lBA!Q&!{_;ws;Un+b~nmFC&&K{{!y; zS96b-!ZE&{Ojsli>U%^2ET?Au-aM zCr~~N)5ljHzly^BnZT!*ntGPziI-GgnF8U3DGl|$kU&Pr#b)pV|{lmgp9DRFh+i6 zvf8l5Be^?4PrIDI0qYt{v~ZOBhIXvh<82&c)iOP)rS4O#7BNwEq{HV-?+E1W(OuLS z>Ad0oZuecufDrb~h8N~KS)1{WfsEmG5t%9RWm_QCyafS4;g`8&!Ki>4-Y9!wV}1C< zP{Vfiyxn$5QKq2UwlM1+ol`#Q5V>W-$52HjVplg=gq?sCVAIBV0gV%KdheThi+b+g z**p+RDqUZ}-#>`M{ZcVBS#V2lIRidizp=#1vo5-VBk8b3(v#v1UZ3w4CC=y})C`?A z9dXt>C4P?*ps31m`uEBNUJfqx=qU)}(mIfc)=6;OI;S{s&1!xHZE8Mb`IMEs>rP;S zA*m&w`UI!N7o*8w%e48Ax<1zxrn@PD$ol)*UYVvN2k|EM&{w`g%Y=4nb-oNb< z0sk{-OS2|vljL7wyITFNEEy1h_0`gORf;acJWno)OQ?8Kc}1rK$Z1S@$Bab~Ck+0b zfO(sdCdX{CHgXjjZ_R}Ffj(vU@@GQB16%gagQ5D~hXl(4hw;b#q(u(m)%0h?;HH1b zflzw|w@^07eogQCaU52&t($4cM+Kqp(j-WoD-uki`TmPtukJQx@W!bgjb^yMjEv+J z+-z37otzQt;fUBEHmnk3>5`oK(ShBe)FK@< zsQLSx-?Asuf@B50z8Y{)EJ3rrp{m0LWw2;6C$d_yGaJ4E(cT|6sSgrOZEc?(GH(%i z*|x_ktdrOj_)ooZ(qnj=5^mz)Z7(M5N{#%GNTGKao8{7jy8i|XdW=sU>sNjUy+EoM z5rn1C}Oq8H4T7*_1>;p5tT*0{o!u|AQ`{{r+ze?GtYZ^>UfY)iHX%S zNSV!UtCpLz>^LJKsm0jZJWY|Q+(`SbS|f1(7+b(2Sa}C?%8UC+KM-}Oo3Ipa<+QoZ zU!k2%YuD%y3uF1ULdO|T>nO7ZaTiAPEBIilY5C;VL~HGMBn^tM@7j(V+@r?f^Dmq%M&mznRF4(SB%uEWwmBc_%j;^%VBlSfv?fFLC9^2rsn^*0)G@g&vi@g(0G)n;(ti<@0T+(m=QfYaR-Gge7rD+q!sj@nh z_==cJ3pXfoXWVJ!W3a!EC`I&>G}eeTxoVQ+E%C%^As)4n1CFo^`EW0L=D!~;Rt8m? zlufO$%djw3af2L0Wr|Y;ENHAAu)>&nO|9y`I^*Q~4}{h4U@cLGaNGZFN3%(y zmHO*9$vqOWMbJD2@+WvS91~dU_8l)6t#86e@X3P~Y-lo&*zeqs^;k>43UX#(A^MQt z6gm@%1@E`THUd29!cQqi!H!#G0IU8ff9Y4|_szHQ$~76R@KjhVcjZsIro zeln?o!PWfzAIGc~urCxbT68UkF)az}`Fl;S1WGz*gk)_+eAZL)MourPc5ul!$10$e zf{F#xR_y=oXO0smYPb)4a;8lOx4ZsYyYOPJQgs+?i8@}wdS5Vaxv#w*9GePBwB1ut z!ngWFx_c^dw2!g5u=ObLvgHEuvsSS0RQ$+f=j2>m0&*nDa7N;LIr`zmVg8#(E0BcP zD?fM3{s!r-j9K#N80Gm=X~6>i7^t(Y|ApM#jfR`cB@*a1_WRyPY=>ib=YIAjvyofMMP{hZ(S2%jB z?oJ*+PD+#+?Vh!V2Oak#pXDFfI}W`>Aa)*kM|PHE4L*}yGmc1LnPMM`@11Qci2*G8k;B;b}-gKX6-KNIx1kLks>apAy7YdZYW$A<*=KL8 z&nC1fo%?QGl0263CZvbKthYw{!Zk?9I_>c@HR+|RS1U{Tj&-csK+)AC8!2i1LMRgp zq(+^#O4w93#yGlG$vA9sCh%rozn*-&OF`)c_3p;V!?z6_3Sr)FD9cS5UBhDy;YF(i zW0&iFQVi1eS0|eRSH6bi%@4zHoGE?ct4N^%XJZ7e8|3eBNc%IlJqTH_Ro1ycJg(AN zF}iX7OSFt;wSKfCN(|)lKSM>WVuV#Y^-cY}rGdy~eL9u^1!e_9@?Wc)RD#t=Pu7>1 zRswhtT803#%GSf_dlu}s$;eL7DVOeDaJn0?Jz0zA)-P0EgPoI|R}n&SQu!D~b$}&D zH_G^_EWetXv6{9bR*b;)b%*I}jG!-#8Ojos|MH;Mqav~_C6Nf!Be|aT{SNziraCvp zdTKSYW*+e1F^~IlCg9eweUj-S%4b~i?bhk3x45OenK`vP2)_gt!_{{t*MGnTBy9I$ z$l|xUkCf;Rr(~d}{hOzur__IveA}0Mgl0V z&kWjmr97xS#87znr|pO#6mv~taDy3E$nS)C?`$b;N+B`47W->$@yu7?&CT7bjxLO4 zb`OrjQM2y@*^icAn+i@_YzgjGzkMWzfkJT+kL>FQuP4XT;e9v^{T`rQCuk!)^c$Mg~rKDVXSK8o77|7 z@0zlnS9869fl@$c2<7z~vfX|w2lmjsRi>uKcP~Fpb1*%OR#e!HX>YEVY9S3Y>GYSM zq2Fl#UNQ2XZRJPsarN-yKME4m;%QzbqUYh3xd@^LgH-*Duu;s*8Uo!ChHuY!zPU6? z{kuKYH|!@1P2AozX)=*5rqIazv!3uo`q!x{8?ILNo@ZMm6mV51m^vU*1k zSo^NXnzHpp=j`$fMy{ak+9YHHC%F*o+EdCdxRs#oOKxqceX|}ZYbLt(d3(~HAMBn{ zt-GkaIe6S-nDokgP$I`6%{Jm2^pG9&;a-PnmFOx={utsTc}2ce=alRS>DKF8eLZ)+ zUz)dQM-#;cUSWxVQdraKH%o4@;ZSX!X2_n4Z_tNbO&oaJzTmSb=zI$k&=m5PSwXJbd8;hCtah$Y+f-cuhlxFvWgJP4@+)0ocah-hP2pf zf1uupG8pzdBG5{cXZ{>FaWeK%pRYz<#;${&#fqjaZJg6tJ%;-r!mR_0>y>Y`I6=BZ z@6ODx(YMUC4VxGj-z|}U0y_Wn)m+5+9@aL4jC;6^xkWwxN`|?2q07&9XfXI{0!wQb z&iJs`Kh({Yhk1`_lR!|E5Z1yim>eYjsQlxE<$Fstehb@pZ+yD2QtDTFsX4-r zZ>?mAbc_Ga^$ZobYbdCMy0=@+o_D1c=x`M;Pb<8AK!dC=QCjE)+_m0f7CsYWdIg=f9vH9&3ApG1l($pQ{{fKM&+d$%jycg zD8*XrkJWqrCa3qlb)vG|H$ij_-pI~EGJ3~;tLF>h)6D`NnK+od!WUQ6@Zd_d*Gu=6 z9vPasF3;uer7PXH#C|mi&cD!@Mm%wRyvz`9uAq@{i%KJdjm*6Dd7(()$tq0Y&>Gq^ zS9vYsx`V`+*XnubxWnA0jj?GnAxpkx7+nUvDELd+h6%~OW8h3|sXDMI-xTrGdEk+LEd*XJ44De zH~e}ylfC~%4$w428Zo%?^u?$DvKJ-DHpV_)k46LKwzHh3N5vDpre%iz8-W;&2zK05 zrEmN8)u~r*v#~-)^S?O7i!O)-W0!h`)Ca*e<+21(A^_~&p1K5DjAmj-(1IkzXPL( z6iXI=3;s1{^B*(>jfedIN81c~17^6t0wl-(d)Q#3ALEEir$m8gZO|4N`g4{{?`%7RSDu`Gol55o!9++(U;Wf}0i@(N!l@>&entz|7XM)c?smj6 zcWS(4lUJFLRZ5)el)7eX+xvXZdq7EYFhk4nfB)wEyUIC(pt}43NpGq7C|pp({?xbQ zKNa0e{^wuKou!Y0Nri#cQBt~)H$Fcq7JZg~`1VRJjhT3kDIS9l#FjCv?l>mG4 z8!@!%%4TU} zc^&C!bwi5brF7%szRPqopj+;%wgS-|Y;jjf5{D8azFObV=3t*6e@y-Q-H!o9w+zt! z_0s`6e;sg?0>>8sHP6W#h~>5cq6znSjVV(|KxxZM0LCGbb2Vt2jyBq_MIQh;6+=L1 z2ZEoyl9~yqr&#UUH@j?nZcC5ue_{KVoOAo~6o5A>Ev0N0T&jO^W^FnmyW3(dWtvFQ z)9dZG->znE8fBcElql z*HzV=n^~z*3b5$TNiM9CjEyKG*2v57>xK`G@7Z;J|D=>3cd(3Y1e6dU=su4sbP8x6 zIdtysQ@jT91fab@e%-gSg{e9t=tMp0e@KPV5$l1Jg8P4GMNjtkuttVXNke~J%<=a7 z1E<`7Acd$Idvp?fk5FhvFJcSMd+UT$FeZ23XJfkRn=B8b+aEBys7Bj)we1IafliJA z!ev)Ix|Mm%UVnAqFuHOU%o8={P~;aJ?sVzE0VzK5(#3A5S#{y}m>}k6X z2X0#cp_YQrXUdjOFWztA;(OhGgP2t{0DCzhEyTNpGknZCoE_^pq&+z!`g2Jb z@#o-<&ke0Vcmvw2EZtb{LL3*6F3uXXvqU?7%lsm57!*tg) z54nA7w#4+!K+5NNKIta8#kmiyk z4_$!@1ufs0O@$_xfP@o(XsP``E$7!mYukm|=hdO?=?U^KGumo;-n>S|f132B^l3vP zAQRn~#ER{|zgSoY4vR{@qjD=3Lp#AKhTI3}gBI@bg774+=~Ip%%&-UJfp%yvYw+E#1F|xD>&$z7vz0nyw!$gS>V}k;l=2yeIAgUOYQ*7fl*T^0de4-5c7Im zhj!DuR-?PE22Fw4=eb-{eY9&f)}x(lN4;E4xi+v37W7{wf~&HAG#g~5nySH#V5CmL7ltcz z^U&@a-&a6>jxz0>sF58W|#Vy-eq@C#I+Mn2&5zKJl`Y_i?6Bs~4vC zml+~GAW0>_$vlZmYDYEct+Vusmu5$KWompE{XHYlDAG%NaStTFSZ6;Sp^*R`jkSqa zoBm*;F()4J-x6AX*Wkoy3G@!RRAvZZ-UQ0nP}oZe4ov=u4*uBI=GO1Pd7v||0ucuq zIOz9pMdnlqxbPq5WqTrJ-mMLLQn;&pTYCNHsVx&Wd@`()72mxi78F{u`j%eQ{AO-i zj~EJXN2u*rH0)@)((ULe6DcdeGQ~IAWS`R5iG53I)I~PCEy3{Jp!r$BZW^I^beVxG zCip8YoXwzLT&BA&#KX=?n2~ZVA|+jl|6a;Zs91eUDtq-M5Mb;?^bVb}ftf@Mn8{81 zJKITOS$D*RI^4AhV3`>%jrKMC1Ri+|OVuikJ+lPMh}Z^ib-mYtSb;U`G$hY|3mtv0 z`@s+S+ic=H>~V7N8~afG!amO6^H_A$XK1bdV&8pb(w&a@uS9m~epcq(mf*`_kM)Ic zpAc-C>!(;&TR?V)6L7Kk2?JS2MyKymo7podjx!}zjtJJWT;I2>imN$X5o=5q%lylK zOO3JuvrVqwtw09G$VncBT{oKjKG#asr>bnhXTZ)Fzzuwy`teo7BrGDw4hSHcc;6J8tG zM)>9gC1iycCiP_w)bj^7U?yJ3d=%Lf(K>3}h1W3$U8J9(SwyQIZ9mB`EFyYrqfDMbOps2|DBdJ80hCLZpQP)oQxxp?Ro)>f zTWSC2myqZR2C}%kHFSJJ_un~yt1==lD?==QpOJxYxoO~JzPZ0D!_QD*3)s%`A@O@| z;8JzSQKsIljH9y=wc_mlGJKcE`pT>1Z}f2#!uM&|{)zeiX0k|{DnO=ydRrZX#~W$JmbFbjLAG;04?K6Uk=`(o zhwh^#Z-ejZ-831-bH3Y>%R8Lc@$U>Gu$dm!)E8b9RwulFKJ_fjDdshE!1sRP?{00t z)~D>H?qDCL=DiWOz*KmlOt(z6JNZ4S2s*p~o|!{p*J@~e;*NMt<2@EjlnP(pdPLx*10y(Gum>MQtGb$adsMNlY2- z#ZoLmi)#Pom;B}%fSoGp-s?EL?-mSnkClLy@Nu*uFmI%`rpDc4y=#yyBGMZ_#oVHV z@&%s0y5$RUJi+u8NN|MzaQVEgVi-8{?KFNG2rH@Q)Wph!3C#dXiqY4~ypAXbxCgdX zv}?cfk@GXahigICE?JxYw^&>FL$vF2N!K?w^Xq1Vv+E%NBCwGUM_Xd85_7c-{NGOi zM){77xYuRoM|Fz}5Y@K7`?Z2`XV5ThI3pt!uuQCE=={2fjM#ZpEG}*F`R$5`%w(cB0M$x7#DC-WGhFvk<&18M zdAu#+_dAe#cBd>J!-E|_+TCQyBt{z(9E>HAT8w|hBV~WZo7V7))MsC4;E$80=?CG` z`MK>wF8J(b-lzZVr43&NZuC|)Ws90z-D6;9APu6hsz}Zo(@G;Je=Sw7_AABZn2XK8 z%^}vl3*Kq+_9m)Zi6p4~!tZ4}p4%E$6=Cy5ZAF|v^)-~)Y-o>p0fTwaUVT;IqQ+~OzY!0>c z14k71TGAX+*~EE3Cv@;CIwjKj*htrgEM!3;kbSMk60>Z2OIocp8C1?0;(0J|>&LAH z@3Hla>$xFkw2RyV+IpIG7&gR;;;O(&V|!vQU6>z5v1vaLw9h8qmlNgs))BG;MP1JP z5U`dZ3z{}P>TG6ty0j75zjST+vZ&*XT0i3``Tix^LlD3mqd1l7zeu27#`w^3`0-riUhvlM?ptdv2uZqD&W zYI$#~{{%wpCJNN*ELV%j%RL@uD#SJgfALY6t>p^d`r_Ct7S4f^F` z<@Y{V#%VOCf_Vn{>jQT6bBw&XOxN4+5F3d?AN0lszpZ6v8SnNLig-uN4u#v>^uG5D zjAnvb?|hvYv}=@&r1wtvd5GmE&!~Wb5j-R!IR;YzmFO3ZDlh34Y7p$zGzd1Vv;HRv zqABw|?wh5Z0;ySKZS^H@#z7N6!9+rrvS_8}Hq9i~@!<+NKi3&05+j0=noVA;KSFtM zkb*|rP+Vm(5VkC)bBvPp9+6n?!*@)}xTvDcV{OBdJY~A3RgR!kSuoFX1JYh;F;h0Y zWVK1gZq;v{p8=Ek@}jQmvQuOS)(!Gr^so$_NS)K=iDIe8RKDFipKLk~+wB8_AaWLx zCFbaDbUau-54<{yFPSW5`{+x+LVu~C&xwbln9pV~i1~?mXD{e^niKdaek{JPbw@YH z4ho`LrA=qge$y;neUL!tP2HENi?yC)PEu-GDvLj=9$_gkV)7x>9{SO8T{zEYWC1q=T0^r#Zqz=MI@J679{ zL!EluHpXyqKHxbqSvQq5J57sEWkN*X)qG`WGBD9Fdt5hUf=+taJHjZzIIm^h${!;^ zvK7Mj^yBES#R)B1`|CSNo@vNve<-&t!XV+SENJI+B7*@Qw^!cl_c@_IHU)zL`GfDkYim*b{BHvsSf3pLcSp+vV>e8cIk%(R7HMN0;6WK zkT;?0Jn*hDpS@u4j0=|O#rljn(lu7|z`$E>CR}Y1zLd&-NsMZXr<`AQ$Go+g=)J4L z?jlJ(PL#hV;kfPp*75fJw(W3X97T=soc~!K6S3s8y|2DLpzJ&xIDZ@@QAxx6C0q+* zf97H)U|icRF+ulIUqf}$aO_D7?f!zu%onwl)O1R0rfmwcE^>OCqmIijiyf7?HVe_1 z+FmIqQIWruLQ>LftB8JS>70&6NDE6m#;Ut-@jz^nG_ptH_X=&qtoFqecx*AZoyqr) zs!D6ATtXi9=0ehom7efw2!JZtQhvVhZ^}Nj{bTQ@hrcp`^@i-PWSa{U{hol|PI;h7 z;MJz3`G`+a=(O{#v?r#AnY5VhTag&oh(iH9g3&cSxpjbd*5(GiUOotu?vmRVC8CIb z#vIM81}2Ns+mBH%G3#a(-0?#l{b3Csvqe+RVK z+RqhNS>=_(jRYPngdLN5lxAfx;wjI?5w2q4P-UmPXA4oT+<)j`uH%%lsExe|%Z80x(eBHL{kF=1^^uN8}mKxYy?_z>U@wajh`@*xd%*ed-RJCTny z&)3vm_1-&-em45;X|cOh?tth+D1F0XNjyjPQ9MDY+GDF+oXaH7{mKhiv9)12|4KU? z|L-MABya9%kp}P0i>-uLLq0((;eauZLjG&p#tKwJv`SZt=k9oMt<=Q;%j-8WwQQmH zF8vk+`e79ek~5LaK7JXSA<&+i<>jlTNQMF2Vx*pteb>Ylf-4m^Di7r_ftibCAW=F* zbRGh-MtX5IQgrsL-Tq>`Kipvv7PzkW5-X!*qw#^+h%^7u8OHb0HC5>i7I3#b-1%>c zqwq*lL~?sr2lL+uJQ;+e+>G4qQSjPqog=0(j$K-naw3l**&oy^`kFsLNkvB6TW0ZN z9Ksb`>O&tGB}_sE(UgC%jwqz1^^Q^tnh}t7$gLvky9q%Ft;kLh5d?&)WD^_>2ki+; zW^{5q(K*QWq86aggoT8j7~b*uQbFjvGmm-t${h*FO7(oBk0cOJVjb?2Ju(c!Up3&+ zT2fp5^x#R$itPwva~AbjJSRCqI0aSV%t&lX3MWTC$b#Wr5JpElZ~Ge^vp0exzUox~W)q8I(wu@$o~=$j?` zQ3tODuG@b|rKG9Pd_0PmIApAt&?^&cYJOR9C5_={VtvVk(QDfDcoZ*az;MPA)BC0O z?P@_o$9NZp6^I{%)8sLfNw;p-!Tf%BTX5Tp!El}|vRWFII_~oE48cGzVQ;zzy(d@`_$S-9!IMNrm|`>X%7?SjH;w?nxuPi&v9-b=6ejrIb}YE~ZRH`M z4k@-RYdoZ&YZZ!vz&>mqSmJ*}y@sN@SoAT^=>goFAjVHgACmQOJ_{bG=hN{7Rdt5WkMa>8EN)N&y{WWd6lj8*TEX5@ZHX@IC zFY_nK1ITqd&Y$4gQ}K>itoVYTryoa|89>t^7zsjq3baKlHR_4MWt`$8%ht1kb0D2# zks!aY*KGzNg#EC4Fl=C5W|k>Uym$Ahc-Wa#qo%~$XnkK_@9|N#iy{oT878tDtJ#WZ zl~wjlEG7;wA;Vg}cuD|!((#^at$O76Q#>yzjKbEJdbD}|G$${iBblv!-gS2eV^~IN zZ6?zk{wxd`GCkk7F^7*S-bf#ttyy)h)&!JsE^Z_khob5_+*Bg=tG>THPzmXZ#(;s;O}@jo7Hvi;Gi9b_L|&UFmg>1QKu zSEI?r>T-U_k1m-#SIdc z;T^;VMMivK(O=Jv5B5VeMirY=EcwaCa4sLE^oy@5L*>R5a(lI7^kRx$bl@feSqn#Q z(GgGmPA5aAqAR0NA6@Vg3g>EL#k1>EX*$WyJp?OI)n2~+bbGY#5FMQMH2iBNjeN?@ z?+#l3-Rqji6n?#6IDX6%EZ;Z+mKp6C zk)y~PF*EIH1dtUJB)!Z%9CDvWNyOXOSXfl+FG#1afs0WAQs@bfA}4+4CVC}w6z|q5 zm{I*qL-VWRLY=zu+P87(D!z!|v{;n%CGKGhg2+N}Xt=YfsIz{f%CXil`I?Wuqh|#~W^$)fEX4E_ZRFD zw?1`K(vy!DUengXMQQmkDctt@!44XCqsi5)+kOT% zP7pKpJMIpJv6!I*dg!zDcb*55A{vFv7R?cxA-qQ;O;vd62is}2$dGGB`KFy6+DIZ) znH*$w^}}T$!^l~-hhVespz%RMs>2Znmf)6A$(P;$=o|~Fa;Jx`a(vD8b@dBMR79XQ zif@~Klb$AzY}Gnncl7EvMXaI}{QTkavCT)1R~C$0j9uhgk{I=Z&Xg2ku5)co99bt9 z-wzNaFO?f>=rSKDN8k+nu(^CtOhZJ09gCOnLsl74hE0)@f0%V-W!jc0BUx&W`YqVb zQq0~JJM(MM^7dsT#W|FzvGlo_kYGb=!?sK?t(tJ?$cxpiDh ztT+T>!H?hF?_As$Vo{Xafv~{nNFgm@uiXB`OX;qj#&@(C<;42<2Ub>?Z1Q$9%0|0K zpMgcG1doNNGch%S8*ZiW`1lMTb6tlzUzW_Vmov?5pRVAVk5%tsbkQeg$j@eH{Ik6H z$2{ZAjm#~UE8OzGQ!QoQSlVf5=;E>9EaPsUfaWPLu-_tV-#wH!-JdF)chfG}Pzp$6 zq<+zXkT`hBQ%p&1EM!-MdwSsZcry6!+hCYDJE8R*+Z5k6>@5z|HuhCk#FTr$zFNWS z_p64D9ol4^J;D6}O!3W3L6`p@U2g%@)*g0y6P)5uAh;KY04+{&_dEQ{VXxn@pyLI1o^ z<+u$TyM5f~b5An#S`t>X!rGNYt22zj#6-f8No;Gnpa>`e$xcg_^Vkrt@>n>vvv$-0 zJYoLe8N1G?qSMab!|t1pTp>|qlP=EkGNTgcmJK8yUtW?QSE_RB2#JtgrkMTtm`nYvt04 z)%Yr9h_NeqwfN%`y>odv`a#*8PYw^mMk$w=8f+c!NBUqAN2GbW$~=;l5s-Z3-=IK4 zlV6jRhOPy8U#J@r@Fq@O%a5M-UOVU5gn32utFE|M*Rk^sv{YDiAM*TY3T|c&*p>eB zyk2{x^zMZtD(?{`^ryUFbDHN-!m+F2q@V8+Zjfu{7&7P?HJwIk#%l zNl3E3R=))SCUqD_2R_YY@~BQ6V-I0jS`z-3Y9^LoG!p z<>)3!?cN=?cE(tn)nO{d$V}KDTHQ0{L{l2@E}tWP1Y08EeAxo{cnfd|eZu$e^*&r7 zhksduku23QG8_(y3r8FdYa0Ib81%ysT4~{`v20UTf77-3RrAfKR&MnShT&WCqTBNS zfD8Zn1mHh)&A|>})(u3RA}|;YxPqZX)334lU;Q5T94x*~Es(}h5_!>td) ze1K@i7KEog3~8DHh$_v^qNM+Smnj5Dkna}^^XbkL3iuP~j~tTRTj$}0Hu=Q=Zlj9~ zhJB~>x)D)cpmQ&IKz9lb_z)x{7hYCZ{NLf}E`ed+@S+_)!R862^_C_2D&LI4pLP-= z>T^EMU>BwJcZa+q>~LFd)m=&H+y5(%K?_Tn5b15VTWa{v>HoXy0Qegc!!O$2dC$!J zzqa@u5s+B;u3S3}6}3X<0hmoL>%?d8B0sdkRq*7xDFPTSp8+6;h|#0}=CE^&{HlHi zgj@4KZSa7x9IG+r6B^RrhuOANxO|OW>onK53`DtOqTt%+Fc3NCVS2yu2d*;Z;V$`= zod{2N2E>c~UdQFefhW6fh?uA!$sAG^N#PpmeiyA->TdJ=upQqipWsz;>sjeC5M|%< z;$u3C`rQ+dsI6BFSNla&6ZL9MO*Bl`xcu&whJMb`B*WagmwFAnlAD$ahRSA%kTSsj zvKNh=^#^)sLTr{1Lw|>!ey9Aj4)XBQGFh4k1N;SQ!=ixDQh5;V8KYNbnthTzvJS4l znovsX1#b6g^8$ooiM0`^4)IngdVd96d4k7L)4WzLGaZ+JL49B>)yz7epESX}f@%EC z>)4&2r<)OxNDLe#E-S)B*~9bT*{5N66c6?nj#OB>A93SU939#IW|cW#(sa@YFYA~r z0hG*PV5mG}0Aw1goT|9>p8$>lzPtPMPors__&GZ`HR1#S^P>cz{W$^TWq!DpmTENBj=%PBTDn%QIPna~n$Nf0nm;LPEzB0e1N#^INY0h+Nf5mC^E_n>zc<-&;)l zfZJo%Yrxr19nNm>ESWqksZw=kJ6&+z|Dit#&`-L>+jQ-hh(Fwa<%SQ+8=!$K>oQ!P z8p;F~4{sVGbFCa%Q937>P z%q&83JiL2CcWc>u1^1O)!ha}^{`v=*F=85qwvHc2-#QEz#{=TwLGf^kjb$Ie!D7>T zky!o`-XucUdZ56C3R@NsCTgiUoR;iGXi@}(BO~;sv6A}nFLqOf0kFqiVb9s7mFa9z z7r^x5nIoosyov~e!Q0t4R~Z?r~^G*#bbbS85XbprJ=?yp)6Sy2uSETW7MG!2W>sJ8Yp0-6rMDX?i zk0{ZB3@$3wRW=&RNcGrNzS7&q=@FByr@LOUlm4`QOm5#&t%L>Obt9CTw4m-y{U$PP zUti^?XivUYwEpo?;X|AdnqBoGxfz#*Ig@FtCBu`3Ck{kolu^#SQ_DP23l{T zTLGn8jdXzsgI(_%RrSKP!gk6a40Cmxr7%5iLQwD@!wYZ{MXj$l#K0!(@A+GE&G60q zYYZi8wF5KmUUy~JPSoysZve)6&Vg`=uHsj8Lc%>YPdtE6xEF6H0dHw*A!}0!e0oOz z!gS^M-cyK=mSpu|rY^Uz;EA@$$27a+v|$*Tq!tb{ zO_!3vC1O_Tsbn)vPj~Dg<-Tcb3^V_h;bSvcgywMcOX~247>RWQUq{8Gg2_}fAf6x0 zTMxf&RD7HQ@E`m(pTcSyv@SERORT=+%hqX~SAjFrYACCo54q|Nh6e1mKrKEPbt8c9 z&cei&Y=A$@@MY$0^IRgo_6l&24=-PuPIUXn&$gVnd<{DAz!@tHGCxpnjjw_aHi71v zjDp|0&kIG1@DK%@iy@all0q1f&_)wFW=Z&4l_b}U?Wot^EL!kIG=T8%fgcXj2sGEJ zW>ud34~*@DmZf^+QAC4xH=7Z6LB@xB2%hF-fI{zdh1CkMj_$ar=V9!usII>tzH~P- zu>Y_whV7b_5}xS4ii0301BvYv*R%fm<+C6;0%JuP2(T^5y&;ZbnH@6)xG)-u|c8ogkP|sI9b43WM^&MOV`?hOfqFQK8XAGt{25QaBYNY8G6?vbL=uT#3uFid+QdP>T zeqgS2C5z(G8_b@FU2%D7LW2O!I+u`d}vq*XR9Qt*K_$Z-2^K3D$rdmw+=9z={%MzC&aaB)=IJy!_-0_u6@3 zH@VFbpKnq|Z{P(z2m}NQkfOoZV7%vl&Qx()9r12~#2Wvr5QHsTdoO(mZ0l0^42HDn z;(F%QxW6Uh zjrm%H$iiCF&x#6eShEwr01BN!H4AP)Yezl()_~cocr?U=`Wj#(^`xvnnT|eF0eJ(& zDqJSM_wuoI-NgD@UqVBk7UT{nPYJzt2*A{k?}n`^1Ha~y5leFB6qEgt#MYAAep~2S zomV1MSn{axw4PPMnnftx2lZD7%$iFEmwNR4bxiylh{bU4iq=-%UsOCs_K<9*zKXI( zfKzZy4Vf~o+oozGC9myyxU<{!;H0DP)kO4TpJTB^eZM3)C!n=aJ(j&Y8R&Y2>kA{{ zYYIZp7aPzbpOOF{s3n_MPvaPqg{`S6L;c#x-*i>TzO(sJos$1)&fx3!?w^TBp%pCz z?FkEsZnFZnEnD|o)7zPI*+#$>4^+o&kqm=9HyYf|tkjs2C{H*Uf8a#t(kP$olquhv zsUPW)AJMODQ3H`(c&lSbbW4!;eD*5flHzxXDf^oXUceHmWzuQw*0>6kKBd{2EhW@S!pFJ^$!j^iCvT(P@-`bOF z6{lDT{uNC`N~teDj+B|}YT6OpC!`6?GX(Hao~p-))#Nr65^ROk&^D!aJxSma?IGj2 zrUh4R>31I&eHL%ttcY=UmWHP|t29nkX`;zs$tCwU{AY=$r+?+;xh|v{%fkZnBle}_ysglshN=Kb6Cp~L+KIH9rh3XpeHz(j9xSy zInf#m%4FC9Ky|?P1WDawEIIP5r-H0v8)@QL7V|@}k2@a^l=kLzb^s_ugvbfT8o89@ zT;`)vIOWIu$$Pu%s-=NEN4D?PKJ$Y{NdswAdvHz%GZqa?F{Bsl-xs=e-aBIY1_;99 z#oz@#Gak?SR-lFYN~#B32(iR_pbDda<}!Ra{)iIz?RT6+_t!Yr9|S=MpM{UBH9zPG z7k%}<=x3_KGeKPll6V!r=1lk`C{el`^j?j%kaH%LC4P4)0aaobMOirZt6i?zy5So^ z)uF2n^<7o}=X5Vl3Mj|4Rm6^&lI_P06*?ckC;-+MR|TT` z#Cq-WWYtpN1_l#4`b$OL6gt<@@B8H^N~i9cw_*fE@I9c#V?#JeC*v*(YxlVjPELXA zFxkdtGg&e}AVVUdLMjA+F)Y>lrRL~M1LVUbUNr+NA+>FMM1*H3Q-PSrcc}4(JPZw0 zf_0iPRWSjMq*}=QLny>riJ}QF#G4;?0Sk4zxBxW>XA`X*-E1P8vPjj-|hDfE9c{t6JGZj)Fh?&6pdzYqy>F%{LPbrtLV0etcB|sft&qH z@u;R4!R?;zBK|m!cu;*dpXxvkbumma?kHdVFTUCH%GcW(d=rK^yJ`TtQ0}*Sq|7o^ zta)8;J2I=Y|MYvoLR^3FRlS_S5G;$>C^#5H&Ldu%QC5Z|k;w$FwMKsT?PfaU^$>5- z{6+-|5i=5Nb`^?1EFyXy)SHlm_!TF@uExTvn9HSigdZAEF_0xo(_Sa<(?#c|h`2Yo zlTk;#(u%+?8q=dB@nS`I#f$I?dK+^t-iFX|3SR9ZM^-N;;-%g#%5bEf;?SU$ElvGH z2BwDrU^z`DmBW-aE`F0&B3dh@zF}md-0#IMzm0YYFv^x^VOkk#ALn5omoyf88qk2( z(t6}V!jDtjG`5cs7Y}%GM0=Qfy|GQC`cht=Eh82EHZ#(KI+`Ffq7!0Iwc8@f*c>k% zLC4~SELmUR2NyzZOkMywjP}eJ0P4_QVEnDs!Qxkb62&TqykD=XC1XDCav?(-!y51FE(r{9~@@TwLCBF)y z_BVXC8sYkNVuh7*n9{E0FhsZ!ia7T*5rH?57t@9|;yUtaQ^3SaF(sMcx9`B!xB8wP za4w=GgIf;>G~C?VQW=x}jNv$j&cawFy;D9(J&BRJ{D(U-|0Kqw>f&7e&M8=OwM#Wq zmE0Zs6cLPx5M~S^HZbEtG0_yzSC95MK?-^%uObxQ4?oh`wJ7^AM*}DniqIaej4nwN zkJ*iS{flCgD$Sy?7k$%#uXiKccjjuo9pRKn7AJ=+)91bw{|>)x>2N1on6Qlu8uF5x zF7uYn_q7q84U?@XPvx15P!aIwwtDZFg?SRDvNwe&-vu4|5^BF!Lxxc2j|0Pz~9OG$rGv zgGDbcoNu3CAInX9QJg%xiFERptDA?MM~+MSCJvghiJfj|mDMuErW?L7@fvz~@OpSG zC}(&jlgnbDiC<#7H4GZY(FC@-GbOtXl);!G?$q69y-SSb9f>!CzCK1Z@Avnq_dtAB7yL6o&)t;UpXN&g8ppHhobQM) zMIBhX9zy+-9mAXi(%W-}k>;R`moNO|%LwKgT;^WRbZQ_3@PAx@6WB60RvLg+m95uA zp_4{i$i9i~`pkU{=S0WxYTVwt#1DUOUrC8bnp8T~0zDYN0ou|q7ogV8^czhE#;oSGR`DQ zeyBG50i!GCn=|`fuCuk*-FTI&oCZm*6xX-U*3%RvMmv-&YXhE_htaA(k`4#Pew3826W$W{w z0n_TJUQJa&Mj;oVq%!zntK$HAJS^FRV08X&Q!(eV;x+HiSX`i>1y!e#5Y6LEzD4^I z>Q?3!{d%a_kc0mxxvS8lOr#F`DLZ_D&U~^Iwg?7sKbvP;&2XM9)`3Vg=&+wKI!|)) zH?Z2q48(0>S=8BfZ@0|t_-y8nf_Rd(%Y9IAVyZIg26DeFvrPj?7lqnqC~Z6F|APza@iJamvg9zx6AVAwSnbW z%_JJ-uzwYK#~oJyw`zFm#cPWOPtjX&>}K8^%H~Lsz9+wTLgwA#tz&{v&Co_Wf-~Xe zvmdRKAXiOpTiSeZjsX_mDU@@6A;X2t^^YcquN=mkc^;LSJGWo8ldFvt&ryE%#fMA1 zB6^?7nWG^RShuyaS=Bw8E+Pc3e+`*t-HNy`LBVqd?j{T2^jt4vxj%!F&eWtkasYp(!X4DFGfE$(y_U)~8 z@g~j5(x`BcuiXkRpPb-aWw$fseFYmvwxl7VBjDs$r~PzsJ9xqyh$dWd&=IkCIoE$E z9AicjzdTL-Gj{$yYL)B9(cJEij|nHL{gF9n)rL@@xqtyAy}neX&(dn!IV_D%=o zej2F<_t+$Cu56Y(Z}ljtf13B2Shz4SF&Q)XqA9+EWSUD>|DshyQV={RL4$i&>GgRP zRm;WpR?WlJQWVGOlI%kF5o}x{mzP55?$k~uRSoKk_Z<569-pTyCy^hhPyB0s;5P=o zp*VD5ep|nuAAL_iPv}_+Qil?AuT|iYQE||sI!tpEd)3D=X=gGhRk`2xzt_Y3$cDzc zPDLSt{g4QibQf|^5Me(EKTD57%iJ|0xEvRlDKll0r87+%VEeEZDL4`5lh~S&Vf_1A@SJL>XCgt8Crb1H&+XdHRf4p|`%uC0P5WMCrH z+c2MfhHidLmddHn#?UOo0c8EM;FbT}7U~Sm!UhwxD1NhVK~88i!4Fe3Za59*9^`oazGsV zYR*-U0TVe}i`n`GPmU0D30NVLxaq^n&G!5Qms#x+XQvO8%vJ+JvNT zr;Wgu6l-rC1nzOg+~!Ccb0|Dz^oG2evAne1U>ql)MPcw8)kKqjh+2*o!Q_#zV{mc8 zlk)-fbxR6hfC*EIS^S3nebS19ynj2NyqAX@8Uy^pCaI!H!1KTxw1vq zk?!*42q{0Lw{RJjJz@Ep3eQHsxA=7M>p4eEvgonIo|H0Zq2Z+e(kFs2U24P}me5%; zmY28)e^+8O ziinzm>$J4H+ZBUM({<^bMPKx*qQja3ACfZfAmkL{Iv~6Vh>5FtgAaWoT2LNtn&Yh2 z+kQP|1BV$H0iJtG<&05Bu zRYifcn$RQteYB}Op-J{lYiU+@*5?`Lz9ZUAyes1#@9~z_XnOcQMk!4pVqgb;p4U1> zdi$;ivaP{I*h$Q}Tj=>*?UiQDsjE8uFVVb7^;H?lV&o}Z4U13deLP}qvabl!MhqB9 zUF4@&HNI4n*&11m3Ho%c<9?`_Yj(Z1RbMW1UP0j#%o9O7ZLcjhHTRO-OR&9+Rwr@w zI9iSPA`}nVOEWv!6y-6(3K|gdTgr1Squ)ZTRW2G>xXcevVoA&OTN9?n?PP5@ef^2+ zU}5H4W07@Sk{IuP(LT0kT@>R242o`R#xL@Dlkhg^#!1{Z-7U({13(ph4(RViu;ePL zBY3d*(Gc(|;1##=sDpf$UIm)c_?TWt@IzQRTl<^?NBeeA;a?A ze;dML-Zb&`!cqP^;Pq?Qe?j`dAUX(C{Bu~fvu65VjrnsxCHI>9QlcOwxrnBxG-~(~+V`#0CGPGrD^4 zzI^g4n7$eLwp``45`UBaV|PB|+lb-hM|zbqN;*`QKl{=1dTp(0JIbPRuIo@$tZWC`c07H-V+{#eK2to8VDY6yRs=(aQG>M@BR4oKes_NxW`Is_97Pk?&b*d5;9>mcmW(v-zlZw2n}h~~Zly%?hrY5v&Zx1P1tHuI zVAzj&I5^q)yqlzO(Y|dtofyy)Pj=q>Ug`7te&}j=0#wvgJD|_|3aCQP2h!YZr2vF} z9|)vwAcWmsYp()X?0q@02aU#y0k%oFAYFadfmsN^;IlK?Ge3e6c9}BWO&b9%cLE7l zBo-)!CvrM^0%GEjQlPneUyAxc9Y72R5#Y4K*AV(A0LD(h2T;3IfYg$k5TGS}V7!^7 zmvvQreZO@DJZcBl@t9wF?Bri~ME!T|F(7~L$0>1g%WXuJ19#y!1YFd|(eDhzTJ?nsGhFr9kkBsRQlaN2c`sAU)m~nVD)1qk-D38! z;?EyImj4b_(-suX{Tx*7u)m~2$cI9*^VBp<~- z5_1ZqsDb%G0Rcj&fZkQ(3_O8U>T#gLx|K?F?-FR~hB}=BglY1$EI?&FzXAe6^uxTP zA{-uSz_`yDIGEau7(wxQKp~qjjpUe#i)lgnqoU*voYYCUARcUg;17d6hl&%L!I(|g zzRFP*Tc$u!wevmzv3ZK_)Lyr@z-xdSn`y1!&*b+C+s$p$+y#eDY$qy?8{0`)X*N{5 z#{KUffN$QV79eR{T3uXLZT$mq3I6)9>@qtnuzQPU zE`J*2NF<(E^5d3c?ZJJ5=hl}e{P1a}^I~4>9ar{JC8BFa>f1GJ_muQDhrwh0aW#4$ z2TQ6(^dk1iD{s7kb24&=U^OawYfz>n{eiKAx0l-YZe6gfdED|vp$BkI28$d$+5mR` z_D#~NxTYEWEb8ewbP8akG=uTD)d6(C>92DdRAm?7Kx=5Eu+l$QUIX-o?uqd8SpsU@ z01$+x$2!vw5KC^aqY{9r@BBq%Wy)>(keMlib{il{fAWBH5PkwwM&a4FtA6K00>tq= zyX&DXI+_b`Lk2fmtqCht=x30C8z?V00FE@ck&t>02uxz61$w=HuWV|Q-&uY;fM>m3 zfVjA}+Uxs#jsrY|*Pu+N5kVv&$=BZ?buWdci&EYrHFhH0IWL_61fs+xC#=4{o`Yd~ z->L$_G?lM^Bvibq~C| z;#Y0d%K$~6xc3!}&Tn)@fynO)auYnbPTZUF0N0EOc5!3G{?r#V05Ysd(cw?ku%9_w zhmC=J7=W9ieW_eEnCUb?WeH%j&wS5E&%^@9O3Ty$zzMCml}g7+>1-jYXpswfB|_vM zW(;M~0dS~2UktEyEuX9>qdMagRGLLu7p>9-_yTG{PLKP6**7|`%P*m7b2SsAxtns)Zs!GW-Wu*#|78V76K|>^x{8}4@8o-Lr`!n)k&VLrv zkyvk$Y*9a(W1u-q=VcX2@5w?BdTPU)4P#Ip>eSBMvd;nY(YAcx685z|4{qwk( zvgp`L>9hoNIV`){B|eMdE*3;*24R3z6=^Mz5RvFZ0?vyO@|R)Kh*t~Rde)4GaWA5) z0i{bh|3t;n*f}+M?EXhkSN;TG&@yXJ#naCn_i^9L2~+kX$(Z&(fzVV^OdeiO?Zvqw z;zO;!yqbZuG=6tZO-T*xtx=s06Z;MQxcYKZIezTv1bL4qFHCqsmU>~mQgbofsb#c% z0$c9)XST8whG%v%l)z9K>GKlse#)Wz25%qN?@mgoS#>X-Z;LOfy3#s={0IsNm1wXC79H*|zvBAw zO%e+^Kqv(L=!I|(0fYik{yC=t#SotZ0JCoP*;-EE{yItF00SxHI({)s2mZ5hqz_jj z#S@@<`U5M&39N5>TI>>CKt%CpCVLq+*nbRB$G<*Tp>PblSTD$34Cr(XLouzEplh|P zf3`7=kq_wIq6%uS6m-Trbepx`Sr9dm%<_Fz%ayh?v7A)lSGisF^CQri+h8>PxIW=k z^OGKZI7IN2oJpIPb8-i7au>282%`(C#I1(Y1Sc z-OLFWYPw>qyjS2iq$;J{pcyx;(wFUnTy5#Efk8S$MoDTrlVksJ#`K`gz#?Z9-vrlM z?V{b_X5VCT*CJ3GyWj3=F(mSMRAv2mTsOK7Ihmt?#wtFz%li919U9kR<41s{u82Cd z5PE*h$tNlkq3c8>6ci-s4LC4oECHT8rfr@SHW*4zKG;4=!U6pcn16W$=BBN-* z=bmZ$OV^znVunC5OUk&gf}3s=M3F9IeW*Ui9!vSvYSO*HAxDHMOx)5vWJ&_a4O+^f6V-jZN#L6D@g1@> z#kuo?jGxQrv@hg2o12~oTkUu17yu9%29!dt1=Q;gTd9hlkObk{EveOv3}~ z7dP&?2&4G&pVwoLoB^$PyH5n5q&)o748R6+$y+apOt5J{XTUaLn*aHCHPO?jvtY*` zG9-pm9Txc0SS|_fP+ypCay|>IbIHy_OlC=mpS~fylZGuS*gdVgtM4{AF?X@Sv4;GN z)pX_}M^hK^IG+=1HA23Ixrf1m9uemRKMVjJy|#q@dTD3fWnj(CejR}84eOE^@4l`5 zMAUAitz(_{{ybcmw{?u#N%R~J5lPaPR%8rSsIh0-j;9#6xWJN%R9RVUH|A(9l)dFgFZLqf}o#(Yzw z={)i*?!A89=iI_He}F5OA6?4*mmK?dmA$3pnq;vJ#A~k4ozce$=wBFJ!;wf+&E6c) zW8hQ8Fv{g-@(S}UCBIQoyxAkCF6P|kSxao@tGE_P@xLYrBhoN*Q~!u|F(YDjcKgpr zTK&h8wIw~Fs!R9yHZp$1!!L*rv-eVkDrl!7BzlTfH*E;nRE?AbB3)qOSbJA2o2quN zQD5xQZ2?_Gfr;&wWNR4+VEv2A=x%NQZtPsVF_z@+s)`D0zl{hc8(tJg5I*chmQ1Js z8kVugH*bD~8KiOHoO47c zvEl0u8Dk3=Xa<4CRcF5q3!T1sLx02Bl4#eTCIF7b`Q&H5A8{+Vu(`274NiH3nAjk7 z(i(N&eRpQeFP*Qt%HiX)Qfh{?=@M5`Sv~X!p&K_mCe{tJ))6d^ORhmdeGzQ=j>;+h zHg6~h4H0+MBnVsYhm}vh?fP~O3diOjTJ$M=Uzrh=-OjH?dP=ssKd*5=K+IlokTUfL z5o!{+42p)*v@dYE$D?cE+@^if+<`hiaiMz0WB%EqKW@VpU2=?*@nupM{Yn0rwhV)Y zIs9i<^VeDu#KbSPS#ze`lL0cx@x`kCiEkHRqZqrY`)M1g=vt~h%<+@!LgLRoGYF7s z_FR!!F)IsQ5T_?iRmL&+%RAK!6cLGTB@#eRXdA2R37V>vgra^_2Z`7*b>kd|Z^TyV z4eam5Yuv#KFn~K|HaddBG!*fkU0leY3H=?PK(kpkWq_hyxUlL~0dATff#{%Zd|6u} zh<0zuCE`I(x7=??c*QD8d|VA?D3P%3$f~q3Q2|~hgUS;Nh%Ytb3#j@jISi(5(MA(G ziLr1@-iwk8P9&kaZPkr+DCW*h_PT6wk8uPH+;*_AL-cPps##n&otf0R8mxh>cKDf9XyuITXNI3Xf}H6 zy&69g&Zkhdw5qP%SMRwf^1V;z`=qe(Gf9={`}gF6NuH+Mss)VdfYEWOV?WO9dPgb4 zYx{Htq3uDT5^(Y!QHoR-27k-1#m znG%mu`c*v_ouOtQGDrj5lV0w>c7G+V0jWR6cjT3m*IuIgpdo^WK5~>)AiQ5NHoMhlk(wrvpx5@r`B-bU7o2HrP5?;r8PB6qh@S$=okm7d|xM~@%_u=d1Szd@WA=vNvky}IX9YP)o(uI zZlW5m*ILAJ{t4>AVa(k^6luc*bA9)LOXh3AUn-D7-4XS;VW!(OK9X(6O+Quf2ZSa3mJOCqmfYQLy>5{L-0@%u!?`#WbiH0uilw->3oav!pe%3GyQR0q|7`+ zpP!W)#9(T(ibWp1j(|?}cZA`OMd&IGEB76;eAG)Fq;u4O?xr7v&`fPQ1LDHTz*=No z&NDH7V7Z%4szG42ghc{v4$u01L#lZQ6mY46SAR&A*K=J;iQLJe9kxPXG;ux@N!Hv& z!RKV*T3F2uIY2#C@sQ?9Rpk^$0E)!a!OQj@@yT>Ky8Visqe_gyqP;Zo42Ku{+Dr}E zhYiC)U-sKKyviUvR~)D&%!;L53tSj6wNJ1!3IwEjeSe8uO&z6^!*vr6T2)fOf_`|2 z)Po#gH*?*7aDHdEYpg~+TiGp+S41E6_mk8RixlOO5G#4y1Dc+iFlpv|6qFmsE}h~V z?jDao9C~&Lze->_gLaxq~$08_V~x%()o@S8S>kp9koAtO*O1beXoVVjo@A z_2?6DY&Nb;6$4~O)j}AxXLTvGQ9%(MwT!IfysUUTL@;Y}pQ?9$wZRXaA7~4|U%2f` zU?}zR@Fiu1c_QURZR`32D=)>r{3K|T!@E2sypko*{(5AAyER127G3S011<}frT~Xz z-VAo$PtV4z*%OZUcc_#S?XF1=`*j(aB_K);)Gu7Z7<4vS9&#Kkw@nBuh&{KP8 zD!hqM#O>3_j58G!$o7N4yrYmo71P@Kj1lHHYMXflK4GA`{1dE-?>Htbl*RZZYd46k zS>27k{Qf`1Z@eKQhfZQ|G^)o%1)VjG^1tbV(GgvquP{l2{NL+RdRMihcJen|zl`7h z7V$X(n*>v(i{*p}Vdxu@jql-Fnnwq%Ht^C!$O-mB40|Esm2T|8b*yS9GAwVHh7J)Z zn=q?kogbsM>yIFY?WhWQxvpM?fis$zB`F9Q5X$r#X^RBstXm$g z1>y2>^WdI3UpLB2`OS%+x8fh#BL1Gehz=uE6}_G^ptz>nUN8J14dEk=$1AM=vsaBV zgz{<$63vWhi4ZJ8F2?l9;KO_2jRVmvmyS;FkrV;RwliLO3?9pf=AtlUbp#YGpNwG{+Tw#f?XbIADm zYYoA7?2IJxFGbuBzz9ef$dt067JQelq*KYr|kAAqvA1>Wzc)(auIY4D&o8d+6BXSnk0V&Js zVNq}QLEqFxkyO^)BB-o;#;Ux!SD=voryO|Ok&N%D7k?3Ln5(W!ADE$3Zs4P9p{O+Q0#YU z`j@s zhJC7juN`IOT^j)&6o9pS)_3cs;{YydCydhwoG3S-2HhciVn0rVwbRcGvL3lO7S}u~ zZ-k%6GXJazJ68v=;R`Wu-#Hkf8CbhN)n}boB5|Vk%HYg+fJ%@ELq|2)$uCbT=Z5aC zc4sX`%psd*e+IPX($0;%1-|yLS8F-TE5*s_72Lv@Wu6A|tf<=)U`uU5fW<$zgIJv>6lc z0s^K8O5Es=)Fucg(lBNd|NeHL{b3fyr(UOF--uWwf^R`xrEyxq{u4t+{i%`4 ztWL&nJue!BGz2$k?-&(W6X#=xZeDqP*O|iuXsxWfvtH6hxDWgW^IYyXz&4Lt{vdw! zXxTexGIYhG+RWL;W5@i{JjH`T$Bkw4S^_5Z{(;wt*yq|&xn6pn-6*%&HRK+#Gan~- z|M~I+a7EJBh);tzth!ZUef6nXwTA=fRg)z~g4DS)K}aZW@rs2&qjo!Um{Yq_J3OuS z@61N-`$oMPt^S}sZp1X~Jp*Dh= zGhQ8f5~&lXzu4<`Z*eE%1!Jzm1^u}fa0HZd*bnT`;1o&DwCX5{9+HnN(x!C?NO8Z9 zmg^M}2f~eJcy&U{Kjc&!(8*(B{;{E|;QiN&H2d$>4aN&kq*nnf$iEe&f+$2Hw%&5D;Z>GrR6~;Y;sZqFGlPLeQf~Eq- zfJ=yuF`!l}|C*-PvlU#XnFN!wJMVQs`%^4C3>Oi5M*`*9cC-?|1+F&@|lY z3`MZWnUJ7PSp|A_GwG${u)3p_Kat^m}fW*mFd;+)d^Orbohn;Q#c}6mKxhJx$s$towRst8?Y- zW=>5qv~G%-78 zW;PbAV924iewHpXQA_Bjj zbUyJX-e)?X%UE8DZOaf|$IGitpbh;EL%LAe0K`NXOit zlUkX z1~3@)JpuW00vJ-a2Ipi%AVdkCifw*B65Bc37jp+yG(P~O@%{<;eA{frNBO1=;C)*I zf(_+Y!Qh6&zfWy{lUKzkEk{y;yky4XKW5wK_{e5ivTg4-i$#&n%HfHspjyM|i zg}=2jv0PtG|J3W9?2;NMR`c(R!P;mQKoUg~8WHJO8mJ?G?SPiegxJ`Ha49C%vp}H4 z&TZn$8VR*Ks3u|LcpL+AuZb^da9t`+O>NCZvCy%iUZU#Bt;^5yDGau)1!7M8c{~*} zA>7?Fxx9@~^QNP8TXLj&$x;s2BZ2g1%>*FAnx*-nYlUZ%+tt&yY*L=~2|%G)fZ%15 zdxh-~J%t?)i9a%n5!FWR^+7^~-2=*KM*T0CgiQs=3Y6+|Gd~H?zS9A&yY%I|8=${+ z(4h(F+ARd6P=23__$+03s)bDPI4ip_%Xi_SJ@F53ZS!BCTR!djFHlUbdb{FPj;{re z8#e-}9h<0M#m#`S(34*kbq*XFFQvmgL^#Ac?yd33*R`WgH|(3wWjj0BtA^hA08Qp4D?oB~k+=Tc`&ct21@a43GT1L** zM9zbW=qwd$fa$t^y@44Pd%c=uHA@K)6Sm*_&tFq#UB%NV2f{dK$QV-+AMn6CJ za00LH$xjsgMm<2n%ffmG&~B3M?5La5?IzW%8-e?>-A1%}WTh?8TIw?P$iCW);?<@b zE37`~TP+0RRTY`~T)2dD)5@wS*{67s>c_cPoHOpIDtU__qY6R&Yd!)3b!{c^(z(-W|Va7*{A_^cQH~#OD z*mYT1IlG26iJagzEhpwV^2YRm?P8}rr5&v6cLbQ1F*{L+{x+nc+0FoPZ*nA z@kl0HOnz~S5QkFl4JoZ~tk758@P;5AW1rCj#rlrqlxC~NUi}(iIM%-c+ya|tH$d<% zTSbFvwTVNpV~IYyD%mU`ceT`?RR7&zd2Nzy1#Xd3g1ugSWy^^MQ=gT!c=5C)55E1F z`oifo9C!`vB|`SjO&w&yzc>WRURS+k*Q-Tr&sSz$+p=AUDG}}dWlK3)Ku2YbOc;NN zLBc7_izFafDx!1-46*)}$r&yT8fUU87CWS|t9#CsV=V%6va@C0tI|G1{TyObKp zhw0x>D>~y=M0{2{@V5%_YV*O3N24{ywnfF0$+>mH7m|9 zi9}%QiIV0wsytDrdsxUN*!k6c|K8R=6L z*C8OD(7%&*Q`&s-Zp22GgT;gqXV49Zan128ti5TwY4)xHRu>#=1ZwxBS1C=neO3gs z)+fFJ0EFoJzriCmarSiVn8N`nzu4NQT z2tYg-$nAbQZk=M0sE7_Cm)xW|G*3cnA6FlP35Xh+3aa%oP*oH9wp&>71H%jhKD4YR zhBa*RX>`5Zz^kpM)7da%@>-s-@4m-hMK5+5cGY6(dIy#xUVhx-@A3#ssJ(9wJ^G;q z+nM5!@!S?NUkpxJAYIol>`_yp_n7xr6hlPhweb{*y^zU$Px~qZ#h!6i&_OKKSYCps z@}sTmArC_4i#>9K&UH}6l0I4jmU%HX-fStCR{Is38gWXlCc^ZsqW9s6uP?Ywvpaci zGhi-(vJO=Pn zL&fctGSwLOcqssA{AbzH2aP4TkEa65S#XikG6;9fsgRfl$Y*X?NSTbPg8#I2&lo?@ zQKE)6O8q7Zu&5r@Rwm#sLo84%kz;rOs<_mX0Y1H+KaBSbDN=0?FN5CEKfytW8^-%vC9Ubi}|i^QImcReD$0)_GU0kgf3uem0~=!h-OOYg`12pZomX zMtCAdNtzPJ3=*-&U2aQ@3)^xuQE5fBzoj`Zf7k@PUsg}a@^r|ge((q1G3r_d*<}Z7 zQ^dOKSopgSZcA zSB1YfX$-77!U}i;TyRt_p1vKrli)Qaw#{tA0u1ok&eX*{u*}npL|rJ}g5^y>(Qsxs zDNO@CFYU&_*>L^xZa2;e!v))tInlSE@?HO&3r~5aix#zlVjB%{uTTjSO zfnw;b@%5Ye+~HdpVOaE|OtvK-S=bHurc`3zlshz}UG>i)!`P!?4zW*&4H_gEIy|;d zaP60qoTdm&Oo#$J-AvS1-{W6x0;)0u3k7@-FM4%xlP@U&J!O;j zkb51I9S^5#xo(H`?Y-PDp(pXo6mi*qpSZuEbt7jR3Vi(5i1cA1CCfd?FPL*7dyvFd}aIJuXv^clHZgfv78D1X_)0uT5xp2Dn$^jtfhqH_2YlWCbQdUcx3#0;Fp zHTSvP?!E4g_5QPqc)_7ZV?Wfk@B!TgBcZr7+PU#SJy6L!wGH!c*jere`8s9+7t*y2 zvaavJyH@f`npR@LH84KBSN89m=Y~}cxGD1HP~W1Lixl>8uQRLk+@eSJ{5TB z-Pp?l?ztUb$oanpNW|ilpUXi*m0}Gy{aZyB+Xzl9!wa9SCGQ*Md2Olt)hEK@U{yhk$)0V`I!!i@~jN1XC=bv6Qo{p z`;ZA}7i0LH#4a%W0DS`#7IJnauao4nt!VKHQT;&S*Z>&)iyHGBFF+D+M!uA}s zY%}h@K37Z%On<^!LlTQz!~s(+6R_$B#wNLg3KdtSDWTFZ=}wb)a*V1v>}IF$BVi7B z4#VU4FEgT-tJwTMy?_HS@Ebi>HYycLBeG)d-}$3G?#lXmY-(=G6B-QZldYGFGZ3<& z@0O|7g-S)ab=L)tji)+v9S7HI3l90^&OmjH_}{lOTXm!MU5T_0ziei2yr~~v|4L;& z9*Y>m4+tvf{}^3BD48UUdXX75llYW|VeS6;x#A*A5u#377i7B`+tHMsRafNWcGsur z9WV|xiKKpPvNLw1#}sjNlE8+CiHfJFbJ!c}^O3M`1sudkvQTTNYK{&)`~bF=AbtF# zZPF@hWCO>vX-1^XrrI&u1TDFEvwc;m?7jk+~0X77}9o%Y|FLz-X!FA z=@AaQTe~kdc5E;Gg-EFMpKnRpKhcONhm4a|cuNdTP=cPotO-=CGO~QD^4) z@W(edlRu;I*qAHKA;=e3F#!H&|6ZBg)hjWp1+-%QyR>(3B}>_R7J}#cnjV9H0jQ~= z^?9c~!q}k-0xw3qE&vA8m~Kdx>ac*9^i{B*Hx<^7vO2B(p&rzpj$|NF{4=E!H%iB| zCbZ>%#~pL_iCM?u&0o4tnNls9!rDdg+Ss`^lJc+RbU1SH{rnhaKl3gsmGd7}%T4H0 zb_Z?Fk%cOV?BWl3VDOt?+=(~)do;93wS-!{CVrvbC1N%sR-ho}B-~Ph8rdNu!KLcx z`iQ3d(*@PiGH#}`)2Pytq{yl~GPyEAl%w2x8`{1L9O{xY-X+Qwm|qIE%7}L1=l4Z1 z(UU-M%jOtyQgOShiTUS&=~wjdt_wHwW$_=zjXn=)AIRKD(?_-YJmJZ20xT_fOw%iN zvWG_qJpS(G=;Mx&zU1A@+HS42Ao`IJo7s0~iC-Cr&K0P==MYWx{r-!Q(9 zo{IYE0WD~bgAJ_*?gcW=T4nj@_d;&-O$EbB8Ph~F>J4ZP9?3jOcmGw3^KX%J{m+Qw zqMTI|G8TUPtE9*@fC}!*k6|9{5aQ5I=dyqjqrN|t6~1% zo8~izXBS%c57ip$OIwPfZ2Zg^@&538I5;Z%AH1=Ert;f=eY4aXhAsDycF-Opk5$Fj z))i~YT$(vSbT|U~4s;+TbFwVnf?p*6>w<3|~p)Z=OG1#l+>UJ-Cf8g$c<2LGBCHcgV7B_@jH}w4I5s34aK~dM z{>HWgl`)T!jP}pCB;oQZmBun%QYxT%mW9JZ%x-Yp(B;?k>-D`i;pL)^c)}!MYAUU4 z_Ly_h@z~B<^@Z?(zLorD>TgmXeC4hgRg@#e0$Dk{wC>s#_c>^Jp?GquLk}tzaLV5G zD;6QIt6ma7LM%)#*nL1trc-Vun`s&@$D6+kX}10N9iGl8{DAOimoJ3m5%1&2NU)|kc zo}Gr|IVE-jEoxFBfKtNVc+lb^#Gq*_eC=;9r}Mnd(_Ejv5S5Z232HmI*>#1AGn5HY z;{KpCtXhTPln^$5^!1*i>yx_Re9=&HiLR~qj}B$x2_3n5g*IaQOZR$G#7X{=h_8uP z?8(HtGV6;(Jmnyhu2Pe?*lHfR&%SGsQmsYCA};}f7K>#Y;MBrOx<^_nTGZk_By`5t z-^8ryV4}?ENm>B&q>B78rVym`Hmr8rQJPaz>4^Z|A5CtrWFpmcr)DQt593o6IDM;CA!T478{$s-^ko%xp_W22^PIHEmJZoTj z$Alm~4f=WPkh7k492XbO_?hX4I)hVX&`UhV@Fw=yIlB>`t+VRC-Z7LjfktT) z5~785d6hS+6LC`s&ypoyMAGIWY8O}2um|RYeLT9>$PiJ&_y4XEm$|ez z)3Yvo=9c$Vu3ndi;~R!`Ygm@PIo;$@W9+H)2{XQ{#T<^x4OU|3;1Xz+|R}CfO z23fevAHg%#iu6m&jr|)#zJb*M=g7j+_v@S6p{x5*5ZFt5V@OX98KYW?3rWLqU6=zy zllw}BQXP&*K#gC>RpD=CCbrH^=j5yqQA>Z$lDd>;8`xZ z9qGg_R1NqLk6(G?UcQc#saiH&?{&Ii6xy z{CL7BZmu%z?Lw|m-@F%iW_xte>Hj@n@SUXO3_a9WmW|Z3Cye8pS|3*i^l$Q@e9tV! zTyqi@Z&gesc;cU({QAYQ0RVK`_c=rh81oo}R^yu=HmP*6@3=RrHtO&XJoLWxg!wF8 znr*>@@m4?4;_wSToR%Uj)Y?@-lJZTJ?zH11sn#yE--(d>#M5;2+C{%h_^gOdZ~IsC zdrv+HOBCc5hdS$w%MLT^x##npEZ8`c#38xt*H|~LzTVn{CM*|o{MvWSPv(f`s<94* z7R>Ui&Z1AwYEP(e_C7=q@Xm7XCY}e}Z;r+9sHq4zO5s5|8vc0%IV9PyoqmU@xcSC- zIp5~gTy+b3IoVRprIn4&Mrc`pZwd3;Q8*9#>&%)ITKeR}MxHHFrRba|;pX?@x(&VF zPEwNm@T!cSv#q{b2a2>;LQ1yYSU2JR;L4h1r*ItEDbmWmwS2I{TKdlOd&|uQ^CSC) zPK2xS7ee9bLB|I~g?5cTBYZEOvfwmvpVsv>?46>XqQfkN9)9sb4)W4w$yke@^Nu(a z#VGFy9sVmYJay_4B#2S_t6-V-UQh5*_u{N}DOp_QnbD2wU7O>$7@6{0oV z?LZG#lMW2i-EC&0Qdf!k<=#T_kG+?D!4!;9aybt(>VM>iQ0I-HKK6zRJ>abP(o@8#QEG#cc%S6+*@f$1&-*@c7D9_2#yAe@;RK<>CyyX< z>`P(wXE?00mOUnngT^o}5;Bq)we0r6JzuRKNTrmy;lcx^Va26&rZ*ERVzqp_xAJwv zt47z9UY<_d3|J(olG^mQk}K(mXqu;e$w#Lww0Avu4;qnF_k|hcJ>i>s1uCx@c9!Qk zbi{&$ZX_aIk)IJa-58q$yCZ(^on#he1XDjv&shx2f!g8}9@sN*F+%jOy}-iuT=(Jk z*p0VIPeMA53V9XpOpK;{(UdBGRN&yOc%uvJH=o*Zb0W^GnW2H^>Bq8*J~=NYxBMV| zYc@~#=rx~!$vrsY0a31DXvsPYeGmyCAa4fY*a!9`+fLMMZT>pxX zmS3=W;Qemo(a{~BVKNdfmzWg+y6eUFk}hr3K5u(<68Q~JkuNreyFS~+AdAFi`FTZ= zAQ?wOVLrSZE8ST(?%2>t9jErJ;D1Z5tr)>EWo%5G^p%7fa-DW2*V_Pa>fKh~MXI|)@j0krSI!+4OO@3_U;YzS2gPwjD3($0i#5fX z#$lrDcX1Xad~zFm)}H_OZq^`Jp@w&mgg7Ka9Tp_a#|S7N8?~l@(~O!~hxy1<@#Fs_ z=A%f6nktjp45sHUn_OfM(qBX-qu)X5f&oN%(OPR>Bt-9(&^TdwF6J6EPd(V!NY8@) z_(U$~zk@NULPm@Rf|I&uDZ}~~E-`%!!tf4=2I1a4!O!j}Yb~5OEpUD4F zq4oJmw7m`X`OVaAEs24?2PVB#1t3^DMpuE>Y^{@CzgGlW=R)Y{U-dgnFTKD_P5pG* zMcr#9#j5{K2RbVjDS5FbZ*>H==c-}{KUqf5dP|_X47a&2Ahs%?BOaHZ|C&!}JKmt{ zD`!CZ&GOZ~JRF#fsV#5azgX+f1&K-_^zV~9mlS9xK&Y3n8|X?d7r)(`1q-*chI?-h zl3FI*JvYDA6oP_FccDZ_Z^_%M!y>jsU1lCIRa*yHTSX}_miZMUlIXAt#_&ggncTaF z(xoS8eRB))YgUK&yh;pUBx>Uqr**<cBbG3p8;Tm|bzS+k#V?YqF;Ei;(`L`{zX zmU!H8>3EN)zU{tymoJzF6aa?qR4?PLGG9}CDOkoI8S#uQ>Smrw{CYH^TLU+f%R)m^ zs=(~dOXrsx<{a+Xe>(ZV(e~fDoA>&*<(89cfCg>{7XjW< zwD0l}Q2U6A8Elq-oa@)FBk1xMJYmdMp_L>_6X``fJSda{=Mg^+5{?73e!o|O{cza= zLf>N$?fy6Q=3Du2SJ4IdN>V!5HzPs=l$Pqf02EWxT1&UbJ@E7);HznXkSK0D$+{^W9splhCuyDJ7EF zYek2TD{H}#*!O$&d^j75@_oraX1(-ZQuu|S*>=q6B$AjkgU2l_ zX|@EMj^9!D`VT{4v=*+@xHvc_(t&R>!(m#-_YX&a72+|Yu@=JH*x&}t?wY`CG3CI> zrnGM53(C;8r`@nC6M24(b^lDdpd(?LXe+f$aZfWO}U)GtxGVzK38uStWEAwsO42xok6v-_=N6HvSqwCv& zGAbiD9l_?m5wSqO=PREoT_7p+;LjcZo1+o+59C`LD2{!xC$?dSxXpHpet@a%p)o!l z!r)ar{Ml`MJ%nq4Ih;F|`th=`2H)IV2cQHPM15LS4D<)N-tRy>Z?;ge>hdD@-&jM$ z$fh!C(6cz%g+O3=B-v;@yITjLaMcy-s5x?lP-r6i^$8u(3(lU%4G^pDGljnsy=TJR zp3N&WEZ0@L9DQg0u6b(J6($J3hWW!xS;A&+Y%sip1(FMy@;xhpSz0lmQs6-ZV&aH+j93xW&b?t@4?6(wxF)U3qKGLDt3>Q$Kyn z=er-CQE%)yg~kAj&M7);IC@m_Z8 z8vZqvX0A>6^MWStweuDTu{t36u+TES*4X&FuJJb*LydUnGKH5!Pe9Zs& zPNkLu6lCGo#xU1D=3&j^4?Y7>>+6nvyfyhqN`+w-MQHyQo8dz=N`Z%{$*}ns8Ol?* zsp0XME{kGGBa-IGH^XhLeE;7?c7P?U3mbV2GOpc9@ek#_z~xV)OhxWISpFxO|9@h? zjIdT5OtBqR#~!vMUAW7r2_vSfG}+iYrA3ZEjNHpLpggq}vK$(uqH&-f;=81Tc|ipmfiAII?WVd(OI1p)#>x$K70hS=lcT z9`qeZprQ;P+X#Pn0|SQ=EDZ8n>egG(GQf$JeH`HrQoqBW)1H|i-hm-1Lvk^tGeF2C z53zpiiIRaqJEhA+`~%C`kiA=A9i}WC*=41-Y2bh^-G!6qx1juKy2ig^>*-X-LSBQMhfa;klH0!bC3L=#Wia68CFCPsF zAuck`V9|S0kR#$H%Nc^X-or-U&{eP#H8X?Z1OS)k39? zsHRO@KVyeVAPN25Lv7Z{2u%h(yuwV=+TgIqu+0VW1=_>r5A{Z+@ZhV4#nJ+JT{~g-5d1%Y#o_NxpHxQa zUvtrr7sOq=tjnfLCO;-E1v?bQzLizk9>9BpnCQEhmSWGtZ}?YM$XHtYcs9+TXmGls z*ZKJ+(*S^7#0aP47a7NTDF9%xmF?A&^M7%QUSrxPV68Bqq&{83#zNw+(5zVa_9vjX z77?5u{Zj$`ud_LUfUj||i@%?t>yzBB9o-P&@HQZVTRsR8Y3AUN>{1lYqn2%z=6I?x zY-U-jFw7Z{2z{Z4yTYVcKB?P*5gU*{WqW;K)nW$6XJ?Ub_PR4>HK_)Rj_^!Bzl$T* zde!Nh(!}Ia^zs2&poqdK1xk{EJb+I zF%!)YWaEnLHXg2A!Oor0fpHg+T>@FC?70aL;2(<<&Jb< zZ*mMtgV}lKdIr@&Z{>$wV&FuzSJb8v$}?Vz75_=*9G={a$G$1Pgdf8{^Wn9sb**##PbF-AKyl{BQBYpRg2xj?36Vimug)Y?7W=~wQ`c}P%+8u>j@Ud)!s4=u zy6Wg=wbmp(RPW6agJGOiUW8D^8>B4hMjf4_e-1gH4)!-HFc?9hBflxa9_mwwv=_Y1 z;kXPQ*=ESgOBWVlvz?b_C(DjU8=eC&kEIWXN6&$a4(~+Z6N56q5Ve0mTX;nBEz1f8 zcC(YF2t%!HkE;a($3H{Itfw9p?jhdT2NEwOVLa47U^H3Ra?%mh_2442lvuD3*p*&K4nnk`w>ZweH_MV#2{Z)F;IFX9K_)ECv=wF+r1oopjdk%B;I#MUW zPPD$-=>eM~5#mb4xR#k^gW_5RN2`(HQT~>1ek5H;u0vqOeNH#?(mwE*4~KEA47Gb` zQS+n?!%T6Izce{~YCT@*6N>1S!m1SV&Iu-rhLx{>Sj>bmPNY#(WRL^a9O$>qWxQ`< z;L=D4E9Yvt(@eO?Y7sZmt$O?4@Yvhk@$kCifUD>ZuuPc5Le$fR9z)XX=D5WrnKT!~ za329(NYE2HCVcfv6erlMfWlkce}j`z>H3L>uBY2(4L8zlEl4_uoFGT$^|EE;uM`ww z<5`V_%f`IjKRNpcgL2tQw!^*4tSv<8`d%5$#WgG%%2@Z*vY(cj%h`gbN?SeT=T&gI zJLDgyo4#(AQ(5?IDmJ?Y*IqeK>9{fOTrW^%rrwfT;?jrKIxk_hX@iGvJ+kSJY#aI>bur{4)6Hw%9JE`NgWlQ z?Q~`fOuy|&IP)hyN=&wCqPKvkis@Q-7kzLIhqz`L7QyISG*9EtK$?+Ly2uU4A) z-s`8*)4mO3w;Q{pul0>tT$$~?mgYO%b~n%2noK~TS7A*i3Bjw^de(`tq}@-KCVoY` zQBcjSNfUReyCA+q1uus);sj1|>Y4^o;FJ&q9LI}7GF-=AtT=25W59Oe?{*@#N;qID zZ@xdI`1tRKjF;X(83i+b3gm>272oRkoK7_RAQ*$6gQrT;;Ubwzwvb5&`_XC-Px~Djf>j03#wq+%VI`B#d52zYLTJA*7T;V7@E3k0CCT`d?38rdb#)o}iz_%5 zBTR%Hj}jTNhc%I{=smKt^qm3=HsLgg|7GrE=9Sm0$@xgbwh56o$99uILR1Nsymc^E zu@;>r*BAPsU61>{@}w+M2=btly{wiC%xx!GlGJeC`eKWu zpXH?4ByWB{ngB#D=OM61uco&5_kYPz%2Zf3{7bw|BNk<^RfD>B$mVAD;4bEbACdrR zLk}hn^01X)Xa}LskYY(fU=AO*joE~JZWWf26`gdTEUVz|X4UL))d%Ba%;M*ZnUpG0 z)W(MV@?+S`wL4vVT4L045UK8<8b}O?((gHnM0*M zqYC{*iBsxE+7IWCdynGwAC?POPTU>(y{Q)M9n~ zr+tW1NO#MWo(afr3G(@a`eE8rpI>n>Yh3u(nRAzRl&6HOArvtkr$(`Td)pRgxukzW z$UJGJ5j6(UOp$8_=Y)!XTr{}4XQ~L>sWy9whB;J+SC6_`pD6zgCBYzl-r&@si8&^} z(7QzW=@f%>^_qL6y1{*sa79i$TSDlj;|_`c0oB`1r;nf5K&XsjhRkufb)6$oxLmRa z|9L~)h=6g!2Q?Jaw9hw$zfOpz0LHiiK=|C7+`mo4>9&?cRv_~YHqo)uu6;=A#wu-m+nw-SAM3YQ2hjUsG*K>FICv2iH^0g=5KT;e_Gj*ti_^ z1@>>(ZN5naJ&kI($M+OD>a%>IsAaQ#>$B*}@LO=()OEwj*@oWFT- zh7$ii*u&z0Z@-C@M&O>QQ|RV_Y!n&27H+6Au6t-CpX&HGPIX?z5MFi+nU$hiTe>%; zbM5C#f%3teTXpxyE$QI9j6FkK8iku4?W(6*o_x<&Ze2boO?xyVStq~MWZ|wnZFb)? zAgl7-MRE?ehb6_Z*{d!tf+<+}hZ{!kFsnS{jV7{j6b56Xf%H49tOkrF6?@diM*Qi0p@aMhUMSFA6u@Y}Y9TKsA?7&Q8Z38M)-vQu9O48ct3J zOPQlqXWA6ZngSI65^Wr&wai^4?_I_3x_RgtUeaQ1#UxX0Zu*~oIu8_uteEtaoR%-H zU-e2rE5Gxa5xG?2PYA-B(^gIjj}#^`c>Ncx_nZi^bmfWdB%c>i9P{EjIQU#us9|h( zd0*4+A1qE;!3Ht#03gXkmDna?>Q9QB{CA?cOd4KGq1g`hrB}53z1P?uquxt#n~EvW zbq+7|%ETqy*{nicbz2L3wQsq84?6T{aH>2~9_yUa6Er(b<`7n&XP{CaYRk=RFo^K_ zTOG{*$PXO;r4rYoDh!Egz&7lRZ-qIwSj9)sl1;yxe~;=82#r+2PEYxhR9sPapLE}< zb8n}!7VeiI$VZcPdTpnuGD9eVwr??; zd$e{qzwVaTDAV@bRo*5W`eoP2$F?gIX!~O^{M9?}4uMRk2G-!fh0>#QC3-QYYUfs} z8$Gw-clPO3OoCYm@4pxp;Gwu zF6kwy>n&XIIi+8t{$?+%WLS?bL0K2s-D6J-8|=Sd_Nls045Yv{d&R!BIhddQ(8 zo_eMpQV%{^CUaK4z9_z!p`0{S%58s4=%ak68u!8vOzteZ=l*D&+!tmeAs`wi>AcwbZ`nu(z zf=Ths(vv^W46&TF?WKF&IZ0o9FWmgvFkroEK!F)c_=0?XY2xx%Lb<$W1$Rn^j~3=q zzDhVPJ?>TO1$)=X{6(km)o+!3klg=;PV+ALHh{bE{5 z-bKLi)Ji28Cb%m|zhTW`@!nJDo8XX|gQ7xP3_?$18QFQ3NUTmEEa8xh>{V4^kJI~e z{+9uk9YnHiOSJ-iPZfSfJ_STHUL^HOtiTh=>=c5GoFyj-@LY6nA6^Q-*g*b>>6D9? z)P%L(itkqSWEGG1zyf-ni6z$)?R*J!?4mowgmSMCC!^TP5@UY*^$W-2zxe68^r78C?_=lSr4)3Sw{g7h znN@A1`-)%2je#aiuk7MSGeR-{F(d^MQxRCN*Th>`m^!b zC4I7b`7=i5(SSu7n1W1p7vujHI^*tPfx6E~()yhWlh|BSm3r{32^%uQf}x?t*f{KD zI6_lzSt{>;Or!Sx3<7`kozgJH4N9#T-v3li6-KDS_fa+df<7^SuhFd63v!SCCxQD2 zs=z&7e-E`T_o0$yE=xGdo8pD+e+n&#X$nJ4I(57hmcHr56+Q|5Wr|NOy+x=)00_G1 zbZ@Q+h8y7@1xH*e0AHrSa{4&M)y3@d-)oaGV0eqJTSm-9V-<4tr4(=09`tCW*9AJd zKQbS$C>H(iO+krq%1Hg20%eJxxO&`0YO+({JjHd>Y}#3~{hv4R{}E?lEwE7XKl_*V zxfcH~<<&$Jy=756uFtFdfByMDr`iASt5rlI4>o;)z&Z?6qoPM(>s17T27d82_isn9 z53_Dn(0SAg@JsqE=({Zhi$$e*UO7p~$U1tQV+{t|YA`x95Vy7FADGdmfyBV$N)7QD z*O3(2gU^Mj4`01XK&L8-JXbS>SwbCR%7}f|Wa%?9SD`E(0p`bGI>z`*WC=;%eGQnz zncrH*(gcClnY@tUb@s-?a@GUXFOEEyJcvPkAO>H~W1LKYPdLE?H0(RiL-mb!d3r1fbz0!&zvC2 zclh0el$%=kfoN2-bwPsm!+<48INTdHSjYp+71=%6`X>H&zSJ~r+l^iVMMTM=Y*@bT z0u6V*TYdVRg8AMT;Ec>0Ua9y`%WOLS=J3rD47)c9l8oMMwSqf|k+m%N(YO9sDmSQY zd~=XQJ0d@i>PB$qXoGk_gWcAi4{*dxDQRPWMJL-5rafMQy3jDD#p1k3;1<&{dpjXA z(k@|%cL9`Q9UhQW98;U}228#8wtXNKWVw{te30j7<}o?lehvH>FMYtw=rd?)_H*U7 z%6;|;-*nd-P*bzsz7D@RV#4_`VMcJtjy4A+j)jM5`vA$JV%K%bx~STrhD`>fG^b4F z(PHrRP`}`SA)28*N;`Mfr3C$@G}iL>-&>+)-~h9;y`Wjt8OuVa@1zR>_wqYgUgsFC zdY@YWp%5%u2xv5i=>Dob2zLpaL?-z?IK-okuix24 z+T7F*-sY-cTTFRvej5RzsM#pdSRx2T^Mw^xlbaqeK5KP%?By)VN4u)}FT$lCmx|RU zhaymN^r-%dY!GWJVW1fB_kYobF_$NFs0bYcC0kdmtfEzVHlR#Pt;85D3uP#U{d^l1 z71AnAj$_}r-&M6!zgdXRx2}ULtLAaUakx_;@iJQd?QC^?QU5~i1GEGn(z_;ad(?f0W7lezA}bxk%6|l^ z|G>2q`ifR2M}Ld&+P+R&i+c_7+YTL3INrwvd_J6c&(fR-sAN(*u7b&RYd-=1L|M`>(IV&W8#(<1HZ?aKYUAyK2h(q@m?H~Y{Xw=!w1!WE$Q zO7G$hkX@y{YB#-wuULg77@M=OJXX^~$NfD6M>zTEHeT%0!C(~7&~w8uCOfzN?Q%-s z83r^pKTus#u}jVw2~=wn*gSR||ErL2zUGOsAJ?aIEexY)+@z*lAzC^+F;)BbUEb19 zBsnQ@eH1D>JmMc8E2kLf2=h0YSr5OjD4lcwa^{r}MX0&`wa78(RGJN%9z9I17)aSjxi)1v=zP|ombbN*lt!lH3j-uHF;Y7W(jF*gPn?PFK{!Pak{`~pIf`#M`saAn4m3V2ldQT-Q zzViuihVaad$UC)cr`!zkIn;10PA(}JM4h_Y8Z~ZDe_*(nA!_v9V0%rU^^dFX&hyMf zk#&-^390kYB^^u)uiIY79YtkBJ)+5 z;NDM@WKitTWhb0N2KbpHP1QG@oVL}WCRe`~;)y{&EvEd~ZI^(j}0EpAw&V=b_e;`fD7@N&;6eqxO!P>zdF>~4@znDfj@N_F( zj=O9OLQqV^Jr5zL!s1PlCLU^{1N^nH8_Sw9;HF{6d%|t&+#Xf>;6iF`N5oM~k)}jd z89MWEhGjsp{qQ!19nV^39>nOnMWPAmK}Ixwe5Xko3uY4M z18((GjZ6ttarasaF%R*F<-orz^r_S_^0at5$B<#uRRLYe|Ic2-;QIUA^348R=zMl^ z5cfz5rx{p+3^<~HnEPVtK4+vE2lkmNAXMt=7PXA1OEs~j9+UJ)vc{CzXyC5M;)WWG z39w?F0OJ?I$#qH*^;T~^Sm?xw6oOSL#~jBnFmgSC*i=y+6F|RJ?F|%c(ZA#u z>Tl0MB~?gL2icHEcPB!h|GTKduW}^)E{dcrQ5lge*-2!~?Qds$91{=)3~Pq(Ys8Az zOf`L9%-X1(J(jO=kkNxSD9OZQ{$Tn_0+fw;9e1fz(yJE{4koW0JjQ zwx-mu1}IzTgKuw423MrV^uEVQprg)x`2n+nt8wbkL5TItES~l!$k97JVZ~jk&knE9 zRPrw%4fdyfZyJG%JH|jdHHt3IPET~>0^Y+`Cl55uIHJ0ZgjP!=3U z;&Bb{0pLS473#t=eWsfsJ<6FEl!X07P4*#@X_U%3BU4{w`A8|-45rd-%moSrRllm4 ze>3VGR#e^z5ZR`T{K{qc7o!64dR^|15If1o+TylB4g7ikiV2iRoNIJNVoKtr zuh@!EU6FpK=}FPDo+63qzl1^ltIH@ikTg8SV~IH3Xc7D^V*Zox%`8t!N=5JAAKV!z zor+Hm$6}R%tM+XX21;i3(v(DR*NAOmuv~=aNEQl)l!-VScaLR1MF`JMEV`y{b)u@H z_|e(Vbr$>w8TSEXK>LoF<&4ms47oK>QPT7=N zFOo=kWnUp&Xu6g65P?^MCqnN3{2#%oa=}??gQ<+|sM|}@Ig1^cMq+%QFHf5*zeWol(O7 z1#^`Enp;CTjqsP3x0I4cImCKi{K5Ljko^oS@A0*jJ77&rPIBbzg0*UpBG$foTM>VD zDZw(^C;}Fhp@Yr93Omuz2=l;-m#;c}6>8?K^@=tSVz`G6b;K(Ttt5;~vv%RpQNEX6 zdcyHxcX8)k>Yt#D=ghL3sDCzZ51-l8q8!OkWEZS!hIO+EsQ1q1Zp?AJODl8r6l+a6 z9R|X@o&WluM%rhqMXH2grsqTj|0Zna+Yh6GJMkk*!?40hQ6rB2@~VKHv&12?H%`TVVOcek;AtQ@2KR%a)V9<+ zq7S6Up0mlT=r&op8k7$>PlJ?ybnCn~$?tfmQGXl2X%|sw5z9Fq5OItEd+&l!yNGcq z7-aalns_fGe|{OOW}7PN>9pi|L*45|u3M19#J9S9&WY89X&hOKa;-^uNTH&C<#=GW z67|>k8-MZj4T-E`!Jm67Wk9W)zocZ5=i_pEUy|)TI2->$;kw`n%Sc{mJgs4DIuBwJ zSuZ2~WY$xcC$MAjn?wpn_s-t_pqyvM2-b~|;KoE$4s8+=SH&058=7xvhmVG&Ket|R zWuTkJAG(M2fCAGksT;q7Nk$cs-z&aH4OIIrvjsoDr%UO)B!d)|Cnw3R&c?RlbXrDE z%LmxkHJbi>o8wgHCiA0yDJ$6qwPhd|zmsgK$}unp8veeqj+5M53}+7Kr}M?Xt`Ed^ zqjvV4>}GRmJ`bz`uPG&wL`!?l8gQb>DAGe0+~I~Cx?~KJJ@NyQ9$yYs@6!VB&JvS` zyAZmesHS{2Z7hF1I8+XO1+8dk)Bps-02h5n#o@MFQFrT+kaDq%WP{8pt%8{5IOlVJ zHDR(QP~yO3QuO&Lx&6F1Z*wFgSC=anrgq$5OTFkkn^WioAL^go9V(b)fROb3iPY1{ z@1C9eQuJ(Y>Z0_aks-COA`Bm|_}nwTNySRA*fnoVI=7QLKtpbqK!eIF*EH|d4_pzj zd9!DEkI#=1*p&o1y*+rdV4UL7v)}{Dd$@aWI4$;DG6)8JR=lww5RmiNvOG%0B%Y=G z2nF>eMD9YYW!~*=vN!a739~qh>k9$ewZkNCm{7|06swN#5vtCS>V*z~1?&TN-ssrz zV_N>G#IMSxt4jKJew=KPMM=RI=M{5Vyg2%RAi976)1og>LtcS6axEg#FtPm3dg1c& z*M`!sDOv9aGjUXM``{gOtjA%F2G7^~%{hW3kaDLD(0Zc;UWW{B#ni_T&#Jf_hEn`G za}m(^m{%tf;JRU|XJJr%0jGB@)}MZQw$Mt3{v1K%tKiIGAV5V}9~*dfR@)ci;8!89 zwzQ}+Y#wam?fU<mESzcc%vV_&yP>>z^J|YV?G=6@+ZNx5G z1)iq?gsK#Sc~TKq4V~sklt%%-c#R4VDIu47NT+RBSrx8a0!2X?a$n0VD$o19u{q0D8Y6{5}v!(-m!I z-|`z15hr{l-Vxp5L=}xHrr(qN=lElrD#H)ECT898^uN4BbmK$BC516;9>to^blu_k z@*jo9CF6fw8$v{uw|7KX?6O4hyV+S@k`r!r^AL|E4kA_2TPcqrzj^FF$dGWDWq=Z1 zkTtPGK4hUpLt*pZm}-o2AbnWDo5Lb z$FIh?ds9~5e~JUnZiI7`ATK?ulXY0KbAK$d8TvzRMPk*CIGM~Q&<`7V*ZK9KF^=55 z8hZ4YX0Dv8!^&8BH=*z1HO0zrCc8btF!p1-KLew!qoo|D?0+R+dVKXXTN!8`zcaLq zeKXLD(qxN(5{rlGK4jI7_S~IGi6TX`POa>XpLU3ipVum)d>xet6qW>>`v!MzyQc zA~cEPRg7^fQ;9Buu`VsoPn>Ht-d5o1lU0rBoFZM5B0EpPBaMNcFxlT4@2K2eP-k6| zW32<4@VmqTE8Sb@PIv%>^&Lh_r$@z&7WdMMFjXZ%kw0a*Mhnys%`cE8NcPqUz}4PN zQ6m;3H39}eQe!_N!EhYHZ{os2^qSDD+r!6_6giSdUUY7c)-XO`xd^^!m4XiNj zeILqq%|cjQdZN8~TkE5aK4Z}aGudsWG#>4IPE+E!C(1;y46ZmQ$=>7crOm`d<5fBf zxt~z}&G^-v=}*ArUvej${Mz6^3T&dLY$ zV`tU_IOZ!fD5__tN%S4D!h6LU(`S#(Z7wPNM_xt`p+D}=jNp7nTpp|6j{M+BE3GR3 z(DuGink|C=?(_0LB%Mza<(Q>BM;kI;W;dEZ?xF4kL(fw6e z`z;p(UUIxm0|~2og+hcO-zw1=%9BDPS3K}m=|wh5^!zFf4)WSI5%!alwbk?>UEMHbO! zO2zod!_O%4wDIqxEsL=c10JqsfYTVfyDzx-$7z7vx?~h4!IB?1#Uk2x#Q%O4cu=c3 zbCbrO$rF7R33BQB_X(pTHRvl!H~%x@;XpYcYta@Ux}e6Ff5WkrVFLfZ+;hQ*13?P? zp*6*zTkZ!uvD7oBRF3GszWCUvRNKHsx*sL=Gj0?nMl><4%YXhKod_yGoJ4yNvzfuw zwwY2XtNQlo6#ge_6+B3n4*kDk-Fhd-rRNFrXU|{JbNb{T{ud=f1<5^R>T!d2Nj~=1uR_uVR{Cmf(_${m6TbetN)k#E)5Uf*_mw2euDb1j#EAqah^Uy>h-&- z|NQ;mRdNi$T?@&$6tn-`9r}N9NZhC^%VcDEJzH!52U$|*V)5|vHn{0Bht&xX2xq30?W@8 zH%{Oo5HG9zKm+A-{fX}@!;S(<0|2cL9px*ieng!%Yc zIyA0_JG9&ahgC6wmJanOM-Rj%`^}C#06dN0^`48x@sVKd^>@PCL{mXSAEBIuJQ}qjG-H@zCbb9z}Qz+6+l4;0aTc_3LmwO3QnZ_F-GWMSVow6POjJ%`&012b6HW{ zCrr#@${8D%H<;8Y=xklIjgP$0g&SL1TF|^M(7e37&>g#8hoH^pO1#IBJ30E= ze*Ws?%6HwSmbP6_r*hGpmUM^A->YZtULGG3{stjq$?f0vow(N6C|mW6hW_WXYK6XMzN}`dmBo?~ShGB1xg<0Jm0_J@l{S6~j8d9|P~NY|N5tfT2x% zI&p3gcTWYSHR2rB?ALjl!da5B3lr07jvXGApYVd;B@{B9cUn^rK z)it~aGDj-~#NpMPB)gwV!c&cwh=W0ko#M?Q7zzx(X3%)1T;GD(Ta&L+RuJi3XD5uR zjGk#*U09+a<0H7nYbBu&+sMlXLL~6a)c+;GJ*s@^3UFZCtP&Z`zHLNs+|XDC9+T7D zXkT6l`gHU6PwCnfHsSHD0ZW*N&-IrAKu;{;Pi@)UZS+R0GCvz+i8=)WQNUhMeWEwX zkD@Cpdz;08n!E-QboE+}6j;3c^AJ<{Ol4}MI<1*Ja1J{CsHfOR=SM=0M{r9? zf=xU@kvdn1=^B$slwy^_bctG2Pf)rub-!){P-ZB|z7)P2bDB`<%l#C2QM?A9UEz=B z{?{LV;0O4`h%)^Z0}JB*MJMsh{fjRWO~7fFQjGI@mP)8Zvy`(6rR{7=LDMCK6(Po@ zKWN7RpYyeaDkran*0!`II zK7fCS0LZvzTy2ejS)d>3?JofTF|zXIzs1qgcWB@Mq}_gg_z@P&0iHMflD@gRnUn5X z$>i;0I`n*uY7k3ipw=OoeGCANPiLN|VDCU9e7?2r`w`f{6^Qs#SE}Cy!TyM$q%Ca~ zDt3&54OtTNJA4~P3>Vi3N9woZKxJT(TJJ)mgqW5~ba2=9;H1H*AzYQ9n%M*#^XK^0 z9#6#meh}$962uJ#DY_cvckrF6>>4;>GTQBE4E>J#%DgdfZ0hR=ZA?4~2Dv|CYw4Ig z!gvCU<9Q!m6qMrx_vxYx!T0)THO#=6Gkq{daFSq^XCb{4A&@ z_@!=!&c+nQG(~$g4EcVfb-@H!%dG#3fsLLY*y9*IBd-Y=iNpp|?qc?Dzrr{Y(5dR) z1+$aFCeUo9&?x3u{ z$a6(P*fFp=OxJ%faFu_$!zB`P6xVE8ICy3OFH+WEc&p)l=hC5%ryOhlF0F}QK9AAbRY)AlU9ytEl- ztZ{wjJ9^s6F7VPC&EkA#QIu&?2Dz4HmokXmWHN~xF?Ex~ZlqKeS2(!EDp6qvb$iVw z-3E4s0#YR}t(aJ#&@gzNG6Mw(kBCeLju;*Ml||S$)fUc8G-zqJw3`A zW|mtx_Y`L>bf`23XH9Y)P;>;RCnWUrMMWxB>+*)U1q^YNvB3;$Ily8z$wEpR;JTQU zaRXj{^yS5XD3EG~CHdKs+`!&t51 z@n8XJ#@9--3A)J?@+oYwJc*TJ5lC?|scWfR-2!>Awh}%+%#)OOSTP{yjR;*pvdn>-)J!AOVwy6qb?kyv z1LkCsis<*ZFgx*b$J(fqF4+6A z`&W&rWAtVzr7t8{zS(f&(snszC7QrO>K>&Sb^rmxlry$Fh$g>kb%eB}*A8lUzpPQWe!e|$=+7&Qc1JR1Bg z3ls_Sh|qKtlSp-fO}ld4Z`dzK`C|-1ew9pj=p(6sTD5Lp3&jsfo^k!`wkm@^skX)$ zQmG-f-nYjCAz2z_d+f&xvW(MetUC>>bnjb07rVY{vnWVm@L~Uy$EaAij`UYvXE!g^ zG}OB`QI2qr%%Ve$Ik?w5>Csg~2(B}#N04FmWy%yi_ZyChr-Sa8blKh;rZc(sqie8@ z(4mq#2;;F#z*!Ar&(0Jy zgjkicl{gr1@y0w{Qt-V$PCsF2AHpkML+A@;l@E*XeMD=8{@`3Q&1|xb@f+6Tim$^o#oIlaY-xkO!Vw{B>8;Je3lVMxJZFTryvvMn_+D z)1Gp&KA(8SUO6Cu^iG@>i36I2cZ_LPfePah$N>G_3;+_cM z>n0Ze2(}Puad%$zS(1+i?DWFXUFT`6GjWt- z87k;Hp0b$q=oy&}in2+eA*8WfELCh{K8V<>EPFrj?$&G&&%rnrsWsOkn0G)lZQ{%ILZtY~3#jVFC&5hz zgU8}3NTwg&eG~Q?1oY@}&(56~Wn>2PX;A_H5rIA~1+FO38n~V5=rK(x+IefHKzXIS^-)Doy zG})fN2uGURKFTGh`=ENFghPm@U~>Fqa50EGd9?Q%l}HzgSzOzTM?W6^p>LMb$ zvtS>pU;V;i%*4u8ajhz(ct75Fpn5=CFY4kUF!{)R>VOY7&kF@PK0y$EDtlmr=zXbq zgu!Vw1~Bs>>tWWf8kPk8D}-}|5gq*2U;wD0>JUV7hzUxYoo|k!UCA)j+SAKKi~-pf zVk}?=Diw*Wk71^}8>Q*vbz(t;Fej^AU+RrS9i!$O=sQEXb;(*>U-M1}TA1`YHtQro zHc<0k&}@PD5{!*G8IP1`i*1iTzOu$O)W)kX3j)9*psTGN3TFwRuuJs!BE&90Ai$)a zy$)y1F%lw0?6-4gJvQ?PM-DBXa8Vayllc+Yb&OU@qQ8|&h29NUx!v>X_ za@aYEJe65_#i`lJ@K-*f+FB^WgKHy6^M&%KytWT|(pwLQZZwn;SGFH}VnUfh1(2-JXw>VjZXX+}i!`!IEpK5XIE zP(QeHnB{(X5zazsQm6YA#9laH5?N|@Fm_8PtM~j|1-7%|aXe0Wj49@-5;?K!y#npV zoKm?hF~KK@Cf_zfutlNUe_pIsW_|fEM>%iQU1&pc9HjbhT$;aJR?^K@)sW_)@RGmm zw^X7Fzou!|+SjhDO{cGZ!~O-6N90W}y3R}b_s>ho;o&^yA|nRo&t&pw+z76$KPP52 z7N11B<=ao#W-WM^I`^5sxm(mlr}EsMd4VD|!0a#Vr}LMd9->xZuO$){KjkMLm7P{R zU{eQWE`2GagA8@I*yT5|KxS4>(-ohmsX^8D8;Hs-+ZkXthgnTG44pd58t3A4Vl%a` znA7Xu)IyUYX-*0+_*Jct6+A1L%PwZrRf?SY`_ng4Ml-Uc3YnuDoqSOD`}n2Jr}*$f zh&8tzK_2}vNYp5OA_nGR9#W4UBinnw+B2vTkj664Rln=Zl?@u5x+Sgg-C;O=o#pgR zPk0_)AimMUkG&ZHPV;h^(uDNkNClCyT1B+?AWdFdrgLgh^GqL2B`th#x37DSVn*I?fX0!PicHwG<0-}-SNW@{|$7NtUc_bAQ9quE*tx- zO%Sd)mJwl|tt~~;>JK@nNOx#6i+zaVkdkB&1+t8ev%HyQf9BZF$K=7hk_fdPz4O~! zk{yq@@#cnX^KagH*EF@*T6}kXOIlO!5T355`{lznn91IWf29r@7WuxWD*58_`YCEP zHAXavEcBts@7TmJh!#E)?P;LohA?==1YSMa~CM=v&ryMz^WCdTc5UE%+HeUBWxmi}V# zjc=nvd{CATR&oRTR>a}(1Tux4rl+Q$PZKLyEUPL%J zKh!%Owm;nadYCI_1JH;K2y;40G6Ohd?hlO~p3vv`xi$i|Y!BcG2!3UYQFFRD{BPYtJDgtj}HpVDqiCt zErlN(Ad!y}cHywuI#}!2K$>YICQ^H43ZF4*K%r1L90YM0a%%_QZ5@Pwp~Ex5;9XI8 z&VKJWBY~(^jHRX%>0sg(XgV-Je@>7fbs!LV_kdBmY-|p0;jQT>vD@my{CorNdYZn# z{0&#FL4m%l2PlXQPp?24nQ9~G*y#c9P@;PvheJJ)++kShjI(SjxhxQDXCn7gshy55uL8I8*riy1GnY5@NqBx@3*kLO+Eo6vD-f(W89#z z#iJ3x5vL_nzB?1}<_r*u%Ao0{WfT5l4K&u^vo-JK{{hI)fldbqqX>gbOiU_j`ma`$6X>SP{u<3;18K3s0@(3;fMHfYWe%Av7_`|4c`38Xh!ftcrIqu8oqzL^5gw%D zkwb+XT@3pLJVt~TNag=NKyXp-;A8j($KM4rdf`s<7}hTg4kz%zxDlQRlNC0}sI(hA ziw=kX)NYd)#|Fr~4E(_Bas%Yv;e>U`d28+3I(!4CNU-_uvE&?=ev^PUQo4IaY!^r|y}=1x%EYpOBijYUuuSqh-vaSGX&_+d86aK;fNXk| z4HR2N`K=~*W}sOw4i?MtcFqb!_f*_?w==d&kY;M>TBJ0>wcj=Hgq9^bQfD<5UfWBM zr>6Z?G2R^ol^ZFx5?_%+fR3 zCZoX3#$0>`2Zeu}StRnV{sP}t4GUufC@l*&ufVUYn_`f*eO3Xs81_-L5&Swv{gf4O zt5>Kx$3CiK;2KZ10Z_9atSmwQ`g7HtP;L0E4sdu9I17X!XoJ!(UJbER`tK9H-23zr%e|B^vXQK!QV=3GeAP}O5k$2#Hn29ZVX{`ASLUT;x1CH852+E`agExR5(9^Y77`g^q2mvzP>jD4< ztM+u#<@^+Gbi+y4&?4^caw2d zU4%;90Stc=1h^Glf&Q{Dt^7ZXw?mULb)O;UgdH98X zhJwiV{+W@RP=ccQFV#52a*$)Tta@%gZ9@ufgr;^CQ`b1+UYo!X@RgpL z(>JVosD@2WS{1OHJq!8p18YxHneXgsk5>{{Pjqo?(As3hw0g(R+vmh|bx?36j=X{@aT;oHe${P!K05JK5@R& zyQ07hM3vbq!5dS4Ci@saC5{RW#a0Z_Zw_>cHISRs~ z*Ru9royf8BcD)dcK;_Wwj+@A!pNn>n;dH}7;KNArRAy~2!6${s~H5Y7ojw%3q6!aE)h!hO^Yf+5}fwawQ)MtzHK=bHq{mi`wXNw7>$ zp2`PP`NR&&;mCMiveNvPklLL6hGh{cSDK2+Ehh@W76JRAl;$KjLKY|{XMtNGGIed- zTOtQ2A`7^|#2u+f@w)}qQO837XZk%a-Eb^%8z>Ac^#?eKrA@YJ?%rQsho3(IFsxzr z6q=FiIIYO7WPB>_nXg_8eT_ta548EDnDmCq0t6~6Jz)Q?>IZhNrYo?~Qj}nzmMlQl zUJpKY$u8Wvd%|3SBZXFK>8Be?%ya|n08cl;Vli3*JQwM{Z-X$4&mMjLbop^TDa_?S z%24vZvjFOlt2^FkYpL`jUE|p-2;<%{Fw3mQL`IZz3Qk7NI`cxe&h)249?R@S_ZEjl z_U|v4-BBO$xz^>9;zOGY46g6MkE*gTB}3`9ek#)@g`&(i$q+Fb175qrBFeqz-QZcN z?%;eEvd-sBupd?fM48rs+dn2z(PdJpx4k)E4@NG1)D9gi%^!SH5Yj|QZuG~POWqd;fyZ^<)J7`eO&3rl z2AvXBn>t9VTbx8{P@8@7yvtmi3zRT+JL_rq4C z?<5_>KeA!U8?*@)`l!>RlQZ`QSF*uJ$moo`9w*cf6PtaVGu8!hgm7q)-~1bnQhauK z)E#?mFJ38RN(uD!l%Xk*FlV|>%yQ*-sEK{|o4n4mQ_%a)64Pp=TT>(|%kNKe$HE-X zTo1?(yEK-ee3rs|9piad&P!=x92rUTyu$qwG5@D9SY+4aMa2ksv}C5$RZb@Oq9i*o zU<`Y~x_Z5PC#zbNHIIaP>n0;m0(En3+Vz?fu2moAT~Sm`a^q*a+Z21XdCSgToA|{Z zg^Tui8#f=dT3zGZJ@t2LH#)>m9^j8%7sp?xuTq3`Y{#7=-8>4;j=mg14gVXF9eJ5? z5Uq2hVrIJn&AbT!(UV(U1Q&Cw&LJ6Ra!`#1{$YV3;SgGEaWTZ!JKwqQTzdvkh_cFefT3H{Ak?k0>!6Lr67stb@Fk-P~%RW zgvOevrZHxhI(*V?l$pByl&H`~&_c%&)&qi;&1_I$^8O{CaZ$IiprMNa8wIkOMNv@eNDVaS0BKM?o;+P= z{(Xs;(D;Sx+x_BzEs0Ox(0@2i4awJXeI|57WxWoO2|j&@SRu=am>S+wvhSRR)H~h;dD&_zK61Rl-yL&|;eZ zJLYV;4vDhOwua&nt_k;xElnu$d7Gt4cOy%EwSs6tae-ejcq!|7;C7Mk%S+l`++szYz8~0i{?Dv z)Vz0+;u>8_=;p=MO`R)FbqJ0X5vtS?+>S=TEQ5l5>?2iPndA1H)8)D;=9Zx*y#6|oD=Ze`WMk9MTr{3I&4B$<4* zN9HVWM#S1mbX>pHXo)D;R^sGuW%+ys297vdyx4cd=`gw&vE<9i!?!LTwya2dwD}QH z+2qYmici**__YbU{i)5!d|shKXajLDY~77rD6qQBNzzwRIC}_{9}-_1+z?l_p1hn* z$CVG~LFCqr^5~|jic5Ck`bgs5HZd5CoA6^vBm5^G^E6U{URI%czTtA@x4NCTlZ<#H zgdU;m3DXVHaiOM*b*p=25?_Kwr*(W!YqWlZP-2j;d~|RR;!B$<=CW-5`JLt4Tbe8x|)$*zb2~DnWExitM)Gt z_yjPH(5zyHV%e1s)+9_fmE}vfD))5u@#>-@$X*Ma*Z$S8_#1>Mi9l}VuJ9cNcitBB zP@-dau;2QIjb)72buaUFJ2t%NxE$6gL)v@UxvWJdDNREctnt%~Ca=K7e&IFHoRq1@ zuP~TV_a~F!3KrRGam^DtkmpK1sqK0#!%N5;4I?Mb#5rwI-=$iE*zUHLSCuoyqCNTJ z*&LdOFSNZU$Z_4&#ZmHeMVnlZHi+7Ila%2Idj?o`kK%u3-UMo_)FbMc_i)r_;Sg+KJL;w z1xU!XVbmnOg7)DPNh|{TfbQ!gwe>9=)HHk_UP06hoy%!MGpGrbZm5fGv_!FGNd@H+ zlDyR9`HZ;x!`ap=clnziRIn-BH{gE(c_QD(7(QD}HtStW=G8==w$WCpEw9 zxuX_rMBW{${(-ttNg)q=p53lO8qU7fQ-BOU@5^<4@kBBvubSpG22u7Kgx~=CVO|qm zBWKr3^R%t@*EUYSxw6n^$kKUdBsaqbG)dZLY|tiSH(6XsyR=;xp@U3Y&;6SZreLlQ@F0~%Kt z3&7}17nxU4R}#(P9xCu-mpmG`I=WHo)_TS(dc4z!IyvU+t_==7k)#mjjd}LK(G4Zy z$|*>9PBcKvyJ3^*zJBPsN0AlB5%&)kd*%^MQ&Z8lP!i5h?I0zGC_Y+9OJ0?f8%C%n zSN#|J<}psyU@kzESesr=Aw0|zz>!0UpX@2H zJX`Cf#82Nf0dl0tIC#x__sLy&o1z~3#dR;JstsVEA_ta)a_e?KO(n+J(0G0na#>s9 z^(4}oCzd1=@!T4~F|*b#Md}_Kkqhjfaw8ivvn!(-Lv-)`xDlipKQ?C|KKATXqMSW2 zZBF`<%3Vxq<%smEs7BqtF5eGyz8y!%$R)h8*w&}OEiUk_S{ZCHf2#8{moy_0- z;?rJyL>GCTF^LxwAs|ge?Ekyfknm`J4rYA!1$Tw;0hlLC4-otdSCBd?R@HCx?9hk4 zTGh9w7@7vs7_Ywhd{nKLQxG3HyG%9bq~5^!!aOtG^0130eTh>hg2H!9Y7uI+|8r;u z#zYH7;(|xBZCnp8zFgTw5r3j09pLyI?hut_>yK8*xqNcAJU^_ic-XOofcPd+`7S7E zuhe8v{K3_WxPgL}Ml?gq^NRTvI`>j6t(%kDQOAVNh%o({9=YK9#dEJG77m1#bXR@v zA6e_-VKY-vH77rIN>7-fEZ`vX8C4oOrEq;8rFgoI_oyS^v{EH-IJa7RB}u11;{$8A zw@q4P@s4z%?+WWtR_kRLPj?aOZ;r?$dFG8_4XKzjK9hVj{OwQ$|MU$?g0CcVUR%A| z{-wvhPdJs>lgbH5Ev6LrBL}wQuC&?!cmMojB(V+2foe=Ij#MAF3*TD>923IxH?DOg zd<(|Ntg`N8>YQA8pLV05E>Cv*{j#Iws;>`{r9(~m!60KN(4F<^tlPfWa}A~pk(M?Q zp3#hBG3CLUzUf}GrnqGy70uT!7kz##W_uLNk2_rEjGIiMNFn+>Qd&pm3m@~cwk zs?N~d+LBrx^&C;yghti>+>h2r8D^JRo}uRuwPKCs0;Vx*rE#IJ&L;K+S!tz#+BDJ~ zx|^5n=D|dL>uvYNVhLzQ<#kQ@j&Db3k^S3Zoj)0m*S7jqFDK30EKqfNBkcGk)iJ7H ztDcI<3&Oth$REYuOA5&N?H1A+DL0zHvhI`cMHwFt{D|9oy{i_mN{!B8d5U#>v$vh%rpn7^}kb^ zrVeOGM;KY%K!bS4?j>UXhtfoE54kIrkt!{U`^va9Uk5hOlOf5vP)#1x`5@DeRbo%C zq2@V#Zk8}zc!qmCx#lhOU|qq=fnLY0k(e4L5R>Xi4SjrTy|_jrqcroC5dWm|>x$kJ zWPCpS&sTNzt&oz-HTSYOgjjOW5iN3VGK3`KDO|88Y1;^;k9O_W(nN?2TOUbrXZf<- zt9;X{gQyigMcA84Xqku!g^}5ja!Zq>DXu)v6y(5eQc>8@O&E-F^7#@8D@FDl3TY}5 z_9fK572k;Arl*tCU(?lFWS&EPP8|Du{Ss;~wUPadOMcpsS>enpC2E~dd6*b2w(}8$ zg;o1Di3DFh^O*Q0KR&l2?FezKJn?4;a>fVRxylq1`dDEQ?dr*-uWWWEG&nu%*i;OI zMEvGxV&Ndc#UL`=41Rp2bd_#5QrhU73G+Euu_1SBzBP8o3T|JLKw;Nt{tGb=L5>M!%j^?yqcxKtti+ z_<_^x36$+}BL)BbtTn5t`1O?x#-^BPz<$n_iCSMjxm#q)aEj=_&I@Jxh3$5Id0C_P zNzuaTs~7l4_FA=*DHnEgNUfl`Xu-U0l*BjZOjCe%s&=fq@kA+7N_Lhc_((#EtD$;# zfB%7_*nVy&Q);ACx}*0FC75Ul31y+=E#vSitEfb}zDc92sib;g{*0A%c6I}fsIr^s zZ39mqro;{jshLjTqRx1+y>kA>`=MMG5Gy?FlW+e6kSa$GW1p||Auao9!?&TUj@Mjf z9B#plJ<}CuH@8csep?8U$8jF94ROqFAyB)Qq#1;0r`b1}qla4;zrs45HDnF5l3*Nb z=(qbSfv+&?xX{a=e{a`_bo^1FqiB>p9rXtH^bHVKzh__;z5Meys)`OZYGmPM<(Ktr zk#wW5nZ^G@qO}(?LI`n@S;4lzB7)7l>f$6>W+k@ zVsI*(hU$FeAY$s*&}uJYHsll!<)rG(>?)*x6Jv3l=@qP_S>S2Bg=WT7C|OAKS~Heu z+jQ>DRV!?Wu8pJ1Hfq70>(t%9iT!2=z2_BYBRcYjXm*868ef+XYm$36Vxi7QwffnU zC2@WjXI2&3yLWkp1QowM`^vaim8*!90yo;yFmRZ$J9_GzE4Z$uTRF-Ow9r3b)Y;_8 zWSOs9>Dn1qQuLv$DF>VlXZ<7R5D>p-sRxes)ecT{>ENY$b1It$r4?Ah?i!x!x1dEjr03ste!&*;-RAOq3j@1*O{7#$| zB}<|*EH*;uf7sXm#l=F@Q4D&$(z<_P|38_|k}z;x4GG82|IPCL4+jdrYbMb_%=>5D z%RsqMNpb{r>BY4ZeN4`D`vO4PDhCPPXOptk>7F&RYnQ~blg7aXH=u*#vtttH`;+m& zd-Zc-4(;D`!-w6P1dqqoFhP?d&nu`y{UpyQ7)vT;AZ1)PuG;1me25BPNFuqX3s+oP2+?^5oqRt2%X4S=k(vslW&TTYPa!iSjS)B*A^)Gx)C zRlN?nFG5Nm^rQs)KLL8BO6z@@^HlS_6#)yyL>M~9m%9V)j+bUHun<@00Q2{0b^WQj zVxsI-8%#AA!OY`3Su(w8fC;&LN4K$o(++e;c*xi=cl90MTdrVbza4%JebyCoKV58i zLWaG^jTG>9(F)y;2;O4yh%OtRKV+E?xD+ZDz>t}Q6I-Hp-2HOu0XK+}P~X1x4*Z6ur2!o0+`rvc4o+s;COu+ z=v+vVxEgf|D7cGnZv?z;1i-sHnqFL|9RT(cBZj3;ZXw|2*ZIfOHeqm_@Mmdw{{0B3 zojC@dC50Be6D%w11h_pn$e|Kmyy$##D<=d@9pQj^V*`{Xuk8!U@;Y$;19e>b2zuZo zC!CCS21#WaDSQ=3Izc~yRLBHgZU?FxEOfx+dMJ7gwD6d2Bb*WU$NuXEAH}*sQkUo5 z&Yq-SM16cs!<=5ZV>(ca19}%|=s&!xju*T4mUh#v z2MA0P&?NN)gSB4uwc;4?ACQ08SE&et#)I?6Uh|vi#EK5@ca_q*fybGn2V6ejQ||$V zvIKN##z-I0(jIu1oqOsEfi&$53sLu0r~wD@J7-+o-aFUmw*%gHEr5A{nezuQTDGk$ zjs+})1wTcLgg2O|hkk3=w0A)-0c>x#WT6_%Tv`7r`H_3FIuuhMNEypASgL4wl%W}* zJ|n5P-Z%i{v}+VyfU2ZW`B%6705$gpr}{n>(W__wdos`RQM=(BO*)7bvc_jR0cZ{n=p8}eE*Pu*b4=JKJR zJuubtH5{x71K9ILGWql+SVBeEt+5g*uV?rH%`bb5Od#zCKQ zt=kVE&JbG`cZV9-1(?1nV*GKRmooeWpMXZJF_}~^S9F?&-~H9@bTI<*8T|Gq4g_k@ zP_-0BQ!CmiuXXg|DOi&wnFqfA2|4WV2Dx!W{*cvB{y*;wmV&p;MWeqtCX;VzkP|*p z>;`fI6SzM?-8M4kYmf|OBjXiEl( z_7>j(rDwT+Az{chDD|=y-q)3M6+Zz)uPpB9tTWb2u<~KdU(T4AUb%q4wKxD`+nXb& zx;8G7Nl?P`znD*46U6y5mjqaW-ht$PK(HTuJ%9V)uQs56dW=XC3sV!{Tm2< zN}8?VX-Gp?1ufyfKXO>ezk2|tl`8Gt+$c$GyyH&z{QNC6dofJsna|TbzCUR4?AnP6 z0v75n#v7CR&pNU+Y)ITW%tOSF?u?!z8DB2iRoh6ZS)troAd8=?gd&!YEq5n?6gw#e z$@xbc(bn(p<~k9tFF-I)D3DGo+|25j#TDJbmnjBiz-8VX`lNPm;xKyRHsIqW&xbon zHWrnA()WgWB_sVmg8h!*{@}7bw!;4}>9NV#`>Zltoq((D5c@1mS?_PT5(q9{?SWGF z76rwQEsG{u<@yrwWE?1ak|oAej`}JOfk11ak%Bq(IlQ+WkqHXC74=m`I{Jgf@;^K| z=A%$l8-YM<))HykSSYxm)V|kt1w5wW9{N|*Xvpipi8b*DWDe?8|5YiBIr9Ws_AhY# zWt+@e;Iepi%%9jci8Ww}!lcjkHr3RkW5xBDady{i4z}hNd@B6{`$HdxV6mllIN}FH z{a#4SU`jeiaTn2`=AXhKziuH=A@{2B2ghKZS>!wUK)n9ST+8&L`wE5HpFrlP6Jn00 zU(HbrH;%6q5W)G=L;uP^cz@jA?=;BT%>FImM<5mwp1Sr+?R;YV7p8}x*7+jK#$;KH z{iaS^Jp~^>4s_)1jdN?>UvOR#?Y)kS+X14S_A=_dknXh?Uz&_k_I4563k9HzFkU@s z-YN&P6JPrWZwM7mxV*b(nI6r?Cz7$p?>IF%KGV$Q)4$RreirnI$|8zQMz=oVE*614 zB_R^kM(hS;7zVz(dLV+JL^U?u!$lA?P$U^wj<+xxaa)&*Z?JfX;;Up@!D$lZaPXpI zk9?$l@!JEYuv&_cO=OXVkM@oN3V@t-Lha#rz-!$-^cH6m`s*GsA$R;1s8M}IRwtt zg{)`1XeWg}Ir^biD^97NK#I^QZ20WiI{#op(}yGzh)Esq4r#DWKNa<_?Rdf3+A)$x zlI9i9(FYQ!H`~-BsHu`#)y05aNn-nW*j@Ed1n(pJNq)#gWUsPY;_Kk`H0>Y33NDWBG08&cIP}1EUO1E@3 z3?(fk-JK#KEulz<2-2m}lES^l?|I(O`CQle7d)@$HwSq!d#}Cs+G~A|&+$IuVzI5v z$JGq1t3_jt`D{MJFm?v7edM{rgWVko0J2Y|} z-c7N6Tp&LeBVV9GlBp}Dg5d@{UgM4?VrmZ{?n+r|JI2qz5=u%N`xLqKPe_bCLL-GtBf$P@z1B3qnEYN);T7f+b_W!by_1c zreR#wC3P*rA%qBP(NXg~P%C0PgoR0rIA++wUW)KA1SPP^kT{ezBOzt_sk(^81`bIB z4jqreCqqSnDP5u_b&WAXdVFyWBJXbTAaj*PcXtbd*N%0E!P;ZwI?N(6=7UmnBMoN_dG}IW~W8MmU-tM%1SvwtD&S{T%`Cj z8?GWXUa<~UQ--0rgu=DmV(623Be~uPl6})SR`r(a#unlBVnBE#ctRiz>MO1>E{O!O1Z4ftw#_0zULW(JC|y^`-OYYS6z zpeR1tJoCMT?ccm;{9S1zJu@OQnGG+2YMH7^n6!V5kQ7QRk0@5h5rZCEg{4Jw=_@k7 zkzG8oLW~IMxHNV|)s_JOU&Vb2F8AtL5;Aoh=2~t3dsEz|-=>E`B13^u+1bLF9ru9k zOlNYl7hPfj=;UcZeHOuCT`gpTr9olqgpYh>dL4Lu0Ip@cAdfS@Ga9>(RwC@BK%&QI z`H!WcVP+Py5wFx3NiOBDg$s3YSV;VsQ(K9wk~K8P1kwb`a~j`$eA~UCte7AkS{szk zHk}@sbNr|4ZJmzToSadcl>N7?!w4A} z$WS%$Wms-n-Ur(dE9i8p3wMu+bKaYvBR}Mnn+&2oKl6I0|Ni=+bUTfpN(^)WHj?Jj zZ9??#XQ2>LHaeWxVobK}`4h~B` z(5$?;2(U;_P-8#248`lu-Wf?wp20PV(9F||ghD$6EoN26ln{1YY4Oo-31CF)tw_u=zZXHx0sc6*!`A3WAYo`H*dzxza`&;!W`eA{D{jRT{bQ2)sOJ{FUbn z(`+MR_`?k>Qt}T?)9_bPrRr!V^-R>+OCHSt53ts-xO%-z1OeUW@GVBuiHOHjUU-_F zZ8-CRErcCE%ufa4R1Yj`eGDMeWz-SU5)qbT)inJLsGYD^+*xv_W!aeqhe&30X%LT> zdK+D@TMW~HI?YQ8*hYLPZ3i3nE4eB==^H{y_kN;}y>^g0{1AtsLOiiLxN2K5KAm>a zfFw0v0w2OQ2GG|c;ODd#EUVBEJc*$#b{#=aKg2iM8u3humCMkruiX*ot^p7iK7x%Y zdyNWct!MFX@c;*1#eIztf}CxJ4x@_PZO#e2qmIBWp(SoD9%~81-f>#Q8st-h1LDq~ zrMHr3-zGsXx%!`CQ$%TV$e&vXAD2rSq|5Yan#AzO{%0HX7fpqna&l?go!luKA@}dB zLSaJ@JQOmG6=Ue=CF=C#0HoGi%i$l3Np|KDWzx5>J zeZB_8VeOhc&JQqrGnK7+uJb$zjX3e-#0Lf+HlNtLQLU7=yfVhnw@WXc_`xAt%x~%)87LxHPlDx@r2IdMLhnIBr*bBP?>@Eq z64`ix&ruv+R@{S-qr!|1uOlp%if2PQLWvm!T>Xa9#K(`rTp$dk=H7RW z3Cov8`skx>n_cfQar??c6JQsPUY(F8(6--oLV z)8@4EeNu#J2cO<1u1^|besS;3sqtfNOq*!y@7ueTQa^x_TN+c*~X) z?l3E5Wp31 zLed#5R0nVlFi6&8u*x50L#Dry1Mcbze5ZCu_3BefaGBoV{m5S%b>G%Lni z_f%vf$BjrS&Zvg{Dz#j5!GV7aTo;C_n!SM!naCSwH!+^}Mdr=5v0drBRO3|a5cty@ z8mUtM>q!j}l9oad-&n?$>%}@zH3p??{5_LUenygW_;3S;CB(9vnBLE*5sGt2gk?Fu zGyHUyIi2@gox8ETq0+D|Lp#??c>lSTC6DJN9d0!5yiEpS|7Na=!E%7S*)jmyt zxNI#Ke*FERLN%}PXDSL`JW02+!JMvc-iMjX_4-|sRQAUUI;l2t$SOSnugqPdO?sS3 zaofd)C?DTh7W!}n!OCPU3O+X~S0xjt`(^=Yapwu-t}#C>f(3NAjj}98N}<=7d8vh_ zA4JX`V{nh8WL*)t)VNrqtC?3Bv)O9v&vAtchRXJ8vEWG6QiYI3nmNC(Y~6U;q0PWS zr%0OiC7nr7VZ(KlZA{k-QG^`Qf2gCcRISY!HuNfgdz8u# z>eIZq3e(V&tG(pL=IYVPOxIzww{{@*H8X5S-Dv?JJ=~!_QYcL6K#=>w(itd1Su7?!#W_!WRkGGN}MHLH)!e_JZ_)FXEy2 zbPa07ZA4#bA0cHQ-DDNlpP6d6FKzYakz$%ziporvv;h5t>_S?>$Qacfy*Y|um7*sG*dA6c>VQIb-HWkU!SEb$RL|-xQ^kPxU zH_1XKS&Frd#+ME6K5Iq0C&Xyxb5xVPK)U;8llQ>2XEC z?6G3QC`=hMp-wB4NRhbY83ipUDb5JAsjulPGfVMB(R-6(9=5!rM8;!;@r5yB#N*bw zPL6}rDf0`0S)}o4QlB7BKICa7{`*QP`2zgnu6MT>F3_%@9;Dt&Z{f%ghb9e@UPISR zH`BkF4&`=OtRytBpC&}kLMZ4OF^gtgIoM;kXkIZnP+Q=Zb zMXxDEBa>QiDZ@#pVml4Xva4E`D&PNVZMx)xCv~zD9Lu}J`X|%#(MU%uEhSe{--?-864K;7J+hv`Hvz_Sntv6s4`w?kGI9*`zVvYch;6*-$nLl(iTc znR#Zb2(z|%{lxYIw@7}f5xoy%^tv}M$4d)Gi-$qyjRy~EjlSa4d-e`-Q_%2j=z3I^ zYa?b#^kGqGJR|f~rpMj^WE)i0MMj%ut(F((Mh9O9SFbv7A@Qj{C-E@9cS{&HU!zFY z8cOk!$kvdW$Bk7hBke4E#@O-Su0x17x(+~&v+T&v;Ari;l`pyNy)jd}7}i-=7+Wof zJ+B6C@Z%+|yA_}XOc$d&)ba?6sdk9=ic75wH?x&Ux_llyT*b9;>QOv&^^4<}AhL}@ zhe@(_vD~C(Azsp(0OqeyX zQ)IA`vVIGuOP(DO#NKV`8P(A(>A7xoX`i^Dn9L+bp?!^vPC9SRx#ZRe^JhbHe?n9g z?KRo(e7oQ)_ZK&wCi_|THrs8RoAn0eM?@7q35tX4-J^cHHuz^FUGHwUlUxrJhF$j3 z-ZX@^33hDF;qYUwjc4vei`1xF+lE|cjs9w@xPh=v1etMnIF3{E;*qar!Gp({d%=5X z-Mle{$+&}VH~zte+d@;%d}{^i;H`(c$&{YLYb ztI^k=OZ_4E%-Fto#~HfzX1!?&URrhOZ;87(tJ_5{=*@U~-A7LqAO2xuoI_4ICU}(Y z-`FjM$iyRjN}sq<-L5Mw*wf?#wcW(#Ai;3Kkqh~`WWfn0YKQb@8WY|8Oygr9DQz$|d^VI;(j?Le4?Sst;gc=1u~>Xj<2(@G9~HpUS!i=4+3MF=h$ljn_97=+rXO7~&Ovw1pX*v< zQ!cZEvljM?&h>M)w}>R}LONkPxKyBIYI1^+3Bsj&rmC<0W4`Et2%CHbM)4Z#N!9Z2 z&ul?Lc{a(1%KnR39hb)Dl2>{IT|R1EL&fcqEAN{;s*sh=s)q6#otL+6jTuyZ5b?*` z*i3Ms!E5%u@`w(R)_6$qqK}KXbD~XcIK#+cq#%mp<%z;3|X4cxKIFd)C;^T1?ahBudz1u2&!^CEVKa6nIfrheR4_H`e zLsxpCleuiY4hs4cE8bq~1~e-(@=x*GU*8Q9334}HnY9>Q6IRi3xr9YWr}&#SF0z~U z8VCE;t5i0SEKQWdL(7aJIhaf&%XQH(kZ>I+t}LE zGXrb$DG#NA-zLI;!1%%XKF&qKw$kQy)M?*^w$M+4jiMpk#J)-k z`h|Ue>pf31+!&-a3GX7fMmH>uwPKXrhW}*fwivy?1K#ZKSB1S<|5|RL z4VXkgw*IQ@koH&Bri?|)7~In9VKNI{^7;MBqrUBeUFt&&eIrzv^YcGqxUn(*2bqZf z5YOp}#_46I1zhGk_N?C8Y~bvOb>8yt_?Jpv4H3)Kbj{)I+!8OJT3K**tj7M0{HtmU z+-8^l4#Y3@6B;hq%wb*ohpylcn8C%&iv<73(}DKS(1aBpc1JIBPW@a%CnlwAAtNy3 z`i36bj5_g$fw5v}U$M?a`r-g3NE!Rq%zx_Qu57m(kr-~a!EG!5`nFiHRGROw4uiwI z_Vm9$awWVSQ=#HcNV2H;Z$12NB5EI#xR^5Y_Z$AFDH&xW4nAA=n)utu01n|leqoCq ztW$puG`sz5oC%w=%wR`pM7%jciKoEpD>wo&piF=t5l?_qmuqAh(P=za1u{_ z#L^D<2FiK{^@Dh#SB}~i$r{}#g&5^zsR0hJFtEz4w)BeIVnaun%W8mZ5DLopMxD5s zo@Q5;AcE;WkPbXhCe3aT`9RSDjHv+`{l z5Q*|3Zwd72z69LEp9i`T2c7_yfjOen;(rbjo{BruN8jY4Vv&&WZp>vs%WzB z?o8|VR-)R-$Kx_s*g9!iyq6#vW8!#4f>n`wke-=6trG<;+ZKLXkKY0~;KzRsMP2~f zpa*bIOQ)Z$fFqy=ZoO?H=_^#J8HK(3$Zxi^aF4kcz zHS!ZI%%ukJCo=VN9Bho8@d$BY&?DhyvJaS(x|;3tFo{>Atli-cD9QZ+E4mjnT-3vS z-umeSQ02D4mklXbfI6|h;J&Bv>R=UE?o>6USG?W1vLbT{;)1O!MSw$`SHa1z-lOvs=WS}jGRwDU4aiW(xcX&7jWagq0#ec($phxFLLXt2Ko zK#L(T<*O7)D}082mtnmioD^RoT^0YK@WqNK(;A$r-M)8+Xt(qS~yoKP++^9HoLcz=IomdJxiO;$of83CGphizqwxZ%IR^bWejq->)tAJW8;san)#LJZzT)CeT;d_bSh?_LW7jXQLYOtLJFH$`ve?15}Xo6n*NgD4Yk0@9%oJ~Wpz zUD#m{Vw~^_Fdk>v#9oc;Jdo$*d1Z_~!hF%%h`FJrsHgh4)qYE75(WvaAYNa#i~XP~ z$6m-=a1)(o^KHJW<6=j=S28$aXhvaXMusoyi~kR1-VA9(N)KpFnsGhw;RNb&_RbPt zR%s4F9tOwL4RJ*`jm?x#495I6hDT(%H%{*LW7TXa9rw~@QJQqsH^_x$nY zgN&*gM%TY>Y_jO&l&TTBa>l;u(TKI?U$ZhI(0Qq*r(dMm>3)=d_}GmZJ!z!#+7EYk zcy_Ux_^4YiC?Mx;6MBC(X?M35fN@q1eO!sX%T!G8?O8+fkF{Mez?f_v(SYvERs2KW zg~cH5V2?!pX>ArNB~G=G3z;NGQV{VY%wa2pP!ThaCoy!o!=e~Urwt>rPv_{CL~37J4AJw0{Sm@kDJH9n?Er~#S1PFUNuTn4Wlye0!XVpSd?IU_$CeV;`74Y=Em(}$Ra z$RA_z#!j#ocSWPw&`v8!npUia7*4*8QqkzNsg&G)@dc$x&#Z{{e^=m}Lnzq{fP6Sp z*El~Hu>s00w!a$Hs zB(+4l^ag9?GMgnSR52yi zG+~%YcGv8>Sd1mi)0-NXawJ7UaCF)bwH%qp7r_ipkb&w!xOgUasDX6q?Y_KM>ZOAVGxT% z9@e*zX^d8xGZ!Lz1&|k|%dqS>j5C7?DD|*A#DrJNmD}y`o+w>8-YB0XmekPB1G<+X zxsTF#S4ecsA=vgiEX6UcG)=uw&$<_rdb31i>cbBARbCPzwzAGM;+E*ThPDq3Fln5qg&R?LRvg;SXlt$k7|BSy>kg2@m z%X&SyA;}sgn`i22(%n{W^xTJ&)GaW&bMOVs0eYNwvmfr!9GOci@^cOIaWvXemG+Is zHygy%(H=i%4>FqecgC)M#_W4rXN-PYIuo{I5((218Ub8;^cstRJxfGS42lO$!4nj!KC>kbr{xoT5p#l;@o(FHv6ah?{)Jq-;F<-Wn0J5Wfd za>8&-0_@s8WG51`(lOg$9J9;<4SW7VKTF&$`1EloQ=M76^IrSubXRZEBAI?`3{*xN znK!{;8YHe5Nfe~3{Q>=h$4ABdoelULPe5Mh4!BUpcS#JO`PuSiDaF$o`XVoh5*-py z5OCuWiq<&cM}kfhY!()$4Hel1saf_494merbJ}g(*VE+vd)*rmaC!L zVa^^7-}|Yt$pj-O&DkPwPlb#e_M+W>*$G;luQeD3uO~IJy!lN$Sd%(&XX-9uFAkSW z@RNqYI#}R$ruF$hz0C_TrhVWtsLxnj%sVj^C3f?G#gESNfc)FEC41D2S6Fzn=xuEt z(lN)Wr+q0{M*(N4cw0mKaw}?v{DNN&%zg6ZF@4qhT`vfBd7#r^hgI32ZDuP+haCtN z=rz3UOC83;m{2s4(|*nnwG>pzo+2WjnG(XvO^tM$H{YkqERjI=5#JSP z*A0w1S~|RC6%H!a^~sr_q!;;e}q-9IkhR!&w`SIRc=AUT;EP zKI0gg=rO$~>DVM8{ze2metKaSJz0N4ZTI$0&dY_c6?Ub^st1Ur>JSXJSi#s_c?XSYuZ=+ z)$f0`dPz32RTb~C`@=PZXvdU>f=?DN6g5K7BR<>d)I?p>Z8xf zn z8IYz4?4t=}2FYSG7qrp(lRbAxqab$U5kt9 z4a*|3dm0sAtfzF4MDDf2^C1-2h+V-0OFGPNEmxc~H{$9`t~|p-EZD3ohABnR=?o#w zu*lylVQ)!#9IW2W2W@v_bB+X02)Fug1p(*6CmOLOfcLwgeG>9+x7>1Q|8cAs9Rtn$`$b&sb{+1q6sXT8w;tBayctgfD% zp+LCMwpDIn2C8WPdhRD+KlpgI%EIcN9#sA%*&J*iG`&|ua9qF}WRUeV3^9svYMZnH zx$v*D7Kyp?;p4h@38R<3O0~wmdLk}TyKg&pGDQEGXZ8^a|H(Vj>jsJY)Hw!lMo-o) zz_h@{=(HEV0({qmA!mk0CCDzq=w=q353*Sb8|OUuw=6f?vN5X)o7EI+91vS2b;|gu z+`Ng3d~@bI;YsN5&OY~-v&7i&QjDj`pI7ZRJ4)nUj1%`A(2&kZB1b-66{%vF^}B@W zE)Zy|wxiOay*`m?d2b%G`V4P`bm}7lyz}{!fiRyH7vS5>mpx^j0APcC9#Tg2xFvN$ zeJ3HlN_`GJhpHXIJ>6IHWSFz>D^IVjWo?XK65jDbAvmqsd=VAM^7cd`CjQ2u5BLPX zY2I+nTDh@PbRNA}KRsg!Ey91wCP=&UfF10pTe~8;MCh?ySo|{2;xT8%}xrP@%$ip-DlB#eTBzbuLeQ zFE=k&O@TLgqvupdal=fTo*)m}7}@=}44cH~9hL;S3n^Efn0!^Vxt736B57ypnPj7b z7wD6WZ3zw73Mb*XFgu83%vMf3C+R2Fl7*3EXq9fX!_8C>C93JL&*gThgbPtZ1JwRL z&x0d<4+rhtoeASb@p5uBsZDgJMj4lIf09VCAL8f~s3#d+iMM5Pm*Yt-Kt7rlr_ulE zzv>jm6Rq<6)`u3}kL9AX%+Yfg!1IgSk>2%0A&UH)vYkZP5=BCQ2=^)GF+{7^&QX zf1KByjkz;L`<;|Zdq)yFJwGvft_um5+qP&n%;C&1jfzR`@h+lXk)qwpNn$KEe3Nq> zWF%VrOG=Edqd^qYEaAct0@;0k%z2sOd@6HxmaM@2i2?f;6U8gtBB)vglXWPu=9m42 z92P7@oKa67rhac{8MxbxMJk+v`!h8PP`j=ru2nkw4rsoPXrzV{?u)8nSw1@6Oc6$k z7;=jacd`LA350D#lMsjVJ0QG zUQfTxLSn@_WD3DdlssR12dbZHMrKYZhn;4@z$r~4$M!)j^MwF$$HI8$Av`$Ou`hF5zl70X^{ z!nAsqDfR$xdJ@jZpp7Ks8C+p_0c9e*dF|X@hXqX@ln|{5nIdl`@X%%7(%Wy63NGP zc@I14Ey-ejdE5M)G2N*5`IV2yWmNmQmMcQHJ~!u-cSSOYEovtCzUb)mv!`gZah1ti zamRS9;ocWhVAg&(2M@He4Pz6f`1t9|mt2XHbkhRm>J^ym*Jczez8@zep&|4<#uGxI zWnY>t6t{Qpru5-$u3{a^mcO;gW9{+|>Fl1sFttlM_(P4P)a}P&m>;d8cfKs&)H7|s z#Wcuk226XUNaA;tR5E#HDluB!3#55%MD1<6fiDy|!R&Pfso=_!|VhLLT(=XNS9DJC;6OYYEEZoqO{*X__6ljXH(ulu0V zL)1`Mt=&|1?I~E@dF|!w5FbACUfSrLrk+PQH2K-XG?5U246+246xp_R7es6qvGA%c z>{SFw{)`aVlugO2`GnoP`df$5zK!q2HPIwLy2CM+x4NwKqDP+=N{jQF`{-&&phR*!EdP@vn8S6m+$GKGx(jYXXx5Q z0{=1sf>@3~w2T6%QTKo~yH!eHNvddlJ4&%=Uksn=|Er0l(9t|8DV6Un%=))D5f~^Y z_5)J#CURC|tM=u-*yK!(ARI+cfVW(#{UZV~U_SIaTNYti%BJO*^n|Azznf1QYMHVELcnnX5<4*w$> z{io3o_%#`B(@i3`zhjQrn>`vC{NKM4Xpb-kX^nU*Iqz2Ah%k{&f-2ghx9;m}|NF~O zOx&sKNQO5|3qVbwoN=8I|JkCoLHzeh{*SNax(zP_yg>cc5WA#qH|4Ke79JY^9;W}0 za$XYO&g#z`w|}9mck;Xa;lHocfBvyR5dhA$&iQ^c@^5wN|DHR_VOog_Jkg}xUjHv+ z^BwaT3)~f#=s7R`%P|7#EHUu5HrG z)Gs^Y*M_nG^{{eKho!XdY58BrQWG_nj80KZp0zpNsu5gA5`b~XY)LP zEpsyb4HjWQm&q67h}a z_3!4+P@rcBv;nBdGKdYs5;_HWFxBZDoRB5|8(#rnx$Fk+0Vpb*3cgd4|GQA&lQ*cv zgrYVnNWS@(%cPxWq0|1rB#Xyd)neLH2kNIw`=I%jr3qlK{JT-k=Q9rQ=ZQVRbUx(> zjw=jEo&s$^O|McT#R-^>FVLte9~+uhuzx zpk~Ni|7ecZm)hWjcnu_P9p3SI1;QWTz$}l>8vJ<4=SU&V{Ix8R#Bk5$)0?ZK9w3`h zOOaa@pz>WxGJ(#z*Dq>;s3GjlT{^p6>=eZGx3__+ndpcz zK>2ro+WVb7aON|=oZQZ)e*us4KF|oZo?Zc zMI_<6W!}0x6i8`0TFR(EwiTx&W+QE5Kn| zVG>eZ(|z9wSahT7B9N%yvM|nuFVApm@xxfDKq!0ZLle#24ahy3Um%f81#0n$PTuj` zaeL$yP`6e<4@2foZ+(c)PX(1i&ya&?Ag0@}_yb8evioIfQKOj2+A0v{GY&_9=&r(d zpG~*AE&`=LG#BN52KZ|?bfbBf-OA>EAZ!_}76HyO6Vg!9&<{|&IZCgVz`cSJ4q^bY zQcd4HK{5|M$sBuXl#;`ZvQi}}rhPpF?Er+C5rX4)j2NMSp7oPdnN(WTASyzEsd-`wvIju|Ew)4;L3#2Ab zNkiApXi)YcPz5b)bhkAWod~Db0s}c-XKLDzr^yN$a7eKx_IT6YfE(iBx@$cPuG3W( zfUOccwYdvIkj~si2cS5hh@z#lj_;b$v$`32H-9j1A{_i&+6#?&tncu-+*Z zW2Q}dp^-6!$;v+=lcZcA7ry@I1d}+u&=HZ>C8HR+D`Jyj*M#L55Atn`p|1Dw~v0C-*jG(wh25`!}l(3ouEP%yHOSXJprW` zE8jwBf2Aj8a)kL`ty0hb*2hVE3?5H^{33(C1c=}-^JnOWe3Tap=oeDO_->NuT8h6f z)h!&q0=%huNT)VF%N-yUDaI?rnkN0TH2wf72^8BLq30$4-u3s)C!dKS_KNNJpVHZl#M?)GhU+) z7a>-8!Cxk)#IHvVI*ku9Z0jO-7D@Qwtyp&)%Kt7xDiNqfSl+e;Dyv72HUN^5ovrWK z{TtlX_Y{v2{%lC#zV@nX02a_4SzVnwTwy_wEbuVvPbl(EsV@TuCX1Xd&kvxhjH^MB zM;~a+W;cPLT7sISQNuX}S9Va;;}T2C$=tvxnZnv2q!WX2P=aE#HFi~t^Gbv`{Yw;< z9b_fdf)#P&-s4g9wiQu&~4@opS;CIx5W zGyfPL!Z^xCj-CGrW?A`X!@cv;KpS)qO+rb+%AHNs(9A6JNGsP-aNAZuZ{)!2QHKRp zon!!$SMb*3-OD=?ijQgew89=xmbsCt=;P8+GhRZ;SG_IGR#4(@X2@%IAQLImDZkOa zHZhNOpzd}gmwE?vr&*i;Ejh%Rx>kh&ArcAk)3Y|!?Z@=lb>~gSuS%OCCtWS%6g+vm z6=t_79)XO5(rFAcgSKH};B7b7Nj(w!5 za*eX=A4pP8g7J~Yos1})IRlLIK0y0rPj&&_2UUCEd$>E8)73b zVoTa&T6z2DN8lxd5d1SP0HIY}enqG0t|sD0T=ZVLMMtnG*t$O>>d##|bwQJ)$fn4& z+8wyADACwTlDuMWengq|ljE0Tsq2EQ)ospY^|mAh#|!&ZGST8JCa)W8f8h>Tx+;&Y zf8J$8=I&hTlBp3P>3;%=T!qhD-GR(k0m-d152*RvQ*nNeaFVC7DNT=iWf?Qjm~k&M z+p2*kq0mX%VO85-zTJCRUzCU&sV>qw++9$#l*BmV+2>FTt2}=I5*vs{>u(0I%@q z)Ab~^$L+QS2$OL&!QbCZ&|=$!QvE_yxabbY8R1)f-lh-pM@?ow{oN`CDvE)QM7M6e z!zUnrQ*0RjW$)W=`ns(Q;QJou(GeTMO3-DpptU#0VM%$SgZ@nWGp`v>QX&Nbi|ql$}w-HcKcz*6?{nYUJcA-S(*o@Ec2I?paK%kFH8%5Ymt>hay;)GtQN|dq!f`W zV11EmV);0{=>wE(okSfKo{C-NU5InNHd)fmln}~qs%(N}`w2oMbF!x*#2=X?wX#jQoDT)CJl-OG}oB$af4drU)9T zpzpFiaUHvQ3mTKhztV+y2I@~;FWDVO<=x%frnH33stx_k1*G2P-xv^0vT9YCe>Lj# z)8IcR&&GJyuBF_goB36_!CU;+nvY5q6aUTG0o{O!rn?HeO$uwPGjQcvefjM_Z7 zLP%wvPV*DQ2cXBM2XJ&83|GmB-6mkV-LeUho1O{m^@X_0F8nMqC3V8+Cx+(!+WOk; zQ2t&v^-B}a;`b<05E-D)lTXyglGN@~IL$(EU#wqXBYf#N{2gS#^Ci2YzK4XM(K2}y zzUa^yL?71Ue6L!ccyy6B5|}O64pYudO=Z`aLD7IN2KaaJ*44Ht=ZwDbQv{eAz{$tMEJVV zW-bi->0pU z-#8o4HuT_9(k7^A8)cM>*x*kO@HN{K`KR&ExCo(J%{;Q7d5Fi~p@-?T&2PW(@pN)7 zi{NbEmr)4Kef706fmQ)gGqbRLXKA7T)x#R z{_!~bRJzMWbT&;A+lx4zQA{#;uC+A%@t?s@3%I`n;f$3?3_$;!jpk&y@X(nqx-OL9 znJOjshdd&udeIc8ATlC;?lxF&y**(a4qY!a%#A-;#W2$B(KL^Bh$V8NN#wyCKh;r( zZ+t>C5l!qPsR!b+H2vIcw&$J`Igb9e?~T3RyzNch|A5wKW<;ymfZlO={~+9CYN(}W zCEQfZ$F$lpXPR?$?`|JmMftnZ6})$!TV8dyX3kK}#a@OO^{U5)`gt+0hj#3=O4cGS zI?hIFS6Amm9+}9Fq$$3Rs-12}UeahjUYO>2%6*XQQ)Sm{;T#k0eQ-a!H%hAg>kp2K zGS(ymkGC%&*hskFhV#Kn-_^nm?KTNlrr8|-gZ5bJ(a@j0Xmm`0e|Xa=+^>RzMjsX> zX{BijxlG;?88Z`QNSiu+OO;uhqiscBaZp|}S=1fJtvFH(yM-lV`~ZFW=0$o>1Z6%t zJx!p0IvPomUbB5=w?owA`Q|sjq{5&=#M~1=DQJ%X|O3xbDvy)t*u< z<+|k*(bc23`rsX+FVp<+oiFLCm={MzEX_N}5Fws%ci*2$Gwm0z>2lMguB@(Cmoa3A z;-A|~au*&EBnh*j`q`$o2E4(A(Xo%y{wzev|E-15^ij`_&ztYr+UwS@20iqvs*mMT<|PUigjBfQHI$wD zvQ)#W4BOw#x!62Rh%Z{CI@bMFW#KvS?D=m){pWO59yWhw43r}33}y~a_mHQ3-_~M9^c^B^bbilEi%VGHj{6cgg!bROl17z5}+!g@wx;o`gmHmlWs0vZ6KXv zVV)7+qhf3itC)tZb*AtHG3FXQUk06G1Qk;69*d-0OMKqtLd{`*7`KQgm&C_Jz#Y(s z?{U1P(n`PL7x8{C_wZg zGVRVdDV9n2A+u^k7lzMicbX5VX1+K}BAmJ?of6-+A;#Y>;EqZRts-76YL+J*3b%jV zEaGy0#^yzgCrCy8NZD}^!J*#*Uu>V*l%Yxbd2_K_?bDZ>q%HS65BbgMbf?7zNnBr% zt<8f++;#^)skiP-(`a=!&LxFn|7^a*3`VQnkLYjy!q>vO>_ zB9Ps>SAu#vzRzNnyrsIlFDL^3-Au6MP~u&#kX2xcc6ou+hS%aaA4yks*G?+<+YRt0 zo^d6WcKB^3!4MU!-CUD(KOCH$xH>$KEL){Cmx|keyO6VDyRoHE^q(BA56?GDu-1l* z(ALE_{qDt0QSIx09-)RiG~d5@Eg+({nuvHRV=iVV>+CFXiZRSMg#W{&PL_qrp^f^~ ziby>~`?D95@=s$!n+YT8A1~~+ZHuiH^2C;(V{JO+Or1{JFx&nSF=gE@PKqvLjN&#R zSeM)R`KH{#fM@kwOW%~TH#p?EDIzbsOhWH+xLdIBOoPI(_HYG;yi45F{#_~x&X6Q9 zuOY;(xgU;4y>WdZ;ln)iLMK)QF8BRld!iUQwI)nr%r>*Xx}e=m*Yk?kNZ9)~TXJn( z(oC%G*9)PO=SyZL4^|st?+Ck3LJnh+PTm{k>{L$|iA;282@T-o$k-!nS)G3Pj=cPI z>%k-2jCsXbu{{F3qYJ}W|MD_UqenEiupSZzo;iU&-CI~!5cFrB6ihr2(e86j``CJ0 z$pu8y`RNH6Gu<<*u$F^S-H3;z(-E3VHA8YCjjY2$$~g&MF_SL}kQf%?URZ_jQMqr= zo+~7&Ge?nYF-cb1uXea8Gv_=Lb)tJ3^4>Yi^k*^w+^wo3sZTfmm&Ahpi@|7R*lP)< zB^x(VurJN;-EQ+mhv7i{@<)=y>$qLlhfx<5`aW1|`T4!ZpMYK>C4=o|WJ5_YS) z_jlcz@YeI~94LD;l;xehwJ)3(eqi4fl6&_BZ{3pV)6sHIIGcj1?~&Kd^&eWIg^u@) zry7=FO-Yehl3pd;&!?2kd#PZ4PpeOqk@L{G(Su1-+`Enu;o@`dOd9VVc8_c3t!PBX zdG^fYrHn1Fvj6LoXWLLY?M+>S;cJiSC^HDrU812fx#+xyTtPnB!QGb?Z zSJ*M=u1ady3Af4fj}K7oZJeW~{viYg9mZmm1Q*Cr~`Oyu@ z9cvnMJ37b^59ehxL4Qw}pP$JfHLQy7{YoZesjZ2c!`E&#V$a~Kk`a@e40Fk(NL9G9 zkJeVO4J5Rh6r6yK(B#?rDFa)D9mQn}h-PBS{cWusSdSaU&?z~2hD*9+{TffQe`!|+ z#*11cR61P5Rm^)nJX%}ETGH9+t1Hs4UsheXIEg_mHOv_Hsqc}B+D4&1h`vD+4RyLR z55=eEQ*;dZ`hS)mFSpdR&wR)JW4&43(X!vKZ@>FZPCR*%NvP3`+}!^s?UGVX`qaFz z_Dv7g@QFizIzTXyaji2`H$jj#0u|iI${A|_7y$9x+PdO};{Xh2A@y2MA z`-?Tp7FKNAq}jt8ULus)y69^8#&7c`nIHLo?bn*ObAB*{r(FJVqkna=M%mB14V>#v z^|V^8xZRSyI3h3G{9b#s{_~khMtQs6r~jBRVNI6U`|3S!LB-n~P?h_6!8=P32h?}4 z@M5yD(O{k0;<_gsRO)#=c*8M6<>i}*YBjJtu$l%71C`!zdaytG+fHv_u7C*s31m5u z)H6H($lJU%cYnDv7H$H`oSV@gcEy_zD zrvq#0wA0TPz`O=^rA|MvvHt1W6-kh7NZy&D3Ji)!z1hvv5MBgHZ?Iv~T5&o$I9&x2 zLNF}}(^x_R(s$=d#Wzp$PzRD3@9Q literal 0 HcmV?d00001 From 2d9cb33c11a94a954f3f7983469398fe7a370328 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Mon, 18 Nov 2024 14:07:00 -0500 Subject: [PATCH 44/50] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5a69557..de3eda0 100644 --- a/README.md +++ b/README.md @@ -324,7 +324,7 @@ For an example of how MiM pre-trained models work, see the example inference not - For expected model input see "Expected Model Input" section - For steps taken for generating the MODIS-TOA pre-training dataset see "MODIS-TOA Dataset Generation" section -![MODIS TOA Bands](modis_toa_bands.png) +![MODIS TOA Bands](docs/static/modis_toa_bands.png) ## MODIS-TOA Dataset Generation From 769b5526bd99ff043d4a29ba3f782d29b9c0790c Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Tue, 19 Nov 2024 13:17:51 -0500 Subject: [PATCH 45/50] Update Dockerfile.dev --- requirements/Dockerfile.dev | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/requirements/Dockerfile.dev b/requirements/Dockerfile.dev index 8bbaf20..f18c3b9 100644 --- a/requirements/Dockerfile.dev +++ b/requirements/Dockerfile.dev @@ -107,8 +107,7 @@ RUN pip --no-cache-dir install \ yacs \ termcolor \ segmentation-models-pytorch \ - coverage \ - GDAL==`ogrinfo --version | grep -Eo '[0-9]\.[0-9]\.[0-9]+'` + coverage HEALTHCHECK NONE ENTRYPOINT [] From 1a80649c3b31b3b721bbd7f652a4e476087fbb04 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 21 Nov 2024 10:50:12 -0500 Subject: [PATCH 46/50] Update Dockerfile.dev --- requirements/Dockerfile.dev | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements/Dockerfile.dev b/requirements/Dockerfile.dev index f18c3b9..0157464 100644 --- a/requirements/Dockerfile.dev +++ b/requirements/Dockerfile.dev @@ -7,7 +7,6 @@ FROM ${FROM_IMAGE}:${VERSION_DATE}-py3 # Ubuntu needs noninteractive to be forced ENV DEBIAN_FRONTEND noninteractive -ENV PROJ_LIB="/usr/share/proj" ENV CPLUS_INCLUDE_PATH="/usr/include/gdal" ENV C_INCLUDE_PATH="/usr/include/gdal" From b587c34059132790a0de37bd3d40aa0cb8dd2d9e Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 21 Nov 2024 11:12:18 -0500 Subject: [PATCH 47/50] Update Dockerfile --- requirements/Dockerfile | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/requirements/Dockerfile b/requirements/Dockerfile index 4178c12..0157464 100644 --- a/requirements/Dockerfile +++ b/requirements/Dockerfile @@ -7,7 +7,6 @@ FROM ${FROM_IMAGE}:${VERSION_DATE}-py3 # Ubuntu needs noninteractive to be forced ENV DEBIAN_FRONTEND noninteractive -ENV PROJ_LIB="/usr/share/proj" ENV CPLUS_INCLUDE_PATH="/usr/include/gdal" ENV C_INCLUDE_PATH="/usr/include/gdal" @@ -75,13 +74,13 @@ RUN git clone --single-branch --branch master https://github.com/pkolano/shift.g rm -rf /app # Pip -RUN pip --no-cache-dir install omegaconf \ +RUN pip --no-cache-dir install \ pytorch-lightning \ Lightning \ transformers \ datasets \ - webdataset \ deepspeed \ + webdataset \ 'huggingface_hub[cli,torch]' \ torchgeo \ rasterio \ @@ -95,9 +94,6 @@ RUN pip --no-cache-dir install omegaconf \ opencv-contrib-python-headless \ tifffile \ webcolors \ - Pillow \ - seaborn \ - xgboost \ tiler \ segmentation-models \ timm \ From 912fe75e9b5481e7e4ec422cf9bc3009fd60dfe6 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 21 Nov 2024 11:14:51 -0500 Subject: [PATCH 48/50] Update requirements.txt --- requirements/requirements.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/requirements/requirements.txt b/requirements/requirements.txt index b89597c..fdb2b12 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,9 +1,11 @@ torch>=2.0.0 torchvision>=0.15 lightning +datasets rasterio rioxarray xarray +geopandas tifffile webcolors tiler @@ -20,3 +22,5 @@ joblib GDAL>=3.3.0 coverage deepspeed +webdataset +torchgeo From c3a949729c756894a8bd2eb293e9e6099dc32811 Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 21 Nov 2024 11:15:09 -0500 Subject: [PATCH 49/50] Update requirements-test.txt --- requirements/requirements-test.txt | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/requirements/requirements-test.txt b/requirements/requirements-test.txt index a574a34..fdb2b12 100644 --- a/requirements/requirements-test.txt +++ b/requirements/requirements-test.txt @@ -1,22 +1,14 @@ torch>=2.0.0 torchvision>=0.15 -pytorch-lightning -omegaconf +lightning +datasets rasterio rioxarray xarray geopandas -opencv-python -opencv-python-headless -opencv-contrib-python -opencv-contrib-python-headless tifffile webcolors -Pillow -seaborn -xgboost tiler -segmentation-models pytest coveralls rtree @@ -26,4 +18,9 @@ yacs termcolor numba segmentation-models-pytorch +joblib +GDAL>=3.3.0 coverage +deepspeed +webdataset +torchgeo From c6efdb0671fbf2a1189f94c24600ab059cb017fb Mon Sep 17 00:00:00 2001 From: Caleb Spradlin <72508718+cssprad1@users.noreply.github.com> Date: Thu, 21 Nov 2024 11:15:25 -0500 Subject: [PATCH 50/50] Update pyproject.toml --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 931e61b..df70096 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,4 +3,4 @@ requires = ["setuptools", "wheel"] [tool.black] -target_version = ['py39'] +target_version = ['py310']