Пример #1
0
    def initializeFromBuilder(self, data, exported_builder):
        # Copy the components
        self.staticComponents = deepcopy(exported_builder.staticComponents)
        self.automaticComponents = deepcopy(
            exported_builder.automaticComponents)
        self.dynamicComponents = deepcopy(exported_builder.dynamicComponents)
        self.componentIndex = deepcopy(exported_builder.componentIndex)
        self.discount = deepcopy(exported_builder.discount)
        self.initialDegreeFreedom = exported_builder.model.df

        # Copy the model states
        self.statePrior = exported_builder.model.state
        self.sysVarPrior = exported_builder.model.sysVar
        self.noiseVar = exported_builder.model.noiseVar
        self.transition = exported_builder.transition
        self.evaluation = exported_builder.evaluation
        # update the evaluation to the current.
        self.updateEvaluation(step=0, data=data)

        self.model = baseModel(transition=self.transition,
                               evaluation=self.evaluation,
                               noiseVar=self.noiseVar,
                               sysVar=self.sysVarPrior,
                               state=self.statePrior,
                               df=self.initialDegreeFreedom)
        self.model.initializeObservation()

        # compute the renew period
        if self.renewDiscount is None:
            self.renewDiscount = np.min(self.discount)

        if self.renewDiscount < 1.0 - 1e-8:
            self.renewTerm = np.log(0.001 * (1 - self.renewDiscount)) \
                             / np.log(self.renewDiscount)

        self.initilized = True
        self.initialized = True
        if self._printInfo:
            print('Initialization finished.')
Пример #2
0
    def initializeFromBuilder(self, data, exported_builder):
        # Copy the components
        self.staticComponents = deepcopy(exported_builder.staticComponents)
        self.automaticComponents = deepcopy(exported_builder.automaticComponents)
        self.dynamicComponents = deepcopy(exported_builder.dynamicComponents)
        self.componentIndex = deepcopy(exported_builder.componentIndex)
        self.discount = deepcopy(exported_builder.discount)
        self.initialDegreeFreedom = exported_builder.model.df

        # Copy the model states
        self.statePrior = exported_builder.model.state
        self.sysVarPrior = exported_builder.model.sysVar
        self.noiseVar = exported_builder.model.noiseVar
        self.transition = exported_builder.transition
        self.evaluation = exported_builder.evaluation
        # update the evaluation to the current.
        self.updateEvaluation(step=0, data=data)

    
        self.model = baseModel(transition=self.transition,
                               evaluation=self.evaluation,
                               noiseVar=self.noiseVar,
                               sysVar=self.sysVarPrior,
                               state=self.statePrior,
                               df=self.initialDegreeFreedom)
        self.model.initializeObservation()

        # compute the renew period
        if self.renewDiscount is None:
            self.renewDiscount = np.min(self.discount)

        if self.renewDiscount < 1.0 - 1e-8:
            self.renewTerm = np.log(0.001 * (1 - self.renewDiscount)) \
                             / np.log(self.renewDiscount)
        
        self.initialized = True
        if self._printInfo:
            print('Initialization finished.')
Пример #3
0
    def initialize(self, data=[], noise=1):
        """ Initialize the model. It construct the baseModel by assembling all
        quantities from the components.

        Args:
            noise: the initial guess of the variance of the observation noise.
        """
        if len(self.staticComponents) == 0 and \
           len(self.dynamicComponents) == 0 and \
           len(self.automaticComponents) == 0:

            raise NameError('The model must contain at least' +
                            ' one component')

        # construct transition, evaluation, prior state, prior covariance
        if self._printInfo:
            print('Initializing models...')
        transition = None
        evaluation = None
        state = None
        sysVar = None
        self.discount = np.array([])

        # first construct for the static components
        # the evaluation will be treated separately for static or dynamic
        # as the latter one will change over time
        currentIndex = 0  # used for compute the index
        for i in self.staticComponents:
            comp = self.staticComponents[i]
            transition = mt.matrixAddInDiag(transition, comp.transition)
            evaluation = mt.matrixAddByCol(evaluation,
                                           comp.evaluation)
            state = mt.matrixAddByRow(state, comp.meanPrior)
            sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
            self.discount = np.concatenate((self.discount, comp.discount))
            self.componentIndex[i] = (currentIndex, currentIndex + comp.d - 1)
            currentIndex += comp.d

        # if the model contains the dynamic part, we add the dynamic components
        if len(self.dynamicComponents) > 0:
            self.dynamicEvaluation = None
            for i in self.dynamicComponents:
                comp = self.dynamicComponents[i]
                comp.updateEvaluation(0)
                transition = mt.matrixAddInDiag(transition, comp.transition)
                evaluation = mt.matrixAddByCol(evaluation,
                                               comp.evaluation)
                state = mt.matrixAddByRow(state, comp.meanPrior)
                sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
                self.discount = np.concatenate((self.discount, comp.discount))
                self.componentIndex[i] = (currentIndex,
                                          currentIndex + comp.d - 1)
                currentIndex += comp.d

        # if the model contains the automatic dynamic part, we add
        # them to the builder
        if len(self.automaticComponents) > 0:
            self.automaticEvaluation = None
            for i in self.automaticComponents:
                comp = self.automaticComponents[i]
                comp.updateEvaluation(0, data)
                transition = mt.matrixAddInDiag(transition, comp.transition)
                evaluation = mt.matrixAddByCol(evaluation,
                                               comp.evaluation)
                state = mt.matrixAddByRow(state, comp.meanPrior)
                sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
                self.discount = np.concatenate((self.discount, comp.discount))
                self.componentIndex[i] = (currentIndex,
                                          currentIndex + comp.d - 1)
                currentIndex += comp.d

        self.statePrior = state
        self.sysVarPrior = sysVar
        self.noiseVar = np.matrix(noise)
        self.model = baseModel(transition=transition,
                               evaluation=evaluation,
                               noiseVar=np.matrix(noise),
                               sysVar=sysVar,
                               state=state,
                               df=self.initialDegreeFreedom)
        self.model.initializeObservation()

        # compute the renew period
        if self.renewDiscount is None:
            self.renewDiscount = np.min(self.discount)

        if self.renewDiscount < 1.0 - 1e-8:
            self.renewTerm = np.log(0.001 * (1 - self.renewDiscount)) \
                             / np.log(self.renewDiscount)

        self.initialized = True
        if self._printInfo:
            print('Initialization finished.')
Пример #4
0
    def initialize(self, data=[], noise=1):
        """ Initialize the model. It construct the baseModel by assembling all
        quantities from the components.

        Args:
            noise: the initial guess of the variance of the observation noise.
        """
        if len(self.staticComponents) == 0 and \
           len(self.dynamicComponents) == 0 and \
           len(self.automaticComponents) == 0:

            raise NameError('The model must contain at least' +
                            ' one component')

        # construct transition, evaluation, prior state, prior covariance
        if self._printInfo:
            print('Initializing models...')
        transition = None
        evaluation = None
        state = None
        sysVar = None
        self.discount = np.array([])

        # first construct for the static components
        # the evaluation will be treated separately for static or dynamic
        # as the latter one will change over time
        currentIndex = 0  # used for compute the index
        for i in self.staticComponents:
            comp = self.staticComponents[i]
            transition = mt.matrixAddInDiag(transition, comp.transition)
            evaluation = mt.matrixAddByCol(evaluation, comp.evaluation)
            state = mt.matrixAddByRow(state, comp.meanPrior)
            sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
            self.discount = np.concatenate((self.discount, comp.discount))
            self.componentIndex[i] = (currentIndex, currentIndex + comp.d - 1)
            currentIndex += comp.d

        # if the model contains the dynamic part, we add the dynamic components
        if len(self.dynamicComponents) > 0:
            self.dynamicEvaluation = None
            for i in self.dynamicComponents:
                comp = self.dynamicComponents[i]
                comp.updateEvaluation(0)
                transition = mt.matrixAddInDiag(transition, comp.transition)
                evaluation = mt.matrixAddByCol(evaluation, comp.evaluation)
                state = mt.matrixAddByRow(state, comp.meanPrior)
                sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
                self.discount = np.concatenate((self.discount, comp.discount))
                self.componentIndex[i] = (currentIndex,
                                          currentIndex + comp.d - 1)
                currentIndex += comp.d

        # if the model contains the automatic dynamic part, we add
        # them to the builder
        if len(self.automaticComponents) > 0:
            self.automaticEvaluation = None
            for i in self.automaticComponents:
                comp = self.automaticComponents[i]
                comp.updateEvaluation(0, data)
                transition = mt.matrixAddInDiag(transition, comp.transition)
                evaluation = mt.matrixAddByCol(evaluation, comp.evaluation)
                state = mt.matrixAddByRow(state, comp.meanPrior)
                sysVar = mt.matrixAddInDiag(sysVar, comp.covPrior)
                self.discount = np.concatenate((self.discount, comp.discount))
                self.componentIndex[i] = (currentIndex,
                                          currentIndex + comp.d - 1)
                currentIndex += comp.d

        self.statePrior = state
        self.sysVarPrior = sysVar
        self.noiseVar = np.matrix(noise)
        self.model = baseModel(transition=transition,
                               evaluation=evaluation,
                               noiseVar=np.matrix(noise),
                               sysVar=sysVar,
                               state=state,
                               df=self.initialDegreeFreedom)
        self.model.initializeObservation()

        # compute the renew period
        if self.renewDiscount is None:
            self.renewDiscount = np.min(self.discount)

        if self.renewDiscount < 1.0 - 1e-8:
            self.renewTerm = np.log(0.001 * (1 - self.renewDiscount)) \
                             / np.log(self.renewDiscount)

        self.initialized = True
        if self._printInfo:
            print('Initialization finished.')