def getUpdateScheme(configOptions):
"""Return an UpdateScheme as specified by the user configOptions.
Arguments:
configOptions (XML object, defined in xmlbase):
An XML element of type "Blending"; either
<ConsumerBlending/> or <ProducerBlending/>; containing the
weightings and default settings for the model update schemes.
"""
if configOptions is None:
return UpdateScheme("unweighted")
params = configOptions.attrib.copy()
scheme = "unweighted"
if "method" in params:
scheme = params["method"]
if scheme == "computerTimeWindowSeconds":
raise NotImplementedError
elif scheme == "eventTimeWindow":
scheme = "synchronized"
del params["method"]
if "windowLag" not in params:
if scheme not in ("unweighted", "exponential"):
params["windowLag"] = 0
return UpdateScheme(scheme, **params)
def _getUpdateScheme(self, configuration):
"""Return an UpdateScheme as specified by the user configuration.
Arguments:
configuration (XML object, defined in xmlbase):
An XML element of type "Blending"; either
<ConsumerBlending/> or <ProducerBlending/>; containing the
weightings and default settings for the model update schemes.
"""
if configuration is None: return UpdateScheme("unweighted")
params = dict(configuration.attrib)
scheme = "unweighted"
if "method" in params:
scheme = params["method"]
if scheme == "eventTimeWindow": scheme = "synchronized"
del params["method"]
if scheme in ("window", "synchronized") and "windowLag" not in params:
params["windowLag"] = 0
return UpdateScheme(scheme, **params)
def initialize(self):
"""Initialize a baseline consumer.
Unlike other consumers, this creates the score function
dynamically, depending on the type of testStatistic.
"""
testDistributions = self.segmentRecord.pmmlModel.child(
pmml.TestDistributions)
self.field = testDistributions.attrib["field"]
testStatistic = testDistributions.attrib["testStatistic"]
# updating can be configured in the Augustus configuration file and in the "windowSize" attribute in this segment
# I will assume that the "windowSize" attribute can override CUSUM and GLR only
# (the only other baseline consumer that has an intermediate state is chiSquareDistribution, which only makes
# sense as UpdateScheme("synchronized"), and that one depends on the configuration of syncNumber, not in PMML)
# the general case:
self.updateScheme = self.engine.consumerUpdateScheme
# the special case:
if testStatistic in ("CUSUM", "GLR"):
if "windowSize" in testDistributions.attrib and testDistributions.attrib[
"windowSize"] != 0:
self.updateScheme = UpdateScheme(
"window",
windowSize=testDistributions.attrib["windowSize"],
windowLag=0)
if testStatistic == "CUSUM":
self.baseline = testDistributions.child(pmml.Baseline).child()
self.alternate = testDistributions.child(pmml.Alternate).child()
self.updator = self.updateScheme.updator(CUSUM)
self.updator.resetValue = testDistributions.attrib["resetValue"]
self.score = self.scoreCUSUM
extension = testDistributions.child(pmml.Extension,
exception=False)
if extension is not None:
init = extension.child(pmml.X_ODG_CUSUMInitialization,
exception=False)
if init is not None:
self.updator.initialize({CUSUM: [init.attrib["value"]]})
self.pseudoField = self.field
self.pseudoOutputAll = True
elif testStatistic == "zValue":
self.baseline = testDistributions.child(pmml.Baseline).child()
if isinstance(self.baseline, pmml.GaussianDistribution):
self.score = self.scoreZValueGaussian
else:
self.score = self.scoreZValue
self.pseudoField = self.field
self.pseudoOutputAll = True
elif testStatistic in ("chiSquareDistribution", "scalarProduct"):
self.updators = {}
self.countTable = testDistributions.child(pmml.Baseline).child()
if "weightField" in testDistributions.attrib:
self.weightField = testDistributions.attrib["weightField"]
else:
self.weightField = None
if "normalizationScheme" not in testDistributions.attrib:
self.normalizationScheme = None
elif testDistributions.attrib[
"normalizationScheme"] == "Independent":
self.normalizationScheme = self.INDEPENDENT
elif testDistributions.attrib[
"normalizationScheme"] == "SizeWeighted":
self.normalizationScheme = self.SIZEWEIGHTED
self.testStatistic = {
"chiSquareDistribution": self.CHISQUAREDISTRIBUTION,
"scalarProduct": self.SCALARPRODUCT,
}[testStatistic]
self.score = self.scoreHistogram
self.pseudoField = (self.field, self.weightField)
self.pseudoOutputAll = False
# ODG extensions
self.binsOfInterest = testDistributions.descendant(
pmml.X_ODG_BinsOfInterest, exception=False)
elif testStatistic == "chiSquareIndependence":
self.baseline = testDistributions.child(pmml.Baseline)
self.fields = None
self.countTable = None
self.score = self.scoreChiSquareIndependence
self.pseudoField = None
self.pseudoOutputAll = True
# ODG extensions
elif testStatistic == "GLR":
self.baseline = testDistributions.child(pmml.Baseline).child()
if not isinstance(
self.baseline,
(pmml.GaussianDistribution, pmml.PoissonDistribution)):
raise NotImplementedError, "GLR has only been implemented for Gaussian and Poisson distributions"
self.updator = self.updateScheme.updator(GLR)
self.score = self.scoreGLR
self.pseudoField = self.field
self.pseudoOutputAll = False
