def main(readcsv=read_csv, method='defaultDense'): infile = os.path.join('..', 'data', 'batch', 'covcormoments_dense.csv') # Load the data data = readcsv(infile, range(10)) # Using of the classic way (computations on CPU) result_classic = compute(data, method) data = to_numpy(data) # It is possible to specify to make the computations on GPU if gpu_available: with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, 'defaultDense') assert np.allclose(result_classic.covariance, result_gpu.covariance) assert np.allclose(result_classic.mean, result_gpu.mean) assert np.allclose(result_classic.correlation, result_gpu.correlation) # It is possible to specify to make the computations on CPU with sycl_context('cpu'): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, 'defaultDense') # covariance result objects provide correlation, covariance and mean assert np.allclose(result_classic.covariance, result_cpu.covariance) assert np.allclose(result_classic.mean, result_cpu.mean) assert np.allclose(result_classic.correlation, result_cpu.correlation) return result_classic
def main(readcsv=read_csv): # input data file train_file = os.path.join('..', 'data', 'batch', 'svm_two_class_train_dense.csv') predict_file = os.path.join('..', 'data', 'batch', 'svm_two_class_test_dense.csv') nFeatures = 20 train_data = readcsv(train_file, range(nFeatures)) train_labels = readcsv(train_file, range(nFeatures, nFeatures + 1)) predict_data = readcsv(predict_file, range(nFeatures)) predict_labels = readcsv(predict_file, range(nFeatures, nFeatures + 1)) predict_result_classic, decision_function_classic = compute(train_data, train_labels, predict_data, 'boser') train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) # It is possible to specify to make the computations on GPU if gpu_available: with sycl_context('gpu'): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) predict_result_gpu, decision_function_gpu = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, 'thunder') assert np.allclose(predict_result_gpu, predict_result_classic) return predict_labels, predict_result_classic, decision_function_classic
def main(readcsv=read_csv, method='svdDense'): dataFileName = os.path.join('..', 'data', 'batch', 'pca_transform.csv') nComponents = 2 # read data data = readcsv(dataFileName, range(3)) # Using of the classic way (computations on CPU) result_classic = compute(data, nComponents) data = to_numpy(data) # It is possible to specify to make the computations on GPU if gpu_available: with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, nComponents) assert np.allclose(result_classic.transformedData, result_gpu.transformedData) # It is possible to specify to make the computations on CPU with sycl_context('cpu'): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, nComponents) # pca_transform_result objects provides transformedData assert np.allclose(result_classic.transformedData, result_cpu.transformedData) return (result_classic)
def main(readcsv=read_csv, method='svdDense'): infile = os.path.join('..', 'data', 'batch', 'pca_normalized.csv') # Load the data data = readcsv(infile, t=np.float32) # Using of the classic way (computations on CPU) result_classic = compute(data) data = to_numpy(data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data) assert np.allclose(result_classic.eigenvalues, result_gpu.eigenvalues, atol=1e-5) assert np.allclose(result_classic.eigenvectors, result_gpu.eigenvectors, atol=1e-5) assert np.allclose(result_classic.means, result_gpu.means, atol=1e-5) assert np.allclose(result_classic.variances, result_gpu.variances, atol=1e-5) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data) # PCA result objects provide eigenvalues, eigenvectors, means and variances assert result_classic.eigenvalues.shape == (1, data.shape[1]) assert result_classic.eigenvectors.shape == (data.shape[1], data.shape[1]) assert result_classic.means.shape == (1, data.shape[1]) assert result_classic.variances.shape == (1, data.shape[1]) assert np.allclose(result_classic.eigenvalues, result_cpu.eigenvalues) assert np.allclose(result_classic.eigenvectors, result_cpu.eigenvectors) assert np.allclose(result_classic.means, result_cpu.means, atol=1e-7) assert np.allclose(result_classic.variances, result_cpu.variances) return result_classic
def main(readcsv=None, method='defaultDense'): infile = os.path.join('..', 'data', 'batch', 'covcormoments_dense.csv') # Using of the classic way (computations on CPU) # configure a covariance object algo = d4p.covariance(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 112, readcsv) # ... and iterate through chunks/stream for chunk in rn: algo.compute(chunk) # finalize computation result_classic = algo.finalize() try: from dpctx import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): # configure a covariance object algo = d4p.covariance(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 112, readcsv) # ... and iterate through chunks/stream for chunk in rn: sycl_chunk = sycl_buffer(to_numpy(chunk)) algo.compute(sycl_chunk) # finalize computation result_gpu = algo.finalize() assert np.allclose(result_classic.covariance, result_gpu.covariance) assert np.allclose(result_classic.mean, result_gpu.mean) assert np.allclose(result_classic.correlation, result_gpu.correlation) # It is possible to specify to make the computations on CPU with cpu_context(): # configure a covariance object algo = d4p.covariance(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 112, readcsv) # ... and iterate through chunks/stream for chunk in rn: sycl_chunk = sycl_buffer(to_numpy(chunk)) algo.compute(sycl_chunk) # finalize computation result_cpu = algo.finalize() # covariance result objects provide correlation, covariance and mean assert np.allclose(result_classic.covariance, result_cpu.covariance) assert np.allclose(result_classic.mean, result_cpu.mean) assert np.allclose(result_classic.correlation, result_cpu.correlation) return result_classic
def main(readcsv=read_csv, method='defaultDense'): infile = "../data/batch/dbscan_dense.csv" epsilon = 0.04 minObservations = 45 # Load the data data = readcsv(infile, range(2)) result_classic = compute(data, minObservations, epsilon) data = to_numpy(data) # It is possible to specify to make the computations on GPU if gpu_available: with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, minObservations, epsilon) assert np.allclose(result_classic.nClusters, result_gpu.nClusters) assert np.allclose(result_classic.assignments, result_gpu.assignments) with sycl_context('cpu'): sycl_data2 = sycl_buffer(data) result_cpu = compute(sycl_data2, minObservations, epsilon) return result_classic
def main(readcsv=read_csv, method='randomDense'): infile = os.path.join('..', 'data', 'batch', 'kmeans_dense.csv') nClusters = 20 maxIter = 5 # Load the data data = readcsv(infile, range(20), t=np.float32) # Using of the classic way (computations on CPU) result_classic = compute(data, nClusters, maxIter, method) data = to_numpy(data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) _ = compute(sycl_data, nClusters, maxIter, method) # TODO: investigate why results_classic and result_gpu differ # assert np.allclose(result_classic.centroids, result_gpu.centroids) # assert np.allclose(result_classic.assignments, result_gpu.assignments) # assert np.isclose(result_classic.objectiveFunction, # result_gpu.objectiveFunction) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, nClusters, maxIter, method) # Kmeans result objects provide assignments (if requested), # centroids, goalFunction, nIterations and objectiveFunction assert result_classic.centroids.shape[0] == nClusters assert result_classic.assignments.shape == (data.shape[0], 1) assert result_classic.nIterations <= maxIter assert np.allclose(result_classic.centroids, result_cpu.centroids) assert np.allclose(result_classic.assignments, result_cpu.assignments) assert np.isclose(result_classic.objectiveFunction, result_cpu.objectiveFunction) assert result_classic.nIterations == result_cpu.nIterations return result_classic
def main(readcsv=read_csv, method="defaultDense"): # read data from file file = os.path.join('..', 'data', 'batch', 'covcormoments_dense.csv') data = readcsv(file, range(10)) # Using of the classic way (computations on CPU) result_classic = compute(data, method) data = to_numpy(data) try: from dppl import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, "defaultDense") for name in [ 'minimum', 'maximum', 'sum', 'sumSquares', 'sumSquaresCentered', 'mean', 'secondOrderRawMoment', 'variance', 'standardDeviation', 'variation' ]: assert np.allclose(getattr(result_classic, name), getattr(result_gpu, name)) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, "defaultDense") # result provides minimum, maximum, sum, sumSquares, sumSquaresCentered, # mean, secondOrderRawMoment, variance, standardDeviation, variation assert (all( getattr(result_classic, name).shape == (1, data.shape[1]) for name in [ 'minimum', 'maximum', 'sum', 'sumSquares', 'sumSquaresCentered', 'mean', 'secondOrderRawMoment', 'variance', 'standardDeviation', 'variation' ])) for name in [ 'minimum', 'maximum', 'sum', 'sumSquares', 'sumSquaresCentered', 'mean', 'secondOrderRawMoment', 'variance', 'standardDeviation', 'variation' ]: assert np.allclose(getattr(result_classic, name), getattr(result_cpu, name)) return result_classic
def main(readcsv=read_csv, method='defaultDense'): nFeatures = 3 # input data file train_file = os.path.join('..', 'data', 'batch', 'df_classification_train.csv') predict_file = os.path.join('..', 'data', 'batch', 'df_classification_test.csv') # Read train data. Let's use 3 features per observation train_data = readcsv(train_file, range(nFeatures), t=np.float32) train_labels = readcsv(train_file, range(nFeatures, nFeatures + 1), t=np.float32) # Read test data (with same #features) predict_data = readcsv(predict_file, range(nFeatures), t=np.float32) predict_labels = readcsv(predict_file, range(nFeatures, nFeatures + 1), t=np.float32) # Using of the classic way (computations on CPU) train_result, predict_result = compute(train_data, train_labels, predict_data, "defaultDense") assert predict_result.prediction.shape == (predict_labels.shape[0], 1) assert (np.mean(predict_result.prediction != predict_labels) < 0.03).any() train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) train_result, predict_result = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, 'hist') assert predict_result.prediction.shape == (predict_labels.shape[0], 1) assert (np.mean(predict_result.prediction != predict_labels) < 0.03).any() return (train_result, predict_result, predict_labels)
def main(readcsv=read_csv): # input data file train_file = os.path.join('..', 'data', 'batch', 'svm_two_class_train_dense.csv') predict_file = os.path.join('..', 'data', 'batch', 'svm_two_class_test_dense.csv') nFeatures = 20 train_data = readcsv(train_file, range(nFeatures), t=np.float32) train_labels = readcsv(train_file, range(nFeatures, nFeatures + 1), t=np.float32) predict_data = readcsv(predict_file, range(nFeatures), t=np.float32) predict_labels = readcsv(predict_file, range(nFeatures, nFeatures + 1), t=np.float32) predict_result_classic, decision_function_classic = \ compute(train_data, train_labels, predict_data, 'boser') train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) predict_result_gpu, decision_function_gpu = \ compute(sycl_train_data, sycl_train_labels, sycl_predict_data, 'thunder') assert np.allclose(predict_result_gpu, predict_result_classic) with cpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_predict_data = sycl_buffer(predict_data) predict_result_cpu, decision_function_cpu = \ compute(sycl_train_data, train_labels, sycl_predict_data, 'thunder') assert np.allclose(predict_result_cpu, predict_result_classic) return predict_labels, predict_result_classic, decision_function_classic
def main(readcsv=None, method='defaultDense'): # read data from file infile = os.path.join('..', 'data', 'batch', 'covcormoments_dense.csv') # Using of the classic way (computations on CPU) # Configure a low order moments object for streaming algo = d4p.low_order_moments(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 55, readcsv) # ... and iterate through chunks/stream for chunk in rn: algo.compute(chunk) # finalize computation result_classic = algo.finalize() # It is possible to specify to make the computations on GPU with sycl_context('gpu'): # Configure a low order moments object for streaming algo = d4p.low_order_moments(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 55, readcsv) # ... and iterate through chunks/stream for chunk in rn: sycl_chunk = sycl_buffer(to_numpy(chunk)) algo.compute(sycl_chunk) # finalize computation result_gpu = algo.finalize() # It is possible to specify to make the computations on CPU with sycl_context('cpu'): # Configure a low order moments object for streaming algo = d4p.low_order_moments(streaming=True) # get the generator (defined in stream.py)... rn = read_next(infile, 55, readcsv) # ... and iterate through chunks/stream for chunk in rn: sycl_chunk = sycl_buffer(to_numpy(chunk)) algo.compute(sycl_chunk) # finalize computation result_cpu = algo.finalize() # result provides minimum, maximum, sum, sumSquares, sumSquaresCentered, # mean, secondOrderRawMoment, variance, standardDeviation, variation for name in [ 'minimum', 'maximum', 'sum', 'sumSquares', 'sumSquaresCentered', 'mean', 'secondOrderRawMoment', 'variance', 'standardDeviation', 'variation' ]: assert np.allclose(getattr(result_classic, name), getattr(result_gpu, name)) assert np.allclose(getattr(result_classic, name), getattr(result_cpu, name)) return result_classic
def main(readcsv=read_csv, method='defaultDense'): infile = os.path.join('..', 'data', 'batch', 'dbscan_dense.csv') epsilon = 0.04 minObservations = 45 # Load the data data = readcsv(infile, range(2), t=np.float32) result_classic = compute(data, minObservations, epsilon) data = to_numpy(data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, minObservations, epsilon) assert np.allclose(result_classic.nClusters, result_gpu.nClusters) assert np.allclose(result_classic.assignments, result_gpu.assignments) assert np.allclose(result_classic.coreIndices, result_gpu.coreIndices) assert np.allclose(result_classic.coreObservations, result_gpu.coreObservations) with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, minObservations, epsilon) assert np.allclose(result_classic.nClusters, result_cpu.nClusters) assert np.allclose(result_classic.assignments, result_cpu.assignments) assert np.allclose(result_classic.coreIndices, result_cpu.coreIndices) assert np.allclose(result_classic.coreObservations, result_cpu.coreObservations) return result_classic
def main(readcsv=read_csv, method='defaultDense'): infile = os.path.join('..', 'data', 'batch', 'covcormoments_dense.csv') # Load the data data = readcsv(infile, range(10), t=np.float32) # Using of the classic way (computations on CPU) result_classic = compute(data, method) data = to_numpy(data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, 'defaultDense') assert np.allclose(result_classic.covariance, result_gpu.covariance) assert np.allclose(result_classic.mean, result_gpu.mean) assert np.allclose(result_classic.correlation, result_gpu.correlation) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, 'defaultDense') # covariance result objects provide correlation, covariance and mean assert np.allclose(result_classic.covariance, result_cpu.covariance) assert np.allclose(result_classic.mean, result_cpu.mean) assert np.allclose(result_classic.correlation, result_cpu.correlation) return result_classic
def main(readcsv=read_csv, method='randomDense'): infile = os.path.join('..', 'data', 'batch', 'kmeans_dense.csv') nClusters = 20 maxIter = 5 # Load the data data = readcsv(infile, range(20)) # Using of the classic way (computations on CPU) result_classic = compute(data, nClusters, maxIter, method) data = to_numpy(data) # It is possible to specify to make the computations on GPU with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, nClusters, maxIter, method) # Kmeans result objects provide assignments (if requested), centroids, goalFunction, nIterations and objectiveFunction assert result_classic.centroids.shape[0] == nClusters assert result_classic.assignments.shape == (data.shape[0], 1) assert result_classic.nIterations <= maxIter assert np.allclose(result_classic.centroids, result_gpu.centroids) assert np.allclose(result_classic.assignments, result_gpu.assignments) assert np.isclose(result_classic.objectiveFunction, result_gpu.objectiveFunction) assert result_classic.nIterations == result_gpu.nIterations return result_classic
def main(readcsv=read_csv, method='defaultDense'): infile = "../data/batch/dbscan_dense.csv" epsilon = 0.04 minObservations = 45 # Load the data data = readcsv(infile, range(2)) result_classic = compute(data, minObservations, epsilon) data = to_numpy(data) # It is possible to specify to make the computations on GPU with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, minObservations, epsilon) # Note: we could have done this in just one line: # assignments = d4p.dbscan(minObservations=minObservations, epsilon=epsilon, resultsToCompute='computeCoreIndices|computeCoreObservations').compute(data).assignments # DBSCAN result objects provide assignments, nClusters and coreIndices/coreObservations (if requested) assert np.allclose(result_classic.nClusters, result_gpu.nClusters) assert np.allclose(result_classic.assignments, result_gpu.assignments) return result_classic
def main(readcsv=read_csv, method='defaultDense'): maxIterations = 200 # input data file infile = os.path.join('..', 'data', 'batch', 'df_regression_train.csv') testfile = os.path.join('..', 'data', 'batch', 'df_regression_test.csv') # Read data. Let's use 13 features per observation train_indep_data = readcsv(infile, range(13), t=np.float32) train_dep_data = readcsv(infile, range(13, 14), t=np.float32) # read test data (with same #features) test_indep_data = readcsv(testfile, range(13), t=np.float32) # Using of the classic way (computations on CPU) result_classic = compute(train_indep_data, train_dep_data, test_indep_data, maxIterations) train_indep_data = to_numpy(train_indep_data) train_dep_data = to_numpy(train_dep_data) test_indep_data = to_numpy(test_indep_data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') # It is possible to specify to make the computations on GPU with gpu_context(): sycl_train_indep_data = sycl_buffer(train_indep_data) sycl_train_dep_data = sycl_buffer(train_dep_data) sycl_test_indep_data = sycl_buffer(test_indep_data) _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data, maxIterations) test_dep_data = np.loadtxt(testfile, usecols=range(13, 14), delimiter=',', ndmin=2, dtype=np.float32) return (result_classic, test_dep_data)
def main(readcsv=read_csv, method='svdDense'): dataFileName = os.path.join('..', 'data', 'batch', 'pca_transform.csv') nComponents = 2 # read data data = readcsv(dataFileName, range(3), t=np.float32) # Using of the classic way (computations on CPU) result_classic = compute(data, nComponents) data = to_numpy(data) try: from dpctx import device_context, device_type def gpu_context(): return device_context(device_type.gpu, 0) def cpu_context(): return device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context def gpu_context(): return sycl_context('gpu') def cpu_context(): return sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data, nComponents) assert np.allclose(result_classic.transformedData, result_gpu.transformedData) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data, nComponents) # pca_transform_result objects provides transformedData assert np.allclose(result_classic.transformedData, result_cpu.transformedData) return (result_classic)
def main(readcsv=read_csv, method='defaultDense'): # Input data set parameters train_file = os.path.join('..', 'data', 'batch', 'k_nearest_neighbors_train.csv') predict_file = os.path.join('..', 'data', 'batch', 'k_nearest_neighbors_test.csv') # Read data. Let's use 5 features per observation nFeatures = 5 nClasses = 5 train_data = readcsv(train_file, range(nFeatures)) train_labels = readcsv(train_file, range(nFeatures, nFeatures + 1)) predict_data = readcsv(predict_file, range(nFeatures)) predict_labels = readcsv(predict_file, range(nFeatures, nFeatures + 1)) train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dppl import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') # It is possible to specify to make the computations on GPU with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) # Create an algorithm object and call compute train_algo = d4p.bf_knn_classification_training(nClasses=nClasses) train_result = train_algo.compute(sycl_train_data, sycl_train_labels) # Create an algorithm object and call compute predict_algo = d4p.bf_knn_classification_prediction() predict_result = predict_algo.compute(sycl_predict_data, train_result.model) # We expect less than 170 mispredicted values assert np.count_nonzero(predict_labels != predict_result.prediction) < 170 return (predict_result, predict_labels)
def main(readcsv=read_csv, method='svdDense'): infile = os.path.join('..', 'data', 'batch', 'pca_normalized.csv') # Load the data data = readcsv(infile) # Using of the classic way (computations on CPU) result_classic = compute(data) data = to_numpy(data) # It is possible to specify to make the computations on GPU if gpu_available: with sycl_context('gpu'): sycl_data = sycl_buffer(data) result_gpu = compute(sycl_data) assert np.allclose(result_classic.eigenvalues, result_gpu.eigenvalues) assert np.allclose(result_classic.eigenvectors, result_gpu.eigenvectors) assert np.allclose(result_classic.means, result_gpu.means, atol=1e-7) assert np.allclose(result_classic.variances, result_gpu.variances) # It is possible to specify to make the computations on CPU with sycl_context('cpu'): sycl_data = sycl_buffer(data) result_cpu = compute(sycl_data) # PCA result objects provide eigenvalues, eigenvectors, means and variances assert result_classic.eigenvalues.shape == (1, data.shape[1]) assert result_classic.eigenvectors.shape == (data.shape[1], data.shape[1]) assert result_classic.means.shape == (1, data.shape[1]) assert result_classic.variances.shape == (1, data.shape[1]) assert np.allclose(result_classic.eigenvalues, result_cpu.eigenvalues) assert np.allclose(result_classic.eigenvectors, result_cpu.eigenvectors) assert np.allclose(result_classic.means, result_cpu.means, atol=1e-7) assert np.allclose(result_classic.variances, result_cpu.variances) return result_classic
def main(readcsv=read_csv, method='defaultDense'): nClasses = 2 nFeatures = 20 # read training data from file with 20 features per observation and 1 class label trainfile = os.path.join('..', 'data', 'batch', 'binary_cls_train.csv') train_data = readcsv(trainfile, range(nFeatures), t=np.float32) train_labels = readcsv(trainfile, range(nFeatures, nFeatures + 1), t=np.float32) # read testing data from file with 20 features per observation testfile = os.path.join('..', 'data', 'batch', 'binary_cls_test.csv') predict_data = readcsv(testfile, range(nFeatures), t=np.float32) predict_labels = readcsv(testfile, range(nFeatures, nFeatures + 1), t=np.float32) # Using of the classic way (computations on CPU) result_classic, train_result = compute(train_data, train_labels, predict_data, nClasses) train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dpctx import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) result_gpu, _ = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) assert np.allclose(result_classic.prediction, result_gpu.prediction) # It is possible to specify to make the computations on GPU with cpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) result_cpu, _ = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) # the prediction result provides prediction assert result_classic.prediction.shape == (predict_data.shape[0], train_labels.shape[1]) assert np.allclose(result_classic.prediction, result_cpu.prediction) return (train_result, result_classic, predict_labels)
def main(readcsv=read_csv, method='defaultDense'): nClasses = 5 nFeatures = 6 # read training data from file with 6 features per observation and 1 class label trainfile = os.path.join('..', 'data', 'batch', 'logreg_train.csv') train_data = readcsv(trainfile, range(nFeatures), t=np.float32) train_labels = readcsv(trainfile, range(nFeatures, nFeatures + 1), t=np.float32) # read testing data from file with 6 features per observation testfile = os.path.join('..', 'data', 'batch', 'logreg_test.csv') predict_data = readcsv(testfile, range(nFeatures), t=np.float32) # Using of the classic way (computations on CPU) result_classic, train_result = compute(train_data, train_labels, predict_data, nClasses) train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dpctx import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) result_gpu, _ = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) assert np.allclose(result_classic.prediction, result_gpu.prediction) assert np.allclose(result_classic.probabilities, result_gpu.probabilities, atol=1e-3) assert np.allclose(result_classic.logProbabilities, result_gpu.logProbabilities, atol=1e-2) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) result_cpu, _ = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) # the prediction result provides prediction, probabilities and logProbabilities assert result_classic.probabilities.shape == (predict_data.shape[0], nClasses) assert result_classic.logProbabilities.shape == (predict_data.shape[0], nClasses) predict_labels = np.loadtxt(testfile, usecols=range(nFeatures, nFeatures + 1), delimiter=',', ndmin=2) assert np.count_nonzero(result_classic.prediction-predict_labels)/predict_labels.shape[0] < 0.025 assert np.allclose(result_classic.prediction, result_cpu.prediction) assert np.allclose(result_classic.probabilities, result_cpu.probabilities) assert np.allclose(result_classic.logProbabilities, result_cpu.logProbabilities) return (train_result, result_classic, predict_labels)
def main(readcsv=read_csv, method='defaultDense'): # Input data set parameters train_file = os.path.join('..', 'data', 'batch', 'k_nearest_neighbors_train.csv') predict_file = os.path.join('..', 'data', 'batch', 'k_nearest_neighbors_test.csv') # Read data. Let's use 5 features per observation nFeatures = 5 nClasses = 5 train_data = readcsv(train_file, range(nFeatures)) train_labels = readcsv(train_file, range(nFeatures, nFeatures + 1)) predict_data = readcsv(predict_file, range(nFeatures)) predict_labels = readcsv(predict_file, range(nFeatures, nFeatures + 1)) predict_result_classic = compute(train_data, train_labels, predict_data, nClasses) # We expect less than 170 mispredicted values assert np.count_nonzero( predict_labels != predict_result_classic.prediction) < 170 train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) try: from dpctx import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') if gpu_available: with gpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) predict_result_gpu = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) assert np.allclose(predict_result_gpu.prediction, predict_result_classic.prediction) with cpu_context(): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) predict_result_cpu = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) assert np.allclose(predict_result_cpu.prediction, predict_result_classic.prediction) return (predict_result_classic, predict_labels)
def main(readcsv=read_csv, method='defaultDense'): nClasses = 2 nFeatures = 20 # read training data from file with 20 features per observation and 1 class label trainfile = os.path.join('..', 'data', 'batch', 'binary_cls_train.csv') train_data = readcsv(trainfile, range(nFeatures)) train_labels = readcsv(trainfile, range(nFeatures, nFeatures + 1)) # read testing data from file with 20 features per observation testfile = os.path.join('..', 'data', 'batch', 'binary_cls_test.csv') predict_data = readcsv(testfile, range(nFeatures)) predict_labels = readcsv(testfile, range(nFeatures, nFeatures + 1)) # Using of the classic way (computations on CPU) result_classic, train_result = compute(train_data, train_labels, predict_data, nClasses) train_data = to_numpy(train_data) train_labels = to_numpy(train_labels) predict_data = to_numpy(predict_data) # It is possible to specify to make the computations on GPU with sycl_context('gpu'): sycl_train_data = sycl_buffer(train_data) sycl_train_labels = sycl_buffer(train_labels) sycl_predict_data = sycl_buffer(predict_data) result_gpu, _ = compute(sycl_train_data, sycl_train_labels, sycl_predict_data, nClasses) # the prediction result provides prediction assert result_classic.prediction.shape == (predict_data.shape[0], train_labels.shape[1]) assert np.allclose(result_classic.prediction, result_gpu.prediction) return (train_result, result_classic, predict_labels)
def main(readcsv=read_csv, method='defaultDense'): # read training data. Let's have 10 independent, and 2 dependent variables (for each observation) trainfile = os.path.join('..', 'data', 'batch', 'linear_regression_train.csv') train_indep_data = readcsv(trainfile, range(10)) train_dep_data = readcsv(trainfile, range(10, 12)) # read testing data testfile = os.path.join('..', 'data', 'batch', 'linear_regression_test.csv') test_indep_data = readcsv(testfile, range(10)) test_dep_data = readcsv(testfile, range(10, 12)) # Using of the classic way (computations on CPU) result_classic, train_result = compute(train_indep_data, train_dep_data, test_indep_data) train_indep_data = to_numpy(train_indep_data) train_dep_data = to_numpy(train_dep_data) test_indep_data = to_numpy(test_indep_data) # It is possible to specify to make the computations on GPU with sycl_context('gpu'): sycl_train_indep_data = sycl_buffer(train_indep_data) sycl_train_dep_data = sycl_buffer(train_dep_data) sycl_test_indep_data = sycl_buffer(test_indep_data) result_gpu, _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data) # The prediction result provides prediction assert result_classic.prediction.shape == (test_dep_data.shape[0], test_dep_data.shape[1]) assert np.allclose(result_classic.prediction, result_gpu.prediction) return (train_result, result_classic, test_dep_data)
def main(readcsv=read_csv, method='defaultDense'): # read training data. Let's have 10 independent, and 2 dependent variables (for each observation) trainfile = os.path.join('..', 'data', 'batch', 'linear_regression_train.csv') train_indep_data = readcsv(trainfile, range(10), t=np.float32) train_dep_data = readcsv(trainfile, range(10, 12), t=np.float32) # read testing data testfile = os.path.join('..', 'data', 'batch', 'linear_regression_test.csv') test_indep_data = readcsv(testfile, range(10), t=np.float32) test_dep_data = readcsv(testfile, range(10, 12), t=np.float32) # Using of the classic way (computations on CPU) result_classic, train_result = compute(train_indep_data, train_dep_data, test_indep_data) train_indep_data = to_numpy(train_indep_data) train_dep_data = to_numpy(train_dep_data) test_indep_data = to_numpy(test_indep_data) try: from dpctx import device_context, device_type gpu_context = lambda: device_context(device_type.gpu, 0) cpu_context = lambda: device_context(device_type.cpu, 0) except: from daal4py.oneapi import sycl_context gpu_context = lambda: sycl_context('gpu') cpu_context = lambda: sycl_context('cpu') # It is possible to specify to make the computations on GPU if gpu_available: with gpu_context(): sycl_train_indep_data = sycl_buffer(train_indep_data) sycl_train_dep_data = sycl_buffer(train_dep_data) sycl_test_indep_data = sycl_buffer(test_indep_data) result_gpu, _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data) assert np.allclose(result_classic.prediction, result_gpu.prediction) # It is possible to specify to make the computations on CPU with cpu_context(): sycl_train_indep_data = sycl_buffer(train_indep_data) sycl_train_dep_data = sycl_buffer(train_dep_data) sycl_test_indep_data = sycl_buffer(test_indep_data) result_cpu, _ = compute(sycl_train_indep_data, sycl_train_dep_data, sycl_test_indep_data) # The prediction result provides prediction assert result_classic.prediction.shape == (test_dep_data.shape[0], test_dep_data.shape[1]) assert np.allclose(result_classic.prediction, result_cpu.prediction) return (train_result, result_classic, test_dep_data)