def main():
parser = argparse.ArgumentParser(
description='af vs sklearn logit comparison')
parser.add_argument('-b',
'--backend',
choices=['default', 'cpu', 'cuda', 'opencl'],
default='default',
action='store',
help='ArrayFire backend to be used')
parser.add_argument('-v',
'--device',
type=int,
default=0,
action='store',
help='ArrayFire backend device to be used')
parser.add_argument('-d',
'--dataset',
choices=['iris', 'mnist', 'notmnist'],
default='iris',
action='store',
help='Dataset to be used')
parser.add_argument('-t',
'--type',
choices=['simple', 'predict', 'benchmark'],
default='simple',
action='store',
help='Demo type')
args = parser.parse_args()
af.set_backend(args.backend)
af.set_device(args.device)
af.info()
dataset = None
if args.dataset == 'iris':
dataset = read_and_preprocess_iris_data()
elif args.dataset == 'mnist':
dataset = read_and_preprocess_mnist_data()
elif args.dataset == 'notmnist':
dataset = read_and_preprocess_notmnist_data()
else:
parser.print_help()
return -1
print('------------')
if args.type == 'simple':
demo_simple(arrayfire_knn_demo, sklearn_knn_demo, dataset)
elif args.type == 'predict':
demo_pred(arrayfire_knn_demo, sklearn_knn_demo, dataset)
elif args.type == 'benchmark':
demo_bench(arrayfire_knn_demo, sklearn_knn_demo, dataset)
else:
parser.print_help()
return -1
def main():
argc = len(sys.argv)
device = int(sys.argv[1]) if argc > 1 else 0
console = sys.argv[2][0] == '-' if argc > 2 else False
perc = int(sys.argv[3]) if argc > 3 else 60
try:
af.set_device(device)
af.info()
logit_demo(console, perc)
except Exception as e:
print('Error: ', str(e))
return af.mean(payoff) * math.exp(-r * t)
def monte_carlo_simulate(N, use_barrier, num_iter = 10):
steps = 180
stock_price = 100.0
maturity = 0.5
volatility = 0.3
rate = 0.01
strike = 100
barrier = 115.0
start = time()
for i in range(num_iter):
monte_carlo_options(N, stock_price, maturity, volatility, rate, strike, steps,
use_barrier, barrier)
return (time() - start) / num_iter
if __name__ == "__main__":
if (len(sys.argv) > 1):
af.set_device(int(sys.argv[1]))
af.info()
monte_carlo_simulate(1000, use_barrier = False)
monte_carlo_simulate(1000, use_barrier = True )
af.sync()
for n in range(10000, 100001, 10000):
print("Time for %7d paths - vanilla method: %4.3f ms, barrier method: % 4.3f ms\n" %
(n, 1000 * monte_carlo_simulate(n, False, 100), 1000 * monte_carlo_simulate(n, True, 100)))
# The complete license agreement can be obtained at:
# http://arrayfire.com/licenses/BSD-3-Clause
########################################################
import arrayfire as af
import sys
import os
if __name__ == "__main__":
if (len(sys.argv) == 1):
raise RuntimeError("Expected to the image as the first argument")
if not os.path.isfile(sys.argv[1]):
raise RuntimeError("File %s not found" % sys.argv[1])
if (len(sys.argv) > 2):
af.set_device(int(sys.argv[2]))
af.info()
hist_win = af.Window(512, 512, "3D Plot example using ArrayFire")
img_win = af.Window(480, 640, "Input Image")
img = (af.load_image(sys.argv[1])).(af.Dtype.u8)
hist = af.histogram(img, 256, 0, 255)
while (not hist_win.close()) and (not img_win.close()):
hist_win.hist(hist, 0, 255)
img_win.image(img)
from dg_maxwell import advection_2d
from dg_maxwell import utils
from dg_maxwell import global_variables
af.set_backend(params.backend)
#print(af.mean(af.abs(advection_2d.u_analytical(0) - params.u_e_ij)))
gv = global_variables.advection_variables(params.N_LGL, params.N_quad,\
params.x_nodes, params.N_Elements,\
params.c, params.total_time, params.wave,\
params.c_x, params.c_y, params.courant,\
params.mesh_file, params.total_time_2d)
print('start')
print(af.info())
#print(wave_equation_2d.dx_deta(gv.nodes[gv.elements[0]][:, 1], gv.xi_i, gv.eta_j))
#print(gv.nodes[gv.elements[1]][:, 1])
#print(af.np_to_af_array(gv.nodes[gv.elements[1]]))#[:, 0])
elements_nodes = (af.reorder(
af.transpose(af.np_to_af_array(gv.nodes[gv.elements[:]])), 0, 2,
1)) #[0, :, :])
#print(elements_nodes)
#dxi_dx_elements = (wave_equation_2d.trial_dxi_dx(elements_nodes[:, 0, :],\
# elements_nodes[:, 1, :], gv.xi_i, gv.eta_j))
#print(dxi_dx_elements.shape)
#print((wave_equation_2d.trial_dxi_dx(elements_nodes[:, 0, :],
# elements_nodes[:, 1, :], gv.xi_i, gv.eta_j)).shape)
#print(wave_equation_2d.F_xi(gv.u_e_ij, gv).shape)
#print(wave_equation_2d.F_eta(gv.u_e_ij, gv).shape)
