class_docstr: DefaultReshapeGenerator which deals with the sharding strategies of Reshape Op which have to recover the tensor
  to Replica status.
class_docstr_tok: ["DefaultReshapeGenerator","which","deals","with","the","sharding","strategies","of","Reshape","Op","which","have","to","recover","the","tensor","to","Replica","status","."]
code: def collate_strategies(self) -> List[ShardingStrategy]:
      strategy_list = []
      # For default reshape strategy, to keep the computing correctness we keep the
      # sharding spec of input is fully replicated. In addition, we will keep the output
      # in replica status and let the successor node choose the way to resharding the
      # output node. Therefore, the different strategies of input node with same
      # output sharding spec will generate same strategy for reshape function.
      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"]
          ]
          dim_partition_dict_for_input = (
              input_sharding_spec.dim_partition_dict
          )
          dim_partition_dict_for_output = {}
          if isinstance(self.op_data["output"].data, tuple):
              dim_partition_dict_for_output = [
                  {} for _ in range(len(self.op_data["output"].data))
              ]
          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.
          name = f'{sharding_spec_mapping["input"].sharding_sequence} -> FULLY REPLICATED_{index}'
  
          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]
              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,
              )
              input_comm_action.comm_spec.gather_dim = (
                  total_mesh_dim_list
              )
              input_comm_action.comm_spec.shard_dim = (
                  total_mesh_dim_list
              )
  
          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 DefaultReshapeGenerator obj's underlying member method code with example usage: obj.collate_strategies() and returns: strategy_list