

# 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__						):
      return (torch.arange(state.num_processes						) + 1.0 + (state.num_processes * state.process_index)).to(state.device						)







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						Optional[int]					=					create_tensor(lowercase__						)
      __lowerCAmelCase					:						Tuple					=					gather(lowercase__						)
      assert gathered_tensor.tolist() == list(range(1   ,	state.num_processes**2 + 1						)						)







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







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







def 		_lowercase (     lowercase__						):
      # For xla_spawn (TPUs)
      main()







def 		_lowercase (     ):
      __lowerCAmelCase					:						Union[str, Any]					=					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()





from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						str					=					[]
      __lowerCAmelCase					:						List[Any]					=					[]
      __lowerCAmelCase					:						str					=					[]

      for rt in rc.restypes:
            __lowerCAmelCase					:						List[Any]					=					rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
            restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]						)
            __lowerCAmelCase					:						List[str]					=					{name: i for i, name in enumerate(lowercase__						)}
            restype_atomaa_to_atomaa_list.append(
                [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]						)

            restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]						)

      # Add dummy mapping for restype 'UNK'
      restype_atomaa_to_atomaa_list.append([0] * 1_4						)
      restype_atomaa_to_atomaa_list.append([0] * 3_7						)
      restype_atomaa_mask_list.append([0.0] * 1_4						)

      __lowerCAmelCase					:						List[Any]					=					torch.tensor(
          lowercase__   ,	dtype=torch.intaa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						Optional[Any]					=					torch.tensor(
          lowercase__   ,	dtype=torch.intaa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						Tuple					=					torch.tensor(
          lowercase__   ,	dtype=torch.floataa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						List[Any]					=					protein['''aatype'''].to(torch.long						)

      # create the mapping for (residx, atom14) --> atom37, i.e. an array
      # with shape (num_res, 14) containing the atom37 indices for this protein
      __lowerCAmelCase					:						Any					=					restype_atomaa_to_atomaa[protein_aatype]
      __lowerCAmelCase					:						Union[str, Any]					=					restype_atomaa_mask[protein_aatype]

      __lowerCAmelCase					:						int					=					residx_atomaa_mask
      __lowerCAmelCase					:						List[str]					=					residx_atomaa_to_atomaa.long()

      # create the gather indices for mapping back
      __lowerCAmelCase					:						int					=					restype_atomaa_to_atomaa[protein_aatype]
      __lowerCAmelCase					:						Union[str, Any]					=					residx_atomaa_to_atomaa.long()

      # create the corresponding mask
      __lowerCAmelCase					:						str					=					torch.zeros([2_1, 3_7]   ,	dtype=torch.floataa   ,	device=protein['''aatype'''].device						)
      for restype, restype_letter in enumerate(rc.restypes						):
            __lowerCAmelCase					:						Optional[int]					=					rc.restype_atoa[restype_letter]
            __lowerCAmelCase					:						Optional[Any]					=					rc.residue_atoms[restype_name]
            for atom_name in atom_names:
                  __lowerCAmelCase					:						str					=					rc.atom_order[atom_name]
                  __lowerCAmelCase					:						List[Any]					=					1

      __lowerCAmelCase					:						Union[str, Any]					=					restype_atomaa_mask[protein_aatype]
      __lowerCAmelCase					:						Any					=					residx_atomaa_mask

      return protein







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						Dict					=					tree_map(lambda lowercase__						: torch.tensor(lowercase__   ,	device=batch['''aatype'''].device						)   ,	lowercase__   ,	np.ndarray						)
      __lowerCAmelCase					:						Tuple					=					tensor_tree_map(lambda lowercase__						: np.array(lowercase__						)   ,	make_atomaa_masks(lowercase__						)						)
      return out


