Method _feed_data

python/paddle/base/executor.py:1403–1457

(self, program, feed, feed_var_name, scope)

        )

    def _feed_data(self, program, feed, feed_var_name, scope):
        # feed var to framework
        global_block = program.global_block()
        for op in global_block.ops:
            if op.desc.type() == 'feed':
                feed_target_name = op.desc.output('Out')[0]
                cur_feed = feed[feed_target_name]
                var = global_block.var(feed_target_name)
                if var.dtype != core.VarDesc.VarType.STRINGS:
                    if not isinstance(cur_feed, core.DenseTensor):
                        cur_feed = _as_lodtensor(
                            cur_feed, self.place, var.dtype
                        )
                    check_feed_shape_type(var, cur_feed)
                idx = op.desc.attr('col')
                pir_flag_name = 'FLAGS_enable_pir_in_executor'
                if get_flags(pir_flag_name)[pir_flag_name]:
                    core.set_feed_variable(
                        scope, cur_feed, feed_target_name, idx
                    )
                else:
                    micro_cur_feed = [cur_feed]
                    num_micro_batch = 1
                    if (
                        program._pipeline_opt
                        and "standalone_opt" in program._pipeline_opt
                    ):
                        num_micro_batch = program._pipeline_opt[
                            "standalone_opt"
                        ]["num_micro_batches"]
                        batch_size = (
                            cur_feed.shape()[0]
                            if callable(cur_feed.shape)
                            else cur_feed.shape[0]
                        )
                        assert batch_size % num_micro_batch == 0
                        micro_cur_feed = np.split(
                            np.array(cur_feed), num_micro_batch, 0
                        )
                    for i in range(num_micro_batch):
                        micro_feed = (
                            _as_lodtensor(
                                micro_cur_feed[i], self.place, var.dtype
                            )
                            if num_micro_batch > 1
                            else micro_cur_feed[i]
                        )
                        core.set_feed_variable(
                            scope,
                            micro_feed,
                            feed_var_name,
                            idx * num_micro_batch + i,
                        )
            else:
                break

    def _pir_feed_data(self, program, feed, scope, data_op_infos):
        # feed var to framework