Method _make_program

python/paddle/hapi/model.py:591–689

(self, mode)

            self._initialize(self._progs[mode], mode)

    def _make_program(self, mode):
        prog = self._progs.get(mode, None)
        if prog is not None:
            return

        prog = self._orig_prog.clone()

        losses = []
        metrics = []
        prog_param = prog.get_all_parameter_values()

        named_sublayers = self.model.network.named_sublayers(
            prefix='',
            include_self=True,
            remove_duplicate=True,
        )
        for layer_prefix, sublayer in named_sublayers:
            params = sublayer._parameters.items()
            for key, param in params:
                sublayer._parameters[key] = prog_param[param.name]

        with base.program_guard(prog, self._startup_prog):
            inputs = self.model._inputs
            labels = self.model._labels if self.model._labels else []
            inputs = [k._create_feed_layer() for k in to_list(inputs)]
            labels = [k._create_feed_layer() for k in to_list(labels)]
            self._label_vars[mode] = labels

            if mode == 'train' and self.model._optimizer:
                opt_param = []
                for key, value in prog_param.items():
                    opt_param.append(value)

                self.model._optimizer._parameter_list = list(opt_param)

                if self._amp_level != "O0" and core.is_compiled_with_cuda:
                    self.model.network, self.model._optimizer = (
                        paddle.amp.decorate(
                            models=self.model.network,
                            optimizers=self.model._optimizer,
                            level=self._amp_level,
                        )
                    )

                    with paddle.amp.auto_cast(
                        level=self._amp_level, dtype='float16', use_promote=True
                    ):
                        outputs = to_list(self.model.network.forward(*inputs))

                        if mode != 'test' and self.model._loss:
                            losses = self.model._loss(*(outputs + labels))

                        if mode != 'test':
                            for metric in self.model._metrics:
                                metrics.append(
                                    to_list(metric.compute(*(outputs + labels)))
                                )
                else: