



# 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(	UpperCAmelCase__ ):


      """simple docstring"""



      return (torch.arange(state.num_processes ) + 1.0 + (state.num_processes * state.process_index)).to(state.device )

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      lowerCamelCase								=		create_tensor(UpperCAmelCase__ )
      lowerCamelCase								=		gather(UpperCAmelCase__ )
      assert gathered_tensor.tolist() == list(range(1   ,   state.num_processes**2 + 1 ) )

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      lowerCamelCase								=		[state.process_index]
      lowerCamelCase								=		gather_object(UpperCAmelCase__ )
      assert len(UpperCAmelCase__ ) == state.num_processes, F"""{gathered_obj}, {len(UpperCAmelCase__ )} != {state.num_processes}"""
      assert gathered_obj == list(range(state.num_processes ) ), F"""{gathered_obj} != {list(range(state.num_processes ) )}"""

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      lowerCamelCase								=		create_tensor(UpperCAmelCase__ )
      lowerCamelCase								=		broadcast(UpperCAmelCase__ )
      assert broadcasted_tensor.shape == torch.Size([state.num_processes] )
      assert broadcasted_tensor.tolist() == list(range(1   ,   state.num_processes + 1 ) )

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      if state.is_main_process:
            lowerCamelCase								=		torch.arange(state.num_processes + 1 ).to(state.device )
      else:
            lowerCamelCase								=		torch.arange(state.num_processes ).to(state.device )
      lowerCamelCase								=		pad_across_processes(UpperCAmelCase__ )
      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(	UpperCAmelCase__ ):


      """simple docstring"""



      if state.num_processes != 2:
            return
      lowerCamelCase								=		create_tensor(UpperCAmelCase__ )
      lowerCamelCase								=		reduce(UpperCAmelCase__   ,   "sum" )
      lowerCamelCase								=		torch.tensor([4.0, 6] ).to(state.device )
      assert torch.allclose(UpperCAmelCase__   ,   UpperCAmelCase__ ), F"""{reduced_tensor} != {truth_tensor}"""

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      if state.num_processes != 2:
            return
      lowerCamelCase								=		create_tensor(UpperCAmelCase__ )
      lowerCamelCase								=		reduce(UpperCAmelCase__   ,   "mean" )
      lowerCamelCase								=		torch.tensor([2.0, 3] ).to(state.device )
      assert torch.allclose(UpperCAmelCase__   ,   UpperCAmelCase__ ), F"""{reduced_tensor} != {truth_tensor}"""

def     __lowercase(	UpperCAmelCase__ ):


      """simple docstring"""



      main()

def     __lowercase(	):


      """simple docstring"""



      lowerCamelCase								=		PartialState()
      state.print(F"""State: {state}""" )
      state.print("testing gather" )
      test_gather(UpperCAmelCase__ )
      state.print("testing gather_object" )
      test_gather_object(UpperCAmelCase__ )
      state.print("testing broadcast" )
      test_broadcast(UpperCAmelCase__ )
      state.print("testing pad_across_processes" )
      test_pad_across_processes(UpperCAmelCase__ )
      state.print("testing reduce_sum" )
      test_reduce_sum(UpperCAmelCase__ )
      state.print("testing reduce_mean" )
      test_reduce_mean(UpperCAmelCase__ )


if __name__ == "__main__":
     main()




from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a_						:     int	     =		{'configuration_van': ['VAN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VanConfig']}


try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     a_						:     Dict	     =		[
         'VAN_PRETRAINED_MODEL_ARCHIVE_LIST',
         'VanForImageClassification',
         'VanModel',
         'VanPreTrainedModel',
     ]

if TYPE_CHECKING:
     from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_van import (
              VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
              VanForImageClassification,
              VanModel,
              VanPreTrainedModel,
          )

else:
     import sys

     a_						:     Union[str, Any]	     =		_LazyModule(__name__, globals()['__file__'], _import_structure)