Diffusion RationalROMPy (develop) Browse

rational_interpolant_greedy.py
59d292829982develop

rational_interpolant_greedy.py
View Options

			# Copyright (C) 2018 by the RROMPy authors
			#
			# This file is part of RROMPy.
			#
			# RROMPy is free software: you can redistribute it and/or modify
			# it under the terms of the GNU Lesser General Public License as published by
			# the Free Software Foundation, either version 3 of the License, or
			# (at your option) any later version.
			#
			# RROMPy is distributed in the hope that it will be useful,
			# but WITHOUT ANY WARRANTY; without even the implied warranty of
			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			# GNU Lesser General Public License for more details.
			#
			# You should have received a copy of the GNU Lesser General Public License
			# along with RROMPy. If not, see <http://www.gnu.org/licenses/>.
			#

			from copy import deepcopy as copy
			import numpy as np
			from rrompy.hfengines.base.linear_affine_engine import checkIfAffine
			from .generic_greedy_approximant import GenericGreedyApproximant
			from rrompy.utilities.poly_fitting.polynomial import (polybases,
			PolynomialInterpolator as PI,
			polyvanderTotal as pvT)
			from rrompy.utilities.numerical import totalDegreeN, dot
			from rrompy.utilities.expression import expressionEvaluator
			from rrompy.reduction_methods.standard import RationalInterpolant
			from rrompy.utilities.base.types import Np1D, Tuple, paramVal, List
			from rrompy.utilities.base import verbosityManager as vbMng
			from rrompy.utilities.poly_fitting import customFit
			from rrompy.utilities.exception_manager import (RROMPyWarning, RROMPyException,
			RROMPyAssert, RROMPy_FRAGILE)
			from rrompy.parameter import checkParameterList
			from rrompy.sampling import sampleList, emptySampleList

			__all__ = ['RationalInterpolantGreedy']

			class RationalInterpolantGreedy(GenericGreedyApproximant, RationalInterpolant):
			"""
			ROM greedy rational interpolant computation for parametric problems.

			Args:
			HFEngine: HF problem solver.
			mu0(optional): Default parameter. Defaults to 0.
			approxParameters(optional): Dictionary containing values for main
			parameters of approximant. Recognized keys are:
			- 'POD': whether to compute POD of snapshots; defaults to True;
			- 'S': number of starting training points;
			- 'sampler': sample point generator;
			- 'greedyTol': uniform error tolerance for greedy algorithm;
			defaults to 1e-2;
			- 'collinearityTol': collinearity tolerance for greedy algorithm;
			defaults to 0.;
			- 'maxIter': maximum number of greedy steps; defaults to 1e2;
			- 'nTestPoints': number of test points; defaults to 5e2;
			- 'trainSetGenerator': training sample points generator; defaults
			to sampler;
			- 'polybasis': type of basis for interpolation; defaults to
			'MONOMIAL';
			- 'errorEstimatorKind': kind of error estimator; available values
			include 'AFFINE', 'DISCREPANCY', 'INTERPOLATORY',
			'LOOK_AHEAD', 'LOOK_AHEAD_OUTPUT', and 'NONE'; defaults to
			'NONE';
			- 'interpRcond': tolerance for interpolation; defaults to None;
			- 'robustTol': tolerance for robust rational denominator
			management; defaults to 0.
			Defaults to empty dict.
			approx_state(optional): Whether to approximate state. Defaults and must
			be True.
			verbosity(optional): Verbosity level. Defaults to 10.

			Attributes:
			HFEngine: HF problem solver.
			mu0: Default parameter.
			mus: Array of snapshot parameters.
			approxParameters: Dictionary containing values for main parameters of
			approximant. Recognized keys are in parameterList.
			parameterListSoft: Recognized keys of soft approximant parameters:
			- 'POD': whether to compute POD of snapshots.
			- 'greedyTol': uniform error tolerance for greedy algorithm;
			- 'collinearityTol': collinearity tolerance for greedy algorithm;
			- 'maxIter': maximum number of greedy steps;
			- 'nTestPoints': number of test points;
			- 'trainSetGenerator': training sample points generator;
			- 'errorEstimatorKind': kind of error estimator;
			- 'interpRcond': tolerance for interpolation;
			- 'robustTol': tolerance for robust rational denominator
			management.
			parameterListCritical: Recognized keys of critical approximant
			parameters:
			- 'S': total number of samples current approximant relies upon;
			- 'sampler': sample point generator.
			approx_state: Whether to approximate state.
			verbosity: Verbosity level.
			POD: whether to compute POD of snapshots.
			S: number of test points.
			sampler: Sample point generator.
			greedyTol: uniform error tolerance for greedy algorithm.
			collinearityTol: Collinearity tolerance for greedy algorithm.
			maxIter: maximum number of greedy steps.
			nTestPoints: number of starting training points.
			trainSetGenerator: training sample points generator.
			robustTol: tolerance for robust rational denominator management.
			errorEstimatorKind: kind of error estimator.
			interpRcond: tolerance for interpolation.
			robustTol: tolerance for robust rational denominator management.
			muBounds: list of bounds for parameter values.
			samplingEngine: Sampling engine.
			estimatorNormEngine: Engine for estimator norm computation.
			uHF: High fidelity solution(s) with parameter(s) lastSolvedHF as
			sampleList.
			lastSolvedHF: Parameter(s) corresponding to last computed high fidelity
			solution(s) as parameterList.
			uApproxReduced: Reduced approximate solution(s) with parameter(s)
			lastSolvedApprox as sampleList.
			lastSolvedApproxReduced: Parameter(s) corresponding to last computed
			reduced approximate solution(s) as parameterList.
			uApprox: Approximate solution(s) with parameter(s) lastSolvedApprox as
			sampleList.
			lastSolvedApprox: Parameter(s) corresponding to last computed
			approximate solution(s) as parameterList.
			"""

			_allowedEstimatorKinds = ["AFFINE", "DISCREPANCY", "INTERPOLATORY",
			"LOOK_AHEAD", "LOOK_AHEAD_OUTPUT", "NONE"]

			def __init__(self, args, *kwargs):
			self._preInit()
			self._addParametersToList(["errorEstimatorKind"], ["DISCREPANCY"],
			toBeExcluded = ["M", "N", "polydegreetype",
			"radialDirectionalWeights",
			"nNearestNeighbor"])
			super().__init__(args, *kwargs)
			if not self.approx_state and self.errorEstimatorKind not in [
			"LOOK_AHEAD", "LOOK_AHEAD_OUTPUT", "NONE"]:
			raise RROMPyException(("Must compute greedy approximation of "
			"state, unless error estimator allows "
			"otherwise."))
			self.M, self.N = ("AUTO",) * 2
			self._postInit()

			@property
			def approx_state(self):
			"""Value of approx_state."""
			return self._approx_state
			@approx_state.setter
			def approx_state(self, approx_state):
			RationalInterpolant.approx_state.fset(self, approx_state)
			if (not self.approx_state and hasattr(self, "_errorEstimatorKind")
			and self.errorEstimatorKind not in [
			"LOOK_AHEAD", "LOOK_AHEAD_OUTPUT", "NONE"]):
			raise RROMPyException(("Must compute greedy approximation of "
			"state, unless error estimator allows "
			"otherwise."))

			@property
			def E(self):
			"""Value of E."""
			self._E = self.sampleBatchIdx - 1
			return self._E
			@E.setter
			def E(self, E):
			RROMPyWarning(("E is used just to simplify inheritance, and its value "
			"cannot be changed from that of sampleBatchIdx - 1."))

			def _setMAuto(self):
			self.M = self.E

			def _setNAuto(self):
			self.N = self.E

			@property
			def polydegreetype(self):
			"""Value of polydegreetype."""
			return "TOTAL"
			@polydegreetype.setter
			def polydegreetype(self, polydegreetype):
			RROMPyWarning(("polydegreetype is used just to simplify inheritance, "
			"and its value cannot be changed from 'TOTAL'."))

			@property
			def polybasis(self):
			"""Value of polybasis."""
			return self._polybasis
			@polybasis.setter
			def polybasis(self, polybasis):
			try:
			polybasis = polybasis.upper().strip().replace(" ","")
			if polybasis not in polybases:
			raise RROMPyException("Sample type not recognized.")
			self._polybasis = polybasis
			except:
			RROMPyWarning(("Prescribed polybasis not recognized. Overriding "
			"to 'MONOMIAL'."))
			self._polybasis = "MONOMIAL"
			self._approxParameters["polybasis"] = self.polybasis

			@property
			def errorEstimatorKind(self):
			"""Value of errorEstimatorKind."""
			return self._errorEstimatorKind
			@errorEstimatorKind.setter
			def errorEstimatorKind(self, errorEstimatorKind):
			errorEstimatorKind = errorEstimatorKind.upper()
			if errorEstimatorKind not in self._allowedEstimatorKinds:
			RROMPyWarning(("Error estimator kind not recognized. Overriding "
			"to 'NONE'."))
			errorEstimatorKind = "NONE"
			self._errorEstimatorKind = errorEstimatorKind
			self._approxParameters["errorEstimatorKind"] = self.errorEstimatorKind
			if (self.errorEstimatorKind not in [
			"LOOK_AHEAD", "LOOK_AHEAD_OUTPUT", "NONE"]
			and hasattr(self, "_approx_state") and not self.approx_state):
			raise RROMPyException(("Must compute greedy approximation of "
			"state, unless error estimator allows "
			"otherwise."))

			def _polyvanderAuxiliary(self, mus, deg, *args):
			return pvT(mus, deg, *args)

			def getErrorEstimatorDiscrepancy(self, mus:Np1D) -> Np1D:
			"""Discrepancy-based residual estimator."""
			mus = checkParameterList(mus, self.npar)[0]
			muCTest = self.trainedModel.centerNormalize(mus)
			verb = self.trainedModel.verbosity
			self.trainedModel.verbosity = 0
			QTest = self.trainedModel.getQVal(mus)
			checkIfAffine(self.HFEngine, "apply discrepancy-based error estimator")
			self.HFEngine.buildA()
			self.HFEngine.buildb()
			nAs, nbs = self.HFEngine.nAs, self.HFEngine.nbs
			muTrainEff = self.mus ** self.HFEngine.rescalingExp
			muTestEff = mus ** self.HFEngine.rescalingExp
			PTrain = self.trainedModel.getPVal(self.mus).data.T
			QTrain = self.trainedModel.getQVal(self.mus)
			PTest = self.trainedModel.getPVal(mus).data
			radiusAbTrain = np.empty((self.S, nAs * self.S + nbs),
			dtype = np.complex)
			radiusA = np.empty((self.S, nAs, len(mus)), dtype = np.complex)
			radiusb = np.empty((nbs, len(mus)), dtype = np.complex)
			for j, thA in enumerate(self.HFEngine.thAs):
			idxs = j * self.S + np.arange(self.S)
			radiusAbTrain[:, idxs] = expressionEvaluator(thA[0], muTrainEff,
			(self.S, 1)) * PTrain
			radiusA[:, j] = PTest * expressionEvaluator(thA[0], muTestEff,
			(len(mus),))
			for j, thb in enumerate(self.HFEngine.thbs):
			idx = nAs * self.S + j
			radiusAbTrain[:, idx] = QTrain * expressionEvaluator(thb[0],
			muTrainEff, (self.S,))
			radiusb[j] = QTest * expressionEvaluator(thb[0], muTestEff,
			(len(mus),))
			QRHSNorm2 = self._affineResidualMatricesContraction(radiusb)
			vanTrain = self._polyvanderAuxiliary(self._musUniqueCN, self.E,
			self.polybasis0, self._derIdxs,
			self._reorder)
			interpPQ = customFit(vanTrain, radiusAbTrain,
			rcond = self.interpRcond)
			vanTest = self._polyvanderAuxiliary(muCTest, self.E,
			self.polybasis0)
			DradiusAb = vanTest.dot(interpPQ)
			radiusA = (radiusA
			- DradiusAb[:, : - nbs].reshape(len(mus), -1, self.S).T)
			radiusb = radiusb - DradiusAb[:, - nbs :].T
			ff, Lf, LL = self._affineResidualMatricesContraction(radiusb, radiusA)
			err = np.abs((LL - 2. * np.real(Lf) + ff) / QRHSNorm2) ** .5
			self.trainedModel.verbosity = verb
			return err

			def getErrorEstimatorInterpolatory(self, mus:Np1D) -> Np1D:
			"""Interpolation-based residual estimator."""
			errTest, QTest, idxMaxEst = self._EIMStep(mus)
			self.initEstimatorNormEngine()
			mu_muTestSample = mus[idxMaxEst]
			app_muTestSample = self.getApproxReduced(mu_muTestSample)
			if self._mode == RROMPy_FRAGILE:
			if not self.HFEngine.isCEye:
			raise RROMPyException(("Cannot compute INTERPOLATORY residual "
			"estimator in fragile mode for "
			"non-scalar C."))
			app_muTestSample = dot(self.trainedModel.data.projMat,
			app_muTestSample.data)
			else:
			app_muTestSample = dot(self.samplingEngine.samples,
			app_muTestSample)
			resmu = self.HFEngine.residual(mu_muTestSample, app_muTestSample,
			post_c = False)
			RHSmu = self.HFEngine.residual(mu_muTestSample, None, post_c = False)
			ressamples = (self.estimatorNormEngine.norm(resmu)
			/ self.estimatorNormEngine.norm(RHSmu))
			musT = copy(self.mus)
			musT.append(mu_muTestSample)
			musT = self.trainedModel.centerNormalize(musT)
			musC = self.trainedModel.centerNormalize(mus)
			resT = np.zeros(len(musT), dtype = np.complex)
			err = np.zeros(len(mus))
			for l in range(len(mu_muTestSample)):
			resT[len(self.mus) + l] = ressamples[l] * QTest[idxMaxEst[l]]
			p = PI()
			wellCond, msg = p.setupByInterpolation(musT, resT, self.E + 1,
			self.polybasis, self.verbosity >= 15,
			True, {}, {"rcond": self.interpRcond})
			err += np.abs(p(musC))
			resT[len(self.mus) + l] = 0.
			err /= QTest
			vbMng(self, "MAIN", msg, 15)
			return err

			def getErrorEstimatorLookAhead(self, mus:Np1D,
			force_output : bool = False) \
			-> Tuple[Np1D, List[int]]:
			"""Residual estimator based on look-ahead idea."""
			errTest, QTest, idxMaxEst = self._EIMStep(mus)
			_approx_state_old = self.approx_state
			if force_output and _approx_state_old: self._approx_state = False
			self.initEstimatorNormEngine()
			self._approx_state = _approx_state_old
			mu_muTestSample = mus[idxMaxEst]
			app_muTestSample = self.getApproxReduced(mu_muTestSample)
			if self._mode == RROMPy_FRAGILE:
			app_muTestSample = dot(self.trainedModel.data.projMat,
			app_muTestSample.data)
			else:
			app_muTestSample = dot(self.samplingEngine.samples,
			app_muTestSample)
			for j, mu in enumerate(mu_muTestSample):
			uEx = self.samplingEngine.nextSample(mu)
			if hasattr(self.samplingEngine, "samples_full"):
			uEx = self.samplingEngine.samples_full[-1]
			if j == 0:
			solmu = emptySampleList()
			solmu.reset((len(uEx), len(mu_muTestSample)),
			dtype = uEx.dtype)
			solmu[j] = uEx
			if force_output and self.approx_state:
			solmu = sampleList(self.HFEngine.applyC(solmu.data))
			app_muTestSample = sampleList(self.HFEngine.applyC(
			app_muTestSample.data))
			errmu = solmu - app_muTestSample
			errsamples = (self.estimatorNormEngine.norm(errmu)
			/ self.estimatorNormEngine.norm(solmu))
			musT = copy(self.mus)
			musT.append(mu_muTestSample)
			musT = self.trainedModel.centerNormalize(musT)
			musC = self.trainedModel.centerNormalize(mus)
			errT = np.zeros(len(musT), dtype = np.complex)
			err = np.zeros(len(mus))
			for l in range(len(mu_muTestSample)):
			errT[len(self.mus) + l] = errsamples[l] * QTest[idxMaxEst[l]]
			p = PI()
			wellCond, msg = p.setupByInterpolation(musT, errT, self.E + 1,
			self.polybasis, self.verbosity >= 15,
			True, {}, {"rcond": self.interpRcond})
			err += np.abs(p(musC))
			errT[len(self.mus) + l] = 0.
			err /= QTest
			vbMng(self, "MAIN", msg, 15)
			return err, idxMaxEst

			def getErrorEstimatorNone(self, mus:Np1D) -> Np1D:
			"""EIM-based residual estimator."""
			err = np.max(self._EIMStep(mus, True), axis = 1)
			err *= self.greedyTol / np.mean(err)
			return err

			def _EIMStep(self, mus:Np1D,
			only_one : bool = False) -> Tuple[Np1D, Np1D, List[int]]:
			"""Residual estimator based on look-ahead idea."""
			mus = checkParameterList(mus, self.npar)[0]
			verb = self.trainedModel.verbosity
			self.trainedModel.verbosity = 0
			QTest = self.trainedModel.getQVal(mus)
			QTest = np.abs(QTest)
			muCTest = self.trainedModel.centerNormalize(mus)
			muCTrain = self.trainedModel.centerNormalize(self.mus)
			vanTest = self._polyvanderAuxiliary(muCTest, self.E, self.polybasis)
			vanTestNext = self._polyvanderAuxiliary(muCTest, self.E + 1,
			self.polybasis)[:,
			vanTest.shape[1] :]
			idxsTest = np.arange(vanTestNext.shape[1])
			basis = np.zeros((len(idxsTest), 0), dtype = float)
			idxMaxEst = []
			while len(idxsTest) > 0:
			vanTrial = self._polyvanderAuxiliary(muCTrain, self.E,
			self.polybasis)
			vanTrialNext = self._polyvanderAuxiliary(muCTrain, self.E + 1,
			self.polybasis)[:,
			vanTrial.shape[1] :]
			vanTrial = np.hstack((vanTrial, vanTrialNext.dot(basis).reshape(
			len(vanTrialNext), basis.shape[1])))
			valuesTrial = vanTrialNext[:, idxsTest]
			vanTestEff = np.hstack((vanTest, vanTestNext.dot(basis).reshape(
			len(vanTestNext), basis.shape[1])))
			vanTestNextEff = vanTestNext[:, idxsTest]
			coeffTest = np.linalg.solve(vanTrial, valuesTrial)
			errTest = (np.abs(vanTestNextEff - vanTestEff.dot(coeffTest))
			/ np.expand_dims(QTest, 1))
			if only_one:
			self.trainedModel.verbosity = verb
			return errTest
			idxMaxErr = np.unravel_index(np.argmax(errTest), errTest.shape)
			idxMaxEst += [idxMaxErr[0]]
			muCTrain.append(muCTest[idxMaxErr[0]])
			basis = np.pad(basis, [(0, 0), (0, 1)], "constant")
			basis[idxsTest[idxMaxErr[1]], -1] = 1.
			idxsTest = np.delete(idxsTest, idxMaxErr[1])
			self.trainedModel.verbosity = verb
			return errTest, QTest, idxMaxEst

			def errorEstimator(self, mus:Np1D, return_max : bool = False) -> Np1D:
			"""Standard residual-based error estimator."""
			setupOK = self.setupApproxLocal()
			if setupOK > 0:
			err = np.empty(len(mus))
			err[:] = np.nan
			if not return_max: return err
			return err, 0, np.nan
			mus = checkParameterList(mus, self.npar)[0]
			vbMng(self.trainedModel, "INIT",
			"Evaluating error estimator at mu = {}.".format(mus), 10)
			if self.errorEstimatorKind == "AFFINE":
			err = self.getErrorEstimatorAffine(mus)
			else:
			self._setupInterpolationIndices()
			if self.errorEstimatorKind == "DISCREPANCY":
			err = self.getErrorEstimatorDiscrepancy(mus)
			elif self.errorEstimatorKind == "INTERPOLATORY":
			err = self.getErrorEstimatorInterpolatory(mus)
			elif self.errorEstimatorKind[: 10] == "LOOK_AHEAD":
			err, idxMaxEst = self.getErrorEstimatorLookAhead(mus,
			self.errorEstimatorKind == "LOOK_AHEAD_OUTPUT")
			else: #if self.errorEstimatorKind == "NONE":
			err = self.getErrorEstimatorNone(mus)
			vbMng(self.trainedModel, "DEL", "Done evaluating error estimator", 10)
			if not return_max: return err
			if self.errorEstimatorKind[: 10] != "LOOK_AHEAD":
			idxMaxEst = np.empty(self.sampleBatchSize, dtype = int)
			errCP = copy(err)
			for j in range(self.sampleBatchSize):
			k = np.argmax(errCP)
			idxMaxEst[j] = k
			if j + 1 < self.sampleBatchSize:
			musZero = self.trainedModel.centerNormalize(mus, mus[k])
			errCP *= np.linalg.norm(musZero.data, axis = 1)
			return err, idxMaxEst, err[idxMaxEst]

			def plotEstimator(self, args, *kwargs):
			super().plotEstimator(args, *kwargs)
			if self.errorEstimatorKind == "NONE":
			vbMng(self, "MAIN",
			("Warning! Error estimator has been arbitrarily normalized "
			"before plotting."), 5)

			def greedyNextSample(self, *args,
			**kwargs) -> Tuple[Np1D, int, float, paramVal]:
			"""Compute next greedy snapshot of solution map."""
			RROMPyAssert(self._mode, message = "Cannot add greedy sample.")
			self.sampleBatchIdx += 1
			self.sampleBatchSize = totalDegreeN(self.npar - 1, self.sampleBatchIdx)
			err, muidx, maxErr, muNext = super().greedyNextSample(args, *kwargs)
			if maxErr is not None and (np.any(np.isnan(maxErr))
			or np.any(np.isinf(maxErr))):
			self.sampleBatchIdx -= 1
			self.sampleBatchSize = totalDegreeN(self.npar - 1,
			self.sampleBatchIdx)
			if (self.errorEstimatorKind == "NONE" and not np.isnan(maxErr)
			and not np.isinf(maxErr)):
			maxErr = None
			return err, muidx, maxErr, muNext

			def _preliminaryTraining(self):
			"""Initialize starting snapshots of solution map."""
			RROMPyAssert(self._mode, message = "Cannot start greedy algorithm.")
			if self.samplingEngine.nsamples > 0:
			return
			S = self.S
			self.sampleBatchIdx, self.sampleBatchSize, self._S = -1, 0, 0
			nextBatchSize = 1
			while self._S + nextBatchSize <= S:
			self.sampleBatchIdx += 1
			self.sampleBatchSize = nextBatchSize
			self._S += self.sampleBatchSize
			nextBatchSize = totalDegreeN(self.npar - 1,
			self.sampleBatchIdx + 1)
			super()._preliminaryTraining()

			def setupApproxLocal(self) -> int:
			"""Compute rational interpolant."""
			if self.checkComputedApprox(): return -1
			RROMPyAssert(self._mode, message = "Cannot setup approximant.")
			self.verbosity -= 10
			vbMng(self, "INIT", "Setting up local approximant.", 5)
			pMat = self.samplingEngine.samples.data
			pMatEff = dot(self.HFEngine.C, pMat) if self.approx_state else pMat
			if self.trainedModel is None:
			self.trainedModel = self.tModelType()
			self.trainedModel.verbosity = self.verbosity
			self.trainedModel.timestamp = self.timestamp
			datadict = {"mu0": self.mu0, "projMat": pMatEff,
			"scaleFactor": self.scaleFactor,
			"rescalingExp": self.HFEngine.rescalingExp}
			self.trainedModel.data = self.initializeModelData(datadict)[0]
			else:
			self.trainedModel = self.trainedModel
			self.trainedModel.data.projMat = copy(pMatEff)
			self.trainedModel.data.mus = copy(self.mus)
			self.trainedModel.data.mus = copy(self.mus)
			self.catchInstability = 2
			unstable = False
			if self.E > 0:
			try:
			Q = self._setupDenominator()[0]
			except RROMPyException as RE:
			RROMPyWarning(RE._msg)
			vbMng(self, "DEL", "", 7)
			unstable = True
			else:
			Q = PI()
			Q.coeffs = np.ones((1,) * self.npar, dtype = np.complex)
			Q.npar = self.npar
			Q.polybasis = self.polybasis
			if not unstable:
			self.trainedModel.data.Q = copy(Q)
			try:
			P = copy(self._setupNumerator())
			except RROMPyException as RE:
			RROMPyWarning(RE._msg)
			vbMng(self, "DEL", "", 7)
			unstable = True
			if not unstable:
			self.trainedModel.data.P = copy(P)
			self.trainedModel.data.approxParameters = copy(
			self.approxParameters)
			vbMng(self, "DEL", "Done setting up local approximant.", 5)
			self.catchInstability = 0
			self.verbosity += 10
			return 1 * unstable

			def loadTrainedModel(self, filename:str):
			"""Load trained reduced model from file."""
			super().loadTrainedModel(filename)
			self.sampleBatchIdx, self.sampleBatchSize, _S = -1, 0, 0
			nextBatchSize = 1
			while _S + nextBatchSize <= self.S + 1:
			self.sampleBatchIdx += 1
			self.sampleBatchSize = nextBatchSize
			_S += self.sampleBatchSize
			nextBatchSize = totalDegreeN(self.npar - 1,
			self.sampleBatchIdx + 1)

RROMPy/rrompy/reduction_methods/standard/greedy/rational_interpolant_greedy.py59d292829982develop

rational_interpolant_greedy.pyView Options

RROMPy/rrompy/reduction_methods/standard/greedy/rational_interpolant_greedy.py
59d292829982develop

rational_interpolant_greedy.py
View Options