
'''simple docstring'''


import importlib.util
import weakref
from functools import partialmethod

from .dependency_versions_check import dep_version_check
from .utils import is_accelerate_available, is_torch_available, logging


if is_torch_available():
	import torch

__SCREAMING_SNAKE_CASE						=      logging.get_logger(__name__)
def 					__magic_name__(       ):
						return importlib.util.find_spec("""deepspeed"""	) is not None


if is_accelerate_available() and is_deepspeed_available():
	from accelerate.utils.deepspeed import HfDeepSpeedConfig as DeepSpeedConfig
else:
	# Inherits from a dummy `object` if accelerate is not available, so that python succeeds to import this file.
	# Deepspeed glue code will never inherit this dummy object as it checks if accelerate is available.
	from builtins import object as DeepSpeedConfig




class     __snake_case			(    _a	):




		def __init__(  self					:Any			,    _SCREAMING_SNAKE_CASE					:Tuple)					->			Any:






								'''simple docstring'''






								set_hf_deepspeed_config(self)
								dep_version_check("""accelerate""")
								dep_version_check("""deepspeed""")
								super().__init__(_SCREAMING_SNAKE_CASE)







class     __snake_case			(    _a	):




		def __init__(  self					:Optional[int]			,    _SCREAMING_SNAKE_CASE					:Optional[int])					->			Tuple:






								'''simple docstring'''






								super().__init__(_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Union[str, Any]					     =     None
								UpperCamelCase_     :	List[str]					     =     []




		def 	_snake_case	(  self					:Union[str, Any])					->			Any:






								'''simple docstring'''






								if self._dtype is None:
														raise ValueError("""trainer_config_process() wasn't called yet to tell dtype""")
								return self._dtype




		def 	_snake_case	(  self					:List[str]			,    _SCREAMING_SNAKE_CASE					:Any)					->			Tuple:






								'''simple docstring'''






								UpperCamelCase_     :	Union[str, Any]					     =     self.get_value(_SCREAMING_SNAKE_CASE)
								if val is None:
														return False
								else:
														return val == "auto"




		def 	_snake_case	(  self					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:Optional[Any]			,    _SCREAMING_SNAKE_CASE					:Optional[Any]			,    _SCREAMING_SNAKE_CASE					:Dict=None			,    _SCREAMING_SNAKE_CASE					:str=True)					->			Union[str, Any]:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	str					     =     self.find_config_node(_SCREAMING_SNAKE_CASE)
								if config is None:
														return

								if config.get(_SCREAMING_SNAKE_CASE) == "auto":
														UpperCamelCase_     :	Union[str, Any]					     =     hf_val
														return

								if not must_match:
														return

								UpperCamelCase_     :	Any					     =     config.get(_SCREAMING_SNAKE_CASE)
								if ds_val is not None and ds_val != hf_val:
														self.mismatches.append(F"""- ds {ds_key_long}={ds_val} vs hf {hf_key}={hf_val}""")

		a_          =					partialmethod(_a					,			must_match=_a	)




		def 	_snake_case	(  self					:str			,    _SCREAMING_SNAKE_CASE					:List[str])					->			Dict:






								'''simple docstring'''






								UpperCamelCase_     :	List[str]					     =     args.world_size * args.per_device_train_batch_size * args.gradient_accumulation_steps
								self.fill_match(
								    """train_micro_batch_size_per_gpu"""			,    args.per_device_train_batch_size			,    """per_device_train_batch_size""")
								self.fill_match("""gradient_accumulation_steps"""			,    args.gradient_accumulation_steps			,    """gradient_accumulation_steps""")
								self.fill_match("""train_batch_size"""			,    _SCREAMING_SNAKE_CASE			,    """train_batch_size (calculated)""")
								self.fill_match("""gradient_clipping"""			,    args.max_grad_norm			,    """max_grad_norm""")

								self.fill_match("""optimizer.params.lr"""			,    args.learning_rate			,    """learning_rate""")
								self.fill_match("""optimizer.params.betas"""			,    [args.adam_betaa, args.adam_betaa]			,    """adam_beta1+adam_beta2""")
								self.fill_match("""optimizer.params.eps"""			,    args.adam_epsilon			,    """adam_epsilon""")
								self.fill_match("""optimizer.params.weight_decay"""			,    args.weight_decay			,    """weight_decay""")

								self.fill_only("""scheduler.params.warmup_min_lr"""			,    0)  # not a trainer arg
								self.fill_match("""scheduler.params.warmup_max_lr"""			,    args.learning_rate			,    """learning_rate""")
								# total_num_steps - will get set in trainer_config_finalize

								# fp16
								if args.fpaa or args.fpaa_full_eval:
														UpperCamelCase_     :	Optional[Any]					     =     """apex""" if args.fpaa_backend == """apex""" else """amp"""
								else:
														UpperCamelCase_     :	Any					     =     None

								if args.save_on_each_node:
														# deepspeed uses shared storage by default. Let's override this setting if save_on_each_node == True
														UpperCamelCase_     :	Optional[Any]					     =     self.config.get("""checkpoint"""			,    {})
														UpperCamelCase_     :	List[Any]					     =     args.save_on_each_node

								# amp: similar to the pytorch native amp - it has a bunch of optional params but we won't set
								# any here unless the user did the work
								self.fill_match(
								    """fp16.enabled"""			,    ((args.fpaa or args.fpaa_full_eval) and fpaa_backend == """amp""")			,    """fp16|fp16_full_eval+fp16_backend(amp)"""			,    )

								# apex: delegates amp work to apex (which needs to be available), but it cannot be used with any
								# ZeRO features
								self.fill_match("""amp.enabled"""			,    fpaa_backend == """apex"""			,    """fp16+fp16_backend(apex)""")
								self.fill_match("""amp.opt_level"""			,    args.fpaa_opt_level			,    """fp16_opt_level""")

								self.fill_match("""bf16.enabled"""			,    (args.bfaa or args.bfaa_full_eval)			,    """bf16|bf16_full_eval""")

								# deepspeed's default mode is fp16 unless there is a config that says differently
								if self.is_true("""bf16.enabled"""):
														UpperCamelCase_     :	Tuple					     =     torch.bfloataa
								elif self.is_false("""fp16.enabled"""):
														UpperCamelCase_     :	Optional[Any]					     =     torch.floataa
								else:
														UpperCamelCase_     :	str					     =     torch.floataa





		def 	_snake_case	(  self					:List[Any]			,    _SCREAMING_SNAKE_CASE					:Tuple			,    _SCREAMING_SNAKE_CASE					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:str)					->			Optional[int]:






								'''simple docstring'''






								UpperCamelCase_     :	Union[str, Any]					     =     [
								    """zero_optimization.reduce_bucket_size""",
								    """zero_optimization.stage3_prefetch_bucket_size""",
								    """zero_optimization.stage3_param_persistence_threshold""",
								]
								UpperCamelCase_     :	List[Any]					     =     [x for x in hidden_size_based_keys if self.is_auto(_SCREAMING_SNAKE_CASE)]

								if len(_SCREAMING_SNAKE_CASE) > 0:
														if hasattr(model.config			,    """hidden_size"""):
																				UpperCamelCase_     :	List[Any]					     =     model.config.hidden_size
														elif hasattr(model.config			,    """hidden_sizes"""):
																				# if there are many hidden sizes pick the largest one
																				UpperCamelCase_     :	Union[str, Any]					     =     max(model.config.hidden_sizes)
														else:
																				raise ValueError(
																				    """The model's config file has neither `hidden_size` nor `hidden_sizes` entry, """
																				    """therefore it's not possible to automatically fill out the following `auto` entries """
																				    F"""in the DeepSpeed config file: {hidden_size_auto_keys}. You can fix that by replacing """
																				    """`auto` values for these keys with an integer value of your choice.""")

														self.fill_only("""zero_optimization.reduce_bucket_size"""			,    hidden_size * hidden_size)
														if self.is_zeroa():
																				# automatically assign the optimal config values based on model config
																				self.fill_only("""zero_optimization.stage3_prefetch_bucket_size"""			,    0.9 * hidden_size * hidden_size)
																				self.fill_only("""zero_optimization.stage3_param_persistence_threshold"""			,    1_0 * hidden_size)

        # scheduler
								self.fill_match("""scheduler.params.total_num_steps"""			,    _SCREAMING_SNAKE_CASE			,    """num_training_steps (calculated)""")
								self.fill_match("""scheduler.params.warmup_num_steps"""			,    args.get_warmup_steps(_SCREAMING_SNAKE_CASE)			,    """warmup_steps""")

								if len(self.mismatches) > 0:
														UpperCamelCase_     :	Optional[Any]					     =     """\n""".join(self.mismatches)
														raise ValueError(
														    """Please correct the following DeepSpeed config values that mismatch TrainingArguments"""
														    F""" values:\n{mismatches}\nThe easiest method is to set these DeepSpeed config values to 'auto'.""")







__SCREAMING_SNAKE_CASE						=      None
def 					__magic_name__(       UpperCAmelCase__ :       Tuple	):
						# this is a special weakref global object to allow us to get to Deepspeed config from APIs
						# that don't have an easy way to get to the Deepspeed config outside of the Trainer domain.
						global _hf_deepspeed_config_weak_ref
						# will go away automatically when HfDeepSpeedConfig is destroyed (when TrainingArguments is destroyed)
						UpperCamelCase_     :	List[Any]					     =     weakref.ref(UpperCAmelCase__	)
def 					__magic_name__(       ):
						# useful for unit tests to ensure the global state doesn't leak - call from `tearDown` method
						global _hf_deepspeed_config_weak_ref
						UpperCamelCase_     :	int					     =     None
def 					__magic_name__(       ):
						if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
												return _hf_deepspeed_config_weak_ref().is_zeroa()
						else:
												return False
def 					__magic_name__(       ):
						if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
												return _hf_deepspeed_config_weak_ref().config
						else:
												return None
def 					__magic_name__(       UpperCAmelCase__ :       Optional[int]							,				UpperCAmelCase__ :       List[Any]							,				UpperCAmelCase__ :       int							,				UpperCAmelCase__ :       str							,				UpperCAmelCase__ :       List[Any]	):
						from accelerate.utils import DummyOptim, DummyScheduler

						UpperCamelCase_     :	Optional[int]					     =     hf_deepspeed_config.config

						# Optimizer + Scheduler
						# Currently supported combos:
						# 1. DS scheduler + DS optimizer: Yes
						# 2. HF scheduler + HF optimizer: Yes
						# 3. DS scheduler + HF optimizer: Yes
						# 4. HF scheduler + DS optimizer: No
						#
						# Unless Offload is enabled in which case it's:
						# 1. DS scheduler + DS optimizer: Yes
						# 2. HF scheduler + HF optimizer: Mostly*
						# 3. DS scheduler + HF optimizer: Mostly*
						# 4. HF scheduler + DS optimizer: No
						#
						# Mostly*: All non-native DeepSpeed optimizers that have both CPU and GPU implementation should work (except LAMB)

						UpperCamelCase_     :	Optional[int]					     =     None
						if "optimizer" in config:
												if args.adafactor:
																		raise ValueError(
																		    """--adafactor was passed, but also found `optimizer` configured in the DeepSpeed config. """
																		    """Only one optimizer can be configured."""	)
												UpperCamelCase_     :	Optional[Any]					     =     DummyOptim(params=UpperCAmelCase__	)
						else:
												if hf_deepspeed_config.is_offload():
																		logger.info(
																		    """Detected ZeRO Offload and non-DeepSpeed optimizers: This combination should work as long as the"""
																		    """ custom optimizer has both CPU and GPU implementation (except LAMB)"""	)

												# ds supports Adam, OneBitAdam, and Lamb optimizers and can import other optimizers from torch.
												# But trainer uses AdamW by default.
												UpperCamelCase_     :	Optional[int]					     =     trainer.create_optimizer()
												# To use other optimizers requires voiding warranty with: `zero_allow_untested_optimizer`
												UpperCamelCase_     :	Optional[int]					     =     True

						UpperCamelCase_     :	Optional[int]					     =     None
						if "scheduler" in config:
												UpperCamelCase_     :	Optional[Any]					     =     DummyScheduler(UpperCAmelCase__	)
						else:
												if isinstance(UpperCAmelCase__							,				UpperCAmelCase__	):
																		raise ValueError(
																		    """Found `optimizer` configured in the DeepSpeed config, but no `scheduler`. """
																		    """Please configure a scheduler in the DeepSpeed config."""	)
												UpperCamelCase_     :	str					     =     trainer.create_scheduler(num_training_steps=UpperCAmelCase__							,				optimizer=UpperCAmelCase__	)

						return optimizer, lr_scheduler
def 					__magic_name__(       UpperCAmelCase__ :       Optional[Any]							,				UpperCAmelCase__ :       Union[str, Any]							,				UpperCAmelCase__ :       int=False	):
						from deepspeed.utils import logger as ds_logger

						UpperCamelCase_     :	Any					     =     trainer.model
						UpperCamelCase_     :	Optional[Any]					     =     trainer.args

						UpperCamelCase_     :	Optional[Any]					     =     trainer.accelerator.state.deepspeed_plugin.hf_ds_config

						# resume config update - some bits like `model` and `num_training_steps` only become available during train
						hf_deepspeed_config.trainer_config_finalize(UpperCAmelCase__							,				UpperCAmelCase__							,				UpperCAmelCase__	)

						# set the Deepspeed log level consistent with the Trainer
						ds_logger.setLevel(args.get_process_log_level()	)

						if inference:
												# only Z3 makes sense for the inference
												if not hf_deepspeed_config.is_zeroa():
																		raise ValueError("""ZeRO inference only makes sense with ZeRO Stage 3 - please adjust your config"""	)

												# in case the training config is re-used for inference
												hf_deepspeed_config.del_config_sub_tree("""optimizer"""	)
												hf_deepspeed_config.del_config_sub_tree("""lr_scheduler"""	)
												UpperCamelCase_     ,UpperCamelCase_     :	Dict					     =     None, None
												UpperCamelCase_     :	Tuple					     =     None
						else:
												UpperCamelCase_     :	Tuple					     =     None  # important for when deepspeed_init is used as re-init
												UpperCamelCase_     :	Optional[int]					     =     list(filter(lambda UpperCAmelCase__	: p.requires_grad							,				model.parameters()	)	)
												UpperCamelCase_     ,UpperCamelCase_     :	Union[str, Any]					     =     deepspeed_optim_sched(
												    UpperCAmelCase__							,				UpperCAmelCase__							,				UpperCAmelCase__							,				UpperCAmelCase__							,				UpperCAmelCase__	)

						# keep for quick debug:
						# from pprint import pprint; pprint(config)

						return optimizer, lr_scheduler







def 					__magic_name__(       UpperCAmelCase__ :       Tuple							,				UpperCAmelCase__ :       List[str]	):
						# it's possible that the user is trying to resume from model_path, which doesn't necessarily
						# contain a deepspeed checkpoint. e.g. examples just check if the dir exists and assume it's
						# a resume from a checkpoint and not just a local pretrained weight. So we check here if the
						# path contains what looks like a deepspeed checkpoint
						import glob

						UpperCamelCase_     :	Optional[Any]					     =     sorted(glob.glob(f"""{checkpoint_path}/global_step*"""	)	)

						if len(UpperCAmelCase__	) > 0:
												logger.info(f"""Attempting to resume from {checkpoint_path}"""	)
												# this magically updates self.optimizer and self.lr_scheduler
												UpperCamelCase_     ,UpperCamelCase_     :	int					     =     deepspeed_engine.load_checkpoint(
												    UpperCAmelCase__							,				load_optimizer_states=UpperCAmelCase__							,				load_lr_scheduler_states=UpperCAmelCase__	)
												if load_path is None:
																		raise ValueError(f"""[deepspeed] failed to resume from checkpoint {checkpoint_path}"""	)
						else:
												raise ValueError(f"""Can't find a valid checkpoint at {checkpoint_path}"""	)






'''simple docstring'''


import math
from collections.abc import Generator
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)	))
						for i in (n for n in numbers if n > 1):
												for j in range(2							,				UpperCAmelCase__	):
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)	))
						for i in (n for n in numbers if n > 1):
												# only need to check for factors up to sqrt(i)
												UpperCamelCase_     :	List[Any]					     =     int(math.sqrt(UpperCAmelCase__	)	) + 1
												for j in range(2							,				UpperCAmelCase__	):
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)							,				2	))
						# It's useless to test even numbers as they will not be prime
						if max_n > 2:
												yield 2  # Because 2 will not be tested, it's necessary to yield it now
						for i in (n for n in numbers if n > 1):
												UpperCamelCase_     :	Optional[int]					     =     int(math.sqrt(UpperCAmelCase__	)	) + 1
												for j in range(3							,				UpperCAmelCase__							,				2	):
																		# As we removed the even numbers, we don't need them now
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       ):
						from timeit import timeit

						UpperCamelCase_     :	int					     =     """from __main__ import slow_primes, primes, fast_primes"""
						print(timeit("""slow_primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)
						print(timeit("""primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)
						print(timeit("""fast_primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)


if __name__ == "__main__":
	__SCREAMING_SNAKE_CASE						=      int(input("Calculate primes up to:\n>> ").strip())
	for ret in primes(number):
		print(ret)
	benchmark()




