def reset(self, params, repetition):
# if params['encoding'] == 'basic':
# self.inputEncoder = PassThroughEncoder()
# elif params['encoding'] == 'distributed':
# self.outputEncoder = PassThroughEncoder()
# else:
# raise Exception("Encoder not found")
print params
self.inputEncoder = PassThroughEncoder()
self.outputEncoder = PassThroughEncoder()
if params['dataset'] == 'nyc_taxi':
self.dataset = NYCTaxiDataset()
else:
raise Exception("Dataset not found")
self.testCounter = 0
self.history = []
self.resets = []
self.currentSequence = self.dataset.generateSequence()
random.seed(6)
self.nDimInput = 3
self.nDimOutput = 1
self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput,
hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True)
def reset(self, params, repetition):
print params
self.nDimInput = 3
self.inputEncoder = PassThroughEncoder()
if params['output_encoding'] == None:
self.outputEncoder = PassThroughEncoder()
self.nDimOutput = 1
elif params['output_encoding'] == 'likelihood':
self.outputEncoder = ScalarBucketEncoder()
self.nDimOutput = self.outputEncoder.encoder.n
if params['dataset'] == 'nyc_taxi' or params['dataset'] == 'nyc_taxi_perturb_baseline':
self.dataset = NYCTaxiDataset(params['dataset'])
else:
raise Exception("Dataset not found")
self.testCounter = 0
self.resets = []
self.iteration = 0
# initialize LSTM network
random.seed(6)
if params['output_encoding'] == None:
self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput,
hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True)
elif params['output_encoding'] == 'likelihood':
self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput,
hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True)
(self.networkInput, self.targetPrediction, self.trueData) = \
self.dataset.generateSequence(
prediction_nstep=params['prediction_nstep'],
output_encoding=params['output_encoding'])
def row_func(i):
pyrandom.seed(initseed + int(i))
scirandom.seed(initseed + int(i))
k = scirandom.binomial(N, p, 1)[0]
cur_row[:] = 0.0
cur_row[pyrandom.sample(myrange, k)] = weight
return cur_row
def test_gmres(self):
# Ensure repeatability
random.seed(0)
# For these small matrices, Householder and MGS GMRES should give the same result,
# and for symmetric (but possibly indefinite) matrices CR and GMRES should give same result
for maxiter in [1,2,3]:
for case, symm_case in zip(self.cases, self.symm_cases):
A = case['A']
b = case['b']
x0 = case['x0']
A_symm = symm_case['A']
b_symm = symm_case['b']
x0_symm = symm_case['x0']
# Test agreement between Householder and GMRES
(x, flag) = gmres_householder(A,b,x0=x0,maxiter=min(A.shape[0],maxiter))
(x2, flag2) = gmres_mgs(A,b,x0=x0,maxiter=min(A.shape[0],maxiter))
assert_array_almost_equal(x/norm(x), x2/norm(x2),
err_msg='Householder GMRES and MGS GMRES gave different results for small matrix')
assert_equal(flag, flag2,
err_msg='Householder GMRES and MGS GMRES returned different convergence flags for small matrix')
# Test agreement between GMRES and CR
if A_symm.shape[0] > 1:
residuals2 = []
(x2, flag2) = gmres_mgs(A_symm, b_symm, x0=x0_symm, maxiter=min(A.shape[0],maxiter),residuals=residuals2)
residuals3 = []
(x3, flag2) = cr(A_symm, b_symm, x0=x0_symm, maxiter=min(A.shape[0],maxiter),residuals=residuals3)
residuals2 = array(residuals2)
residuals3 = array(residuals3)
assert_array_almost_equal(residuals3/norm(residuals3), residuals2/norm(residuals2),
err_msg='CR and GMRES yield different residual vectors')
assert_array_almost_equal(x2/norm(x2), x3/norm(x3), err_msg='CR and GMRES yield different answers')
def setUp(self):
self.numberOfSamples = 1000
pkl_file = open(os.path.join(unittest_dir, "test_data", "kdeOrigin_xyz.pck"), "r")
xp = cPickle.load(pkl_file)
yp = cPickle.load(pkl_file)
zp = cPickle.load(pkl_file)
self.sampOrg = SamplingOrigin.SamplingOrigin(zp, xp, yp)
random.seed(10)
def setRandomParameters(net,seed=None,randFunc=random.random):
"""
Sets parameters to random values given by the function randFunc (by
default, uniformly distributed on [0,1) ).
"""
random.seed(seed)
net.setOptimizables( randFunc(len(net.GetParameters())) )
return net.GetParameters()
def GaussianRandomInitializer(gridShape, sigma=0.2, seed=None, slipSystem=None, slipPlanes=None, slipDirections=None, vacancy=None, smectic=None):
oldgrid = copy.copy(gridShape)
if len(gridShape) == 1:
gridShape = (128,)
if len(gridShape) == 2:
gridShape = (128,128)
if len(gridShape) == 3:
gridShape = (128,128,128)
""" Returns a random initial set of fields of class type PlasticityState """
if slipSystem=='gamma':
state = SlipSystemState.SlipSystemState(gridShape,slipPlanes=slipPlanes,slipDirections=slipDirections)
elif slipSystem=='betaP':
state = SlipSystemBetaPState.SlipSystemState(gridShape,slipPlanes=slipPlanes,slipDirections=slipDirections)
else:
if vacancy is not None:
state = VacancyState.VacancyState(gridShape,alpha=vacancy)
elif smectic is not None:
state = SmecticState.SmecticState(gridShape)
else:
state = PlasticityState.PlasticityState(gridShape)
field = state.GetOrderParameterField()
Ksq_prime = FourierSpaceTools.FourierSpaceTools(gridShape).kSq * (-sigma**2/4.)
if seed is None:
seed = 0
n = 0
random.seed(seed)
Ksq = FourierSpaceTools.FourierSpaceTools(gridShape).kSq.numpy_array()
for component in field.components:
temp = random.normal(scale=gridShape[0],size=gridShape)
ktemp = fft.rfftn(temp)*(sqrt(pi)*sigma)**len(gridShape)*exp(-Ksq*sigma**2/4.)
field[component] = numpy.real(fft.irfftn(ktemp))
#field[component] = GenerateGaussianRandomArray(gridShape, temp ,sigma)
n += 1
"""
t, s = LoadState("2dstate32.save", 0)
for component in field.components:
for j in range(0,32):
field[component][:,:,j] = s.betaP[component].numpy_array()
"""
## To make seed consistent across grid sizes and convergence comparison
gridShape = copy.copy(oldgrid)
if gridShape[0] != 128:
state = ResizeState(state,gridShape[0],Dim=len(gridShape))
state = ReformatState(state)
state.ktools = FourierSpaceTools.FourierSpaceTools(gridShape)
return state
def sample(self, loss_ratios, probs):
ret = []
r = numpy.arange(len(loss_ratios))
for i in range(probs.shape[1]):
random.seed(self.seed)
# the seed is set inside the loop to avoid block-size dependency
pmf = stats.rv_discrete(name='pmf', values=(r, probs[:, i])).rvs()
ret.append(loss_ratios[pmf])
return ret
def test_minimal_residual(self):
# Ensure repeatability
random.seed(0)
self.definite_cases.extend(self.spd_cases)
for case in self.definite_cases:
A = case['A']
maxiter = case['maxiter']
x0 = rand(A.shape[0],)
b = zeros_like(x0)
reduction_factor = case['reduction_factor']
if A.dtype != complex:
# This function should always decrease (assuming zero RHS)
fvals = []
def callback(x):
fvals.append(sqrt(dot(ravel(x),
ravel(A*x.reshape(-1, 1)))))
#
(x, flag) = minimal_residual(A, b, x0=x0,
tol=1e-16, maxiter=maxiter,
callback=callback)
actual_factor = (norm(ravel(b) - ravel(A*x.reshape(-1, 1))) /
norm(ravel(b) - ravel(A*x0.reshape(-1, 1))))
assert(actual_factor < reduction_factor)
if A.dtype != complex:
for i in range(len(fvals)-1):
assert(fvals[i+1] <= fvals[i])
# Test preconditioning
A = pyamg.gallery.poisson((10, 10), format='csr')
x0 = rand(A.shape[0], 1)
b = zeros_like(x0)
fvals = []
def callback(x):
fvals.append(sqrt(dot(ravel(x), ravel(A*x.reshape(-1, 1)))))
#
resvec = []
sa = pyamg.smoothed_aggregation_solver(A)
(x, flag) = minimal_residual(A, b, x0, tol=1e-8, maxiter=20,
residuals=resvec, M=sa.aspreconditioner(),
callback=callback)
assert(resvec[-1] < 1e-8)
for i in range(len(fvals)-1):
assert(fvals[i+1] <= fvals[i])
def sample_sequence_MM(transition_diagram):
"""Samples a Markov model given a pandas dataframe of a transition diagram
where start and end refer to the start and end states
"""
sr.seed()
states = list(transition_diagram.columns) + ["end"]
sequence = []
state = "start"
while state != "end":
state = np.random.choice(states, p=transition_diagram[state].values)
if state != "end":
if len(state.split("_")) > 1:
sequence.append(state.split("_")[0])
else:
sequence.append(state)
return sequence
def reset(self, params, repetition):
print params
self.nDimInput = 3
self.inputEncoder = PassThroughEncoder()
if params['output_encoding'] == None:
self.outputEncoder = PassThroughEncoder()
self.nDimOutput = 1
elif params['output_encoding'] == 'likelihood':
self.outputEncoder = ScalarBucketEncoder()
self.nDimOutput = self.outputEncoder.encoder.n
if (params['dataset'] == 'nyc_taxi'
or params['dataset'] == 'nyc_taxi_perturb_baseline'):
self.dataset = NYCTaxiDataset(params['dataset'])
else:
raise Exception("Dataset not found")
self.testCounter = 0
self.resets = []
self.iteration = 0
# initialize LSTM network
random.seed(6)
if params['output_encoding'] == None:
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outputbias=True,
recurrent=True)
elif params['output_encoding'] == 'likelihood':
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outclass=SigmoidLayer,
recurrent=True)
(self.networkInput, self.targetPrediction, self.trueData) = \
self.dataset.generateSequence(
prediction_nstep=params['prediction_nstep'],
output_encoding=params['output_encoding'],
noise=params['noise'])
def train(self, params, verbose=False):
if params['create_network_before_training']:
if verbose:
print 'create lstm network'
random.seed(6)
if params['output_encoding'] == None:
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outputbias=True,
recurrent=True)
elif params['output_encoding'] == 'likelihood':
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outclass=SigmoidLayer,
recurrent=True)
self.net.reset()
ds = SequentialDataSet(self.nDimInput, self.nDimOutput)
trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=verbose)
networkInput = self.window(self.networkInput, params)
targetPrediction = self.window(self.targetPrediction, params)
# prepare a training data-set using the history
for i in xrange(len(networkInput)):
ds.addSample(self.inputEncoder.encode(networkInput[i]),
self.outputEncoder.encode(targetPrediction[i]))
if verbose:
print " train LSTM on ", len(
ds), " records for ", params['num_epochs'], " epochs "
if len(networkInput) > 1:
trainer.trainEpochs(params['num_epochs'])
# run through the training dataset to get the lstm network state right
self.net.reset()
for i in xrange(len(networkInput)):
self.net.activate(ds.getSample(i)[0])
def test_steepest_descent(self):
# Ensure repeatability
random.seed(0)
for case in self.spd_cases:
A = case['A']
b = case['b']
x0 = case['x0']
maxiter = case['maxiter']
reduction_factor = case['reduction_factor']
# This function should always decrease
fvals = []
def callback(x):
fvals.append(0.5*dot(ravel(x), ravel(A*x.reshape(-1, 1))) -
dot(ravel(b), ravel(x)))
(x, flag) = steepest_descent(A, b, x0=x0, tol=1e-16,
maxiter=maxiter, callback=callback)
actual_factor = (norm(ravel(b) - ravel(A*x.reshape(-1, 1))) /
norm(ravel(b) - ravel(A*x0.reshape(-1, 1))))
assert(actual_factor < reduction_factor)
if A.dtype != complex:
for i in range(len(fvals)-1):
assert(fvals[i+1] <= fvals[i])
# Test preconditioning
A = pyamg.gallery.poisson((10, 10), format='csr')
b = rand(A.shape[0], 1)
x0 = rand(A.shape[0], 1)
fvals = []
def callback(x):
fvals.append(0.5*dot(ravel(x), ravel(A*x.reshape(-1, 1))) -
dot(ravel(b), ravel(x)))
resvec = []
sa = pyamg.smoothed_aggregation_solver(A)
(x, flag) = steepest_descent(A, b, x0, tol=1e-8, maxiter=20,
residuals=resvec, M=sa.aspreconditioner(),
callback=callback)
assert(resvec[-1] < 1e-8)
for i in range(len(fvals)-1):
assert(fvals[i+1] <= fvals[i])
def test_ishermitian(self):
# make tests repeatable
random.seed(0)
casesT = []
casesF = []
# 1x1
casesT.append(mat(rand(1, 1)))
casesF.append(mat(1.0j*rand(1, 1)))
# 2x2
A = array([[1.0, 0.0], [2.0, 1.0]])
Ai = 1.0j*A
casesF.append(A)
casesF.append(Ai)
A = A + Ai
casesF.append(A)
casesT.append(A + A.conjugate().T)
# 3x3
A = mat(rand(3, 3))
Ai = 1.0j*rand(3, 3)
casesF.append(A)
casesF.append(Ai)
A = A + Ai
casesF.append(A)
casesT.append(A + A.H)
for A in casesT:
# dense arrays
assert_equal(ishermitian(A, fast_check=False), True)
assert_equal(ishermitian(A, fast_check=True), True)
# csr arrays
A = csr_matrix(A)
assert_equal(ishermitian(A, fast_check=False), True)
assert_equal(ishermitian(A, fast_check=True), True)
for A in casesF:
# dense arrays
assert_equal(ishermitian(A, fast_check=False), False)
assert_equal(ishermitian(A, fast_check=True), False)
# csr arrays
A = csr_matrix(A)
assert_equal(ishermitian(A, fast_check=False), False)
assert_equal(ishermitian(A, fast_check=True), False)
def get_neural_net(input_number, output_number, NetworkType, HiddenLayerType, neurons_per_layer=[9], use_bias=False):
random.seed(123)
input = LinearLayer(input_number)
output = SoftmaxLayer(output_number)
neural_net = NetworkType()
neural_net.addInputModule(input)
neural_net.addOutputModule(output)
if use_bias:
bias = BiasUnit()
neural_net.addModule(bias)
prev = input
for i in range(0, len(neurons_per_layer)):
hidden = HiddenLayerType(neurons_per_layer[i])
neural_net.addModule(hidden)
neural_net.addConnection(FullConnection(prev, hidden))
if use_bias:
neural_net.addConnection(FullConnection(bias, hidden))
prev = hidden
neural_net.addConnection(FullConnection(prev, output))
if use_bias:
neural_net.addConnection(FullConnection(bias, output))
neural_net.sortModules()
fast_net = neural_net.convertToFastNetwork()
if fast_net is not None:
neural_net = fast_net
print "Use fast C++ implementation"
else:
print "Use standard Python implementation"
print "Create neural network with {} neurons ({} layers)".format(neurons_per_layer, len(neurons_per_layer))
return neural_net
def test_ishermitian(self):
# make tests repeatable
random.seed(0)
casesT = []
casesF = []
# 1x1
casesT.append(mat(rand(1, 1)))
casesF.append(mat(1.0j * rand(1, 1)))
# 2x2
A = array([[1.0, 0.0], [2.0, 1.0]])
Ai = 1.0j * A
casesF.append(A)
casesF.append(Ai)
A = A + Ai
casesF.append(A)
casesT.append(A + A.conjugate().T)
# 3x3
A = mat(rand(3, 3))
Ai = 1.0j * rand(3, 3)
casesF.append(A)
casesF.append(Ai)
A = A + Ai
casesF.append(A)
casesT.append(A + A.H)
for A in casesT:
# dense arrays
assert_equal(ishermitian(A, fast_check=False), True)
assert_equal(ishermitian(A, fast_check=True), True)
# csr arrays
A = csr_matrix(A)
assert_equal(ishermitian(A, fast_check=False), True)
assert_equal(ishermitian(A, fast_check=True), True)
for A in casesF:
# dense arrays
assert_equal(ishermitian(A, fast_check=False), False)
assert_equal(ishermitian(A, fast_check=True), False)
# csr arrays
A = csr_matrix(A)
assert_equal(ishermitian(A, fast_check=False), False)
assert_equal(ishermitian(A, fast_check=True), False)
def SineWaveInitializer(gridShape, randomPhase=False, seed=None, slipSystem=False, slipPlanes=None, slipDirections=None):
"""
Initialize a plasticity state by setting all its components in any dimension with a
single period of a sine function.
"""
if seed is not None:
random.seed(seed)
if slipSystem=='gamma':
pass
#state = SlipSystemState.SlipSystemState(gridShape,slipPlanes=slipPlanes,slipDirections=slipDirections)
elif slipSystem=='betaP':
pass
#state = SlipSystemState.SlipSystemBetaPState(gridShape,slipPlanes=slipPlanes,slipDirections=slipDirections)
else:
state = PlasticityState.PlasticityState(gridShape)
field = state.GetOrderParameterField()
for component in field.components:
field[component] = GenerateSineArray(gridShape, field.GridDimension(), randomPhase = randomPhase)
return state
def init_random_seeds(seed):
"""if seed is None, init to 42, of course
else, init with strig coverted to int
The random and "numx_rand" libraries are used elsewhere in this tree
(e.g. meica.libs/mdp/utils/routines.py), so initialize seeds for both.
"""
import random
from scipy import random as numx_rand
# either init to default of 42 or convert from string
if seed is None:
seed = 42
else:
seed = int(seed)
print '-- initializing random seed to %s' % seed
random.seed(seed)
numx_rand.seed(seed)
def test_random():
random.seed(0) #make tests repeatable
for dim in [1, 2, 3, 4]:
for num_pts in [1, 2, 5, 10, 50]:
pts = (20 * rand(num_pts, dim) - 10)
kdt = kd_tree(pts.tolist())
for sample in (20 * rand(5, dim) - 10).tolist():
#5 sample points per test
distances = sqrt(sum((pts - sample)**2, axis=1))
sorted_pairs = sorted(zip(distances, list(range(len(pts)))))
assert_equal(kdt.nearest(sample), sorted_pairs[0][1])
for n in [1, 2, 5]:
assert_equal(kdt.nearest_n(sample, n),
[x[1] for x in sorted_pairs[:n]])
def train(self, params, verbose=False):
if params['reset_every_training']:
if verbose:
print 'create lstm network'
random.seed(6)
if params['output_encoding'] == None:
self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput,
hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True)
elif params['output_encoding'] == 'likelihood':
self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput,
hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True)
self.net.reset()
ds = SequentialDataSet(self.nDimInput, self.nDimOutput)
networkInput = self.window(self.networkInput, params)
targetPrediction = self.window(self.targetPrediction, params)
# prepare a training data-set using the history
for i in xrange(len(networkInput)):
ds.addSample(self.inputEncoder.encode(networkInput[i]),
self.outputEncoder.encode(targetPrediction[i]))
if params['num_epochs'] > 1:
trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=verbose)
if verbose:
print " train LSTM on ", len(ds), " records for ", params['num_epochs'], " epochs "
if len(networkInput) > 1:
trainer.trainEpochs(params['num_epochs'])
else:
self.trainer.setData(ds)
self.trainer.train()
# run through the training dataset to get the lstm network state right
self.net.reset()
for i in xrange(len(networkInput)):
self.net.activate(ds.getSample(i)[0])
def _set_params_and_init(self, mod, **kwargs):
if not mod.converged: raise ValueError(" Error: This model has not converged, abort sampling ...")
self.seed = 199
self.verbose = False
self.N = 1000
if kwargs is not None:
for key, value in kwargs.iteritems():
setattr(self, key, value)
random.seed(self.seed)
if (mod.multi):
# N is recalculated in case of multi mass
self.Nj = numpy.array(mod.Mj/mod.mj, dtype='int')
self.N = sum(self.Nj)
if min(self.Nj)==0: raise ValueError(" Error: One of the mass components has zero stars!")
self.mod = mod
self.ani = True if min(mod.raj)/mod.rt < 3 else False
def generate_random_large_scale_field(self):
""" mg is a gmg object """
from scipy import random
# level on which the random field is generated
# this controls the scale of the field
# current limitation: this has to be done on a level for which
# each node has the whole domain
flev = self.nlevs - 1 # min(6,self.nlevs-1)
# gaussian noise parameters
mu = 0.
sigma = 1.
# generate it on rank==0 then broadcast it
# so that every rank has the same field
if (self.myrank == 0):
random.seed(1)
forc = random.normal(mu, sigma,
(self.grid[flev].mv, self.grid[flev].nv))
forc = forc * self.grid[flev].msk
else:
forc = None
forc = MPI.COMM_WORLD.bcast(forc, root=0)
# interpolate it on the finest grid
self.x[flev][:, :] = forc
for lev in range(flev - 1, -1, -1):
if self.grid[lev].flag == 'peak':
coarsetofine(self.grid[lev + 1], self.grid[lev],
self.x[lev + 1], self.x[lev])
else:
coarsetofine(self.grid[lev + 1], self.grid[lev],
self.x[lev + 1], self.r[lev])
self.x[lev] += self.r[lev]
# 15oct changed ,1 to ,2
self.grid[lev].smooth(self.x[lev], self.b[lev], 2)
return self.x[0]
def __init__(self, N, k, seed):
'''
Parameters:
N (int): Number of observations
k (int): Number of covariates
Attributes:
weights_treatment_assignment (numpy array): Weight vector, drawn
from a uniform distribution U(0,1), of length k. It is used to
weight covariates when assigning treatment non-randomly and
when creating heterogeneous treatment effects.
weights_covariates_to_outputs (numpy array) Weight vector, drawn
from a beta distribution Beta(1,5), of length k. It is used to
weight covariate importance when creating output y from X.
z_set_size_assignment (int): Number of covariates in subset Z of X
that are used to assign treatment non-randomly.
z_set_size_treatment (int): Number of covariates in subset Z of X
that are used to create heterogeneous treatment effects.
interaction_num (int): Number of interaction terms that are
randomly created if chosen in output creation.
'''
if seed is not None:
random.seed(seed) # For debugging
self.N = N # number of observations
self.k = k # number of covariates
# initilizing weight vector for treatment assignment
# using random weights from U[0,1]
self.weights_treatment_assignment = np.random.uniform(0, 1, self.k)
# doing the same for relation of X and y with
# beta distribution (alpha=1, beta=5)
self.weights_covariates_to_outputs = np.random.beta(1, 5, self.k)
# set size of subset Z of X for heterogeneous treatment creation
self.z_set_size_treatment = np.int(self.k / 2)
# set size of subset Z of X for non-random treatment assignment
self.z_set_size_assignment = np.int(self.k / 2)
# set number of covariates used for creating interaction terms of X
self.interaction_num = int(np.sqrt(self.k))
def test_condest(self):
# make tests repeatable
random.seed(0)
# Should be exact for small matrices
cases = []
A = mat(array([2.14]))
cases.append(A)
A = mat(array([2.14j]))
cases.append(A)
A = mat(array([-1.2 + 2.14j]))
cases.append(A)
for i in range(1, 6):
A = mat(rand(i, i))
cases.append(A)
cases.append(1.0j * A)
A = mat(A + 1.0j * rand(i, i))
cases.append(A)
for A in cases:
eigs = eigvals(A)
exact = max(abs(eigs)) / min(abs(eigs))
c = condest(A)
assert_almost_equal(exact, c)
def test_cond(self):
# make tests repeatable
random.seed(0)
# Should be exact
cases = []
A = mat(array([2.14]))
cases.append(A)
A = mat(array([2.14j]))
cases.append(A)
A = mat(array([-1.2 + 2.14j]))
cases.append(A)
for i in range(1, 6):
A = mat(rand(i, i))
cases.append(A)
cases.append(1.0j * A)
A = mat(A + 1.0j * rand(i, i))
cases.append(A)
for A in cases:
U, Sigma, Vh = svd(A)
exact = max(Sigma) / min(Sigma)
c = cond(A)
assert_almost_equal(exact, c)
def SmecticInitializer(gridShape, sigma=0.2, seed=None):
if seed is None:
seed = 0
random.seed(seed)
state = SmecticState.SmecticState(gridShape)
field = state.GetOrderParameterField()
Ksq = FourierSpaceTools.FourierSpaceTools(gridShape).kSq.numpy_array()
for component in field.components:
temp = random.normal(scale=gridShape[0],size=gridShape)
ktemp = fft.rfftn(temp)*(sqrt(pi)*sigma)**len(gridShape)*exp(-Ksq*sigma**2/4.)
field[component] = numpy.real(fft.irfftn(ktemp))
## To make seed consistent across grid sizes and convergence comparison
gridShape = copy.copy(oldgrid)
if gridShape[0] != 128:
state = ResizeState(state,gridShape[0],Dim=len(gridShape))
state = ReformatState(state)
state.ktools = FourierSpaceTools.FourierSpaceTools(gridShape)
return state
def test_cond(self):
# make tests repeatable
random.seed(0)
# Should be exact
cases = []
A = mat(array([2.14]))
cases.append(A)
A = mat(array([2.14j]))
cases.append(A)
A = mat(array([-1.2 + 2.14j]))
cases.append(A)
for i in range(1, 6):
A = mat(rand(i, i))
cases.append(A)
cases.append(1.0j*A)
A = mat(A + 1.0j*rand(i, i))
cases.append(A)
for A in cases:
U, Sigma, Vh = svd(A)
exact = max(Sigma)/min(Sigma)
c = cond(A)
assert_almost_equal(exact, c)
def test_condest(self):
# make tests repeatable
random.seed(0)
# Should be exact for small matrices
cases = []
A = mat(array([2.14]))
cases.append(A)
A = mat(array([2.14j]))
cases.append(A)
A = mat(array([-1.2 + 2.14j]))
cases.append(A)
for i in range(1, 6):
A = mat(rand(i, i))
cases.append(A)
cases.append(1.0j*A)
A = mat(A + 1.0j*rand(i, i))
cases.append(A)
for A in cases:
eigs = eigvals(A)
exact = max(abs(eigs))/min(abs(eigs))
c = condest(A)
assert_almost_equal(exact, c)
def setUp(self):
random.seed(0) #make tests repeatable
def populate_geo_coord_polygon(polygon, number_of_points, seed=None,
exclude=None, randoms=None):
"""Populate a polygon with uniformly distributed points.
Takes into account the curvature of the earth.
Input:
polygon - list of vertices of polygon, vertices in (lat, long)
number_of_points - (optional) number of points
seed - seed for random number generator (default=None)
exclude - list of polygons (inside main polygon) from where points
should be excluded
randoms - array of numbers between 0 and 1 to be used as the
random numbers for calculating the latitude of the
points. Obviously is this case the numbers are not
random. This should just be used for writing tests.
Output:
points - list of points inside polygon
Examples:
populate_polygon( [[0,0], [-40,0], [-40,1], [0,1]], 6,
randoms = (0.0, 0.2, 0.4, 0.6, 0.8, 1.0))
will return six not so randomly selected points inside the unit square
"""
if seed is not None:
random.seed(seed)
if randoms is None:
randoms = random.random(number_of_points)
else:
# Ensure randoms is a numpy array
randoms = array(randoms)
# print polygon
points = []
# Find outer extent of polygon
max_x = min_x = polygon[0][1]
max_y = min_y = polygon[0][0]
for point in polygon[1:]:
x = point[1]
if x > max_x:
max_x = x
if x < min_x:
min_x = x
y = point[0]
if y > max_y:
max_y = y
if y < min_y:
min_y = y
max_y_rad = radians(max_y)
min_y_rad = radians(min_y)
# Do this until we have a points array of points inside the polygon that
# greater or equal the number of points requested (we'll slice at return)
while len(points) < number_of_points:
y_p_rad = arcsin(randoms * abs((sin(max_y_rad) - sin(min_y_rad))) +
sin(min_y_rad))
y_p = degrees(y_p_rad)
x_p = random.uniform(min_x, max_x, number_of_points)
points_p = array([y_p, x_p]).T
points_p = points_p[inside_polygon(points_p.tolist(), polygon)]
if exclude is not None and len(points_p) > 0:
for ex_poly in exclude:
points_p = points_p[
outside_polygon(points_p.tolist(), ex_poly)]
if len(points_p) > 0:
points.extend(points_p.tolist())
randoms = random.random(number_of_points)
return points[:number_of_points]
def setUp(self):
random.seed(0) #make tests repeatable
def row_func(i):
pyrandom.seed(initseed + int(i))
scirandom.seed(initseed + int(i))
k = scirandom.binomial(N, p, 1)[0]
return (pyrandom.sample(myrange, k), weight)
def mcmc(a, b, phi, snp_dict, beta_mrg, frq_dict, idx_dict, n, ld_blk, blk_size, n_iter, n_burnin, thin, pop, chrom, out_dir, out_name, meta, seed):
print('... MCMC ...')
# seed
if seed != None:
random.seed(seed)
# derived stats
n_pst = (n_iter-n_burnin)/thin
n_pop = len(pop)
p_tot = len(snp_dict['SNP'])
p = {}
n_blk = {}
het = {}
for pp in range(n_pop):
p[pp] = len(beta_mrg[pp])
n_blk[pp] = len(ld_blk[pp])
het[pp] = sp.sqrt(2.0*frq_dict[pp]*(1.0-frq_dict[pp]))
n_grp = sp.zeros((p_tot,1))
for jj in range(p_tot):
for pp in range(n_pop):
if jj in idx_dict[pp]:
n_grp[jj] += 1
# initialization
beta = {}
sigma = {}
for pp in range(n_pop):
beta[pp] = sp.zeros((p[pp],1))
sigma[pp] = 1.0
psi = sp.ones((p_tot,1))
if phi == None:
phi = 1.0; phi_updt = True
else:
phi_updt = False
# space allocation
beta_est = {}
sigma_est = {}
for pp in range(n_pop):
beta_est[pp] = sp.zeros((p[pp],1))
sigma_est[pp] = 0.0
psi_est = sp.zeros((p_tot,1))
phi_est = 0.0
# MCMC
for itr in range(1,n_iter+1):
if itr % 100 == 0:
print('--- iter-' + str(itr) + ' ---')
for pp in range(n_pop):
mm = 0; quad = 0.0
psi_pp = psi[idx_dict[pp]]
for kk in range(n_blk[pp]):
if blk_size[pp][kk] == 0:
continue
else:
idx_blk = range(mm,mm+blk_size[pp][kk])
dinvt = ld_blk[pp][kk]+sp.diag(1.0/psi_pp[idx_blk].T[0])
dinvt_chol = linalg.cholesky(dinvt)
beta_tmp = linalg.solve_triangular(dinvt_chol, beta_mrg[pp][idx_blk], trans='T') \
+ sp.sqrt(sigma[pp]/n[pp])*random.randn(len(idx_blk),1)
beta[pp][idx_blk] = linalg.solve_triangular(dinvt_chol, beta_tmp, trans='N')
quad += sp.dot(sp.dot(beta[pp][idx_blk].T, dinvt), beta[pp][idx_blk])
mm += blk_size[pp][kk]
err = max(n[pp]/2.0*(1.0-2.0*sum(beta[pp]*beta_mrg[pp])+quad), n[pp]/2.0*sum(beta[pp]**2/psi_pp))
sigma[pp] = 1.0/random.gamma((n[pp]+p[pp])/2.0, 1.0/err)
delta = random.gamma(a+b, 1.0/(psi+phi))
xx = sp.zeros((p_tot,1))
for pp in range(n_pop):
xx[idx_dict[pp]] += n[pp]*beta[pp]**2/sigma[pp]
for jj in range(p_tot):
while True:
try:
psi[jj] = gigrnd.gigrnd(a-0.5*n_grp[jj], 2.0*delta[jj], xx[jj])
except:
continue
else:
break
psi[psi>1] = 1.0
if phi_updt == True:
w = random.gamma(1.0, 1.0/(phi+1.0))
phi = random.gamma(p_tot*b+0.5, 1.0/(sum(delta)+w))
# posterior
if (itr > n_burnin) and (itr % thin == 0):
for pp in range(n_pop):
beta_est[pp] = beta_est[pp] + beta[pp]/n_pst
sigma_est[pp] = sigma_est[pp] + sigma[pp]/n_pst
psi_est = psi_est + psi/n_pst
phi_est = phi_est + phi/n_pst
# convert standardized beta to per-allele beta
for pp in range(n_pop):
beta_est[pp] /= het[pp]
# meta
if meta == 'TRUE':
vv = sp.zeros((p_tot,1))
zz = sp.zeros((p_tot,1))
for pp in range(n_pop):
vv[idx_dict[pp]] += n[pp]/sigma_est[pp]/psi_est[idx_dict[pp]]*het[pp]**2
zz[idx_dict[pp]] += n[pp]/sigma_est[pp]/psi_est[idx_dict[pp]]*het[pp]**2*beta_est[pp]
mu = zz/vv
# write posterior effect sizes
for pp in range(n_pop):
if phi_updt == True:
eff_file = out_dir + '/' + '%s_%s_pst_eff_a%d_b%.1f_phiauto_chr%d.txt' % (out_name, pop[pp], a, b, chrom)
else:
eff_file = out_dir + '/' + '%s_%s_pst_eff_a%d_b%.1f_phi%1.0e_chr%d.txt' % (out_name, pop[pp], a, b, phi, chrom)
snp_pp = [snp_dict['SNP'][ii] for ii in idx_dict[pp]]
bp_pp = [snp_dict['BP'][ii] for ii in idx_dict[pp]]
a1_pp = [snp_dict['A1'][ii] for ii in idx_dict[pp]]
a2_pp = [snp_dict['A2'][ii] for ii in idx_dict[pp]]
with open(eff_file, 'w') as ff:
for snp, bp, a1, a2, beta in zip(snp_pp, bp_pp, a1_pp, a2_pp, beta_est[pp]):
ff.write('%d\t%s\t%d\t%s\t%s\t%.6e\n' % (chrom, snp, bp, a1, a2, beta))
if meta == 'TRUE':
if phi_updt == True:
eff_file = out_dir + '/' + '%s_META_pst_eff_a%d_b%.1f_phiauto_chr%d.txt' % (out_name, a, b, chrom)
else:
eff_file = out_dir + '/' + '%s_META_pst_eff_a%d_b%.1f_phi%1.0e_chr%d.txt' % (out_name, a, b, phi, chrom)
with open(eff_file, 'w') as ff:
for snp, bp, a1, a2, beta in zip(snp_dict['SNP'], snp_dict['BP'], snp_dict['A1'], snp_dict['A2'], mu):
ff.write('%d\t%s\t%d\t%s\t%s\t%.6e\n' % (chrom, snp, bp, a1, a2, beta))
# print estimated phi
if phi_updt == True:
print('... Estimated global shrinkage parameter: %1.2e ...' % phi_est )
print('... Done ...')
#!/usr/bin/env python
import sys
sys.path.append("../..")
import scipy as sp
from scipy import io
from scipy import random
import psc585
from psc585 import ps4
foo = ps4.FinalModel.from_mat("FinalModel.mat", "FinalData.mat")
random.seed(4403205)
# Initial Conditional Choice probabilities
# Government
Pg = random.uniform(0, 1, (foo.n, foo.k))
Pg /= Pg.sum(1)[:, newaxis]
# Provinces
Pp0 = random.uniform(0, 1, (foo.n, foo.k))
Pp = sp.concatenate([sp.vstack((Pp0[:, i], 1 - Pp0[:, i])).T
for i in range(Pp0.shape[1])], 1)
# Initial Parameters
theta0 = random.normal(0, 1, (5, 1))
theta = foo.npl(Pp, Pg, verbose=True)
def row_func(i):
pyrandom.seed(initseed + int(i))
scirandom.seed(initseed + int(i))
k = scirandom.binomial(N, p, 1)[0]
return (pyrandom.sample(myrange, k), weight)
mu1 = np.zeros(2)
cov1 = np.eye(2)
mu2 = np.array([5, 3])
cov2 = np.eye(2) * 2
mu3 = np.array([8, 12])
cov3 = np.array([3.4, 0, 0, 5.1]).reshape(2, 2)
# multinom params
p1 = 0.2
p2 = 0
p3 = 1 - p2 - p1
# random draws
rnd.seed(1)
knum = rnd.multinomial(draws, (p1, p2, p3))
gaus1 = rnd.multivariate_normal(mu1, cov1, knum[0])
gaus2 = rnd.multivariate_normal(mu2, cov2, knum[1])
gaus3 = rnd.multivariate_normal(mu3, cov3, knum[2])
# join columns into dataframe
x1 = pd.Series(np.r_[gaus1[:, 0], gaus2[:, 0], gaus3[:, 0]])
x2 = pd.Series(np.r_[gaus1[:, 1], gaus2[:, 1], gaus3[:, 1]])
c = pd.Series(np.r_[np.zeros(knum[0]), np.ones(knum[1]), np.ones(knum[2]) * 2])
dat = {"x1" : x1, "x2" : x2, "c" : c}
clustData = pd.DataFrame(dat)
# plot clusters
#plt.scatter(clustData["x1"], clustData["x2"], c = clustData["c"])
#plt.show()
""" Name : c15_03_4moments.py Book : Python for Finance (2nd ed.) Publisher: Packt Publishing Ltd. Author : Yuxing Yan Date : 6/6/2017 email : [email protected] [email protected] """ import numpy as np from scipy import stats, random # random.seed(12345) ret=random.normal(0,1,50000) print('mean =',np.mean(ret)) print('std =',np.std(ret)) print('skewness=',stats.skew(ret)) print('kurtosis=',stats.kurtosis(ret))
# # http://numenta.org/licenses/ # ---------------------------------------------------------------------- import numpy as np import random as rn import os os.environ['PYTHONHASHSEED'] = '0' #not sure if needed rn.seed(1) np.random.seed(2) from scipy import random random.seed(3) import tensorflow as tf session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1) from keras import backend as K from keras.callbacks import TensorBoard tf.set_random_seed(4) sess = tf.Session(graph=tf.get_default_graph(), config=session_conf) K.set_session(sess) from sys import argv import importlib
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn import linear_model
from scipy import random
random.seed(1)
dataset = np.genfromtxt("../../Dataset/CandC-dataset.csv", delimiter=",")
Y = dataset[:, -1:]
X = np.delete(dataset, 122, 1)
X_train1, X_test1, Y_train1, Y_test1 = train_test_split(X, Y, test_size=0.2)
DS2_train1 = np.append(X_train1, Y_train1, 1)
DS2_test1 = np.append(X_test1, Y_test1, 1)
np.savetxt("../../Dataset/CandC-train1.csv", DS2_train1, delimiter=",")
np.savetxt("../../Dataset/CandC-test1.csv", DS2_test1, delimiter=",")
X_train2, X_test2, Y_train2, Y_test2 = train_test_split(X, Y, test_size=0.2)
DS2_train2 = np.append(X_train2, Y_train2, 1)
DS2_test2 = np.append(X_test2, Y_test2, 1)
np.savetxt("../../Dataset/CandC-train2.csv", DS2_train2, delimiter=",")
np.savetxt("../../Dataset/CandC-test2.csv", DS2_test2, delimiter=",")
X_train3, X_test3, Y_train3, Y_test3 = train_test_split(X, Y, test_size=0.2)
DS2_train3 = np.append(X_train3, Y_train3, 1)
DS2_test3 = np.append(X_test3, Y_test3, 1)
np.savetxt("../../Dataset/CandC-train3.csv", DS2_train3, delimiter=",")
np.savetxt("../../Dataset/CandC-test3.csv", DS2_test3, delimiter=",")
X_train4, X_test4, Y_train4, Y_test4 = train_test_split(X, Y, test_size=0.2)
DS2_train4 = np.append(X_train4, Y_train4, 1)
DS2_test4 = np.append(X_test4, Y_test4, 1)
def run_gru(s):
global global_step
global increment_global_step_op
global reset_global_step_op
global batches
global images_placeholder
global batches_op
global_step = tf.Variable(0,
name='global_step',
trainable=False,
dtype=tf.int32)
increment_global_step_op = tf.assign(global_step, global_step + 1)
reset_global_step_op = tf.assign(global_step, 0)
batches = tf.get_variable(
"batches", [s.nTrain / int(s.batch_size), s.batch_size, 1, 1],
dtype=tf.float32,
initializer=tf.zeros_initializer)
images_placeholder = tf.placeholder(tf.float32,
shape=(s.nTrain / int(s.batch_size),
s.batch_size, 1, 1))
batches_op = tf.assign(batches, images_placeholder)
x_dims = len(x_cols[s.dataSet]) if s.dataSet in x_cols else s.lookback
random.seed(6)
np.random.seed(6)
rnn = Sequential()
rnn.add(
GRU(s.nodes,
input_shape=(None, x_dims),
kernel_initializer='he_uniform',
stateful=False))
#rnn.add(Dropout(0.15))
rnn.add(Dense(1, kernel_initializer='he_uniform'))
opt = adam(lr=s.lr, decay=0.0) #1e-3)
rnn.compile(loss='mae', optimizer=opt)
# prepare dataset as pyBrain sequential dataset
sequence = readDataSet(s.dataSet, s.dataSetDetailed, s)
if s.limit_to:
sequence = sequence[:s.limit_to]
dp = DataProcessor()
# standardize data by subtracting mean and dividing by std
(meanSeq, stdSeq) = dp.normalize('data', sequence, s.nTrain)
#dp.windowed_normalize(sequence)
for key in sequence.keys():
if key != "data":
dp.normalize(key, sequence, s.nTrain)
if s.dataSet in differenceSets:
predictedInputNodiff = np.zeros((len(sequence), ))
targetInputNodiff = np.zeros((len(sequence), ))
if s.dataSet in differenceSets:
backup_sequence = sequence
sequence = dp.difference(sequence, s.lookback)
seq_full = sequence['data'].values
seq_actual = seq_full[s.front_buffer:]
allX = getX(seq_full, s)
allY = seq_actual[s.predictionStep - 1:]
predictedInput = np.full((len(allY), ), np.nan)
#if s.dataSet not in x_cols:
# allY = allY[s.lookback:]
trainX = allX[:s.nTrain]
trainY = allY[:s.nTrain]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
rnn.fit(trainX,
trainY,
epochs=s.epochs,
batch_size=s.batch_size,
verbose=min(s.max_verbosity, 2))
#for i in xrange(0,s.nTrain):
# targetInput[i] = allY[i+s.predictionStep]
targetInput = allY
pred_diffs = []
pred_closer_to_actual = []
isFirst = True
for i in tqdm(xrange(s.nTrain + s.predictionStep, len(allX)),
disable=s.max_verbosity == 0):
#for i in tqdm(xrange(0, len(allX)), disable=s.max_verbosity == 0):
if i % s.retrain_interval == 0 and i > s.numLags + s.nTrain and s.online:
trainX = allX[i - s.nTrain - s.predictionStep:i - s.predictionStep]
trainY = allY[i - s.nTrain - s.predictionStep:i - s.predictionStep]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
rnn.fit(trainX,
trainY,
epochs=s.epochs,
batch_size=s.batch_size,
verbose=0)
#targetInput[i] = allY[i]
predictedInput[i] = rnn.predict(np.reshape(allX[i], (1, 1, x_dims)))
if isFirst:
print predictedInput[i]
isFirst = False
#predictedInput[i] = targetInput[i-1440]
pred_diffs.append(abs(predictedInput[i] - allX[i][-1]))
pred_closer_to_actual.append(
abs(predictedInput[i] - targetInput[i]) < abs(predictedInput[i] -
allX[i][-1]))
if s.dataSet in differenceSets:
predictedInputNodiff[i] = predictedInput[i]
targetInputNodiff[i] = targetInput[i]
predictedInput[i] = dp.inverse_difference(backup_sequence['data'],
predictedInput[i], i - 1)
targetInput[i] = dp.inverse_difference(backup_sequence['data'],
targetInput[i], i - 1)
for i in range(s.nTrain + s.predictionStep):
predictedInput[i] = np.nan
predictedInput = dp.denormalize(predictedInput, meanSeq, stdSeq)
targetInput = dp.denormalize(targetInput, meanSeq, stdSeq)
#dp.windowed_denormalize(predictedInput, targetInput)
print "FINAL", predictedInput[-1], targetInput[-1], len(
predictedInput), len(targetInput)
if s.dataSet in differenceSets:
# predictedInputNodiff = dp.denormalize(predictedInputNodiff)
# targetInputNodiff = dp.denormalize(targetInputNodiff)
pass
dp.saveResultToFile(s.dataSet, predictedInput, targetInput, 'gru',
s.predictionStep, s.max_verbosity)
skipTrain = error_ignore_first[s.dataSet]
from plot import computeSquareDeviation
squareDeviation = computeSquareDeviation(predictedInput, targetInput)
squareDeviation[:skipTrain] = None
nrmse = np.sqrt(np.nanmean(squareDeviation)) / np.nanstd(targetInput)
if s.max_verbosity > 0:
print "", s.nodes, "NRMSE {}".format(nrmse)
mae = np.nanmean(np.abs(targetInput - predictedInput))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
mase = errors.get_mase(predictedInput, targetInput,
np.roll(targetInput, s.season))
if s.max_verbosity > 0:
print "MASE {}".format(mase)
if s.dataSet in differenceSets:
dp.saveResultToFile(s.dataSet, predictedInputNodiff, targetInputNodiff,
'gru_nodiff', s.predictionStep, s.max_verbosity)
squareDeviation = computeSquareDeviation(predictedInputNodiff,
targetInputNodiff)
squareDeviation[:skipTrain] = None
nrmse = np.sqrt(
np.nanmean(squareDeviation)) / np.nanstd(targetInputNodiff)
if s.max_verbosity > 0:
print "", s.nodes, "NRMSE {}".format(nrmse)
mae = np.nanmean(np.abs(targetInputNodiff - predictedInputNodiff))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
closer_rate = pred_closer_to_actual.count(True) / float(
len(pred_closer_to_actual))
if s.max_verbosity > 0:
pred_diffs.sort()
print pred_diffs[0], pred_diffs[-1], pred_diffs[int(0.9 *
len(pred_diffs))]
print "Good results:", closer_rate
return mase, closer_rate
meanTimeOfDay = np.mean(sequence['timeofday'])
stdTimeOfDay = np.std(sequence['timeofday'])
sequence['timeofday'] = (sequence['timeofday'] -
meanTimeOfDay) / stdTimeOfDay
meanDayOfWeek = np.mean(sequence['dayofweek'])
stdDayOfWeek = np.std(sequence['dayofweek'])
sequence['dayofweek'] = (sequence['dayofweek'] -
meanDayOfWeek) / stdDayOfWeek
ds = getPyBrainDataSet(sequence, nTrain, predictionStep, useTimeOfDay,
useDayOfWeek)
print "train LSTM with " + str(rptNum) + " epochs"
random.seed(6)
net = initializeLSTMnet(nDimInput=len(ds.getSample()[0]),
nDimOutput=1,
nLSTMcells=20)
trainer = RPropMinusTrainer(net, dataset=ds, verbose=True)
error = []
for rpt in xrange(rptNum):
err = trainer.train()
error.append(err)
print "test LSTM"
net.reset()
predictedInput = np.zeros((len(sequence), ))
targetInput = np.zeros((len(sequence), ))
import sys
import numpy as np
import pylab as pl
from numpy import arange
from py2app.recipes import scipy
from scipy import stats, random
from sklearn import cross_validation
from sklearn.datasets import load_svmlight_file
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LinearRegression, Ridge, LassoCV, Lasso
from sklearn.preprocessing import StandardScaler
feat_names = []
random.seed(14)
i_to_name = []
def save_insts_to_svm_file(instances, feat_file):
print('saving insts to svm')
dir = os.path.dirname(feat_file)
if not os.path.exists(dir):
print("making: " + dir)
os.makedirs(dir)
with open(feat_file, 'w') as f:
first = True
for url in instances.keys():
inst = instances[url]
if not first:
def mcmc(a, b, phi, sst_dict, n, ld_blk, blk_size, n_iter, n_burnin, thin, chrom, out_dir, beta_std, seed):
print('... MCMC ...')
# seed
if seed != None:
random.seed(seed)
# derived stats
beta_mrg = sp.array(sst_dict['BETA'], ndmin=2).T
maf = sp.array(sst_dict['MAF'], ndmin=2).T
n_pst = (n_iter-n_burnin)/thin
p = len(sst_dict['SNP'])
n_blk = len(ld_blk)
# initialization
beta = sp.zeros((p,1))
psi = sp.ones((p,1))
sigma = 1.0
if phi == None:
phi = 1.0; phi_updt = True
else:
phi_updt = False
beta_est = sp.zeros((p,1))
psi_est = sp.zeros((p,1))
sigma_est = 0.0
phi_est = 0.0
# MCMC
for itr in range(1,n_iter+1):
if itr % 100 == 0:
print('--- iter-' + str(itr) + ' ---')
mm = 0; quad = 0.0
for kk in range(n_blk):
if blk_size[kk] == 0:
continue
else:
idx_blk = range(mm,mm+blk_size[kk])
dinvt = ld_blk[kk]+sp.diag(1.0/psi[idx_blk].T[0])
dinvt_chol = linalg.cholesky(dinvt)
beta_tmp = linalg.solve_triangular(dinvt_chol, beta_mrg[idx_blk], trans='T') + sp.sqrt(sigma/n)*random.randn(len(idx_blk),1)
beta[idx_blk] = linalg.solve_triangular(dinvt_chol, beta_tmp, trans='N')
quad += sp.dot(sp.dot(beta[idx_blk].T, dinvt), beta[idx_blk])
mm += blk_size[kk]
err = max(n/2.0*(1.0-2.0*sum(beta*beta_mrg)+quad), n/2.0*sum(beta**2/psi))
sigma = 1.0/random.gamma((n+p)/2.0, 1.0/err)
delta = random.gamma(a+b, 1.0/(psi+phi))
for jj in range(p):
psi[jj] = gigrnd.gigrnd(a-0.5, 2.0*delta[jj], n*beta[jj]**2/sigma)
psi[psi>1] = 1.0
if phi_updt == True:
w = random.gamma(1.0, 1.0/(phi+1.0))
phi = random.gamma(p*b+0.5, 1.0/(sum(delta)+w))
# posterior
if (itr>n_burnin) and (itr % thin == 0):
beta_est = beta_est + beta/n_pst
psi_est = psi_est + psi/n_pst
sigma_est = sigma_est + sigma/n_pst
phi_est = phi_est + phi/n_pst
# convert standardized beta to per-allele beta
if beta_std == 'False':
beta_est /= sp.sqrt(2.0*maf*(1.0-maf))
# write posterior effect sizes
if phi_updt == True:
eff_file = out_dir + '_pst_eff_a%d_b%.1f_phiauto_chr%d.txt' % (a, b, chrom)
else:
eff_file = out_dir + '_pst_eff_a%d_b%.1f_phi%1.0e_chr%d.txt' % (a, b, phi, chrom)
with open(eff_file, 'w') as ff:
for snp, bp, a1, a2, beta in zip(sst_dict['SNP'], sst_dict['BP'], sst_dict['A1'], sst_dict['A2'], beta_est):
ff.write('%d\t%s\t%d\t%s\t%s\t%.6e\n' % (chrom, snp, bp, a1, a2, beta))
# print estimated phi
if phi_updt == True:
print('... Estimated global shrinkage parameter: %1.2e ...' % phi_est )
print('... Done ...')
def setUp(self):
self.numberOfSamples = 1000
pr = cPickle.load(open(os.path.join(unittest_dir, 'test_data', 'sampling_parameters_xacy.pck')))
self.sampPar = SamplingParameters.SamplingParameters(pr)
random.seed(10)
def run_gru(s):
x_dims = len(x_cols[s.dataSet]) if s.dataSet in x_cols else s.lookback
random.seed(6)
np.random.seed(6)
rnn = Sequential()
rnn.add(
GRU(s.nodes,
input_shape=(None, x_dims),
kernel_initializer='he_uniform',
stateful=False))
#rnn.add(Dropout(0.15))
rnn.add(Dense(1, kernel_initializer='he_uniform'))
opt = adam(lr=s.lr, decay=0.0) #1e-3)
rnn.compile(loss='mae', optimizer=opt)
# prepare dataset as pyBrain sequential dataset
sequence = readDataSet(s.dataSet, s.dataSetDetailed, s)
if s.limit_to:
sequence = sequence[:s.limit_to]
dp = DataProcessor()
# standardize data by subtracting mean and dividing by std
#(meanSeq, stdSeq) = dp.normalize('data', sequence)
dp.windowed_normalize(sequence)
for key in sequence.keys():
if key != "data":
dp.normalize(key, sequence)
predictedInput = np.zeros((len(sequence), ))
targetInput = np.zeros((len(sequence), ))
trueData = np.zeros((len(sequence), ))
if s.dataSet in differenceSets:
predictedInputNodiff = np.zeros((len(sequence), ))
targetInputNodiff = np.zeros((len(sequence), ))
if s.dataSet in differenceSets:
backup_sequence = sequence
sequence = dp.difference(sequence, s.lookback)
allX = getX(sequence, s)
allY = np.array(sequence['data'])
allX = allX[48:]
allY = allY[48:]
#if s.dataSet not in x_cols:
# allY = allY[s.lookback:]
trainX = allX[0:s.nTrain]
trainY = allY[s.predictionStep:s.nTrain + s.predictionStep]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
curBatch = 1.0
callback = LossCallback()
temp_set = np.array(sequence['data'])[:48 + s.nTrain + 5]
configure_batches(48, s.batch_size,
np.reshape(temp_set, (temp_set.shape[0], 1, 1)))
rnn.fit(trainX,
trainY,
epochs=s.epochs,
batch_size=s.batch_size,
verbose=min(s.max_verbosity, 2),
callbacks=[callback])
for i in xrange(0, s.nTrain):
targetInput[i] = allY[i + s.predictionStep]
for i in tqdm(xrange(s.nTrain + s.predictionStep, len(allX)),
disable=s.max_verbosity == 0):
if i % s.retrain_interval == 0 and i > s.numLags + s.nTrain and s.online:
trainX = allX[i - s.nTrain - s.predictionStep:i - s.predictionStep]
trainY = allY[i - s.nTrain:i]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
temp_set = np.array(sequence['data'])[i - s.nTrain -
s.predictionStep - 48:i]
configure_batches(48, s.batch_size,
np.reshape(temp_set, (temp_set.shape[0], 1, 1)))
rnn.fit(trainX,
trainY,
epochs=s.epochs,
batch_size=s.batch_size,
verbose=2,
callbacks=[callback])
targetInput[i] = allY[i + s.predictionStep]
predictedInput[i] = rnn.predict(np.reshape(allX[i], (1, 1, x_dims)))
if s.dataSet in differenceSets:
predictedInputNodiff[i] = predictedInput[i]
targetInputNodiff[i] = targetInput[i]
predictedInput[i] = dp.inverse_difference(backup_sequence['data'],
predictedInput[i], i - 1)
targetInput[i] = dp.inverse_difference(backup_sequence['data'],
targetInput[i], i - 1)
predictedInput[0] = 0
trueData[i] = sequence['data'][i]
#predictedInput = dp.denormalize(predictedInput, meanSeq, stdSeq)
#targetInput = dp.denormalize(targetInput, meanSeq, stdSeq)
dp.windowed_denormalize(predictedInput, targetInput)
if s.dataSet in differenceSets:
# predictedInputNodiff = dp.denormalize(predictedInputNodiff)
# targetInputNodiff = dp.denormalize(targetInputNodiff)
pass
#trueData = (trueData * stdSeq) + meanSeq
dp.saveResultToFile(s.dataSet, predictedInput, targetInput, 'gru',
s.predictionStep, s.max_verbosity)
skipTrain = error_ignore_first[s.dataSet]
from plot import computeSquareDeviation
squareDeviation = computeSquareDeviation(predictedInput, targetInput)
squareDeviation[:skipTrain] = None
nrmse = np.sqrt(np.nanmean(squareDeviation)) / np.nanstd(targetInput)
if s.max_verbosity > 0:
print "", s.nodes, "NRMSE {}".format(nrmse)
mae = np.nanmean(np.abs(targetInput - predictedInput))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
if s.dataSet in differenceSets:
dp.saveResultToFile(s.dataSet, predictedInputNodiff, targetInputNodiff,
'gru_nodiff', s.predictionStep, s.max_verbosity)
squareDeviation = computeSquareDeviation(predictedInputNodiff,
targetInputNodiff)
squareDeviation[:skipTrain] = None
nrmse = np.sqrt(
np.nanmean(squareDeviation)) / np.nanstd(targetInputNodiff)
if s.max_verbosity > 0:
print "", s.nodes, "NRMSE {}".format(nrmse)
mae = np.nanmean(np.abs(targetInputNodiff - predictedInputNodiff))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
mase = errors.get_mase(predictedInput, targetInput,
np.roll(targetInput, 24))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
return nrmse
import numpy as np
from scipy import random, zeros, exp, dot
from scipy.linalg import norm, inv, pinv
__author__ = 'Gibran'
random.seed(17)
class RBF:
def __init__(self, input_length, hidden_length, out_lenght):
self.input_length = input_length
self.out_lenght = out_lenght
self.hidden_length = hidden_length
self.centers = []
for i in xrange(hidden_length):
self.centers.append(random.uniform(-1, 1, input_length))
self.variance = 1
self.W = random.random((self.hidden_length, self.out_lenght))
def basisfunction(self, x, xi):
assert len(xi) == self.input_length
return exp(-1.0 / (2 * self.variance) * norm(x - xi) ** 2)
def calc_activation(self, dataset):
# calculate activations of RBFs
green_matrix = zeros((len(dataset), self.hidden_length), float)
for xi, x in enumerate(dataset):
for ci, c in enumerate(self.centers):
green_matrix[xi, ci] = self.basisfunction(x, c)
return green_matrix
X[ind0, :], dummy = generateGMM(d, ind0.sum(), weights, means0, Covs0)
# class 1: Gaussian
ind1 = (temp > class_prior[0])
y[ind1] = 1
X[ind1, :] = random.multivariate_normal(m1, C1, ind1.sum())
return X, y
#----------------------------------------------------------
# Part 1: generate tarining datasets and validation dataset
# and classify with true class pdf
#----------------------------------------------------------
random.seed(1234)
# class prior
class_prior = np.array([.6, .4])
# class pdf
means0 = np.array([[5, 0], [0, 4]])
Covs0 = np.array([[[4, 0], [0, 2]], [[1, 0], [0, 3]]])
weights = np.array([.5, .5])
m1 = np.array([3, 2])
C1 = np.array([[2, 0], [0, 2]])
# training dataset of 100
X1, y1 = generateSamples(1e2, means0, Covs0, m1, C1, class_prior)
def get_random_indices(self, i):
pyrandom.seed(self.initseed + int(i))
scirandom.seed(self.initseed + int(i))
k = scirandom.binomial(self.m, self.p, 1)[0]
return self.offset + array(pyrandom.sample(xrange(self.m), k), dtype=int)
import numpy as np
from scipy import random
from matplotlib import pyplot as plt
# Parameters
N = 200
A = 5
E = 1.0
L = 2.0
myseed = 42
# Initialize the random with seed
random.seed(myseed)
# Hidden Model
x = np.linspace(-L, L, N)
y1 = A * np.cos(0.5*np.pi*x/L)
y2 = E * random.normal(size=N)
# Show
plt.plot(x, y1+y2, 'bs', alpha=0.5, label="Medicion")
plt.plot(x, y1, 'k-', lw=2.0, label="Relacion determinista")
plt.xlim([-2.5,2.5])
plt.ylim([-5,10])
plt.xlabel("x []")
plt.ylabel("y []")
plt.legend(numpoints=1, loc="lower center")
#plt.savefig("images/dataN%d.png"%N)
plt.show()
# Shuffle the data
def init_random_seeds(seed):
import random
from scipy import random as numx_rand
print '-- initializing random seed to %s' % seed
random.seed(seed)
numx_rand.seed(seed)
def MaximumEntropy(p, tau, Gt):
beta = tau[-1]
random.seed(1) # seed for random numbers
omega = linspace(-p['L'], p['L'], 2 * p['Nw'] + 1)
f0, f1, f2 = me.initf0(omega)
fsg = 1
if p['statistics'] == 'fermi':
Gt = -Gt
fsg = -1
normalization = Gt[0] + Gt[-1]
Ker = me.initker_fermion(omega, beta, tau)
elif p['statistics'] == 'bose':
normalization = integrate.trapz(Gt, x=tau)
Ker = me.initker_boson(omega, beta, tau)
print 'beta=', beta
print 'normalization=', normalization
# Set error
if p['idg']:
sxt = ones(len(tau)) / (p['deltag']**2)
else:
sxt = Gt * p['deltag']
for i in range(len(sxt)):
if sxt[i] < 1e-5: sxt[i] = 1e-5
sxt = 1. / sxt**2
# Set model
if p['iflat'] == 0:
model = normalization * ones(len(omega)) / sum(f0)
elif p['iflat'] == 1:
model = exp(-omega**2 / p['gwidth'])
model *= normalization / dot(model, f0)
else:
dat = loadtxt('model.dat').transpose()
fm = interpolate.interp1d(dat[0], dat[1])
model = fm(omega)
model *= normalization / dot(model, f0)
#savetxt('brisi_test', vstack((tau, fsg*dot(model,Ker))).transpose())
print 'Model normalization=', dot(model, f0)
# Set starting Aw(omega)
Aw = random.rand(len(omega))
Aw = Aw * (normalization / dot(Aw, f0))
print 'Aw normalization=', dot(Aw, f0)
dlda = me.initdlda(omega, Ker, sxt)
temp = 10.
rfac = 1.
alpha = p['alpha0']
for itt in range(p['Nitt']):
print itt, 'Restarting maxent with rfac=', rfac, 'alpha=', alpha
iseed = random.randint(0, maxint)
me.maxent(Aw, rfac, alpha, temp, Ker, sxt, Gt, model, f0, p['Asteps'],
iseed)
S = me.entropy(Aw, model, f0)
Trc = me.lambdac(alpha, Aw, omega, dlda)
ratio = -2 * S * alpha / Trc
print 'Finished maxent with alpha=', alpha, '-2*alpha*S=', -2 * alpha * S, 'Trace=', Trc
print ' ratio=', ratio
savetxt('dos_' + str(itt), vstack((omega, Aw)).transpose())
temp = 0.001
rfac = 0.05
if abs(ratio - 1) < p['min_ratio']: break
if (abs(ratio) < 0.05):
alpha *= 0.5
else:
alpha *= (1. + 0.001 * (random.rand() - 0.5)) / ratio
for itt in range(p['Nr']):
print 'Smoothing itt ', itt
Aw = Broad(p['bwdth'], omega, Aw)
Aw *= (normalization / dot(Aw, f0)) # Normalizing Aw
savetxt('dos_' + str(p['Nitt']), vstack((omega, Aw)).transpose())
temp = 0.005
rfac = 0.005
iseed = random.randint(0, maxint)
me.maxent(Aw, rfac, alpha, temp, Ker, sxt, Gt, model, f0, p['Asteps'],
iseed)
S = me.entropy(Aw, model, f0)
Trc = me.lambdac(alpha, Aw, omega, dlda)
ratio = -2 * S * alpha / Trc
print 'Finished smoothing run with alpha=', alpha, '-2*alpha*S=', -2 * alpha * S, 'Trace=', Trc
print ' ratio=', ratio
savetxt('gtn', vstack((tau, fsg * dot(Aw, Ker))).transpose())
Aw = Broad(p['bwdth'], omega, Aw)
savetxt('dos.out', vstack((omega, Aw)).transpose())
return (Aw, omega)
meanSeq = np.mean(sequence['data'])
stdSeq = np.std(sequence['data'])
sequence['data'] = (sequence['data'] - meanSeq)/stdSeq
meanTimeOfDay = np.mean(sequence['timeofday'])
stdTimeOfDay = np.std(sequence['timeofday'])
sequence['timeofday'] = (sequence['timeofday'] - meanTimeOfDay)/stdTimeOfDay
meanDayOfWeek = np.mean(sequence['dayofweek'])
stdDayOfWeek = np.std(sequence['dayofweek'])
sequence['dayofweek'] = (sequence['dayofweek'] - meanDayOfWeek)/stdDayOfWeek
(X, T) = getTimeEmbeddedMatrix(sequence, numLags, predictionStep,
useTimeOfDay, useDayOfWeek)
random.seed(6)
net = initializeELMnet(nDimInput=X.shape[1],
nDimOutput=1, numNeurons=50)
net.initializePhase(X[:nTrain, :], T[:nTrain, :])
predictedInput = np.zeros((len(sequence),))
targetInput = np.zeros((len(sequence),))
trueData = np.zeros((len(sequence),))
for i in xrange(nTrain, len(sequence)-predictionStep):
net.train(X[[i], :], T[[i], :])
Y = net.predict(X[[i], :])
predictedInput[i] = Y[-1]
targetInput[i] = sequence['data'][i+predictionStep]
trueData[i] = sequence['data'][i]
import numpy as np from itertools import cycle from sys import stdout import matplotlib.pyplot as plt from scipy import random from scipy.signal import argrelextrema from pybrain.supervised import RPropMinusTrainer, BackpropTrainer from pybrain.datasets import SequentialDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.structure.modules import LSTMLayer, SigmoidLayer, LinearLayer, TanhLayer, SoftmaxLayer from pybrain.tools.validation import testOnSequenceData from pybrain.structure.modules.neuronlayer import NeuronLayer from pybrain.tools.xml.networkwriter import NetworkWriter from pybrain.tools.xml.networkreader import NetworkReader random.seed(42) def ir(p, i, data): # p-days, i=current day a = np.sum([n['adj_close'] for n in data[i:i+p]]) / p c = data[i]['adj_close'] return ((a - c) / c) # prepare date symbol = '^HSI' yahoo_data = YahooHistorical() yahoo_data.open(os.path.join(os.path.dirname(__file__), 'data/' + symbol + '.csv')) training_set = np.array([n for n in yahoo_data.data if n['date'] >= date(2007, 1, 1) and n['date'] <= date(2013, 12, 31)]) test_set = np.array([n for n in yahoo_data.data if n['date'] >= date(2014, 1, 1) and n['date'] <= date(2015, 12, 31)]) rsi = yahoo_data.relative_strength(n=14) (sma13, sma7, macd) = yahoo_data.moving_average_convergence(7, 13) # 7 days and 13 days moving average and MACD test_label = []
def get_random_indices(self, i):
pyrandom.seed(self.initseed + int(i))
scirandom.seed(self.initseed + int(i))
k = scirandom.binomial(self.m, self.p, 1)[0]
return self.offset + array(pyrandom.sample(xrange(self.m), k),
dtype=int)
def test_hodge_star(self):
"""Test the hodge * operator"""
regular_cases = []
#Unit line segment
regular_cases.append((matrix([[0],[1]]),matrix([[0,1]]),[1,1],[0.5,1]))
#One regular triangle, edge length 1
regular_cases.append((matrix([[0,0],[1,0],[0.5,sqrt(3.0)/2.0]]),matrix([[0,1,2]]), [1, 1, sqrt(3.0)/4.0],\
[sqrt(3.0)/12.0,sqrt(3.0)/6.0,1]))
# One regular tet, edge length sqrt(2)
regular_cases.append((matrix([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]]),matrix([[0,1,2,3]]),\
[1, sqrt(2.0),sqrt(3.0/4.0), 1.0/3.0],[1.0/12.0,sqrt(2.0)/12.0,sqrt(3.0/36.0),1]))
for v,e,primal,dual in regular_cases:
sc = simplicial_complex((v,e))
for dim in range(sc.complex_dimension() + 1):
(n,m) = sc[dim].star.shape
for i in range(n):
assert_almost_equal( sc[dim].star[i,i], dual[dim]/primal[dim] )
multi_cases = []
#two line segments
multi_cases.append((matrix([[0],[1],[2]]),matrix([[0,1],[1,2]]), \
[([0],0.5),([1],1.0),([2],0.5),([0,1],1),([1,2],1)]))
#three line segments
multi_cases.append((matrix([[0],[1],[2],[3]]),matrix([[0,1],[1,2],[2,3]]), \
[([0],0.5),([1],1.0),([2],1),([3],0.5),([0,1],1),([1,2],1),([2,3],1)]))
#two triangles
multi_cases.append((matrix([[0,0],[1.0,0],[0.5,sqrt(3.0)/2.0],[1.5,sqrt(3.0)/2.0]]), \
matrix([[0,1,2],[1,3,2]]), \
[([0],sqrt(3.0)/12.0),([1],2*sqrt(3.0)/12.0),([2],2*sqrt(3.0)/12.0), ([3],sqrt(3.0)/12.0), \
([0,1],sqrt(3.0)/6.0),([0,2],sqrt(3.0)/6.0),([1,2],2*sqrt(3.0)/6.0),([1,3],sqrt(3.0)/6.0), \
([2,3],sqrt(3.0)/6.0),([0,1,2],4.0/sqrt(3.0)),([1,2,3],4.0/sqrt(3.0))]))
#three triangles
multi_cases.append((matrix([[0,0],[1.0,0],[0.5,sqrt(3.0)/2.0],[1.5,sqrt(3.0)/2.0],[2,0]]), \
matrix([[0,1,2],[1,3,2],[1,4,3]]), \
[([0],sqrt(3.0)/12.0),([1],3*sqrt(3.0)/12.0),([2],2*sqrt(3.0)/12.0), ([3],2*sqrt(3.0)/12.0), \
([4],sqrt(3.0)/12.0),([0,1],sqrt(3.0)/6.0),([0,2],sqrt(3.0)/6.0),([1,2],2*sqrt(3.0)/6.0),
([1,3],2*sqrt(3.0)/6.0), ([1,4],sqrt(3.0)/6.0),([3,4],sqrt(3.0)/6.0),\
([2,3],sqrt(3.0)/6.0),([0,1,2],4.0/sqrt(3.0)),([1,2,3],4.0/sqrt(3.0)),([1,4,3],4.0/sqrt(3.0))]))
for v,e,t_list in multi_cases:
sc = simplicial_complex((v,e))
for s,ratio in t_list:
data = sc[len(s)-1]
index = data.simplex_to_index[simplex(s)]
assert_almost_equal(ratio,data.star[index,index])
#use the same multi_cases, but add dimensions and translate the vertices
#TODO rotate also
random.seed(0)
for v,e,t_list in multi_cases:
(rows,cols) = v.shape
v = concatenate([v,zeros((rows,4))],1)
v += rand(1,cols +4) #translate
sc = simplicial_complex((v,e))
for s,ratio in t_list:
data = sc[len(s)-1]
index = data.simplex_to_index[simplex(s)]
assert_almost_equal(ratio,data.star[index,index])
#Test sign of dual star, check that: ** = -1 ^(k (n-k))
for v,e,t_list in multi_cases:
sc = simplicial_complex((v,e))
for dim,data in enumerate(sc):
n = sc.complex_dimension()
k = dim
assert_almost_equal((data.star * data.star_inv).todense(), \
((-1)**(k*(n-k))*sparse.identity(data.num_simplices)).todense())
def run_gru(s):
prob = tf.placeholder_with_default(1.0, shape=())
global global_step
global increment_global_step_op
global reset_global_step_op
global batches
global images_placeholder
global batches_op
global_step = tf.Variable(0, name='global_step', trainable=False, dtype=tf.int32)
increment_global_step_op = tf.assign(global_step, global_step + 1)
reset_global_step_op = tf.assign(global_step, 0)
batches = tf.get_variable("batches", [s.nTrain / int(s.batch_size), s.batch_size, 1, 1], dtype=tf.float32,
initializer=tf.zeros_initializer)
images_placeholder = tf.placeholder(tf.float32, shape=(s.nTrain / int(s.batch_size), s.batch_size, 1, 1))
batches_op = tf.assign(batches, images_placeholder)
x_dims = s.lookback
random.seed(6)
np.random.seed(6)
tf.set_random_seed(6)
if s.implementation == "keras":
if s.use_binary:
raise Exception("Binary Keras not implemented")
rnn = Sequential()
if s.rnn_type == "lstm":
rnn.add(LSTM(s.nodes, input_shape=(None,x_dims), kernel_initializer='he_uniform'))
elif s.rnn_type == "gru":
rnn.add(GRU(s.nodes, input_shape=(None, x_dims), kernel_initializer='he_uniform'))
rnn.add(Dropout(0.5))
rnn.add(Dense(1, kernel_initializer='he_uniform'))
opt = rmsprop(lr=s.lr)#1e-3)
rnn.compile(loss='mae', optimizer=opt)
input = Input(shape=(1, x_dims))
dense1 = Dense(s.nodes, activation='sigmoid')(input)
dense2 = Dense(s.nodes, activation='sigmoid')(input)
dense3 = Dense(s.nodes, activation='tanh')(input)
mult1 = Multiply()([dense2, dense3])
act1 = Activation('tanh')(mult1)
mult2 = Multiply()([dense1, act1])
reshape = Reshape((s.nodes,))(mult2)
dropout = Dropout(0.5)(reshape)
dense_out = Dense(1)(dropout)
rnn = Model(inputs=[input], outputs=[dense_out])
opt = adam(lr=s.lr) # 1e-3)
rnn.compile(loss='mae', optimizer=opt)
print rnn.summary()
elif s.implementation == "tf":
data = tf.placeholder(tf.float32, [None, s.lookback, 1]) # Number of examples, number of input, dimension of each input
target = tf.placeholder(tf.float32, [None, 1])
if s.rnn_type == "lstm" and s.use_binary:
cell = rnn_tf.LSTMCell(s.nodes)
elif s.rnn_type == "lstm" and not s.use_binary:
cell = tf.nn.rnn_cell.LSTMCell(s.nodes)
elif s.rnn_type == "gru" and s.use_binary:
cell = rnn_tf.GRUCell(s.nodes)
elif s.rnn_type == "gru" and not s.use_binary:
cell = tf.nn.rnn_cell.GRUCell(s.nodes)
val, _ = tf.nn.dynamic_rnn(cell, data, dtype=tf.float32)
with tf.name_scope('rnn_summaries'):
var = val
mean = tf.reduce_mean(var)
tf.summary.scalar('mean', mean)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('stddev', stddev)
tf.summary.scalar('max', tf.reduce_max(var))
tf.summary.scalar('min', tf.reduce_min(var))
tf.summary.histogram('histogram', var)
val = tf.nn.dropout(val, prob)
if not s.use_binary:
dense = tf.layers.dense(val, 1)
else:
dense = core_discretize.dense(val, 1)
with tf.name_scope('dense_summaries'):
var = dense
mean = tf.reduce_mean(var)
tf.summary.scalar('mean', mean)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('stddev', stddev)
tf.summary.scalar('max', tf.reduce_max(var))
tf.summary.scalar('min', tf.reduce_min(var))
tf.summary.histogram('histogram', var)
pred = tf.reshape(dense, (tf.shape(dense)[0], 1))
summary = tf.summary.merge_all()
optimizer = tf.train.AdamOptimizer(learning_rate=s.lr)
#cost = tf.losses.mean_squared_error(target, pred)
cost = tf.reduce_mean(tf.abs(target - pred))
minimize = optimizer.minimize(cost)
else:
raise Exception("Unknown implementation " + s.implementation)
sequence = readDataSet(s.dataSet, s.dataSetDetailed, s)
if s.limit_to:
sequence = sequence[:s.limit_to]
#TEMP SANITY CHECK
# sequence['data'][7001] = 0
# sequence['data'][7002] = 0
# sequence['data'][7003] = 0
# sequence['data'][7004] = 0
# sequence['data'][7005] = 0
seq_full = sequence['data'].values #use .values to copy
targetInput = seq_full[s.front_buffer + s.predictionStep - 1:].copy() #grab this now to avoid having to denormalize
dp = DataProcessor()
if s.normalization_type == 'default':
(meanSeq, stdSeq) = dp.normalize('data', sequence, s.nTrain)
elif s.normalization_type == 'windowed':
dp.windowed_normalize(sequence)
elif s.normalization_type == 'AN':
an = AdaptiveNormalizer(s.lookback, s.lookback + s.predictionStep)
an.set_pruning(False)
an.set_source_data(seq_full, s.nTrain)
an.do_ma('s')
an.do_stationary()
an.remove_outliers()
seq_norm = an.do_adaptive_normalize()
else:
raise Exception("Unsupported normalization type: " + s.normalization_type)
seq_actual = seq_full[s.front_buffer:] #Leave enough headroom for MASE calculation and lookback
seq_full_norm = sequence['data'].values
seq_actual_norm = seq_full_norm[s.front_buffer:]
if s.normalization_type != "AN":
#Default and windowed change the seq itself but still require creating lookback frames
allX = getX(seq_full_norm, s)
allY = seq_actual_norm[s.predictionStep-1:]
else:
#AN creates a new array but takes care of lookback internally
allX= seq_norm[:,0:-s.predictionStep]
allY = np.reshape(seq_norm[:,-1], (-1,))
# TODO FIX PROPERLY (now rolled too far)
too_long = len(allX) - (len(seq_full) - s.front_buffer - s.predictionStep + 1)
if too_long > 0:
allX = allX[too_long:]
allY = allY[too_long:]
print len(allX), len(allY), s.front_buffer
predictedInput = np.full((len(allY),), np.nan) #Initialize all predictions to NaN
trainX = allX[:s.nTrain]
trainY = allY[:s.nTrain]
trainX = np.reshape(trainX, (trainX.shape[0],1, trainX.shape[1]))
trainY = np.reshape(trainY, ( trainY.shape[0],))
if s.implementation == "keras":
rnn.fit(trainX, trainY, epochs=s.epochs, batch_size=s.batch_size, verbose=min(s.max_verbosity, 2))
elif s.implementation == "tf":
sess = tf.Session()
writer = tf.summary.FileWriter("results/", graph=sess.graph)
init = tf.global_variables_initializer()
sess.run(init)
for v in tf.trainable_variables():
print v.name
for epoch in tqdm(range(s.epochs)):
the_cost, _, summ = sess.run([cost, minimize, summary], feed_dict={data: trainX, target: trainY, prob: 0.5})
writer.add_summary(summ, epoch)
if epoch % 10 == 0:
print the_cost
#print(psutil.Process(os.getpid()).memory_percent())
var = [v for v in tf.trainable_variables() if v.name == "rnn/gru_cell/gates/kernel:0"][0]
print sess.run(tf.reduce_min(var))
print sess.run(tf.reduce_max(var))
# var = [v for v in tf.trainable_variables() if v.name == "rnn/gru_cell/gates/bias:0"][0]
# print sess.run(tf.reduce_min(var))
# print sess.run(tf.reduce_max(var))
# var = [v for v in tf.trainable_variables() if v.name == "rnn/gru_cell/candidate/kernel:0"][0]
# print sess.run(tf.reduce_min(var))
# print sess.run(tf.reduce_max(var))
# var = [v for v in tf.trainable_variables() if v.name == "rnn/gru_cell/candidate/bias:0"][0]
# print sess.run(tf.reduce_min(var))
# print sess.run(tf.reduce_max(var))
# print "loop"
var = [v for v in tf.trainable_variables() if v.name == "dense/bias:0"]
print sess.run(var)
minval = 10
latestStart = None
for i in tqdm(xrange(s.nTrain + s.predictionStep, len(allX)), disable=s.max_verbosity == 0):
#for i in tqdm(xrange(0, len(allX)), disable=s.max_verbosity == 0):
#for i in tqdm(xrange(10475, len(allX)), disable=s.max_verbosity == 0):
if i % s.retrain_interval == 0 and i > s.numLags+s.nTrain and s.online:
if s.normalization_type == 'AN':
predictedInput = np.array(an.do_adaptive_denormalize(predictedInput, therange=(i-s.retrain_interval, i)))
latestStart = i
an.set_ignore_first_n(i-s.nTrain-s.predictionStep)
an.do_ma('s')
an.do_stationary()
an.remove_outliers()
seq_norm = an.do_adaptive_normalize()
allX = seq_norm[:, 0:-s.predictionStep]
allY = np.reshape(seq_norm[:, -1], (-1,))
trainX = allX[i-s.nTrain-s.predictionStep:i-s.predictionStep]
trainY = allY[i-s.nTrain-s.predictionStep:i-s.predictionStep]
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
trainY = np.reshape(trainY, (trainY.shape[0], 1))
if s.implementation == "keras":
rnn.fit(trainX, trainY, epochs=s.epochs, batch_size=s.batch_size, verbose=0)
elif s.implementation == "tf":
for epoch in range(s.epochs):
sess.run(minimize, feed_dict={data: trainX, target: trainY, prob: 0.5})
if s.implementation == "keras":
predictedInput[i] = rnn.predict(np.reshape(allX[i], (1,1,x_dims)))
elif s.implementation == "tf":
predictedInput[i] = sess.run(dense, feed_dict={data: np.reshape(allX[i], (1, x_dims, 1))})
#if len(allX) > i+5:
# predictedInput[i] = allY[i-3000]
# if i == 10000:
# print allX[i]
# print "should be ", (targetInput[i] - meanSeq) / stdSeq
# print "predicted as ", predictedInput[i]
# for i in range(s.nTrain + s.predictionStep):
# predictedInput[i] = np.nan
print "SMALLEST", minval
# np.set_printoptions(threshold=np.nan, suppress=True)
# print "ALLY START"
# for val in allY:
# print val
# print "ALLY STOP"
if s.normalization_type == 'default':
predictedInput = dp.denormalize(predictedInput, meanSeq, stdSeq)
#targetInput = dp.denormalize(targetInput, meanSeq, stdSeq)
elif s.normalization_type == 'windowed':
dp.windowed_denormalize(predictedInput, targetInput, pred_step=s.predictionStep)
elif s.normalization_type == 'AN':
if latestStart:
predictedInput = np.array(an.do_adaptive_denormalize(predictedInput, therange=(latestStart, len(predictedInput))))
else:
predictedInput = np.array(an.do_adaptive_denormalize(predictedInput))
if an.pruning:
targetInput = np.delete(targetInput, an.deletes)
print len(predictedInput), len(targetInput), "LENS"
#TEMP SANITY CHECK
#print predictedInput[7005 - s.front_buffer - s.predictionStep +1]
#print predictedInput[7006 - s.front_buffer - s.predictionStep + 1]
dp.saveResultToFile(s.dataSet, predictedInput, targetInput, 'gru', s.predictionStep, s.max_verbosity)
skipTrain = s.ignore_for_error
from plot import computeSquareDeviation
squareDeviation = computeSquareDeviation(predictedInput, targetInput)
squareDeviation[:skipTrain] = None
nrmse = np.sqrt(np.nanmean(squareDeviation)) / np.nanstd(targetInput)
if s.max_verbosity > 0:
print "", s.nodes, "NRMSE {}".format(nrmse)
mae = np.nanmean(np.abs(targetInput-predictedInput))
if s.max_verbosity > 0:
print "MAE {}".format(mae)
mape = errors.get_mape(predictedInput,targetInput, s.ignore_for_error)
if s.max_verbosity > 0:
print "MAPE {}".format(mape)
mase = errors.get_mase(predictedInput, targetInput, np.roll(targetInput, s.season), s.ignore_for_error)
if s.max_verbosity > 0:
print "MASE {}".format(mase)
if s.implementation == "tf":
sess.close()
return mase
import os
from os import path
from glob import glob
import csv
import scipy as sp
from scipy import random
mypath = path.dirname(path.abspath(__file__))
random.seed(1)
itype_l = ['H', 'B', 'M', 'F']
itype_name_l = ['Head', 'Close-body', 'Medium-body', 'Far-body']
ntrials = 20
nsamples = 75
target_l = glob(path.join(mypath, "Targets/*.jpg"))
distractor_l = glob(path.join(mypath, "Distractors/*.jpg"))
target_d = dict(zip(itype_l,
[[elt for elt in target_l
if path.split(elt)[-1].startswith(itype)
]
for itype in itype_l
]
)
)
distractor_d = dict(zip(itype_l,
[[elt for elt in distractor_l
if path.split(elt)[-1].startswith(itype)
]
def test_gmres(self):
# Ensure repeatability
random.seed(0)
# For these small matrices, Householder and MGS GMRES should give the
# same result, and for symmetric (but possibly indefinite) matrices CR
# and GMRES should give same result
for maxiter in [1, 2, 3]:
for case, symm_case in zip(self.cases, self.symm_cases):
A = case['A']
b = case['b']
x0 = case['x0']
A_symm = symm_case['A']
b_symm = symm_case['b']
x0_symm = symm_case['x0']
# Test agreement between Householder and GMRES
(x, flag) = gmres_householder(A,
b,
x0=x0,
maxiter=min(A.shape[0], maxiter))
(x2, flag2) = gmres_mgs(A,
b,
x0=x0,
maxiter=min(A.shape[0], maxiter))
err_msg = ('Householder GMRES and MGS GMRES gave '
'different results for small matrix')
assert_array_almost_equal(x / norm(x),
x2 / norm(x2),
err_msg=err_msg)
err_msg = ('Householder GMRES and MGS GMRES returned '
'different convergence flags for small matrix')
assert_equal(flag, flag2, err_msg=err_msg)
# Test agreement between GMRES and CR
if A_symm.shape[0] > 1:
residuals2 = []
(x2, flag2) = gmres_mgs(A_symm,
b_symm,
x0=x0_symm,
maxiter=min(A.shape[0], maxiter),
residuals=residuals2)
residuals3 = []
(x3, flag2) = cr(A_symm,
b_symm,
x0=x0_symm,
maxiter=min(A.shape[0], maxiter),
residuals=residuals3)
residuals2 = array(residuals2)
residuals3 = array(residuals3)
err_msg = 'CR and GMRES yield different residual vectors'
assert_array_almost_equal(residuals3 / norm(residuals3),
residuals2 / norm(residuals2),
err_msg=err_msg)
err_msg = 'CR and GMRES yield different answers'
assert_array_almost_equal(x2 / norm(x2),
x3 / norm(x3),
err_msg=err_msg)
