Пример #1
0
    def to_training_sentences(self, from_state: str) -> None:
        """Transition to training_sentences state."""
        # Use doit to train
        saved_argv = sys.argv
        try:
            # Store doit database in profile directory
            sys.argv = [
                sys.argv[0],
                "--db-file",
                str(self.profile.write_path(".doit.db")),
            ]

            code, errors = train_profile(Path(self.profile.read_path()), self.profile)
            if code != 0:
                raise Exception("\n".join(errors))

            self.transition("training_intent")

            intent_fst_path = self.profile.read_path(
                self.profile.get("intent.fsticuffs.intent_fst", "intent.fst")
            )

            intent_fst = fst.Fst.read(str(intent_fst_path))
            self.send(self.intent_trainer, TrainIntent(intent_fst))
        except Exception as e:
            self.transition("ready")
            self.send(self.training_receiver, ProfileTrainingFailed(str(e)))
        finally:
            # Restore sys.argv
            sys.argv = saved_argv
Пример #2
0
    def in_training_intent(self, message: Any, sender: RhasspyActor) -> None:
        """Handle messages in training_intent state."""
        if isinstance(message, IntentTrainingComplete):
            self._logger.info("Training complete")

            if self.reload_actors_after_training:
                self._logger.debug("Reloading actors")

                # Wake listener
                self.send(self.wake, ActorExitRequest())
                self._wake = self.createActor(self.wake_class)
                self.actors["wake"] = self.wake

                # Speech decoder
                self.send(self.decoder, ActorExitRequest())
                self._decoder = self.createActor(self.decoder_class)
                self.actors["decoder"] = self.decoder

                # Intent recognizer
                self.send(self.recognizer, ActorExitRequest())
                self._recognizer = self.createActor(self.recognizer_class)
                self.actors["recognizer"] = self.recognizer

                # Configure actors
                self.wait_actors = {
                    "wake": self.wake,
                    "decoder": self.decoder,
                    "recognizer": self.recognizer,
                }

                for actor in self.wait_actors.values():
                    if actor == self.mqtt:
                        continue  # skip

                    self.send(
                        actor,
                        ConfigureEvent(self.profile,
                                       preload=self.preload,
                                       **self.actors),
                    )

                self.transition("training_loading")
            else:
                self.transition("ready")
                self.send(self.training_receiver, ProfileTrainingComplete())
        elif isinstance(message, IntentTrainingFailed):
            self.transition("ready")
            self.send(self.training_receiver,
                      ProfileTrainingFailed(message.reason))