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 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)
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 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)