



from __future__ import annotations

from collections.abc import Callable







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase = 100				,   )			->			Dict:



						'''simple docstring'''






						UpperCAmelCase_					=	x_start
						UpperCAmelCase_					=	fnc(_lowercase      )
						UpperCAmelCase_					=	0.0

						for _ in range(_lowercase      ):
												# Approximates small segments of curve as linear and solve
												# for trapezoidal area
												UpperCAmelCase_					=	(x_end - x_start) / steps + xa
												UpperCAmelCase_					=	fnc(_lowercase      )
												area += abs(fxa + fxa      ) * (xa - xa) / 2

												# Increment step
												UpperCAmelCase_					=	xa
												UpperCAmelCase_					=	fxa
						return area


if __name__ == "__main__":







							def 							A     (						__UpperCAmelCase      )			->			Optional[Any]:



													'''simple docstring'''






													return x**3

							print("f(x) = x^3")
							print("The area between the curve, x = -10, x = 10 and the x axis is:")
							UpperCamelCase_      			=  10
							while i <= 100_000:
														UpperCamelCase_      			=  trapezoidal_area(f, -5, 5, i)
														print(f"with {i} steps: {area}")
														i *= 10













import torch

from accelerate import Accelerator, DistributedType

class        snake_case_				:







   """simple docstring"""



   def __enter__(     self:						int						)	->		Tuple:


       """simple docstring"""



       if self.enabled:
           _lowercase     			=						self.model.no_sync()
           self.model_sync_obj.__enter__()

       return self

   def __exit__(     self:						str ,							snake_case__:						Tuple ,							snake_case__:						int ,							snake_case__:						Tuple						)	->		Any:


       """simple docstring"""



       if self.enabled:
           # Average all models on exit
           self._sync_and_avg_model_params()
           self.model_sync_obj.__exit__(snake_case__ ,							snake_case__ ,							snake_case__						)

   def __init__(     self:						int ,							snake_case__:						Accelerator ,							snake_case__:						torch.nn.Module ,							snake_case__:						int ,							snake_case__:						bool = True						)	->		Optional[Any]:


       """simple docstring"""



       if accelerator.distributed_type not in [
           DistributedType.NO,
           DistributedType.MULTI_CPU,
           DistributedType.MULTI_GPU,
       ]:
           raise NotImplementedError('LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)'						)
       _lowercase     			=						enabled and accelerator.distributed_type != DistributedType.NO
       _lowercase     			=						0
       if self.enabled:
           _lowercase     			=						accelerator
           _lowercase     			=						model
           _lowercase     			=						local_sgd_steps

   def       SCREAMING_SNAKE_CASE__					(     self:						str						)	->		List[Any]:


       """simple docstring"""



       self.num_steps += 1
       if not self.enabled:
           return

       if self.num_steps % self.local_sgd_steps == 0:
           self._sync_and_avg_model_params()

   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[int]						)	->		Dict:


       """simple docstring"""



       self.accelerator.wait_for_everyone()
       with self.accelerator.autocast():
           for param in self.model.parameters():
               _lowercase     			=						self.accelerator.reduce(param.data ,							reduction='mean'						)
