


# Copyright 2023 The HuggingFace Team. 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.

import torch

from accelerate import PartialState
from accelerate.utils.operations import broadcast, gather, gather_object, pad_across_processes, reduce







def     lowerCAmelCase_					( __lowerCamelCase     ):
							return (torch.arange(state.num_processes     ) + 1.0 + (state.num_processes * state.process_index)).to(state.device     )







def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      List[Any]										=       create_tensor(__lowerCamelCase     )
							__snake_case		:      Tuple										=       gather(__lowerCamelCase     )
							assert gathered_tensor.tolist() == list(range(1							,     state.num_processes**2 + 1     )     )







def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Tuple										=       [state.process_index]
							__snake_case		:      Optional[int]										=       gather_object(__lowerCamelCase     )
							assert len(__lowerCamelCase     ) == state.num_processes, F'{gathered_obj}, {len(__lowerCamelCase     )} != {state.num_processes}'
							assert gathered_obj == list(range(state.num_processes     )     ), F'{gathered_obj} != {list(range(state.num_processes     )     )}'







def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Optional[int]										=       create_tensor(__lowerCamelCase     )
							__snake_case		:      Any										=       broadcast(__lowerCamelCase     )
							assert broadcasted_tensor.shape == torch.Size([state.num_processes]     )
							assert broadcasted_tensor.tolist() == list(range(1							,     state.num_processes + 1     )     )







def     lowerCAmelCase_					( __lowerCamelCase     ):
							# We need to pad the tensor with one more element if we are the main process
							# to ensure that we can pad
							if state.is_main_process:
														__snake_case		:      Tuple										=       torch.arange(state.num_processes + 1     ).to(state.device     )
							else:
														__snake_case		:      Optional[Any]										=       torch.arange(state.num_processes     ).to(state.device     )
							__snake_case		:      Dict										=       pad_across_processes(__lowerCamelCase     )
							assert padded_tensor.shape == torch.Size([state.num_processes + 1]     )
							if not state.is_main_process:
														assert padded_tensor.tolist() == list(range(0							,     state.num_processes     )     ) + [0]







def     lowerCAmelCase_					( __lowerCamelCase     ):
							# For now runs on only two processes
							if state.num_processes != 2:
														return
							__snake_case		:      List[Any]										=       create_tensor(__lowerCamelCase     )
							__snake_case		:      Dict										=       reduce(__lowerCamelCase							,     "sum"     )
							__snake_case		:      Dict										=       torch.tensor([4.0, 6]     ).to(state.device     )
							assert torch.allclose(__lowerCamelCase							,     __lowerCamelCase     ), F'{reduced_tensor} != {truth_tensor}'







def     lowerCAmelCase_					( __lowerCamelCase     ):
							# For now runs on only two processes
							if state.num_processes != 2:
														return
							__snake_case		:      List[str]										=       create_tensor(__lowerCamelCase     )
							__snake_case		:      int										=       reduce(__lowerCamelCase							,     "mean"     )
							__snake_case		:      str										=       torch.tensor([2.0, 3]     ).to(state.device     )
							assert torch.allclose(__lowerCamelCase							,     __lowerCamelCase     ), F'{reduced_tensor} != {truth_tensor}'







def     lowerCAmelCase_					( __lowerCamelCase     ):
							# For xla_spawn (TPUs)
							main()







def     lowerCAmelCase_					( ):
							__snake_case		:      Dict										=       PartialState()
							state.print(F'State: {state}'     )
							state.print("testing gather"     )
							test_gather(__lowerCamelCase     )
							state.print("testing gather_object"     )
							test_gather_object(__lowerCamelCase     )
							state.print("testing broadcast"     )
							test_broadcast(__lowerCamelCase     )
							state.print("testing pad_across_processes"     )
							test_pad_across_processes(__lowerCamelCase     )
							state.print("testing reduce_sum"     )
							test_reduce_sum(__lowerCamelCase     )
							state.print("testing reduce_mean"     )
							test_reduce_mean(__lowerCamelCase     )


if __name__ == "__main__":
			main()





def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							return x if y == 0 else greatest_common_divisor(__lowerCamelCase							,     x % y     )







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							return (x * y) // greatest_common_divisor(__lowerCamelCase							,     __lowerCamelCase     )







def     lowerCAmelCase_					( __lowerCamelCase = 2_0     ):
							__snake_case		:      Optional[Any]										=       1
							for i in range(1							,     n + 1     ):
														__snake_case		:      Any										=       lcm(__lowerCamelCase							,     __lowerCamelCase     )
							return g


if __name__ == "__main__":
			print(f'''{solution() = }''')

