def randomSeed(value, seedBoth=False, engine=None):
"""
Function to get a random seed
@ In, value, float, the seed
@ In, engine, instance, optional, random number generator
@ In, seedBoth, bool, optional, if True then seed both random environments
@ Out, None
"""
# we need a flag to tell us if the global numpy stochastic environment is needed to be changed
replaceGlobalEnv = False
## choose an engine if it is none
if engine is None:
if stochasticEnv == 'crow':
distStochEnv.seedRandom(value)
engine = crowStochEnv
elif stochasticEnv == 'numpy':
replaceGlobalEnv = True
global npStochEnv
# global npStochEvn is needed in numpy environment here
# to prevent referenced before assignment in local loop
engine = npStochEnv
if isinstance(engine, np.random.RandomState):
engine = np.random.RandomState(value)
elif isinstance(engine, findCrowModule('randomENG').RandomClass):
engine.seed(value)
if seedBoth:
np.random.seed(value + 1) # +1 just to prevent identical seed sets
if stochasticEnv == 'numpy' and replaceGlobalEnv:
npStochEnv = engine
if replaceGlobalEnv:
print('randomUtils: Global random number seed has been changed to',
value)
def newRNG(env=None):
"""
Provides a new instance of the random number generator.
@ In, env, string, optional, type of random number generator. Defaults to global option stored in "stochasticEnv".
@ Out, engine, object, RNG producer
"""
if env is None:
env = stochasticEnv
if env == 'crow':
engine = findCrowModule('randomENG').RandomClass()
elif env == 'numpy':
engine = np.random.RandomState()
return engine
def getEngine(eng):
"""
Choose an engine if it is none and raise error if engine type not recognized
@ In, engine, instance, random number generator
@ Out, engine, instance, random number generator
"""
if eng is None:
if stochasticEnv == 'numpy':
eng = npStochEnv
elif stochasticEnv == 'crow':
eng = crowStochEnv
if not isinstance(eng, np.random.RandomState) and not isinstance(
eng,
findCrowModule('randomENG').RandomClass):
raise TypeError('Engine type not recognized! {}'.format(type(eng)))
return eng
def randomPermutation(l, caller, engine=None):
"""
Function to get a random permutation
@ In, l, list, list to be permuted
@ In, caller, instance, the caller
@ In, engine, instance, optional, random number generator
@ Out, newList, list, randomly permuted list
"""
engine = getEngine(engine)
if isinstance(engine, np.random.RandomState):
return engine.permutation(l)
elif isinstance(engine, findCrowModule('randomENG').RandomClass):
newList = []
oldList = l[:]
while len(oldList) > 0:
newList.append(
oldList.pop(
randomIntegers(0, len(oldList) - 1, caller,
engine=engine)))
return newList
def randomIntegers(low, high, caller, engine=None):
"""
Function to get a random integer
@ In, low, int, low boundary
@ In, high, int, upper boundary
@ In, caller, instance, object requesting the random integers
@ In, engine, instance, optional, random number generator
@ Out, rawInt, int, random int
"""
engine = getEngine(engine)
if isinstance(engine, np.random.RandomState):
return engine.randint(low, high=high + 1)
elif isinstance(engine, findCrowModule('randomENG').RandomClass):
intRange = high - low
rawNum = low + random(engine=engine) * intRange
rawInt = int(round(rawNum))
if rawInt < low or rawInt > high:
caller.raiseAMessage("Random int out of range")
rawInt = max(low, min(rawInt, high))
return rawInt
else:
raise TypeError('Engine type not recognized! {}'.format(type(engine)))
def randomNormal(dim=1, samples=1, keepMatrix=False, engine=None):
"""
Function to get a single random value, an array of random values, or a matrix of random values, normally distributed
@ In, dim, int, optional, dimensionality of samples
@ In, samples, int, optional, number of arrays to deliver
@ In, keepMatrix, bool, optional, if True then will always return np.array(np.array(float))
@ In, engine, instance, optional, random number generator
@ Out, vals, float, random normal number (or np.array with size [n] if n>1, or np.array with size [n,samples] if sampels>1)
"""
engine = getEngine(engine)
dim = int(dim)
samples = int(samples)
if isinstance(engine, np.random.RandomState):
vals = engine.randn(samples, dim)
elif isinstance(engine, findCrowModule('randomENG').RandomClass):
vals = np.zeros([samples, dim])
for i in range(len(vals)):
for j in range(len(vals[0])):
vals[i, j] = boxMullerGen.generate(engine=engine)
if keepMatrix:
return vals
else:
return _reduceRedundantListing(vals, dim, samples)
def randomNormal(size=(1, ), keepMatrix=False, engine=None):
"""
Function to get a single random value, an array of random values, or a matrix of random values, normally distributed
@ In, size, int or tuple, optional, shape of the samples to return
(if int, an array of samples will be returned if size>1, otherwise a float if keepMatrix is false)
@ In, keepMatrix, bool, optional, if True then will always return np.array(np.array(float))
@ In, engine, instance, optional, random number generator
@ Out, vals, float, random normal number (or np.array with size [n] if n>1, or np.array with size [n,samples] if sampels>1)
"""
engine = getEngine(engine)
if isinstance(size, int):
size = (size, )
if isinstance(engine, np.random.RandomState):
vals = engine.randn(*size)
elif isinstance(engine, findCrowModule('randomENG').RandomClass):
vals = np.zeros(np.prod(size))
for i in range(len(vals)):
vals[i] = boxMullerGen.generate(engine=engine)
vals.shape = size
if keepMatrix:
return vals
else:
return _reduceRedundantListing(vals, size)
"""
Tests distribution of samples over a large number.
@ In, n, int, optional, number of samples to test with
@ Out, mean, float, mean of sample set
@ Out, stdev, float, standard deviation of sample set
"""
n = int(n)
samples = np.array([self.generate() for _ in range(n)])
mean = np.average(samples)
stdev = np.std(samples)
return mean,stdev
if stochasticEnv == 'numpy':
npStochEnv = np.random.RandomState()
else:
crowStochEnv = findCrowModule('randomENG').RandomClass()
# this is needed for now since we need to split the stoch enviroments
distStochEnv = findCrowModule('distribution1D').DistributionContainer.instance()
boxMullerGen = BoxMullerGenerator()
def randomSeed(value):
"""
Function to get a random seed
@ In, value, float, the seed
@ Out, None
"""
if stochasticEnv == 'numpy':
global npStochEnv
npStochEnv = np.random.RandomState(value)
else:
crowStochEnv.seed(value)
# limitations under the License.
"""
This Module performs Unit Tests for the frontUtils methods
"""
import os, sys
import numpy as np
frameworkDir = os.path.normpath(
os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), os.pardir,
os.pardir, os.pardir, os.pardir, 'framework'))
sys.path.append(frameworkDir)
from utils import utils
utils.find_crow(frameworkDir)
from utils import frontUtils
randomENG = utils.findCrowModule("randomENG")
print(frontUtils)
results = {"pass": 0, "fail": 0}
def checkAnswer(comment, value, expected, tol=1e-7, updateResults=True):
"""
This method is aimed to compare two floats given a certain tolerance
@ In, comment, string, a comment printed out if it fails
@ In, value, float, the value to compare
@ In, expected, float, the expected value
@ In, tol, float, optional, the tolerance
@ In, updateResults, bool, optional, if True updates global results
@ Out, None
@author: talbpaul
Originally from SupervisedLearning.py, split in PR #650 in July 2018
Specific ROM implementation for NDinterpolatorRom
"""
#for future compatibility with Python 3--------------------------------------------------------------
from __future__ import division, print_function, unicode_literals, absolute_import
#End compatibility block for Python 3----------------------------------------------------------------
#External Modules------------------------------------------------------------------------------------
import numpy as np
#External Modules End--------------------------------------------------------------------------------
#Internal Modules------------------------------------------------------------------------------------
from utils import utils
interpolationND = utils.findCrowModule("interpolationND")
from .SupervisedLearning import supervisedLearning
#Internal Modules End--------------------------------------------------------------------------------
class NDinterpolatorRom(supervisedLearning):
"""
A Reduced Order Model for interpolating N-dimensional data
"""
def __init__(self, **kwargs):
"""
A constructor that will appropriately intialize a supervised learning object
@ In, kwargs, dict, an arbitrary dictionary of keywords and values
@ Out, None
"""
if sys.version_info.major > 2:
from crow_modules.distribution1Dpy3 import CDF
else:
from crow_modules.distribution1Dpy2 import CDF
#External Modules------------------------------------------------------------------------------------
import numpy as np
import abc
import copy
#External Modules End--------------------------------------------------------------------------------
#Internal Modules------------------------------------------------------------------------------------
from utils import utils, mathUtils, xmlUtils
import MessageHandler
interpolationND = utils.findCrowModule('interpolationND')
#Internal Modules End--------------------------------------------------------------------------------
class supervisedLearning(utils.metaclass_insert(abc.ABCMeta),MessageHandler.MessageUser):
"""
This is the general interface to any supervisedLearning learning method.
Essentially it contains a train method and an evaluate method
"""
returnType = '' # this describe the type of information generated the possibility are 'boolean', 'integer', 'float'
qualityEstType = [] # this describe the type of estimator returned known type are 'distance', 'probability'. The values are returned by the self.__confidenceLocal__(Features)
ROMtype = '' # the broad class of the interpolator
ROMmultiTarget = False #
ROMtimeDependent = False # is this ROM able to treat time-like (any monotonic variable) explicitly in its formulation?
@staticmethod
def checkArrayConsistency(arrayIn,isDynamic=False):
