def initialization(self, Ic_image_up):
'''
initialization initializes the sample's transmittance function and the speckle field.
'''
pad = lambda x, pad_y, pad_x: af_pad(x, pad_y, pad_x, 0)
F = lambda x: af.signal.fft2(x)
iF = lambda x: af.signal.ifft2(x)
# Initialization of object and pattern
self.obj = af.constant(1, self.Nc, self.Mc, dtype=af.Dtype.c64)
self.field_p_whole = af.constant(1,
self.Npp,
self.Mpp,
dtype=af.Dtype.c64)
for i in range(0, self.Nimg):
I_temp = af.interop.np_to_af_array((Ic_image_up[0, i])**(1 / 2))
field_p_shift_back = af.arith.maxof(0, af.arith.real(iF(F(pad(pad(I_temp, self.N_bound_pad, self.N_bound_pad),\
self.yshift_max, self.xshift_max))* \
af.arith.exp( -1j*2*np.pi*self.ps*\
(self.fxxp * self.xshift[0,i] +\
self.fyyp * self.yshift[0,i])))))
self.field_p_whole = (self.field_p_whole +
field_p_shift_back / self.Nimg).copy()
def _train(self, X: af.Array, Y: af.Array, alpha: float,
lambda_param: float, penalty: str, maxerr: float,
maxiter: int) -> af.Array:
# Add bias feature
bias = af.constant(1, X.dims()[0], 1)
X_biased = af.join(1, bias, X)
# Initialize parameters to 0
Weights = af.constant(0, X_biased.dims()[1], Y.dims()[1])
for i in range(maxiter):
# Get the cost and gradient
J, dJ = self._cost(Weights, X_biased, Y, lambda_param, penalty)
err = af.max(af.abs(J))
if err < maxerr:
Weights = Weights[1:] # Remove bias weights
return Weights
# Update the weights via gradient descent
Weights = Weights - alpha * dJ
# Remove bias weights
Weights = Weights[1:]
return Weights
def calculate_p_center(p1_start, p2_start, p3_start,
N_p1, N_p2, N_p3,
dp1, dp2, dp3,
):
"""
Initializes the cannonical variables p1, p2 and p3 using a centered
formulation.
"""
p1_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p1_start), dtype = af.Dtype.f64)
p2_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p2_start), dtype = af.Dtype.f64)
p3_center = af.constant(0, N_p1 * N_p2 * N_p3, len(p3_start), dtype = af.Dtype.f64)
# Assigning for each species:
for i in range(len(p1_start)):
p1 = p1_start[i] + (0.5 + np.arange(N_p1)) * dp1[i]
p2 = p2_start[i] + (0.5 + np.arange(N_p2)) * dp2[i]
p3 = p3_start[i] + (0.5 + np.arange(N_p3)) * dp3[i]
p2_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[0]))
p1_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[1]))
p3_center[:, i] = af.flat(af.to_array(np.meshgrid(p2, p1, p3)[2]))
af.eval(p1_center, p2_center, p3_center)
return (p1_center, p2_center, p3_center)
def monte_carlo_options(N,
K,
t,
vol,
r,
strike,
steps,
use_barrier=True,
B=None,
ty=af.Dtype.f32):
payoff = af.constant(0, N, 1, dtype=ty)
dt = t / float(steps - 1)
s = af.constant(strike, N, 1, dtype=ty)
randmat = af.randn(N, steps - 1, dtype=ty)
randmat = af.exp((r - (vol * vol * 0.5)) * dt +
vol * math.sqrt(dt) * randmat)
S = af.product(af.join(1, s, randmat), 1)
if (use_barrier):
S = S * af.all_true(S < B, 1)
payoff = af.maxof(0, S - K)
return af.mean(payoff) * math.exp(-r * t)
def test_surface_term():
'''
A test function to test the surface_term function in the wave_equation
module using analytical Lax-Friedrichs flux.
'''
threshold = 1e-13
params.c = 1
params.N_LGL = 8
params.N_quad = 10
params.N_Elements = 10
wave = 'gaussian'
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
analytical_f_i = (gv.u_init[-1, :])
analytical_f_i_minus1 = (af.shift(gv.u_init[-1, :], 0, 1))
L_p_1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_1[params.N_LGL - 1] = 1
L_p_minus1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_minus1[0] = 1
analytical_surface_term = af.blas.matmul(L_p_1, analytical_f_i)\
- af.blas.matmul(L_p_minus1, analytical_f_i_minus1)
numerical_surface_term = (wave_equation.surface_term(gv.u_init[:, :], gv))
assert af.max(af.abs(analytical_surface_term - numerical_surface_term)) \
< threshold
return analytical_surface_term
def setUpdateParams(self, flag_update = None, pupil_step_size = None, update_method = None, global_update = False, \
measurement_num = None, \
pupil = None, pupil_support = None):
"""Modify update parameters for pupil"""
if pupil is not None: self.setPupil(pupil=pupil)
if pupil_support is not None: self.setPupilSupport(pupil_support)
self.flag_update = flag_update if flag_update is not None else self.flag_update
if self.flag_update:
self.update_method = update_method if update_method is not None else self.update_method
self.pupil_step_size = pupil_step_size if pupil_step_size is not None else self.pupil_step_size
self.pupil_gradient_amp = af.constant(0.0,
self.shape[0],
self.shape[1],
dtype=af_complex_datatype)
self.pupil_gradient_phase = af.constant(0.0,
self.shape[0],
self.shape[1],
dtype=af_complex_datatype)
self.measurement_num = measurement_num if global_update else 1
self.measure_count = 0
if self.update_method == "GaussNewton":
self.approx_hessian = af.constant(0.0,
self.shape[0],
self.shape[1],
dtype=af_complex_datatype)
def _meanObject(self, obj, adjoint=False):
"""
function to bin the object by factor of slice_binning_factor
"""
if self.slice_binning_factor == 1:
return obj
assert self.shape[2] >= 1
if adjoint:
obj_out = af.constant(0.0,
self._shape_full[0],
self._shape_full[1],
self._shape_full[2],
dtype=af_complex_datatype)
for idx in range((self.shape[2] - 1) * self.slice_binning_factor,
-1, -self.slice_binning_factor):
idx_slice = slice(
idx,
np.min([obj_out.shape[2],
idx + self.slice_binning_factor]))
obj_out[:, :, idx_slice] = af.broadcast(
self.assign_broadcast, obj_out[:, :, idx_slice],
obj[:, :, idx // self.slice_binning_factor])
else:
obj_out = af.constant(0.0,
self.shape[0],
self.shape[1],
self.shape[2],
dtype=af_complex_datatype)
for idx in range(0, obj.shape[2], self.slice_binning_factor):
idx_slice = slice(
idx,
np.min([obj.shape[2], idx + self.slice_binning_factor]))
obj_out[:, :, idx // self.slice_binning_factor] = af.mean(
obj[:, :, idx_slice], dim=2)
return obj_out
def af_pad(image, NN, MM, val):
'''
af_pad is a short-cut function to constant-pad a 2D array with arrayfire arrays
Inputs:
image : a 2D array needed to be padded
NN : number of pixels padded in each side of dimension 0
MM : number of pixels padded in each side of dimension 1
Outputs:
image_pad : the padded 2D array
'''
N, M = image.shape
Np = N + 2 * NN
Mp = M + 2 * MM
if image.dtype() == af.Dtype.f32 or image.dtype() == af.Dtype.f64:
image_pad = af.constant(val, Np, Mp)
else:
image_pad = af.constant(val * (1 + 1j * 0), Np, Mp)
image_pad[NN:NN + N, MM:MM + M] = image
return image_pad
def test_surface_term():
'''
A test function to test the surface_term function in the wave_equation
module using analytical Lax-Friedrichs flux.
'''
threshold = 1e-13
params.c = 1
change_parameters(8, 10, 8, 'gaussian')
analytical_f_i = (params.u[-1, :, 0])
analytical_f_i_minus1 = (af.shift(params.u[-1, :, 0], 0, 1))
L_p_1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_1[params.N_LGL - 1] = 1
L_p_minus1 = af.constant(0, params.N_LGL, dtype=af.Dtype.f64)
L_p_minus1[0] = 1
analytical_surface_term = af.blas.matmul(L_p_1, analytical_f_i)\
- af.blas.matmul(L_p_minus1, analytical_f_i_minus1)
numerical_surface_term = (wave_equation.surface_term(params.u[:, :, 0]))
assert af.max(af.abs(analytical_surface_term - numerical_surface_term)) \
< threshold
return analytical_surface_term
def test_dirichlet():
obj = test('dirichlet', 'dirichlet')
obj._A_q1, obj._A_q2 = af.Array([100]), af.Array([100])
obj._A_q1 = af.tile(obj._A_q1, 1, 1, obj.q1_center.shape[2])
obj._A_q2 = af.tile(obj._A_q2, 1, 1, obj.q1_center.shape[2])
obj.dt = 0.001
obj.f = af.constant(0,
obj.q1_center.shape[0],
obj.q1_center.shape[1],
obj.q1_center.shape[2],
dtype=af.Dtype.f64)
apply_bcs_f(obj)
expected = af.constant(0,
obj.q1_center.shape[0],
obj.q1_center.shape[1],
obj.q1_center.shape[2],
dtype=af.Dtype.f64)
N_g = obj.N_ghost
# Only ingoing characteristics should be affected:
expected[:N_g] = af.select(obj.q1_center < obj.q1_start, 1, expected)[:N_g]
expected[:, :N_g] = af.select(obj.q2_center < obj.q2_start, 2,
expected)[:, :N_g]
assert (af.max(af.abs(obj.f[:, N_g:-N_g] - expected[:, N_g:-N_g])) < 5e-14)
assert (af.max(af.abs(obj.f[N_g:-N_g, :] - expected[N_g:-N_g, :])) < 5e-14)
def simple_data(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
display_func(af.constant(100, 3,3, dtype=af.Dtype.f32))
display_func(af.constant(25, 3,3, dtype=af.Dtype.c32))
display_func(af.constant(2**50, 3,3, dtype=af.Dtype.s64))
display_func(af.constant(2+3j, 3,3))
display_func(af.constant(3+5j, 3,3, dtype=af.Dtype.c32))
display_func(af.range(3, 3))
display_func(af.iota(3, 3, tile_dims=(2,2)))
display_func(af.identity(3, 3, 1, 2, af.Dtype.b8))
display_func(af.identity(3, 3, dtype=af.Dtype.c32))
a = af.randu(3, 4)
b = af.diag(a, extract=True)
c = af.diag(a, 1, extract=True)
display_func(a)
display_func(b)
display_func(c)
display_func(af.diag(b, extract = False))
display_func(af.diag(c, 1, extract = False))
display_func(af.join(0, a, a))
display_func(af.join(1, a, a, a))
display_func(af.tile(a, 2, 2))
display_func(af.reorder(a, 1, 0))
display_func(af.shift(a, -1, 1))
display_func(af.moddims(a, 6, 2))
display_func(af.flat(a))
display_func(af.flip(a, 0))
display_func(af.flip(a, 1))
display_func(af.lower(a, False))
display_func(af.lower(a, True))
display_func(af.upper(a, False))
display_func(af.upper(a, True))
a = af.randu(5,5)
display_func(af.transpose(a))
af.transpose_inplace(a)
display_func(a)
display_func(af.select(a > 0.3, a, -0.3))
af.replace(a, a > 0.3, -0.3)
display_func(a)
def simple_data(verbose=False):
display_func = _util.display_func(verbose)
display_func(af.constant(100, 3, 3, dtype=af.Dtype.f32))
display_func(af.constant(25, 3, 3, dtype=af.Dtype.c32))
display_func(af.constant(2**50, 3, 3, dtype=af.Dtype.s64))
display_func(af.constant(2+3j, 3, 3))
display_func(af.constant(3+5j, 3, 3, dtype=af.Dtype.c32))
display_func(af.range(3, 3))
display_func(af.iota(3, 3, tile_dims=(2, 2)))
display_func(af.identity(3, 3, 1, 2, af.Dtype.b8))
display_func(af.identity(3, 3, dtype=af.Dtype.c32))
a = af.randu(3, 4)
b = af.diag(a, extract=True)
c = af.diag(a, 1, extract=True)
display_func(a)
display_func(b)
display_func(c)
display_func(af.diag(b, extract=False))
display_func(af.diag(c, 1, extract=False))
display_func(af.join(0, a, a))
display_func(af.join(1, a, a, a))
display_func(af.tile(a, 2, 2))
display_func(af.reorder(a, 1, 0))
display_func(af.shift(a, -1, 1))
display_func(af.moddims(a, 6, 2))
display_func(af.flat(a))
display_func(af.flip(a, 0))
display_func(af.flip(a, 1))
display_func(af.lower(a, False))
display_func(af.lower(a, True))
display_func(af.upper(a, False))
display_func(af.upper(a, True))
a = af.randu(5, 5)
display_func(af.transpose(a))
af.transpose_inplace(a)
display_func(a)
display_func(af.select(a > 0.3, a, -0.3))
af.replace(a, a > 0.3, -0.3)
display_func(a)
display_func(af.pad(a, (1, 1, 0, 0), (2, 2, 0, 0)))
def simple_device(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
print_func(af.device_info())
print_func(af.get_device_count())
print_func(af.is_dbl_supported())
af.sync()
curr_dev = af.get_device()
print_func(curr_dev)
for k in range(af.get_device_count()):
af.set_device(k)
dev = af.get_device()
assert(k == dev)
print_func(af.is_dbl_supported(k))
af.device_gc()
mem_info_old = af.device_mem_info()
a = af.randu(100, 100)
af.sync(dev)
mem_info = af.device_mem_info()
assert(mem_info['alloc']['buffers'] == 1 + mem_info_old['alloc']['buffers'])
assert(mem_info[ 'lock']['buffers'] == 1 + mem_info_old[ 'lock']['buffers'])
af.set_device(curr_dev)
a = af.randu(10,10)
display_func(a)
dev_ptr = af.get_device_ptr(a)
print_func(dev_ptr)
b = af.Array(src=dev_ptr, dims=a.dims(), dtype=a.dtype(), is_device=True)
display_func(b)
c = af.randu(10,10)
af.lock_array(c)
af.unlock_array(c)
a = af.constant(1, 3, 3)
b = af.constant(2, 3, 3)
af.eval(a)
af.eval(b)
print_func(a)
print_func(b)
c = a + b
d = a - b
af.eval(c, d)
print_func(c)
print_func(d)
print_func(af.set_manual_eval_flag(True))
assert(af.get_manual_eval_flag() == True)
print_func(af.set_manual_eval_flag(False))
assert(af.get_manual_eval_flag() == False)
display_func(af.is_locked_array(a))
def relu(image):
#TODO: Remove assumption of image.dims()[3] == 1
if len(image.dims()) is 1:
return af.maxof(image, af.constant(0, image.dims()[0]))
elif len(image.dims()) is 3:
d0, d1, d2 = image.dims()
return af.maxof(image, af.constant(0, d0, d1, d2))
print "error, bad val num dims"
return
def Get_Linear_Equation_Gpu(x,
weight,
bin_data_num,
bin_data_y,
r,
dtype='f4'):
n, p = x.shape
d = p - 1
if dtype is 'f4':
dtype = af.Dtype.f32
elif dtype is 'f8':
dtype = af.Dtype.f64
xw = af.constant(0, n, p, dtype=dtype)
for ii in af.ParallelRange(p):
xw[:, ii] = x[:, ii] * weight
s = af.constant(0, p, p, np.prod(bin_data_num.shape), dtype=dtype)
t = af.constant(0, p, np.prod(bin_data_num.shape), dtype=dtype)
ker_d = np.ones(4, dtype='int')
ker_d[:d] = 2 * r + 1
if d is 4:
for i in range(p):
for j in range(i, p):
if i is 0:
kernel = af.moddims(xw[:, j], ker_d[0], ker_d[1], ker_d[2],
ker_d[3])
t[j] = af.flat(
af.reorder(Convolve4(bin_data_y, kernel), 3, 2, 1, 0))
else:
kernel = af.moddims(xw[:, i] * x[:, j], ker_d[0], ker_d[1],
ker_d[2], ker_d[3])
s[i, j] = af.flat(
af.reorder(Convolve4(bin_data_num, kernel), 3, 2, 1, 0))
s[j, i] = s[i, j]
elif d < 4:
for i in range(p):
for j in range(i, p):
if i is 0:
kernel = af.moddims(xw[:, j], ker_d[0], ker_d[1], ker_d[2],
ker_d[3])
if kernel.elements() is 1:
t[j] = af.flat((bin_data_y * kernel.to_list()[0]).T)
else:
t[j] = af.flat(af.fft_convolve(bin_data_y, kernel).T)
else:
kernel = af.moddims(xw[:, i] * x[:, j], ker_d[0], ker_d[1],
ker_d[2], ker_d[3])
if kernel.elements() is 1:
s[i, j] = af.flat((bin_data_num * kernel.to_list()[0]).T)
else:
s[i, j] = af.flat(af.fft_convolve(bin_data_num, kernel).T)
s[j, i] = s[i, j]
for i in range(1, p):
s[i, i] += 1e-12
return ([
np.array(s).reshape(p**2, -1).T.reshape(-1, p, p),
np.array(af.flat(t))
])
def arrayfire_perceptron_demo(dataset, num_classes=None):
# Determine number of classes if not provided
if num_classes is None:
num_classes = np.amax(dataset[1] + 1)
# Convert numpy array to af array (and convert labels/targets from ints to
# one-hot encodings)
train_feats = af.from_ndarray(dataset[0])
train_targets = af.from_ndarray(ints_to_onehots(dataset[1], num_classes))
test_feats = af.from_ndarray(dataset[2])
test_targets = af.from_ndarray(ints_to_onehots(dataset[3], num_classes))
num_train = train_feats.dims()[0]
num_test = test_feats.dims()[0]
# Add bias
train_bias = af.constant(1, num_train, 1)
test_bias = af.constant(1, num_test, 1)
train_feats = af.join(1, train_bias, train_feats)
test_feats = af.join(1, test_bias, test_feats)
print('arrayfire perceptron classifier implementation')
clf = AfPerceptron(alpha=0.1, maxerr=0.01, maxiter=1000, verbose=False)
# Initial run to avoid overhead in training
clf.train(train_feats, train_targets)
clf.init_weights(train_feats, train_targets)
# Benchmark training
t0 = time.time()
clf.train(train_feats, train_targets)
clf.eval()
t1 = time.time()
dt_train = t1 - t0
print('Training time: {0:4.4f} s'.format(dt_train))
# Benchmark prediction
iters = 100
test_outputs = None
t0 = time.time()
for i in range(iters):
test_outputs = clf.predict_proba(test_feats)
af.eval(test_outputs)
af.sync()
t1 = time.time()
dt = t1 - t0
print('Prediction time: {0:4.4f} s'.format(dt / iters))
print('Accuracy (test data): {0:2.2f}'.format(
accuracy(test_outputs, test_targets)))
# print('Accuracy on training data: {0:2.2f}'.format(accuracy(train_outputs, train_targets)))
# print('Accuracy on testing data: {0:2.2f}'.format(accuracy(test_outputs, test_targets)))
# print('Maximum error on testing data: {0:2.2f}'.format(abserr(test_outputs, test_targets)))
return clf, dt_train
def forward(nn_np, data):
"""
Given a dictionary representing a feed forward neural net and an input data matrix compute the network's output and store it within the dictionary
:param nn: neural network dictionary
:param data: a numpy n by m matrix where m in the number of input units in nn
:return: the output layer activations
"""
nn = nn_np
nn['activations'] = []
#prct = []
#prct.append(data[0][0])
#prct.append(data[1][0])
#src = data.astype(float)
nsrc = data#af.Array(prct)
nn['activations'].append(nsrc)
#(af.Array(src.ctypes.data, src.shape, src.dtype.char))
nn['zs'] = []
for w, s, b in map(None, nn['weights'], nn['nonlin'], nn['biases']):
#:wq
#print af.transpose(nn['activations'][-1])
#print(type(nn['activations'][0]))
#print(nn['activations'][0])
z = af.matmul(w, nn['activations'][-1])
#for i in range(w.shape[1]-1):
# newB = af.join(1,newB,b)
p = z.T + b
nn['zs'].append(p.T)
if len(p.shape) == 2:
maxVal = af.constant(1e-5,p.shape[0],p.shape[1]).T
else:
maxVal = af.constant(1e-5,p.shape[0]).T
q = af.maxof(p.T,1e-5)#p(i) = 1e-5
nn['activations'].append(q)
return nn['activations'][-1]
def af_pad(image, NN, MM, val):
N, M = image.shape
Np = N + 2 * NN
Mp = M + 2 * MM
if image.dtype() == af.Dtype.f32 or image.dtype() == af.Dtype.f64:
image_pad = af.constant(val, Np, Mp)
else:
image_pad = af.constant(val * (1 + 1j * 0), Np, Mp)
image_pad[NN:NN + N, MM:MM + M] = image
return image_pad
def _dense_fit(self, X, strategy, missing_values, fill_value):
"""Fit the transformer on dense data."""
mask = _get_mask(X, missing_values)
X_np = X.to_ndarray()
masked_X = ma.masked_array(X_np, mask=np.isnan(X_np)) # FIXME
# Mean
if strategy == "mean":
mean_masked = ma.mean(masked_X, axis=0)
# Avoid the warning "Warning: converting a masked element to nan."
mean = ma.getdata(mean_masked)
mean[ma.getmask(mean_masked)] = np.nan
return mean
# Median
elif strategy == "median":
median_masked = ma.median(masked_X, axis=0)
# Avoid the warning "Warning: converting a masked element to nan."
median = ma.getdata(median_masked)
median[ma.getmaskarray(median_masked)] = np.nan
return median
# Most frequent
elif strategy == "most_frequent":
# Avoid use of scipy.stats.mstats.mode due to the required
# additional overhead and slow benchmarking performance.
# See Issue 14325 and PR 14399 for full discussion.
# To be able access the elements by columns
X = X.T
mask = mask.T
npdtype = typemap(X.dtype())
if npdtype.kind == "O":
most_frequent = af.constant(0, X.shape[0], dtype=object)
else:
most_frequent = af.constant(0, X.shape[0])
for i, (row, row_mask) in enumerate(zip(X[:], mask[:])):
row_mask = row_mask.logical_not()
row = row[row_mask].to_ndarray()
#most_frequent[i] = _most_frequent(row, np.nan, 0)
most_frequent[i] = _most_frequent(row, np.nan, 0)
return most_frequent
# Constant
elif strategy == "constant":
# for constant strategy, self.statistcs_ is used to store
# fill_value in each column
return af.constant(fill_value, X.shape[1], dtype=X.dtype())
def conv(weights, biases, image, wx, wy, sx = 1, sy = 1, px = 0, py = 0, groups = 1):
image = __pad(image, px, py)
batch = util.num_input(image)
n_filters = util.num_filters(weights)
n_channel = util.num_channels(weights)
w_i = image.dims()[0]
h_i = image.dims()[1]
w_o = (w_i - wx) / sx + 1
h_o = (h_i - wy) / sy + 1
tiles = af.unwrap(image, wx, wy, sx, sy)
weights = af.moddims(weights, wx*wy, n_channel, n_filters)
out = af.constant(0, batch, n_filters, w_o, h_o)
if groups > 1:
out = af.constant(0, w_o, h_o, n_filters, batch)
split_in = util.num_channels(image) / groups
s_i = split_in
split_out = n_filters / groups
s_o = split_out
for i in xrange(groups):
weights_slice = af.moddims(weights[:,:,i*s_o:(i+1)*s_o],
wx, wy, n_channel, split_out)
biases_slice = biases[i*s_o:(i+1)*s_o]
image_slice = image[:,:,i*s_i:(i+1)*s_i]
out[:,:,i*s_o:(i+1)*s_o] = conv(weights_slice,
biases_slice,
image_slice,
wx, wy, sx, sy, 0, 0, 1)
# out[:,i*s_o:(i+1)*s_o] = conv(weights_slice,
# biases_slice,
# image_slice,
# wx, wy, sx, sy, 0, 0, 1)
return out
#TODO: Speedup this section
for f in xrange(n_filters):
for d in xrange(n_channel):
tile_d = af.reorder(tiles[:,:,d],1,0)
weight_d = weights[:,d,f]
out[0,f] += af.moddims(af.matmul(tile_d, weight_d), 1,1, w_o, h_o)
out[0,f] += biases[f].to_list()[0]
return af.reorder(out, 2, 3, 1, 0)
def sparse_matrix(n, Lambda, projection='false'):
if projection == 'false':
em1 = af.constant(-1, n**2)
em1[n - 1:n**2:n] = 0
ep1 = af.constant(-1, n**2)
ep1[n:n**2:n] = 0
sp_matrix = af.identity(n**2, n**2,
dtype=af.Dtype.f64) * (1 - 4 * Lambda)
sp_matrix[n:, :-n] += Lambda * af.identity(n**2 - n, n**2 - n)
sp_matrix[:-n, n:] += Lambda * af.identity(n**2 - n, n**2 - n)
for i in range(n**2):
for j in range(n**2):
if (i == j + 1):
sp_matrix[i, j] -= Lambda * em1[j]
if (i == j - 1):
sp_matrix[i, j] -= Lambda * ep1[j]
if projection == 'true':
sp_matrix = af.constant(0, n**2, n**2,
dtype=af.Dtype.f64) * (1 - 4 * Lambda)
ep1 = af.constant(1, n**2, 1, dtype=af.Dtype.f64)
ep1[n:n**2:n] = 0
ep1[1:n**2:n] = 2
epn = af.constant(1, n**2, 1, dtype=af.Dtype.f64)
epn[0:2 * n] = 2
em1 = af.constant(1, n**2, 1, dtype=af.Dtype.f64)
em1[n - 1:n**2:n] = 0
em1[n - 2:n**2:n] = 2
emn = af.constant(1, n**2, 1, dtype=af.Dtype.f64)
emn[n**2 - 2 * n:n**2] = 2
d = af.constant(-4, n**2, 1, dtype=af.Dtype.f64)
for i in range(n**2):
for j in range(n**2):
if (i == j):
sp_matrix[i, j] = d[i]
if (i == j + 1):
sp_matrix[i, j] = em1[j]
if (i == j + n):
sp_matrix[i, j] = emn[j]
if (i == j - 1):
sp_matrix[i, j] = ep1[i + 1]
if (i == j - n):
sp_matrix[i, j] = epn[i + n]
sp_matrix *= Lambda
sp_matrix[-1, :] = 0
sp_matrix[-1, -1] = 1
return sp_matrix
def Convolve4(signal, kernel):
if kernel.elements() is 1:
return(signal * kernel.to_list()[0])
signal_d = signal.shape
if len(kernel.shape) is 3:
out = af.constant(0, signal_d[0], signal_d[1], signal_d[2], signal_d[3])
for i in range(signal.shape[3]):
out[:, :, :, i] = af.fft_convolve3(signal[:, :, :, i], kernel)
return(out)
extend_space = kernel.shape[3] - 1
out = af.constant(0, signal_d[0], signal_d[1], signal_d[2], signal_d[3] + extend_space)
for i in range(extend_space + 1):
for j in range(signal.shape[3]):
out[:, :, :, i + j] = out[:, :, :, i + j] + af.fft_convolve3(signal[:, :, :, j], kernel[:, :, :, i])
return(out[:, :, :, (extend_space / 2):(-extend_space / 2)])
def kernel_gen(self, lambda_f, NA_obj, NAs):
'''
kernel_gen generates the required filter for the algorithm, including the OTF
and the Fourier support of the object, speckle and the OTF.
'''
# Compute transfer function
Pupil_obj = np.zeros((self.Nc,self.Mc))
frc = (self.fxx_c**2 + self.fyy_c**2)**(1/2)
Pupil_obj[frc<NA_obj/lambda_f] = 1
T_incoherent = abs(fft2(abs(ifft2(Pupil_obj))**2))
self.T_incoherent = T_incoherent/np.max(T_incoherent)
self.T_incoherent = af.interop.np_to_af_array(self.T_incoherent)
# Compute support function
self.Pattern_support = af.constant(0, self.Npp, self.Mpp, dtype=af.Dtype.f64)
frp = (self.fxxp**2 + self.fyyp**2)**(1/2)
self.Pattern_support[frp<2*NAs/lambda_f] = 1
self.Object_support = np.zeros((self.Nc,self.Mc))
self.Object_support[frc<2*(NA_obj+NAs)/lambda_f] = 1
self.Object_support = af.interop.np_to_af_array(self.Object_support)
self.OTF_support = np.zeros((self.Nc,self.Mc))
self.OTF_support[frc<2*NA_obj/lambda_f] = 1
self.OTF_support = af.interop.np_to_af_array(self.OTF_support)
def main():
T = 1
nT = 20 * T
R_first = 1000
R = 5000000
x0 = 0 # initial log stock price
v0 = 0.087**2 # initial volatility
r = math.log(1.0319) # risk-free rate
rho = -0.82 # instantaneous correlation between Brownian motions
sigmaV = 0.14 # variance of volatility
kappa = 3.46 # mean reversion speed
vBar = 0.008 # mean variance
k = math.log(0.95) # strike price
# first run
( x, v ) = simulateHestonModel( T, nT, R_first, r, kappa, vBar, sigmaV, rho, x0, v0 )
# Price plain vanilla call option
tic = time.time()
( x, v ) = simulateHestonModel( T, nT, R, r, kappa, vBar, sigmaV, rho, x0, v0 )
af.sync()
toc = time.time() - tic
K = math.exp(k)
zeroConstant = af.constant(0, R, dtype=af.Dtype.f32)
C_CPU = math.exp(-r * T) * af.mean(af.maxof(af.exp(x) - K, zeroConstant))
print("Time elapsed = {} secs".format(toc))
print("Call price = {}".format(C_CPU))
print(af.mean(v))
def main():
T = 1
nT = 20 * T
R_first = 1000
R = 5000000
x0 = 0 # initial log stock price
v0 = 0.087**2 # initial volatility
r = math.log(1.0319) # risk-free rate
rho = -0.82 # instantaneous correlation between Brownian motions
sigmaV = 0.14 # variance of volatility
kappa = 3.46 # mean reversion speed
vBar = 0.008 # mean variance
k = math.log(0.95) # strike price
# first run
(x, v) = simulateHestonModel(T, nT, R_first, r, kappa, vBar, sigmaV, rho,
x0, v0)
# Price plain vanilla call option
tic = time.time()
(x, v) = simulateHestonModel(T, nT, R, r, kappa, vBar, sigmaV, rho, x0, v0)
af.sync()
toc = time.time() - tic
K = math.exp(k)
zeroConstant = af.constant(0, R, dtype=af.Dtype.f32)
C_CPU = math.exp(-r * T) * af.mean(af.maxof(af.exp(x) - K, zeroConstant))
print("Time elapsed = {} secs".format(toc))
print("Call price = {}".format(C_CPU))
print(af.mean(v))
def __init__(self):
self.q1_start = 0
self.q2_start = 0
self.q1_end = 1
self.q2_end = 1
self.N_q1 = 1024
self.N_q2 = 1024
self.dq1 = (self.q1_end - self.q1_start) / self.N_q1
self.dq2 = (self.q2_end - self.q2_start) / self.N_q2
self.N_ghost = self.N_g = np.random.randint(3, 5)
self.q1_center, self.q2_center = \
calculate_q_center(self.q1_start, self.q2_start,
self.N_q1, self.N_q2, self.N_ghost,
self.dq1, self.dq2
)
self.params = type('obj', (object, ), {'eps':1})
self.cell_centered_EM_fields = af.constant(0, 6, 1,
self.q1_center.shape[2],
self.q1_center.shape[3],
dtype=af.Dtype.f64
)
self._comm = PETSc.COMM_WORLD.tompi4py()
self.performance_test_flag = False
def nn_build(seed, layerlist, nonlin='sigmoid', eta=0.01, init='glorot'):
"""
Returns a neural network of given architecture
:param layerlist: a list of number of neurons in each layer starting with input and ending with output
:param nonlin: nonlinearity which is either 'sigmoid', 'tanh', or 'ReLU'
:return: a dictionary with neural network parameters
"""
nn = {}
nn['eta'] = eta
nn['weights'] = []
weights = []
biases = []
nn['biases'] = []
nn['nonlin'] = []
for i in range(len(layerlist) - 1):
nn['weights'].append(
weight_matrix(seed,
layerlist[i],
layerlist[i + 1],
layer=i,
type=init))
nn['biases'].append(af.constant(1, 1, layerlist[i + 1]) * 0.1)
nn['nonlin'].append(activate(nonlin))
#nn['weights'] = weights
#nn['biases'] = biases
#addadadelta(nn)
return nn
def monte_carlo_options(N, K, t, vol, r, strike, steps, use_barrier = True, B = None, ty = af.Dtype.f32):
payoff = af.constant(0, N, 1, dtype = ty)
dt = t / float(steps - 1)
s = af.constant(strike, N, 1, dtype = ty)
randmat = af.randn(N, steps - 1, dtype = ty)
randmat = af.exp((r - (vol * vol * 0.5)) * dt + vol * math.sqrt(dt) * randmat);
S = af.product(af.join(1, s, randmat), 1)
if (use_barrier):
S = S * af.all_true(S < B, 1)
payoff = af.maxof(0, S - K)
return af.mean(payoff) * math.exp(-r * t)
def __init__(self):
self.q1_start = np.random.randint(0, 5)
self.q2_start = np.random.randint(0, 5)
self.q1_end = np.random.randint(5, 10)
self.q2_end = np.random.randint(5, 10)
self.N_q1 = np.random.randint(16, 32)
self.N_q2 = np.random.randint(16, 32)
self.dq1 = (self.q1_end - self.q1_start) / self.N_q1
self.dq2 = (self.q2_end - self.q2_start) / self.N_q2
N_g = self.N_ghost = np.random.randint(1, 5)
self.q1 = self.q1_start \
* (0.5 + np.arange(-self.N_ghost,
self.N_q1 + self.N_ghost
)
) * self.dq1
self.q2 = self.q2_start \
* (0.5 + np.arange(-self.N_ghost,
self.N_q2 + self.N_ghost
)
) * self.dq2
self.q2, self.q1 = np.meshgrid(self.q2, self.q1)
self.q1, self.q2 = af.to_array(self.q1), af.to_array(self.q2)
self.q1 = af.reorder(self.q1, 2, 0, 1)
self.q2 = af.reorder(self.q2, 2, 0, 1)
self.q1 = af.tile(self.q1, 6)
self.q2 = af.tile(self.q2, 6)
self._da_fields = PETSc.DMDA().create([self.N_q1, self.N_q2],
dof=6,
stencil_width=self.N_ghost,
boundary_type=('periodic',
'periodic'),
stencil_type=1,
)
self._glob_fields = self._da_fields.createGlobalVec()
self._local_fields = self._da_fields.createLocalVec()
self._glob_fields_array = self._glob_fields.getArray()
self._local_fields_array = self._local_fields.getArray()
self.cell_centered_EM_fields = af.constant(0, 6, self.q1.shape[1],
self.q1.shape[2],
dtype=af.Dtype.f64
)
self.cell_centered_EM_fields[:, N_g:-N_g, N_g:-N_g] = \
af.sin(2 * np.pi * self.q1 + 4 * np.pi * self.q2)[:, N_g:-N_g,N_g:-N_g]
self.performance_test_flag = False
def train(X,
Y,
alpha=0.1,
lambda_param=1.0,
maxerr=0.01,
maxiter=1000,
verbose=False):
# Initialize parameters to 0
Weights = af.constant(0, X.dims()[1], Y.dims()[1])
for i in range(maxiter):
# Get the cost and gradient
J, dJ = cost(Weights, X, Y, lambda_param)
err = af.max(af.abs(J))
if err < maxerr:
print('Iteration {0:4d} Err: {1:4f}'.format(i + 1, err))
print('Training converged')
return Weights
if verbose and ((i + 1) % 10 == 0):
print('Iteration {0:4d} Err: {1:4f}'.format(i + 1, err))
# Update the parameters via gradient descent
Weights = Weights - alpha * dJ
if verbose:
print('Training stopped after {0:d} iterations'.format(maxiter))
return Weights
def cost(Weights, X, Y, lambda_param=1.0):
# Number of samples
m = Y.dims()[0]
dim0 = Weights.dims()[0]
dim1 = Weights.dims()[1] if len(Weights.dims()) > 1 else None
dim2 = Weights.dims()[2] if len(Weights.dims()) > 2 else None
dim3 = Weights.dims()[3] if len(Weights.dims()) > 3 else None
# Make the lambda corresponding to Weights(0) == 0
lambdat = af.constant(lambda_param, dim0, dim1, dim2, dim3)
# No regularization for bias weights
lambdat[0, :] = 0
# Get the prediction
H = predict_prob(X, Weights)
# Cost of misprediction
Jerr = -1 * af.sum(Y * af.log(H) + (1 - Y) * af.log(1 - H), dim=0)
# Regularization cost
Jreg = 0.5 * af.sum(lambdat * Weights * Weights, dim=0)
# Total cost
J = (Jerr + Jreg) / m
# Find the gradient of cost
D = (H - Y)
dJ = (af.matmulTN(X, D) + lambdat * Weights) / m
return J, dJ
def forward(nn_np, data):
"""
Given a dictionary representing a feed forward neural net and an input data matrix compute the network's output and store it within the dictionary
:param nn: neural network dictionary
:param data: a numpy n by m matrix where m in the number of input units in nn
:return: the output layer activations
"""
nn = nn_np
nn['activations'] = []
#prct = []
#prct.append(data[0][0])
#prct.append(data[1][0])
#src = data.astype(float)
nsrc = data #af.Array(prct)
nn['activations'].append(nsrc)
#(af.Array(src.ctypes.data, src.shape, src.dtype.char))
nn['zs'] = []
for w, s, b in map(None, nn['weights'], nn['nonlin'], nn['biases']):
#:wq
#print af.transpose(nn['activations'][-1])
#print(type(nn['activations'][0]))
#print(nn['activations'][0])
z = af.matmul(w, nn['activations'][-1])
#for i in range(w.shape[1]-1):
# newB = af.join(1,newB,b)
p = z.T + b
nn['zs'].append(p.T)
if len(p.shape) == 2:
maxVal = af.constant(1e-5, p.shape[0], p.shape[1]).T
else:
maxVal = af.constant(1e-5, p.shape[0]).T
q = af.maxof(p.T, 1e-5) #p(i) = 1e-5
nn['activations'].append(q)
return nn['activations'][-1]
def adjoint(self, residual):
if len(residual.shape) > 2:
field_pad = af.constant(0.0,
self.shape[0],
self.shape[1],
residual.shape[2],
dtype=af_complex_datatype)
for z_idx in range(field_pad.shape[2]):
field_pad[self.row_crop, self.col_crop,
z_idx] = residual[:, :, z_idx] + 0.0j
else:
field_pad = af.constant(0.0,
self.shape[0],
self.shape[1],
dtype=af_complex_datatype)
field_pad[self.row_crop, self.col_crop] = residual + 0.0j
return field_pad
def __init__(self,
params,
learning_rate_init=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-8):
super().__init__(params, learning_rate_init)
self.beta_1 = beta_1
self.beta_2 = beta_2
self.epsilon = epsilon
self.t = 0
dims_list = [paddims2(param.dims()) for param in params]
self.ms = [af.constant(0, dim[0], dim[1]) for dim in dims_list]
self.vs = [af.constant(0, dim[0], dim[1]) for dim in dims_list]
def simulateHestonModel( T, N, R, mu, kappa, vBar, sigmaV, rho, x0, v0 ) :
deltaT = T / (float)(N - 1)
x = [af.constant(x0, R, dtype=af.Dtype.f32), af.constant(0, R, dtype=af.Dtype.f32)]
v = [af.constant(v0, R, dtype=af.Dtype.f32), af.constant(0, R, dtype=af.Dtype.f32)]
sqrtDeltaT = math.sqrt(deltaT)
sqrtOneMinusRhoSquare = math.sqrt(1-rho**2)
m = af.constant(0, 2, dtype=af.Dtype.f32)
m[0] = rho
m[1] = sqrtOneMinusRhoSquare
zeroArray = af.constant(0, R, 1, dtype=af.Dtype.f32)
for t in range(1, N) :
tPrevious = (t + 1) % 2
tCurrent = t % 2
dBt = af.randn(R, 2, dtype=af.Dtype.f32) * sqrtDeltaT
vLag = af.maxof(v[tPrevious], zeroArray)
sqrtVLag = af.sqrt(vLag)
x[tCurrent] = x[tPrevious] + (mu - 0.5 * vLag) * deltaT + sqrtVLag * dBt[:, 0]
v[tCurrent] = vLag + kappa * (vBar - vLag) * deltaT + sigmaV * (sqrtVLag * af.matmul(dBt, m))
return (x[tCurrent], af.maxof(v[tCurrent], zeroArray))
def calc_arrayfire(A, b, x0, maxiter=10):
x = af.constant(0, b.dims()[0], dtype=af.Dtype.f32)
r = b - af.matmul(A, x)
p = r
for i in range(maxiter):
Ap = af.matmul(A, p)
alpha_num = af.dot(r, r)
alpha_den = af.dot(p, Ap)
alpha = alpha_num/alpha_den
r -= af.tile(alpha, Ap.dims()[0]) * Ap
x += af.tile(alpha, Ap.dims()[0]) * p
beta_num = af.dot(r, r)
beta = beta_num/alpha_num
p = r + af.tile(beta, p.dims()[0]) * p
af.eval(x)
res = x0 - x
return x, af.dot(res, res)
def mandelbrot(data, it, maxval):
C = data
Z = data
mag = af.constant(0, *C.dims())
for ii in range(1, 1 + it):
# Doing the calculation
Z = Z * Z + C
# Get indices where abs(Z) crosses maxval
cond = ((af.abs(Z) > maxval)).as_type(af.Dtype.f32)
mag = af.maxof(mag, cond * ii)
C = C * (1 - cond)
Z = Z * (1 - cond)
af.eval(C)
af.eval(Z)
return mag / maxval
def nn_build(seed,layerlist, nonlin='sigmoid', eta=0.01, init='glorot'):
"""
Returns a neural network of given architecture
:param layerlist: a list of number of neurons in each layer starting with input and ending with output
:param nonlin: nonlinearity which is either 'sigmoid', 'tanh', or 'ReLU'
:return: a dictionary with neural network parameters
"""
nn = {}
nn['eta'] = eta
nn['weights'] = []
weights = []
biases = []
nn['biases'] = []
nn['nonlin'] = []
for i in range(len(layerlist) - 1):
nn['weights'].append(weight_matrix(seed,layerlist[i], layerlist[i + 1],layer=i,type=init))
nn['biases'].append(af.constant(1,1,layerlist[i + 1]) * 0.1)
nn['nonlin'].append(activate(nonlin))
#nn['weights'] = weights
#nn['biases'] = biases
#addadadelta(nn)
return nn
def simple_arith(verbose = False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3,3,dtype=af.Dtype.u32)
b = af.constant(4, 3, 3, dtype=af.Dtype.u32)
display_func(a)
display_func(b)
c = a + b
d = a
d += b
display_func(c)
display_func(d)
display_func(a + 2)
display_func(3 + a)
c = a - b
d = a
d -= b
display_func(c)
display_func(d)
display_func(a - 2)
display_func(3 - a)
c = a * b
d = a
d *= b
display_func(c * 2)
display_func(3 * d)
display_func(a * 2)
display_func(3 * a)
c = a / b
d = a
d /= b
display_func(c / 2.0)
display_func(3.0 / d)
display_func(a / 2)
display_func(3 / a)
c = a % b
d = a
d %= b
display_func(c % 2.0)
display_func(3.0 % d)
display_func(a % 2)
display_func(3 % a)
c = a ** b
d = a
d **= b
display_func(c ** 2.0)
display_func(3.0 ** d)
display_func(a ** 2)
display_func(3 ** a)
display_func(a < b)
display_func(a < 0.5)
display_func(0.5 < a)
display_func(a <= b)
display_func(a <= 0.5)
display_func(0.5 <= a)
display_func(a > b)
display_func(a > 0.5)
display_func(0.5 > a)
display_func(a >= b)
display_func(a >= 0.5)
display_func(0.5 >= a)
display_func(a != b)
display_func(a != 0.5)
display_func(0.5 != a)
display_func(a == b)
display_func(a == 0.5)
display_func(0.5 == a)
display_func(a & b)
display_func(a & 2)
c = a
c &= 2
display_func(c)
display_func(a | b)
display_func(a | 2)
c = a
c |= 2
display_func(c)
display_func(a >> b)
display_func(a >> 2)
c = a
c >>= 2
display_func(c)
display_func(a << b)
display_func(a << 2)
c = a
c <<= 2
display_func(c)
display_func(-a)
display_func(+a)
display_func(~a)
display_func(a)
display_func(af.cast(a, af.Dtype.c32))
display_func(af.maxof(a,b))
display_func(af.minof(a,b))
display_func(af.rem(a,b))
a = af.randu(3,3) - 0.5
b = af.randu(3,3) - 0.5
display_func(af.abs(a))
display_func(af.arg(a))
display_func(af.sign(a))
display_func(af.round(a))
display_func(af.trunc(a))
display_func(af.floor(a))
display_func(af.ceil(a))
display_func(af.hypot(a, b))
display_func(af.sin(a))
display_func(af.cos(a))
display_func(af.tan(a))
display_func(af.asin(a))
display_func(af.acos(a))
display_func(af.atan(a))
display_func(af.atan2(a, b))
c = af.cplx(a)
d = af.cplx(a,b)
display_func(c)
display_func(d)
display_func(af.real(d))
display_func(af.imag(d))
display_func(af.conjg(d))
display_func(af.sinh(a))
display_func(af.cosh(a))
display_func(af.tanh(a))
display_func(af.asinh(a))
display_func(af.acosh(a))
display_func(af.atanh(a))
a = af.abs(a)
b = af.abs(b)
display_func(af.root(a, b))
display_func(af.pow(a, b))
display_func(af.pow2(a))
display_func(af.exp(a))
display_func(af.expm1(a))
display_func(af.erf(a))
display_func(af.erfc(a))
display_func(af.log(a))
display_func(af.log1p(a))
display_func(af.log10(a))
display_func(af.log2(a))
display_func(af.sqrt(a))
display_func(af.cbrt(a))
a = af.round(5 * af.randu(3,3) - 1)
b = af.round(5 * af.randu(3,3) - 1)
display_func(af.factorial(a))
display_func(af.tgamma(a))
display_func(af.lgamma(a))
display_func(af.iszero(a))
display_func(af.isinf(a/b))
display_func(af.isnan(a/a))
a = af.randu(5, 1)
b = af.randu(1, 5)
c = af.broadcast(lambda x,y: x+y, a, b)
display_func(a)
display_func(b)
display_func(c)
@af.broadcast
def test_add(aa, bb):
return aa + bb
display_func(test_add(a, b))
#!/usr/bin/python ####################################################### # Copyright (c) 2015, ArrayFire # All rights reserved. # # This file is distributed under 3-clause BSD license. # The complete license agreement can be obtained at: # http://arrayfire.com/licenses/BSD-3-Clause ######################################################## import arrayfire as af af.display(af.constant(100, 3,3, dtype=af.f32)) af.display(af.constant(25, 3,3, dtype=af.c32)) af.display(af.constant(2**50, 3,3, dtype=af.s64)) af.display(af.constant(2+3j, 3,3)) af.display(af.constant(3+5j, 3,3, dtype=af.c32)) af.display(af.range(3, 3)) af.display(af.iota(3, 3, tile_dims=(2,2))) af.display(af.randu(3, 3, 1, 2)) af.display(af.randu(3, 3, 1, 2, af.b8)) af.display(af.randu(3, 3, dtype=af.c32)) af.display(af.randn(3, 3, 1, 2)) af.display(af.randn(3, 3, dtype=af.c32)) af.set_seed(1024) assert(af.get_seed() == 1024)
def createValidityMap(self, push=True): #vxy
a = time.time()
if push:
self.volumes[self.indexVolume] = [copy.deepcopy(self.areas),
copy.deepcopy(self.areaViewPoints), copy.deepcopy(self.drawingAreas),
copy.copy(self.indexArea)]
else:
if self.volumes[self.indexVolume]:
self.areas = self.volumes[self.indexVolume][0]
oneAreaMode = len(self.areas) == 1 or (len(self.areas) == 2 and not self.areas[1])
if self.colorMode == 'rgb':
side = 256
else:
side = self.side
if self.gpuMode and oneAreaMode:
self.validityMap = af.constant(0, 256, side, side, dtype=af.Dtype.u8)
else:
self.validityMap = np.zeros(shape=(256, side, side), dtype=np.uint8)
if not self.areas[0]:
self.validityMap = False
self.updateDynamic(self.validityMap)
return
if oneAreaMode:
dict = self.numpyAreas2Dict(self.areas[0], concave=True)
minx, maxx = dict['i'], dict['f']
newbounds = []
for x in xrange(minx, (maxx + 1)):
try:
bounds = dict[x]
if len(bounds) == 2:
if bounds[0] != bounds[1]:
newbounds = bounds
else:
newbounds = [bounds[0]]
for i in xrange(1, len(bounds)):
if abs(bounds[i] - bounds[i - 1]) > 2:
newbounds.append(bounds[i])
if len(newbounds) % 2 == 1:
del newbounds[-1]
except:
pass # use previous values
for i in xrange(0, len(newbounds), 2):
try:
self.validityMap[0:256, x, newbounds[i]:newbounds[i + 1]] = 1
except:
print 'ERROR! in colorspace.createValidityMap', len(newbounds), i, x, newbounds
quit()
if push:
b = time.time()
print 'time to create simple validitymap', 1000*(b-a)
self.updateDynamic(self.validityMap)
return
# complex drawings:
ind = [] # indices in self.areas
indvs = [] # and there corresponding v-values
areaDicts = [] # mini, minv
for i, area in enumerate(self.areas): # preprocessing areas into dicts
if area:
ind.append(i) # make orderedareas
indvs.append(area[2]) # make orderedareas
dict = self.numpyAreas2Dict(area)
areaDicts.append(dict)
orderedareas = [[i, v] for (v, i) in sorted(zip(indvs, ind))]
[lowI, lowV] = orderedareas[0]
for [highI, highV] in orderedareas[1::]:
if highV == lowV:
print 'an area was discounted for having the same intensity as the other'
continue
lowXi = areaDicts[lowI]['i']
lowXf = areaDicts[lowI]['f']
highXi = areaDicts[highI]['i']
highXf = areaDicts[highI]['f']
lowDX = lowXf - lowXi
highDX = highXf - highXi
for v in xrange(lowV, (highV + 1)):
fracV = float(v - lowV) / (highV - lowV)
ofracV = 1 - fracV
avgXi = int(fracV * highXi + ofracV * lowXi)
avgXf = int(fracV * highXf + ofracV * lowXf)
avgDX = float(avgXf - avgXi)
for avgX in xrange(avgXi, (avgXf + 1)):
avgFracX = (avgX - avgXi) / avgDX
highX = int(avgFracX * highDX) + highXi
lowX = int(avgFracX * lowDX) + lowXi
try:
[highYmin, highYmax] = areaDicts[highI][highX] # get min and max
except:
pass # use past values
try:
[lowYmin, lowYmax] = areaDicts[lowI][lowX] # get min max
except:
pass # use previous values
avgYmin = int(highYmin * fracV + lowYmin * ofracV)
avgYmax = int(highYmax * fracV + lowYmax * ofracV) + 1
self.validityMap[v, avgX, avgYmin:avgYmax] = 1
[lowI, lowV] = [highI, highV]
if self.gpuMode:
self.validityMap = af.interop.np_to_af_array(self.validityMap)
b = time.time()
if push:
self.updateDynamic(self.validityMap)
print 'time to create validityMap ms:', (b-a) * 1000
def simple_index(verbose=False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(5, 5)
display_func(a)
b = af.Array(a)
display_func(b)
c = a.copy()
display_func(c)
display_func(a[0,0])
display_func(a[0])
display_func(a[:])
display_func(a[:,:])
display_func(a[0:3,])
display_func(a[-2:-1,-1])
display_func(a[0:5])
display_func(a[0:5:2])
idx = af.Array(host.array('i', [0, 3, 2]))
display_func(idx)
aa = a[idx]
display_func(aa)
a[0] = 1
display_func(a)
a[0] = af.randu(1, 5)
display_func(a)
a[:] = af.randu(5,5)
display_func(a)
a[:,-1] = af.randu(5,1)
display_func(a)
a[0:5:2] = af.randu(3, 5)
display_func(a)
a[idx, idx] = af.randu(3,3)
display_func(a)
a = af.randu(5,1)
b = af.randu(5,1)
display_func(a)
display_func(b)
for ii in ParallelRange(1,3):
a[ii] = b[ii]
display_func(a)
for ii in ParallelRange(2,5):
b[ii] = 2
display_func(b)
a = af.randu(3,2)
rows = af.constant(0, 1, dtype=af.Dtype.s32)
b = a[:,rows]
display_func(b)
for r in rows:
display_func(r)
display_func(b[:,r])
a = af.randu(3)
c = af.randu(3)
b = af.constant(1,3,dtype=af.Dtype.b8)
display_func(a)
a[b] = c
display_func(a)
def simple_algorithm(verbose = False):
display_func = _util.display_func(verbose)
print_func = _util.print_func(verbose)
a = af.randu(3, 3)
k = af.constant(1, 3, 3, dtype=af.Dtype.u32)
af.eval(k)
print_func(af.sum(a), af.product(a), af.min(a), af.max(a),
af.count(a), af.any_true(a), af.all_true(a))
display_func(af.sum(a, 0))
display_func(af.sum(a, 1))
display_func(af.product(a, 0))
display_func(af.product(a, 1))
display_func(af.min(a, 0))
display_func(af.min(a, 1))
display_func(af.max(a, 0))
display_func(af.max(a, 1))
display_func(af.count(a, 0))
display_func(af.count(a, 1))
display_func(af.any_true(a, 0))
display_func(af.any_true(a, 1))
display_func(af.all_true(a, 0))
display_func(af.all_true(a, 1))
display_func(af.accum(a, 0))
display_func(af.accum(a, 1))
display_func(af.scan(a, 0, af.BINARYOP.ADD))
display_func(af.scan(a, 1, af.BINARYOP.MAX))
display_func(af.scan_by_key(k, a, 0, af.BINARYOP.ADD))
display_func(af.scan_by_key(k, a, 1, af.BINARYOP.MAX))
display_func(af.sort(a, is_ascending=True))
display_func(af.sort(a, is_ascending=False))
b = (a > 0.1) * a
c = (a > 0.4) * a
d = b / c
print_func(af.sum(d));
print_func(af.sum(d, nan_val=0.0));
display_func(af.sum(d, dim=0, nan_val=0.0));
val,idx = af.sort_index(a, is_ascending=True)
display_func(val)
display_func(idx)
val,idx = af.sort_index(a, is_ascending=False)
display_func(val)
display_func(idx)
b = af.randu(3,3)
keys,vals = af.sort_by_key(a, b, is_ascending=True)
display_func(keys)
display_func(vals)
keys,vals = af.sort_by_key(a, b, is_ascending=False)
display_func(keys)
display_func(vals)
c = af.randu(5,1)
d = af.randu(5,1)
cc = af.set_unique(c, is_sorted=False)
dd = af.set_unique(af.sort(d), is_sorted=True)
display_func(cc)
display_func(dd)
display_func(af.set_union(cc, dd, is_unique=True))
display_func(af.set_union(cc, dd, is_unique=False))
display_func(af.set_intersect(cc, cc, is_unique=True))
display_func(af.set_intersect(cc, cc, is_unique=False))
#!/usr/bin/python ####################################################### # Copyright (c) 2015, ArrayFire # All rights reserved. # # This file is distributed under 3-clause BSD license. # The complete license agreement can be obtained at: # http://arrayfire.com/licenses/BSD-3-Clause ######################################################## import arrayfire as af a = af.randu(3,3,dtype=af.u32) b = af.constant(4, 3, 3, dtype=af.u32) af.display(a) af.display(b) c = a + b d = a d += b af.display(c) af.display(d) af.display(a + 2) af.display(3 + a) c = a - b d = a d -= b
af.display(B)
print("Negate the first three elements of second column\n")
B[0:3, 1] = B[0:3, 1] * -1
af.display(B)
print("Fourier transform the result\n");
C = af.fft(B);
af.display(C);
print("Grab last row\n");
c = C[-1,:];
af.display(c);
print("Scan Test\n");
r = af.constant(2, 16, 4, 1, 1);
af.display(r);
print("Scan\n");
S = af.scan(r, 0, af.BINARYOP.MUL);
af.display(S);
print("Create 2-by-3 matrix from host data\n");
d = [ 1, 2, 3, 4, 5, 6 ]
D = af.Array(d, (2, 3))
af.display(D)
print("Copy last column onto first\n");
D[:,0] = D[:, -1]
af.display(D);
#!/usr/bin/python import arrayfire as af af.print_array(af.constant(100, 3,3, dtype=af.f32)) af.print_array(af.constant(25, 3,3, dtype=af.c32)) af.print_array(af.constant(2**50, 3,3, dtype=af.s64)) af.print_array(af.constant(2+3j, 3,3)) af.print_array(af.constant(3+5j, 3,3, dtype=af.c32)) af.print_array(af.range(3, 3)) af.print_array(af.iota(3, 3, tile_dims=(2,2))) af.print_array(af.randu(3, 3, 1, 2)) af.print_array(af.randu(3, 3, 1, 2, af.b8)) af.print_array(af.randu(3, 3, dtype=af.c32)) af.print_array(af.randn(3, 3, 1, 2)) af.print_array(af.randn(3, 3, dtype=af.c32)) af.set_seed(1024) assert(af.get_seed() == 1024) af.print_array(af.identity(3, 3, 1, 2, af.b8)) af.print_array(af.identity(3, 3, dtype=af.c32)) a = af.randu(3, 4) b = af.diag(a, extract=True) c = af.diag(a, 1, extract=True) af.print_array(a) af.print_array(b)
