def hit_or_miss(n, generator_method="pseudo"):
#int -> float (gamma hat), boolean (is relative error below 0.0005)
'''
Receives an integer n that will be used to generate n points
and a random generating method ('pseudo' or 'quasi') and
generate the value of gamma hat, estimation for the integral
of f(x) in the interval [0, 1], and its variance
'''
gamma_hat = 0
hit_or_miss_sequencer = ghalton.GeneralizedHalton(2)
for i in range(n):
if generator_method=="pseudo":
x = np.random.uniform(low=0, high=1)
y = np.random.uniform(low=0, high=1)
else:
two_numbers = hit_or_miss_sequencer.get(1)[0]
x = two_numbers[0]
y = two_numbers[1]
f_x = f(x)
if y <= f_x:
gamma_hat += 1
gamma_hat = gamma_hat/n
variance_gamma_hat = gamma_hat*(1 - gamma_hat)
standard_error = math.sqrt(variance_gamma_hat/n)
relative_error = standard_error/gamma_hat
is_error_below_threshold = True if 1.65*relative_error < 0.0005 else False
return gamma_hat, relative_error, is_error_below_threshold
def setRenderSamples(self, samples):
self.render_samples = samples
self.render_sample_num = 0
self.quad_fs.program['aa_passes'].value = self.render_samples
sequencer = ghalton.GeneralizedHalton(ghalton.EA_PERMS[:2])
self.sampling_points = sequencer.get(samples)
def halton_generator(d):
import ghalton
seed = random.randint(0, 1000)
#sequencer = ghalton.Halton(d)
sequencer = ghalton.GeneralizedHalton(d, seed)
#sequencer.reset()
while True:
[weights] = sequencer.get(1)
yield np.array(weights)
def quasi_gaussian_samples(self):
""" Generate standard Gaussian samples using low-discrepancy Halton seq
with inverse transform """
g = ghalton.GeneralizedHalton(100)
unif = np.array(g.get(int(self.n_steps * self.n_paths / 100) +
1)).flatten()
unif = unif[:self.n_steps * self.n_paths]
z_mat = ndtri(unif).reshape((self.n_steps, self.n_paths))
return z_mat
def _drawCoeff(self, rffKernel, m):
if self.quasiRandom:
perms = ghalton.EA_PERMS[:self.d]
sequencer = ghalton.GeneralizedHalton(perms)
points = np.array(sequencer.get(m+1))[1:]
freqs = rffKernel.invCDF(points)
return freqs / self.sigma.reshape(1, len(self.sigma))
else:
freqs = rffKernel.sampleFreqs((m, self.d))
return freqs / self.sigma.reshape(1, len(self.sigma))
def __init__(self,
connection,
space,
clear_db=False,
random_state=None,
permutations=None,
skip=0):
super(QuasiRandom, self).__init__(connection, space, clear_db)
self.skip = skip
if permutations == "ea":
self.seq = ghalton.GeneralizedHalton(
ghalton.EA_PERMS[:len(self.space)])
elif permutations is not None:
self.seq = ghalton.GeneralizedHalton(permutations)
elif random_state is not None:
self.seq = ghalton.GeneralizedHalton(len(self.space), random_state)
else:
self.seq = ghalton.GeneralizedHalton(len(self.space))
self.drawn = 0
def generate_random_colors():
import colorsys
import ghalton
perms = ghalton.EA_PERMS[:1]
sequencer = ghalton.GeneralizedHalton(perms)
while True:
x = sequencer.get(1)[0][0]
HSV_tuple = (x, 1, 0.6)
rgb_colour = colorsys.hsv_to_rgb(*HSV_tuple)
yield (*rgb_colour, 1.0) # add alpha channel
def __init__(self,
n_frequencies,
dim,
kernel_type=list(kernel_samplers.keys())[0],
noise_stddev=1e-2,
lengthscale=1.,
signal_stddev=1.,
mean_function=None,
dtype=torch.float32,
device=None):
"""
Constructor.
Parameters:
n_frequencies (int): Number of Fourier frequencies to generate
dim (int): Dimensionality of the input domain
kernel_type (str): String specifying which kernel to use (default: 'squared_exponential')
noise_stddev (float or torch.Tensor): Standard deviation for the Gaussian observation noise model
(default: 1e-4)
lengthscale (float or torch.Tensor): Length-scale of the GP kernel (default: 1.0)
signal_stddev (float or torch.Tensor): Signal standard deviation, i.e. a multiplicative scaling factor for
the feature maps (default: 1.0)
mean_function (ssgp.mean_functions.AbstractMeanFunction): GP prior mean function. If None, a zero-mean prior
is used. (default: None)
"""
super().__init__()
self.dtype = dtype
self.device = device
self.dim = dim
self.n_frequencies = n_frequencies
self.noise_stddev = self.ensure_torch(noise_stddev)
perm = gh.EA_PERMS[:dim]
sequencer = gh.GeneralizedHalton(perm)
base_freqs = self.ensure_torch(sequencer.get(int(n_frequencies)))
self.raw_spec = ISSGPR.kernel_samplers[kernel_type](base_freqs)
self._set_lengthscale(lengthscale)
self.signal_stddev = self.ensure_torch(signal_stddev)
self.training_mat = None
self.training_vec = None
self.clear_data()
if mean_function is None:
mean_function = mean_functions.ZeroMean(dtype=self.dtype,
device=self.device)
self.mean_function = mean_function
def init_sequencer(self):
# ---------------------------------------#
# HALTON #
# ---------------------------------------#
if self.sequence_type == QMC_SEQUENCE.HALTON:
if self.scramble_type == QMC_SCRAMBLING.GENERALISED:
if self.qmc_kwargs[QMC_KWARG.PERM] is None:
perm = gh.EA_PERMS[:self.d] # Default permutation
else:
perm = self.qmc_kwargs[QMC_KWARG.PERM]
self.sequencer = gh.GeneralizedHalton(perm)
else:
self.sequencer = gh.Halton(int(self.d))
def calc_grid_v2(cell_resolution, max_min, method='grid', X=None, M=None):
"""
:param cell_resolution: resolution to hinge RBFs as (x_resolution, y_resolution)
:param max_min: realm of the RBF field as (x_min, x_max, y_min, y_max)
:param X: a sample of lidar locations
:return: numpy array of size (# of RNFs, 2) with grid locations
"""
if max_min is None:
# if 'max_min' is not given, make a boundarary based on X
# assume 'X' contains samples from the entire area
expansion_coef = 1.2
x_min, x_max = expansion_coef * X[:, 0].min(
), expansion_coef * X[:, 0].max()
y_min, y_max = expansion_coef * X[:, 1].min(
), expansion_coef * X[:, 1].max()
else:
x_min, x_max = max_min[0], max_min[1]
y_min, y_max = max_min[2], max_min[3]
if method == 'grid': # on a regular grid
xvals = np.arange(x_min, x_max, cell_resolution[0])
yvals = np.arange(y_min, y_max, cell_resolution[1])
xx, yy = np.meshgrid(xvals, yvals)
grid = np.hstack((xx.ravel()[:, np.newaxis], yy.ravel()[:,
np.newaxis]))
else: # sampling
D = 2
if M is None:
xsize = np.int((x_max - x_min) / cell_resolution[0])
ysize = np.int((y_max - y_min) / cell_resolution[1])
M = np.int((x_max - x_min) / cell_resolution[0]) * np.int(
(y_max - y_min) / cell_resolution[1])
if method == 'mc':
grid = np.random.uniform(0, 1, (M, D))
elif method == 'halton':
grid = np.array(gh.Halton(D).get(M))
elif method == 'ghalton':
grid = np.array(gh.GeneralizedHalton(gh.EA_PERMS[:D]).get(int(M)))
elif method == 'sobol':
grid = sobol_gen(D, M, 7)
else:
grid = None
grid[:, 0] = x_min + (x_max - x_min) * grid[:, 0]
grid[:, 1] = y_min + (y_max - y_min) * grid[:, 1]
return grid
def generate_colors(number_required, seed):
"""
Generate a list of length number of distinct "good" random colors
See: https://github.com/fmder/ghalton
Based on http://martin.ankerl.com/2009/12/09/
how-to-create-random-colors-programmatically/
:param number_required: int
:param seed: the random seed
:type: int
:type: int
:rtype: a list of lists in the form: [[243, 137, 121], [232, 121, 243],
[216, 121, 243]]
"""
rgb_list = []
if HALTON is True:
sequencer = ghalton.GeneralizedHalton(3, seed)
points = sequencer.get(int(number_required))
for p in points:
print p
rgb_list.append(p)
else:
golden_ratio_conjugate = 0.618033988749895
random.seed(seed)
h = random.random()
for i in range(0, int(number_required)):
# h = random.random()
h += golden_ratio_conjugate
h %= 1
# h = (random.random()+golden_ratio_conjugate) % 1
rgb = hsv_to_rgb(h, 0.5, 0.6)
rgb = rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0
rgb_list.append(rgb)
return rgb_list
def init_sequence(self):
if self.sequence_type == QMC_SEQUENCE.HALTON:
if self.scramble_type == QMC_SCRAMBLING.OWEN17:
self.points = tf.Variable(
initial_value=tfp.mcmc.sample_halton_sequence(dim=self.D,
num_results=self.N,
dtype=self.tfdt,
randomized=True,
seed=self.seed),
dtype=self.tfdt,
trainable=False)
elif self.scramble_type == QMC_SCRAMBLING.GENERALISED:
if self.qmckwargs[QMC_KWARG.PERM] is None:
perm = gh.EA_PERMS[:self.D] # Default permutation
else:
perm = self.qmckwargs[QMC_KWARG.PERM]
self.sequencer = gh.GeneralizedHalton(perm)
self.points = tf.constant(
np.array(self.sequencer.get(int(self.N))), dtype=self.tfdt)
else:
self.sequencer = gh.Halton(int(self.D))
self.points = tf.constant(
np.array(self.sequencer.get(int(self.N))), dtype=self.tfdt)
def generate_generalized_halton(n: int, d: int):
sequencer = ghalton.GeneralizedHalton(ghalton.EA_PERMS[:d])
return sequencer.get(n)
# Nicholas Gialluca Domene # Número USP 8543417 # Felipe de Moura Ferreira # Número USP 9864702 # 23 de maio de 2021 import math import numpy as np from scipy.stats import beta from scipy.stats.stats import pearsonr import random import datetime import ghalton random_seed = 1 np.random.seed(random_seed) sequencer = ghalton.GeneralizedHalton(1, random_seed) ''' - As an Improvement on your 2nd Programming Exercise, consider replacing the Pseudo Random Number Generator by a Quasi Random Number Generator. - Do your Monte Carlo integration routines work better? Empirically, how faster are now your integration routines? - You should carefully explain how and why you did your empirical analysis and reached your conclusions. ''' def f(x): cpf = 0.45361387819 rg = 0.384850546
# GET CHANNEL FOR GS GENERATION
channel = np.load(channel_path)
channel_im = np.reshape(channel,(image_size,image_size))
plt.imsave(output_dir + channel_name + "_channel.png", channel_im, cmap="gray")
#
print("channel.shape",channel.shape)
channel_mask = channel <= threshold
mask_im = np.reshape(channel_mask, (image_size, image_size))
plt.imsave(output_dir + channel_name + "_channel_mask_thres_" + str(threshold) + ".png", mask_im, cmap="gray")
# Generate 2D Halton points in [0,1] range
# for a given seed
sequencer = ghalton.GeneralizedHalton(2,0)
for i in range(seed+1):
print("sequencer i: ", i)
points = sequencer.get(n_patches)
n_iter=seed
# Halton points in the range of image size
#Se generan tantos Halton points como numero de patches
#Recorro todos los halton points para sacar su primera y segunda
# coordenada y los almaceno en una lista
the_list = [None] * n_patches
for i in range(n_patches):
a= int(points[i][0]*image_size)
b= int(points[i][1]*image_size)
the_list[i] = [a,b]
def generate_points(seed, npoints, dim=2):
sequencer = ghalton.GeneralizedHalton(dim, seed)
return np.asarray(sequencer.get(npoints), dtype='float32')
def generate_halton_weights(d, n):
D = get_D(d, n)
sequencer = ghalton.GeneralizedHalton(d)
points = np.array(sequencer.get(D))
M = norm.ppf(points)
return M, None
from blackscholes import EuropeanOptionPricer
params = {'S': 10, 'K': 9, 'T': 1, 'sigma': 0.10, 'r': 0.06}
# get benchmark
bs = EuropeanOptionPricer(**params)
Ctrue = bs.get_call_premium()
# using Quasi Monte Carlo
factor = params['S'] * np.exp(
(params['r'] - 0.5 * params['sigma']**2) * params['T'])
std = params['sigma'] * math.sqrt(params['T'])
seed = 2000
seqr = ghalton.GeneralizedHalton(1, seed)
# print(seqr)
# print(seqr.get(int(1e2)))
aMList = []
aMError = []
# Quasi Monte Carlo
for M in [1e2, 1e3, 1e4, 1e5, 1e5, 1e6]:
M = int(M)
X = np.array(seqr.get(M))
Z = norm.ppf(X)
factorArray = std * Z
sArray = factor * np.exp(factorArray)
payoffArray = sArray - params['K']
payoffArray[payoffArray < 0] = 0
def halton_generator(d):
import ghalton
# sequencer = ghalton.Halton(d)
sequencer = ghalton.GeneralizedHalton(d, random.randint(0, 1000))
while True:
yield sequencer.get(1)[0]
def quasi_rand_num_generator(n, m, seed=1126):
seqr = ghalton.GeneralizedHalton(n, seed)
X = np.array(seqr.get(m))
return stats.norm.ppf(X).astype(np.float32)
def halton(count=1, dimensionality=2, seed=0):
sequencer = ghalton.GeneralizedHalton(dimensionality, seed)
return np.array(sequencer.get(count))
def halton_sampling(no_random, no_samples):
perm = get_perm_list(no_random)
seq = ghalton.GeneralizedHalton(perm)
return seq.get(no_samples)
