


'''simple docstring'''







import json
import os

import torch

from diffusers import UNetaDModel


os.makedirs("""hub/hopper-medium-v2/unet/hor32""", exist_ok=True)
os.makedirs("""hub/hopper-medium-v2/unet/hor128""", exist_ok=True)

os.makedirs("""hub/hopper-medium-v2/value_function""", exist_ok=True)






def 			lowercase				(_A					):







       """simple docstring"""







       if hor == 1_2_8:
              _lowerCAmelCase    :							int   			=       ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D")
              _lowerCAmelCase    :							Tuple   			=       (3_2, 1_2_8, 2_5_6)
              _lowerCAmelCase    :							List[str]   			=       ("UpResnetBlock1D", "UpResnetBlock1D")

       elif hor == 3_2:
              _lowerCAmelCase    :							Union[str, Any]   			=       ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D")
              _lowerCAmelCase    :							str   			=       (3_2, 6_4, 1_2_8, 2_5_6)
              _lowerCAmelCase    :							Union[str, Any]   			=       ("UpResnetBlock1D", "UpResnetBlock1D", "UpResnetBlock1D")
       _lowerCAmelCase    :							List[Any]   			=       torch.load(f'/Users/bglickenhaus/Documents/diffuser/temporal_unet-hopper-mediumv2-hor{hor}.torch'					)
       _lowerCAmelCase    :							Optional[int]   			=       model.state_dict()
       _lowerCAmelCase    :							Union[str, Any]   			=       {
           "down_block_types": down_block_types,
           "block_out_channels": block_out_channels,
           "up_block_types": up_block_types,
           "layers_per_block": 1,
           "use_timestep_embedding": True,
           "out_block_type": "OutConv1DBlock",
           "norm_num_groups": 8,
           "downsample_each_block": False,
           "in_channels": 1_4,
           "out_channels": 1_4,
           "extra_in_channels": 0,
           "time_embedding_type": "positional",
           "flip_sin_to_cos": False,
           "freq_shift": 1,
           "sample_size": 6_5_5_3_6,
           "mid_block_type": "MidResTemporalBlock1D",
           "act_fn": "mish",
       }
       _lowerCAmelCase    :							int   			=       UNetaDModel(**_lowerCAmelCase					)
       print(f'length of state dict: {len(state_dict.keys()					)}'					)
       print(f'length of value function dict: {len(hf_value_function.state_dict().keys()					)}'					)
       _lowerCAmelCase    :							List[Any]   			=       dict(zip(model.state_dict().keys()   ,						hf_value_function.state_dict().keys()					)					)
       for k, v in mapping.items():
              _lowerCAmelCase    :							Tuple   			=       state_dict.pop(_lowerCAmelCase					)
       hf_value_function.load_state_dict(_lowerCAmelCase					)

       torch.save(hf_value_function.state_dict()   ,						f'hub/hopper-medium-v2/unet/hor{hor}/diffusion_pytorch_model.bin'					)
       with open(f'hub/hopper-medium-v2/unet/hor{hor}/config.json'   ,						'w'					) as f:
              json.dump(_lowerCAmelCase   ,						_lowerCAmelCase					)






def 			lowercase				():







       """simple docstring"""







       _lowerCAmelCase    :							Tuple   			=       {
           "in_channels": 1_4,
           "down_block_types": ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D"),
           "up_block_types": (),
           "out_block_type": "ValueFunction",
           "mid_block_type": "ValueFunctionMidBlock1D",
           "block_out_channels": (3_2, 6_4, 1_2_8, 2_5_6),
           "layers_per_block": 1,
           "downsample_each_block": True,
           "sample_size": 6_5_5_3_6,
           "out_channels": 1_4,
           "extra_in_channels": 0,
           "time_embedding_type": "positional",
           "use_timestep_embedding": True,
           "flip_sin_to_cos": False,
           "freq_shift": 1,
           "norm_num_groups": 8,
           "act_fn": "mish",
       }

       _lowerCAmelCase    :							Tuple   			=       torch.load('/Users/bglickenhaus/Documents/diffuser/value_function-hopper-mediumv2-hor32.torch'					)
       _lowerCAmelCase    :							int   			=       model
       _lowerCAmelCase    :							Tuple   			=       UNetaDModel(**_lowerCAmelCase					)
       print(f'length of state dict: {len(state_dict.keys()					)}'					)
       print(f'length of value function dict: {len(hf_value_function.state_dict().keys()					)}'					)

       _lowerCAmelCase    :							List[str]   			=       dict(zip(state_dict.keys()   ,						hf_value_function.state_dict().keys()					)					)
       for k, v in mapping.items():
              _lowerCAmelCase    :							Union[str, Any]   			=       state_dict.pop(_lowerCAmelCase					)

       hf_value_function.load_state_dict(_lowerCAmelCase					)

       torch.save(hf_value_function.state_dict()   ,						'hub/hopper-medium-v2/value_function/diffusion_pytorch_model.bin'					)
       with open('hub/hopper-medium-v2/value_function/config.json'   ,						'w'					) as f:
              json.dump(_lowerCAmelCase   ,						_lowerCAmelCase					)


if __name__ == "__main__":
       unet(32)
       # unet(128)
       value_function()





'''simple docstring'''







import math
from datetime import datetime, timedelta






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Optional[Any]   			=       year % 1_9
       _lowerCAmelCase    :							Any   			=       year % 4
       _lowerCAmelCase    :							Optional[int]   			=       year % 7
       _lowerCAmelCase    :							int   			=       math.floor(year / 1_0_0					)
       _lowerCAmelCase    :							Dict   			=       math.floor((1_3 + 8 * leap_day_inhibits) / 2_5					)
       _lowerCAmelCase    :							Optional[Any]   			=       leap_day_inhibits / 4
       _lowerCAmelCase    :							Dict   			=       (
           1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
       ) % 3_0
       _lowerCAmelCase    :							List[Any]   			=       (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

       # days to be added to March 21
       _lowerCAmelCase    :							Dict   			=       (1_9 * metonic_cycle + secular_moon_shift) % 3_0

       # PHM -> Paschal Full Moon
       _lowerCAmelCase    :							Union[str, Any]   			=       (
           2 * julian_leap_year
           + 4 * non_leap_year
           + 6 * days_to_add
           + century_starting_point
       ) % 7

       if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_9					)
       elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_8					)
       else:
              return datetime(_A   ,						3   ,						2_2					) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday					)					)


if __name__ == "__main__":
       for year in (19_94, 20_00, 20_10, 20_21, 20_23):
              lowerCAmelCase    :     List[str]					=						"""will be""" if year > datetime.now().year else """was"""
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

