





'''simple docstring'''






# 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       lowercase_      (		lowercase__						)   ->Optional[int]:
						return (torch.arange(state.num_processes						) + 1.0 + (state.num_processes * state.process_index)).to(state.device						)





def       lowercase_      (		lowercase__						)   ->Dict:
						_snake_case:   int  					=		create_tensor(lowercase__						)
						_snake_case:   Dict  					=		gather(lowercase__						)
						assert gathered_tensor.tolist() == list(range(1				,  state.num_processes**2 + 1						)						)





def       lowercase_      (		lowercase__						)   ->Union[str, Any]:
						_snake_case:   str  					=		[state.process_index]
						_snake_case:   Union[str, Any]  					=		gather_object(lowercase__						)
						assert len(lowercase__						) == state.num_processes, F'''{gathered_obj}, {len(lowercase__						)} != {state.num_processes}'''
						assert gathered_obj == list(range(state.num_processes						)						), F'''{gathered_obj} != {list(range(state.num_processes						)						)}'''





def       lowercase_      (		lowercase__						)   ->List[str]:
						_snake_case:   str  					=		create_tensor(lowercase__						)
						_snake_case:   Any  					=		broadcast(lowercase__						)
						assert broadcasted_tensor.shape == torch.Size([state.num_processes]						)
						assert broadcasted_tensor.tolist() == list(range(1				,  state.num_processes + 1						)						)





def       lowercase_      (		lowercase__						)   ->Dict:
						# 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:   Any  					=		torch.arange(state.num_processes + 1						).to(state.device						)
						else:
												_snake_case:   List[str]  					=		torch.arange(state.num_processes						).to(state.device						)
						_snake_case:   str  					=		pad_across_processes(lowercase__						)
						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       lowercase_      (		lowercase__						)   ->List[Any]:
						# For now runs on only two processes
						if state.num_processes != 2:
												return
						_snake_case:   Union[str, Any]  					=		create_tensor(lowercase__						)
						_snake_case:   List[str]  					=		reduce(lowercase__				,  'sum'						)
						_snake_case:   Optional[Any]  					=		torch.tensor([4.0, 6]						).to(state.device						)
						assert torch.allclose(lowercase__				,  lowercase__						), F'''{reduced_tensor} != {truth_tensor}'''





def       lowercase_      (		lowercase__						)   ->Union[str, Any]:
						# For now runs on only two processes
						if state.num_processes != 2:
												return
						_snake_case:   Dict  					=		create_tensor(lowercase__						)
						_snake_case:   Optional[int]  					=		reduce(lowercase__				,  'mean'						)
						_snake_case:   Tuple  					=		torch.tensor([2.0, 3]						).to(state.device						)
						assert torch.allclose(lowercase__				,  lowercase__						), F'''{reduced_tensor} != {truth_tensor}'''





def       lowercase_      (		lowercase__						)   ->Optional[int]:
						# For xla_spawn (TPUs)
						main()





def       lowercase_      (		)   ->Optional[Any]:
						_snake_case:   str  					=		PartialState()
						state.print(F'''State: {state}'''						)
						state.print('testing gather'						)
						test_gather(lowercase__						)
						state.print('testing gather_object'						)
						test_gather_object(lowercase__						)
						state.print('testing broadcast'						)
						test_broadcast(lowercase__						)
						state.print('testing pad_across_processes'						)
						test_pad_across_processes(lowercase__						)
						state.print('testing reduce_sum'						)
						test_reduce_sum(lowercase__						)
						state.print('testing reduce_mean'						)
						test_reduce_mean(lowercase__						)


if __name__ == "__main__":
		main()












'''simple docstring'''






import torch





def       lowercase_      (		)   ->Dict:
						if torch.cuda.is_available():
												_snake_case:   Any  					=		torch.cuda.device_count()
						else:
												_snake_case:   Optional[int]  					=		0
						print(F'''Successfully ran on {num_gpus} GPUs'''						)


if __name__ == "__main__":
		main()





