class_docstr: ViewGenerator deals with the sharding strategies of view op.
class_docstr_tok: ["ViewGenerator","deals","with","the","sharding","strategies","of","view","op","."]
code: def collate_strategies(self) -> List[ShardingStrategy]:
      strategy_list = []
      for index, strategy in enumerate(
          self.predecessor_node.strategies_vector
      ):
          dim_partition_dict_mapping = {}
          communication_action_mapping = {}
          input_sharding_spec = strategy.output_sharding_specs[
              self.op_data["input"]
          ]
  
          origin_shape = self.op_data["input"].data.shape
          tgt_shape = self.op_data["tgt_shape"].data
  
          reshape_mapping_dict = detect_reshape_mapping(
              origin_shape, tgt_shape
          )
  
          dim_partition_dict_for_input = (
              input_sharding_spec.dim_partition_dict
          )
          keep_sharding_status = check_keep_sharding_status(
              dim_partition_dict_for_input, reshape_mapping_dict
          )
  
          if keep_sharding_status:
              dim_partition_dict_for_output = (
                  infer_output_dim_partition_dict(
                      dim_partition_dict_for_input, reshape_mapping_dict
                  )
              )
          else:
              dim_partition_dict_for_output = {}
  
          dim_partition_dict_mapping = {
              "input": dim_partition_dict_for_input,
              "output": dim_partition_dict_for_output,
          }
          sharding_spec_mapping = self.to_sharding_spec_mapping(
              dim_partition_dict_mapping
          )
  
          # add index into name to pass the duplicated check
          # we keep same strategies with different name for node merging, and it will not increase the searching space,
          # because in solver, this node will be merged into other nodes, and solver will not create a new variable for this node.
          if keep_sharding_status:
              name = f'{sharding_spec_mapping["input"].sharding_sequence} -> {sharding_spec_mapping["output"].sharding_sequence}_{index}'
          else:
              name = f'{sharding_spec_mapping["input"].sharding_sequence} -> FULLY REPLICATED_{index}'
  
              # add comm action for converting input to fully replicated
              total_mesh_dim_list = []
              for (
                  mesh_dim_list
              ) in dim_partition_dict_for_input.values():
                  total_mesh_dim_list.extend(mesh_dim_list)
              # if there is only one sharding dimension, we should use the value instead of list as logical_process_axis.
              if len(total_mesh_dim_list) == 1:
                  total_mesh_dim_list = total_mesh_dim_list[0]
                  # the total mesh dim list only has one element, so the shard dim has only one element as well.
                  shard_dim = list(dim_partition_dict_for_input.keys())[
                      0
                  ]
                  input_comm_action = self.get_communication_action(
                      sharding_spec=sharding_spec_mapping["input"],
                      communication_pattern=CollectiveCommPattern.GATHER_FWD_SPLIT_BWD,
                      logical_process_axis=total_mesh_dim_list,
                      comm_type=CommType.BEFORE,
                      arg_index=0,
                  )
                  # it will gather the input through gather_dim during forward phase.
                  input_comm_action.comm_spec.gather_dim = shard_dim
                  # it will split the input activation grad through shard_dim during backward phase.
                  input_comm_action.comm_spec.shard_dim = shard_dim
  
              elif len(total_mesh_dim_list) >= 2:
                  source_spec = sharding_spec_mapping["input"]
                  target_spec = ShardingSpec(
                      device_mesh=self.device_mesh,
                      entire_shape=source_spec.entire_shape,
                      dim_partition_dict={},
                  )
                  comm_spec = {
                      "src_spec": source_spec,
                      "tgt_spec": target_spec,
                  }
                  input_comm_action = CommAction(
                      comm_spec=comm_spec,
                      comm_type=CommType.BEFORE,
                      arg_index=0,
                  )
  
              else:
                  input_comm_action = None
  
              if input_comm_action is not None:
                  communication_action_mapping[
                      "input"
                  ] = input_comm_action
  
          strategy = self.get_sharding_strategy(
              name=name,
              sharding_spec_mapping=sharding_spec_mapping,
              communication_action_mapping=communication_action_mapping,
          )
          strategy_list.append(strategy)
  
      return strategy_list
  
imports: import copy
  from typing import List
  from colossalai.auto_parallel.tensor_shard.node_handler.strategy.strategy_generator import FollowingStrategyGenerator
  from colossalai.auto_parallel.tensor_shard.sharding_strategy import CommAction, CommType, MemoryCost, ShardingStrategy, TrainCycleItem
  from colossalai.auto_parallel.tensor_shard.utils import check_keep_sharding_status, detect_reshape_mapping, infer_output_dim_partition_dict
  from colossalai.tensor.shape_consistency import CollectiveCommPattern
  from colossalai.tensor.sharding_spec import ShardingSpec
label_desc: Use image node_id 1 for calling the ViewGenerator obj's underlying member method code with example usage: obj.collate_strategies() and returns: strategy_list