def init(backend: tp.Optional[str] = None): try: if backend: af.set_backend(backend) af.get_device() except: af.set_backend('cpu')
def _split_fourier_cuda(self, signal: Signal, step): ''' This function is called by split_fourier,and should not be used outside :param signal: signal to traverse the span :param step: the step of split fourier :return: None ''' af.set_backend('cuda') freq = fftfreq(len(signal.data_sample[0, :]), (signal.sps * signal.symbol_rate_in_hz)**(-1)) freq = af.Array(freq.ctypes.data, freq.shape, freq.dtype.char) signal_x = np.asarray(signal.data_sample[0, :]) signal_y = np.asarray(signal.data_sample[1, :]) signal_x = af.Array(signal_x.ctypes.data, signal_x.shape, dtype=signal_x.dtype.char) signal_y = af.Array(signal_y.ctypes.data, signal_x.shape, dtype=signal_y.dtype.char) Disper = (1j / 2) * self.beta2 * (2 * np.pi * freq)**2 * step + ( 1j / 6) * self.beta3 * ( (2 * np.pi * freq)**3 * step) - self.alphalin / 2 * step dz_Eff = (1 - np.exp(-self.alphalin * step)) / self.alphalin step_number = np.ceil(self.length / step) for number in range(int(step_number)): print(number) if number == step_number - 1: # dz = step dz = self.length - (step_number - 1) * step dz_Eff = (1 - np.exp(-self.alphalin * dz)) / self.alphalin Disper = (1j / 2) * self.beta2 * (2 * np.pi * freq)**2 * dz + ( 1j / 6) * self.beta3 * ( (2 * np.pi * freq)**3 * dz) - self.alphalin / 2 * step signal_x, signal_y = self.linear(signal_x, signal_y, Disper) energy = signal_x * af.conjg(signal_x) + signal_y * af.conjg( signal_y) signal_x, signal_y = self.nonlinear(energy, signal_x, signal_y, dz_Eff) signal_x, signal_y = self.linear(signal_x, signal_y, Disper) signal_x_array = np.array(signal_x.to_list()) signal_y_array = np.array(signal_y.to_list()) signal_x_array = signal_x_array[:, 0] + 1j * signal_x_array[:, 1] signal_y_array = signal_y_array[:, 0] + 1j * signal_y_array[:, 1] signal.data_sample[0, :] = signal_x_array signal.data_sample[1, :] = signal_y_array
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 init(): # Valid datatypes global valid_dtypes valid_dtypes = ('complex32', 'complex64', 'int32', 'int64', 'float32', 'float64') # Default backend global default_backend default_backend = 'numpy' # Default datatype global default_dtype default_dtype = 'float32' # Defualt FFT Backend global default_fft_backend default_fft_backend = 'scipy' # Default arrayfire backend global default_arrayfire_backend default_arrayfire_backend = None # Determine valid backends based on imports global valid_backends valid_backends = ['numpy'] try: import arrayfire valid_backends.append('arrayfire') # Set default arrayfire backend af_backends = arrayfire.get_available_backends() if 'cuda' in af_backends: default_arrayfire_backend = 'cuda' elif 'opencl' in af_backends: default_arrayfire_backend = 'opencl' else: default_arrayfire_backend = 'cpu' # set default backend arrayfire.set_backend(default_arrayfire_backend) except: pass # Determine valid fft backends based on imports global valid_fft_backends valid_fft_backends = ['numpy', 'scipy'] try: import pyfftw valid_fft_backends.append('fftw') default_fft_backend = 'fftw' except: pass
#! /usr/bin/env python3 # -*- coding: utf-8 -*- import numpy as np from scipy import special as sp import arrayfire as af from dg_maxwell import utils from dg_maxwell import params af.set_backend(params.backend) af.set_device(params.device) def LGL_points(N): ''' Calculates : math: `N` Legendre-Gauss-Lobatto (LGL) points. LGL points are the roots of the polynomial :math: `(1 - \\xi ** 2) P_{n - 1}'(\\xi) = 0` Where :math: `P_{n}(\\xi)` are the Legendre polynomials. This function finds the roots of the above polynomial. Parameters ---------- N : int Number of LGL nodes required Returns
from dg_maxwell import params from dg_maxwell import wave_equation import arrayfire as af af.set_backend('cpu') af.set_device(0) def L1_norm(u): ''' A function to calculate the L1 norm of error using the polynomial obtained using Lagrange interpolation Parameters ---------- u : arrayfire.Array [N_LGL N_Elements 1 1] Difference between analytical and numerical u at the mapped LGL points. Returns ------- L1_norm : float64 The L1 norm of error. ''' interpolated_coeffs = af.reorder(lagrange.lagrange_interpolation_u(\ u), 2, 1, 0) L1_norm = af.sum(lagrange.integrate(interpolated_coeffs)) return L1_norm
import numpy as np import arrayfire as af import time af.set_backend('cuda') def test(): x1 =np.arange(2000) x = af.Array(x1.ctypes.data, x1.shape, x1.dtype.char) alpha = 2/3 s_old = x[0] a = time.time() for i in range(1, 2000): s = alpha * x[i] + (1- alpha) * s_old s_old = s #time.sleep(1) b = time.time() print(b - a) return s print(test()) #test()
import time import numpy as np import arrayfire as af af.set_backend("opencl") # This is a benchmark test to compare numpy and arrayfire: print("The following line displays the ArrayFire build and device details:") af.info() aNumPy = np.random.rand(100, 100) bNumPy = np.random.rand(100, 100) np_time_start = time.time() for i in range(1000000): cNumPy = aNumPy + bNumPy np_time_end = time.time() np_time_elapsed = np_time_end - np_time_start #print("numpy answer is = ", cNumPy) print("numpy implementation run took time =", np_time_elapsed, " seconds") aArrayFire = af.Array(aNumPy.ctypes.data, aNumPy.shape, aNumPy.dtype.char) bArrayFire = af.Array(bNumPy.ctypes.data, bNumPy.shape, bNumPy.dtype.char) kernel_compilation_time_start = time.time() cArrayFire = aArrayFire + bArrayFire af.eval(cArrayFire)
def Set_arrayfire_backend(backend): if backend not in ['cuda', 'opencl', 'cpu']: raise ValueError("Must be 'cuda', 'opencl' or 'cpu'") af.set_backend(backend)
#! /usr/bin/env python3 # -*- coding: utf-8 -*- import os from matplotlib import pyplot as pl from tqdm import trange import h5py import numpy as np import arrayfire as af af.set_backend('opencl') af.set_device(0) import parameters as params pl.rcParams['figure.figsize'] = 9.6, 6. pl.rcParams['figure.dpi'] = 100 pl.rcParams['image.cmap'] = 'jet' pl.rcParams['lines.linewidth'] = 1.5 pl.rcParams['font.family'] = 'serif' pl.rcParams['font.size'] = 20 pl.rcParams['font.sans-serif'] = 'serif' pl.rcParams['text.usetex'] = False pl.rcParams['axes.linewidth'] = 1.5 pl.rcParams['axes.titlesize'] = 'medium' pl.rcParams['axes.labelsize'] = 'medium' pl.rcParams['xtick.major.size'] = 8 pl.rcParams['xtick.minor.size'] = 4 pl.rcParams['xtick.major.pad'] = 8 pl.rcParams['xtick.minor.pad'] = 8
def set_backend(proc): af.set_backend(proc)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Checks that the initialize function initializes the distribution function array as we expect. """ # Importing dependencies: import numpy as np from numpy.fft import fftfreq import arrayfire as af af.set_backend("cpu") from petsc4py import PETSc # Importing solver functions: from bolt.lib.nonlinear_solver.nonlinear_solver import nonlinear_solver from bolt.lib.nonlinear_solver.compute_moments \ import compute_moments as compute_moments_imported from bolt.lib.nonlinear_solver.communicate import communicate_fields from bolt.lib.nonlinear_solver.apply_boundary_conditions \ import apply_bcs_fields initialize = nonlinear_solver._initialize moment_exponents = dict(density=[0, 0, 0], mom_p1_bulk=[1, 0, 0], mom_p2_bulk=[0, 1, 0], mom_p3_bulk=[0, 0, 1], energy=[2, 2, 2])
#! /usr/bin/env python3 # -*- coding: utf-8 -*- import numpy as np import arrayfire as af backend = 'opencl' device = 0 af.set_backend(backend) af.set_device(device) from dg_maxwell import lagrange from dg_maxwell import isoparam from dg_maxwell import utils from dg_maxwell import msh_parser from dg_maxwell import wave_equation from dg_maxwell import wave_equation_2d # The domain of the function. x_nodes = af.np_to_af_array(np.array([-1., 1.])) # The number of LGL points into which an element is split. N_LGL = 6 # Number of elements the domain is to be divided into. N_Elements = 9 # The scheme to be used for integration. Values are either # 'gauss_quadrature' or 'lobatto_quadrature'
def main(): for backend in af.get_available_backends(): af.set_backend(backend, unsafe=True) benchmark_current_backend()