File "main_attention.py", line 88, in <module>

    autofe.fit_attention(args)

  File "/root/FETCH-main/autofe.py", line 251, in fit_attention

    actions, log_probs, m1_output, m2_output, m3_output, action_softmax = self.ppo.choose_action_c(

  File "/root/FETCH-main/feature_engineer/attention_searching/ppo.py", line 48, in choose_action_c

    action_softmax, m1_output, m2_output, m3_output = self.actor_c(input_c, step)

  File "/root/miniconda3/lib/python3.8/site-packages/mindspore/nn/cell.py", line 659, in __call__

    raise AttributeError("For 'Cell', the method 'construct' is not defined.")

AttributeError: For 'Cell', the method 'construct' is not defined.

actions, log_probs, m1_output, m2_output, m3_output, action_softmax = self.ppo.choose_action_c(workers_c[i].states[-1], step, epoch, c_ops, sample_rule)

actions, log_probs, m1_output, m2_output, m3_output, action_softmax = ppo.choose_action_c(state_c, step, epoch, c_ops, sample_rule)

self.actor_c = Actor(args, data_nums, operations_c, d_model, d_k, d_v, d_ff, n_heads, dropout=dropout, enc_load_pth=args.enc_c_pth)

class Actor(nn.Cell):

    def __init__(self, args, data_nums, operations, d_model, d_k, d_v, d_ff, n_heads, dropout=None, enc_load_pth=None):

        super(Actor, self).__init__()

        self.args = args

        self.reduction_dimension = ReductionDimension(data_nums, d_model)

        self.encoder = EncoderLayer(d_model, d_k, d_v, d_ff, n_heads, dropout)

        logging.info(f"Randomly initial encoder")

        if os.path.exists(enc_load_pth):

            self.encoder.load_state_dict(mindspore.load(enc_load_pth))

            logging.info(f"Successfully load encoder, enc_load_pth:{enc_load_pth}")

        self.select_operation = SelectOperations(d_model, operations)

        self.c_nums = len(args.c_columns)

        self.layernorm = nn.LayerNorm(normalized_shape=(data_nums,))

    def forward(self, input, step):

        input_norm = self.layernorm(input)

        data_reduction_dimension = self.reduction_dimension(input_norm)

        data_reduction_dimension = mindspore.ops.where(mindspore.ops.isnan(data_reduction_dimension),

                                               mindspore.ops.full_like(data_reduction_dimension, 0), data_reduction_dimension)

        encoder_output = self.encoder(data_reduction_dimension)

        encoder_output = mindspore.ops.where(mindspore.ops.isnan(encoder_output), mindspore.ops.full_like(encoder_output, 0), encoder_output)

        output = self.select_operation(encoder_output)

        output = mindspore.ops.where(mindspore.ops.isnan(output), mindspore.ops.full_like(output, 0), output)

        operation_softmax = mindspore.ops.softmax(output, dim=-1)

        return operation_softmax, data_reduction_dimension.squeeze(), \

               encoder_output.squeeze(), output