├── Chapter06
    ├── 6.1. Understanding How CUDA-C-C++ Works with A Simple Example
    │   ├── README.md
    │   ├── cpu_multiply.cpp
    │   ├── gpu_multiply.cu
    │   └── gpu_multiply_revised.cu
    ├── 6.4. How Computing in PyCUDA Works on Python
    │   ├── README.md
    │   ├── conventional_python_code.py
    │   ├── pycuda_based_python_code.py
    │   └── testing_pycuda_without_any_cuda_code.py
    └── 6.6. Writing your first PyCUDA Programs to Compute a General Purpose Solution
    │   ├── README.md
    │   ├── hello_world_from_nvidia_gpu.py
    │   └── mathematical_formula.py
├── Chapter07
    ├── 7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL
    │   ├── README.md
    │   ├── gpu_multiply_kernel.cl
    │   ├── gpu_multiply_ported_to_hip.cpp
    │   ├── gpu_multiply_revised_partially_ported_to_hip.cpp
    │   └── main.cpp
    ├── 7.4. How Computing in PyOpenCL Works on Python
    │   ├── README.md
    │   ├── pyopencl_based_python_code.py
    │   ├── pyopencl_version_of_pycuda_example.py
    │   └── testing_pyopencl_without_opencl_code.py
    └── 7.6. Writing your first PyOpenCL Programs to Compute a General Purpose Solution
    │   ├── README.md
    │   ├── pyopencl_shortened_kernel_with_python.py
    │   ├── pyopencl_simplified_opencl_with_python.py
    │   └── simultaneous_division.py
├── Chapter08
    ├── 8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions
    │   ├── CuPy
    │   │   ├── README.md
    │   │   ├── raw_cuda_kernel_on_cupy.py
    │   │   └── replacing_numpy_code_with_cupy.py
    │   ├── Numba
    │   │   ├── README.md
    │   │   ├── numba_cuda_kernel_with_numpy.py
    │   │   ├── using_jit_with_numba.py
    │   │   └── using_numba_with_vectorized_cuda_target.py
    │   └── README.md
    └── 8.8. Interoperability between CuPy and Numba within a Single Python Program
    │   ├── README.md
    │   └── numba_cuda_kernel_with_cupy_interoperability.py
├── Chapter10
    └── 10.10. Writing your first GPU accelerated machine learning programs
    │   ├── README.md
    │   ├── pytorch_cifar-10.py
    │   └── tensorflow_fashion-mnist.py
├── Chapter11
    └── 11.4. Testing an Example from the Deepchem Repository
    │   ├── DeepChem_BACE.ipynb
    │   ├── README.md
    │   └── deepchem_predicting_a_ki_ligand_for_a_protein.py
├── LICENSE
└── README.md


/Chapter06/6.1. Understanding How CUDA-C-C++ Works with A Simple Example/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter06/6.1. Understanding How CUDA-C-C++ Works with A Simple Example/cpu_multiply.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream> //Defining standard input/output stream objects
 2 | #include <math.h>   //For using predefined math functions
 3 | #define N 500000000 //500 Million elements
 4 | 
 5 | clock_t begin, end;
 6 | float cpu_time_used;
 7 |      
 8 | // This is a function to multiply two array elements and also update the results on the second array
 9 | void multiply(int n, double *p, double *q)
10 | {
11 |   for (int i = 0; i < n; i++)
12 |       q[i] = p[i] * q[i];
13 | }
14 | 
15 | int main(void)
16 | {
17 |   double *p = new double[N];
18 |   double *q = new double[N];
19 | 
20 |   // initialize arrays p and q on the host
21 |   for (int i = 0; i < N; i++) {
22 |     p[i] = 24.0;
23 |     q[i] = 12.0;
24 |   }
25 | 
26 |   // Run function on 500 Million elements on the CPU
27 |   begin = clock();
28 |   multiply(N, p, q);
29 |   end = clock();
30 |   cpu_time_used = ((double) (end - begin)) / CLOCKS_PER_SEC;
31 | 
32 |   // Verifying all values to be 288.0
33 |   // fabs(q[i]-288) (absolute value) should be 0
34 |   double maxError = 0.0;
35 |   for (int i = 0; i < N; i++){
36 |       maxError = fmax(maxError, fabs(q[i]-288.0));
37 |   }
38 |       std::cout << "Multiply function CPU execution time: " << cpu_time_used << " second(s)" << std::endl;
39 |       std::cout << "Max error: " << maxError << std::endl;
40 | 
41 |   // Free memory
42 |   delete [] p;
43 |   delete [] q;
44 | 
45 |   return 0;
46 | }
47 | 
48 | 


--------------------------------------------------------------------------------
/Chapter06/6.1. Understanding How CUDA-C-C++ Works with A Simple Example/gpu_multiply.cu:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | #define N 500000000 //500 Million Elements
 4 | #define THREADS_PER_BLOCK 1024
 5 | 
 6 | // GPU kernel function to multiply two array elements and also update the results on the second array
 7 | __global__ void multiply(double *p, double *q, unsigned long n){
 8 | 	int index = threadIdx.x + blockIdx.x * blockDim.x;
 9 | 	if (index < n)
10 | 		q[index] = p[index] * q[index];
11 | }
12 | 
13 | 
14 | int main(void) {
15 | 
16 | 	double *p, *q; // host copies of p, q
17 | 	double *gpu_p, *gpu_q; // device copies of p, q
18 | 	unsigned long size = N * sizeof(unsigned long); // we need space for N unsigned long integers
19 | 	unsigned long i;
20 | 	// Allocate GPU/device copies of gpu_p, gpu_q
21 | 	cudaMalloc((void**)&gpu_p, size);
22 | 	cudaMalloc((void**)&gpu_q, size);
23 | 
24 | 
25 | 	// Allocate CPU/host copies of p, q
26 | 	p = (double *)malloc(size);
27 | 	q = (double *)malloc(size);
28 | 
29 | 
30 | 	// Setup input values
31 | 	for (i = 0; i < N - 1; ++i)
32 | 	{
33 | 		p[i] = 24.0;
34 | 		q[i] = 12.0;
35 | 	}
36 | 
37 | 	// Copy inputs to device
38 | 	cudaMemcpy(gpu_p, p, size, cudaMemcpyHostToDevice);
39 | 	cudaMemcpy(gpu_q, q, size, cudaMemcpyHostToDevice);
40 | 
41 | 	//INITIALIZE CUDA EVENTS
42 | 	cudaEvent_t start, stop;
43 | 	float elapsedTime; 
44 | 
45 | 	//CREATING EVENTS
46 | 	cudaEventCreate(&start);
47 | 	cudaEventCreate(&stop);
48 | 	cudaEventRecord(start, 0);
49 | 
50 | 	//CUDA KERNEL STUFF HERE...
51 | 	// Launch multiply() kernel on GPU with N threads
52 | 	multiply << <(N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK, THREADS_PER_BLOCK >> >(gpu_p, gpu_q, N);
53 | 
54 | 	//FINISH RECORDING
55 | 	cudaEventRecord(stop, 0);
56 | 	cudaEventSynchronize(stop);
57 | 
58 | 	//CALCULATE ELAPSED TIME
59 | 	cudaEventElapsedTime(&elapsedTime, start, stop);
60 | 
61 | 	//DISPLAY COMPUTATION TIME
62 | 	
63 | 	cudaDeviceProp prop;
64 | 	int count;
65 | 
66 | 	cudaGetDeviceCount(&count);
67 | 
68 | 	for (int igtx = 0; igtx < count; igtx++) {
69 | 		cudaGetDeviceProperties(&prop, igtx);
70 | 		printf("\nGPU Device used for computation: %s\n", prop.name);
71 | 		printf("\nMultiplication on GPU computed in: %f milliseconds", elapsedTime);
72 | 	}
73 | 	
74 | 	// Copy device result back to host copy of q
75 | 	cudaMemcpy(q, gpu_q, size, cudaMemcpyDeviceToHost);
76 | 	
77 | 	// Verifying all values to be 288.0
78 |   	// fabs(q[i]-288) (absolute value) should be 0
79 | 	double maxError = 0.0;
80 | 	for (int i = 0; i < N-1; ++i){
81 |     		maxError = fmax(maxError, fabs(q[i]-288.0));
82 | 	}
83 |   	std::cout << "\nMax error: " << maxError << std::endl;
84 | 
85 | 	// Clean CPU memory allocations
86 | 	free(p); free(q); 
87 | 
88 | 	// Clean GPU memory allocations
89 | 	cudaFree(gpu_p);
90 | 	cudaFree(gpu_q);
91 | 	
92 | 	return 0;
93 | }
94 | 


--------------------------------------------------------------------------------
/Chapter06/6.1. Understanding How CUDA-C-C++ Works with A Simple Example/gpu_multiply_revised.cu:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | #define N 500000000 //500 Million Elements
  4 | #define THREADS_PER_BLOCK 1024
  5 | 
  6 | // GPU kernel function to multiply two array elements and also update the results on the second array
  7 | __global__ void multiply(double *p, double *q, unsigned long n){
  8 | 	int index = threadIdx.x + blockIdx.x * blockDim.x;
  9 | 	if (index < n)
 10 | 		q[index] = p[index] * q[index];
 11 | }
 12 | 
 13 | 
 14 | int main(void) {
 15 | 
 16 | 	double *p, *q; // host copies of p, q
 17 | 	//double *gpu_p, *gpu_q; // device copies of p, q
 18 | 	unsigned long size = N * sizeof(unsigned long); // we need space for N unsigned long integers
 19 | 	unsigned long i;
 20 | 	
 21 | 	/*	
 22 | 	// Allocate GPU/device copies of gpu_p, gpu_q
 23 | 	cudaMalloc((void**)&gpu_p, size);
 24 | 	cudaMalloc((void**)&gpu_q, size);
 25 | 
 26 | 
 27 | 	// Allocate CPU/host copies of p, q
 28 | 	p = (double *)malloc(size);
 29 | 	q = (double *)malloc(size);
 30 | 	*/
 31 | 
 32 | 	//Unified Memory Allocation for CPU and GPU
 33 |  	cudaMallocManaged((void**)&p, size);
 34 |   	cudaMallocManaged((void**)&q, size);
 35 | 
 36 | 
 37 | 	// Setup input values
 38 | 	for (i = 0; i < N - 1; ++i)
 39 | 	{
 40 | 		p[i] = 24.0;
 41 | 		q[i] = 12.0;
 42 | 	}
 43 | 
 44 | 	/*
 45 | 	// Copy inputs to device
 46 | 	cudaMemcpy(gpu_p, p, size, cudaMemcpyHostToDevice);
 47 | 	cudaMemcpy(gpu_q, q, size, cudaMemcpyHostToDevice);
 48 | 	*/
 49 | 
 50 | 	//INITIALIZE CUDA EVENTS
 51 | 	cudaEvent_t start, stop;
 52 | 	float elapsedTime; 
 53 | 
 54 | 	//CREATING EVENTS
 55 | 	cudaEventCreate(&start);
 56 | 	cudaEventCreate(&stop);
 57 | 	cudaEventRecord(start, 0);
 58 | 	cudaMemPrefetchAsync(p, N * sizeof(double), 0);
 59 | 	cudaMemPrefetchAsync(q, N * sizeof(double), 0);
 60 | 	cudaDeviceSynchronize();
 61 | 
 62 | 	//CUDA KERNEL STUFF HERE...
 63 | 	// Launch multiply() kernel on GPU with N threads
 64 | 	multiply <<<(N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK, THREADS_PER_BLOCK >>>(p, q, N);
 65 | 
 66 | 	//FINISH RECORDING
 67 | 	cudaEventRecord(stop, 0);
 68 | 	cudaDeviceSynchronize();
 69 | 	cudaEventSynchronize(stop);
 70 | 
 71 | 	//CALCULATE ELAPSED TIME
 72 | 	cudaEventElapsedTime(&elapsedTime, start, stop);
 73 | 
 74 | 	//DISPLAY COMPUTATION TIME
 75 | 	
 76 | 	cudaDeviceProp prop;
 77 | 	int count;
 78 | 
 79 | 	cudaGetDeviceCount(&count);
 80 | 
 81 | 	for (int igtx = 0; igtx < count; igtx++) {
 82 | 		cudaGetDeviceProperties(&prop, igtx);
 83 | 		printf("\nGPU Device used for computation: %s\n", prop.name);
 84 | 		printf("\nMultiplication on GPU computed in: %f milliseconds", elapsedTime);
 85 | 	}
 86 | 
 87 | 	
 88 | 	/*
 89 | 	// Copy device result back to host copy of q
 90 | 	cudaMemcpy(q, gpu_q, size, cudaMemcpyDeviceToHost);
 91 | 	*/
 92 | 	
 93 |   	// Verifying all values to be 288.0
 94 | 	// fabs(q[i]-288) (absolute value) should be 0
 95 | 	double maxError = 0.0;
 96 | 	for (int i = 0; i < N-1; ++i){
 97 | 		maxError = fmax(maxError, fabs(q[i]-288.0));
 98 | 	}
 99 |   	std::cout << "\nMax error: " << maxError << std::endl;
100 | 
101 | 	// Clean unified memory allocations
102 | 	cudaFree(p);
103 | 	cudaFree(q);
104 | 
105 | 	return 0;
106 | }
107 | 


--------------------------------------------------------------------------------
/Chapter06/6.4. How Computing in PyCUDA Works on Python/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter06/6.4. How Computing in PyCUDA Works on Python/conventional_python_code.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from timeit import default_timer as timer
 3 | 
 4 | N = 500000000 #500 Million Elements
 5 | 
 6 | # CPU Function to multiply two array elements and also update the results on the second array
 7 | def multiply(p_cpu, q_cpu):
 8 |     for i in range(N):
 9 |         q_cpu[i] = p_cpu[i] * q_cpu[i]
10 | 
11 | def main():
12 |     #Initialize the two arrays of double data type all with 0.0 values upto N
13 |     p = np.zeros(N, dtype=np.double)
14 |     q = np.zeros(N, dtype=np.double)
15 |     #Update all the elements in the two arrays with 23.0 and 12.0 respectively
16 |     p.fill(23.0)
17 |     q.fill(12.0)
18 | 
19 |     #Time the CPU Function
20 |     begin = timer()
21 |     multiply(p, q)
22 |     numpy_cpu_time = timer() - begin
23 | 
24 |     #Report CPU Computation Time
25 |     print("CPU function took %f seconds." % numpy_cpu_time)
26 | 
27 |     #Choose a random integer index value between 0 to N
28 |     random = np.random.randint(0, N)
29 |     #Verify all values to be 276.0 for second array by random selection
30 |     print("New value of second array element with random index", random, "is", q[random])
31 | 
32 | if __name__ == "__main__":
33 |     main()


--------------------------------------------------------------------------------
/Chapter06/6.4. How Computing in PyCUDA Works on Python/pycuda_based_python_code.py:
--------------------------------------------------------------------------------
 1 | import pycuda.autoinit
 2 | import pycuda.driver as cudadrv
 3 | import numpy
 4 | import pycuda.gpuarray as gpuarray
 5 | from pycuda.elementwise import ElementwiseKernel
 6 | 
 7 | #Here, we multiply the two values and update all the elements of the second array with the new product
 8 | #Note that we pass C syntax into the ElementwiseKernel
 9 | multiply = ElementwiseKernel(
10 |         "double *a_gpu, double *b_gpu",
11 |         "b_gpu[i] = a_gpu[i] * b_gpu[i]",
12 |         "multiply")
13 | 
14 | N = 500000000 #500 Million Elements
15 | 
16 | a_gpu = gpuarray.to_gpu(numpy.zeros(N).astype(numpy.double))
17 | b_gpu = gpuarray.to_gpu(numpy.zeros(N).astype(numpy.double))
18 | 
19 | a_gpu.fill(23.0)
20 | b_gpu.fill(12.0)
21 | 
22 | begin = cudadrv.Event()
23 | end = cudadrv.Event()
24 | 
25 | # Time the GPU function
26 | begin.record()
27 | multiply(a_gpu, b_gpu)
28 | end.record()
29 | end.synchronize()
30 | gpu_multiply_time = begin.time_till(end)
31 | 
32 | random = numpy.random.randint(0,N)
33 | 
34 | #Randomly choose index from second array to confirm changes to second array
35 | print("New value of second array element with random index", random, "is", b_gpu[random])
36 | 
37 | # Report GPU Function time
38 | print("GPU function took %f milliseconds." % gpu_multiply_time)


--------------------------------------------------------------------------------
/Chapter06/6.4. How Computing in PyCUDA Works on Python/testing_pycuda_without_any_cuda_code.py:
--------------------------------------------------------------------------------
 1 | import pycuda.autoinit
 2 | import pycuda.gpuarray as gpuarray
 3 | import numpy as np
 4 | import pycuda.driver as cudrv
 5 | 
 6 | N = 500000000
 7 | 
 8 | begin = cudrv.Event()
 9 | end = cudrv.Event()
10 | 
11 | begin.record()
12 | a_gpu = gpuarray.to_gpu(np.zeros(N).astype(np.double))
13 | a_gpu.fill(23.0)
14 | b_gpu=a_gpu*12.0
15 | end.record()
16 | end.synchronize()
17 | pycuda_gpu_time = begin.time_till(end)
18 | 
19 | random = np.random.randint(0,N)
20 | 
21 | print("Choosing second array element with index", random, "at random:", b_gpu[random])
22 | 
23 | print("\nGPU took %f milliseconds." % pycuda_gpu_time)
24 | 
25 | 
26 | 
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/Chapter06/6.6. Writing your first PyCUDA Programs to Compute a General Purpose Solution/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter06/6.6. Writing your first PyCUDA Programs to Compute a General Purpose Solution/hello_world_from_nvidia_gpu.py:
--------------------------------------------------------------------------------
 1 | #Auto initialization for CUDA
 2 | import pycuda.autoinit
 3 | #Importing SourceModule from the PyCUDA Compiler module
 4 | from pycuda.compiler import SourceModule
 5 | 
 6 | #For a single thread on a single block
 7 | N=1
 8 | #Setting threads per block. Here, it is set to 1
 9 | Threads_per_block = (int(1))
10 | #Setting blocks per grid, also calculated as 1.
11 | Blocks_per_grid = (int((N + Threads_per_block - 1) / Threads_per_block))
12 | 
13 | #Printing from the GPU device itself!
14 | mod = SourceModule("""
15 | __global__ void hello_from_nvidia_gpu()
16 | {
17 |   printf("Hello World from NVIDIA GPU!");
18 | }
19 | """)
20 | #Return the Function name in the get_function module
21 | hello_from_nvidia_gpu = mod.get_function("hello_from_nvidia_gpu")
22 | 
23 | #Invoking the NVIDIA GPU Kernel
24 | hello_from_nvidia_gpu(block=(Threads_per_block, 1, 1), grid=(Blocks_per_grid, 1))


--------------------------------------------------------------------------------
/Chapter06/6.6. Writing your first PyCUDA Programs to Compute a General Purpose Solution/mathematical_formula.py:
--------------------------------------------------------------------------------
 1 | import pycuda.autoinit
 2 | import numpy
 3 | import pycuda.gpuarray as gpuarray
 4 | import pycuda.driver as drv
 5 | from pycuda.elementwise import ElementwiseKernel
 6 | 
 7 | #Here, we compute a mathematical formula
 8 | #Note that we pass C/C++ syntax into the ElementwiseKernel
 9 | compute = ElementwiseKernel(
10 |         "double *a_gpu, double *b_gpu, double *c_gpu",
11 |         "c_gpu[i] = (cos(a_gpu[i])*cos(a_gpu[i])) * (b_gpu[i]* b_gpu[i])+sin(a_gpu[i]*b_gpu[i])",
12 |         "compute")
13 | 
14 | N = 500000000
15 | #Threads_per_block = (int(1024))
16 | #Blocks_per_grid = (int((N + Threads_per_block - 1) / Threads_per_block))
17 | 
18 | a_gpu = gpuarray.to_gpu(numpy.zeros(N).astype(numpy.double))
19 | b_gpu = gpuarray.to_gpu(numpy.zeros(N).astype(numpy.double))
20 | c_gpu = gpuarray.to_gpu(numpy.zeros(N).astype(numpy.double))
21 | 
22 | a_gpu.fill(24.0)
23 | b_gpu.fill(12.0)
24 | 
25 | start = drv.Event()
26 | end = drv.Event()
27 | 
28 | # Time the GPU function
29 | start.record()
30 | compute(a_gpu, b_gpu, c_gpu)
31 | end.record()
32 | end.synchronize()
33 | gpu_compute_time = start.time_till(end)
34 | 
35 | random = numpy.random.randint(0,N)
36 | 
37 | #Randomly choose index from second array to confirm changes to second array
38 | print("New value of second array element with random index ", random, "is ", c_gpu[random])
39 | 
40 | # Report times
41 | print("GPU function took %f milliseconds." % gpu_compute_time)


--------------------------------------------------------------------------------
/Chapter07/7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter07/7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL/gpu_multiply_kernel.cl:
--------------------------------------------------------------------------------
 1 | // GPU kernel function to multiply two array elements and also update the results on a third array
 2 | __kernel void multiply(__global double *p, __global double *q, __global double *r) {
 3 |  
 4 |     // Indexing the current element to process - equivalent to int index = threadIdx.x + blockIdx.x * blockDim.x in CUDA
 5 |     int index = get_global_id(0);
 6 |  
 7 |     // Simultaneous multiplication within this OpenCL kernel
 8 |     r[index] = p[index] * q[index];
 9 | }
10 | 


--------------------------------------------------------------------------------
/Chapter07/7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL/gpu_multiply_ported_to_hip.cpp:
--------------------------------------------------------------------------------
 1 | #include <hip/hip_runtime.h>
 2 | #include <iostream>
 3 | 
 4 | #define N 500000000 //500 Million Elements
 5 | #define THREADS_PER_BLOCK 1024
 6 | 
 7 | // GPU kernel function to multiply two array elements and also update the results on the second array
 8 | __global__ void multiply(double *p, double *q, unsigned long n){
 9 | 	int index = threadIdx.x + blockIdx.x * blockDim.x;
10 | 	//int index = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
11 | 	if (index < n)
12 | 		q[index] = p[index] * q[index];
13 | }
14 | 
15 | 
16 | int main(void) {
17 | 
18 | 	double *p, *q; // host copies of p, q
19 | 	double *gpu_p, *gpu_q; // device copies of p, q
20 | 	unsigned long size = N * sizeof(unsigned long); // we need space for N unsigned long integers
21 | 	unsigned long i;
22 | 	// Allocate GPU/device copies of gpu_p, gpu_q
23 | 	hipMalloc((void**)&gpu_p, size);
24 | 	hipMalloc((void**)&gpu_q, size);
25 | 
26 | 
27 | 	// Allocate CPU/host copies of p, q
28 | 	p = (double *)malloc(size);
29 | 	q = (double *)malloc(size);
30 | 
31 | 
32 | 	// Setup input values
33 | 	for (i = 0; i < N - 1; ++i)
34 | 	{
35 | 		p[i] = 24.0;
36 | 		q[i] = 12.0;
37 | 	}
38 | 
39 | 	// Copy inputs to device
40 | 	hipMemcpy(gpu_p, p, size, hipMemcpyHostToDevice);
41 | 	hipMemcpy(gpu_q, q, size, hipMemcpyHostToDevice);
42 | 
43 | 	//INITIALIZE HIP EVENTS
44 | 	hipEvent_t start, stop;
45 | 	float elapsedTime; 
46 | 
47 | 	//CREATING EVENTS
48 | 	hipEventCreate(&start);
49 | 	hipEventCreate(&stop);
50 | 	hipEventRecord(start, 0);
51 | 
52 | 	//HIP KERNEL STUFF HERE...
53 | 	// Launch multiply() kernel on GPU with N threads
54 | 	hipLaunchKernelGGL(multiply, dim3((N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK), dim3(THREADS_PER_BLOCK), 0, 0, gpu_p, gpu_q, N);
55 | 
56 | 	//FINISH RECORDING
57 | 	hipEventRecord(stop, 0);
58 | 	hipEventSynchronize(stop);
59 | 
60 | 	//CALCULATE ELAPSED TIME
61 | 	hipEventElapsedTime(&elapsedTime, start, stop);
62 | 
63 | 	//DISPLAY COMPUTATION TIME
64 | 	
65 | 	hipDeviceProp_t prop;
66 | 	int count;
67 | 
68 | 	hipGetDeviceCount(&count);
69 | 
70 | 	for (int igtx = 0; igtx < count; igtx++) {
71 | 		hipGetDeviceProperties(&prop, igtx);
72 | 		printf("\nGPU Device used for computation: %s\n", prop.name);
73 | 		printf("\nMultiplication on GPU computed in: %f milliseconds", elapsedTime);
74 | 	}
75 | 	
76 | 	// Copy device result back to host copy of q
77 | 	hipMemcpy(q, gpu_q, size, hipMemcpyDeviceToHost);
78 | 	
79 | 	// Verifying all values to be 288.0
80 |   	// fabs(q[i]-288) (absolute value) should be 0
81 | 	double maxError = 0.0;
82 | 	for (int i = 0; i < N-1; ++i){
83 |     		maxError = fmax(maxError, fabs(q[i]-288.0));
84 | 	}
85 |   	std::cout << "\nMax error: " << maxError << std::endl;
86 | 
87 | 	// Clean CPU memory allocations
88 | 	free(p); free(q); 
89 | 
90 | 	// Clean GPU memory allocations
91 | 	hipFree(gpu_p);
92 | 	hipFree(gpu_q);
93 | 	
94 | 	return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/Chapter07/7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL/gpu_multiply_revised_partially_ported_to_hip.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <hip/hip_runtime.h>
  3 | #include <iostream>
  4 | 
  5 | #define N 500000000 //500 Million Elements
  6 | #define THREADS_PER_BLOCK 1024
  7 | 
  8 | // GPU kernel function to multiply two array elements and also update the results on the second array
  9 | __global__ void multiply(double *p, double *q, unsigned long n){
 10 | 	int index = threadIdx.x + blockIdx.x * blockDim.x;
 11 | 	if (index < n)
 12 | 		q[index] = p[index] * q[index];
 13 | }
 14 | 
 15 | 
 16 | int main(void) {
 17 | 
 18 | 	double *p, *q; // host copies of p, q
 19 | 	//double *gpu_p, *gpu_q; // device copies of p, q
 20 | 	unsigned long size = N * sizeof(unsigned long); // we need space for N unsigned long integers
 21 | 	unsigned long i;
 22 | 	
 23 | 	/*	
 24 | 	// Allocate GPU/device copies of gpu_p, gpu_q
 25 | 	cudaMalloc((void**)&gpu_p, size);
 26 | 	cudaMalloc((void**)&gpu_q, size);
 27 | 
 28 | 
 29 | 	// Allocate CPU/host copies of p, q
 30 | 	p = (double *)malloc(size);
 31 | 	q = (double *)malloc(size);
 32 | 	*/
 33 | 
 34 | 	//Unified Memory Allocation for CPU and GPU
 35 |  	cudaMallocManaged((void**)&p, size);
 36 |   	cudaMallocManaged((void**)&q, size);
 37 | 
 38 | 
 39 | 	// Setup input values
 40 | 	for (i = 0; i < N - 1; ++i)
 41 | 	{
 42 | 		p[i] = 24.0;
 43 | 		q[i] = 12.0;
 44 | 	}
 45 | 
 46 | 	/*
 47 | 	// Copy inputs to device
 48 | 	cudaMemcpy(gpu_p, p, size, cudaMemcpyHostToDevice);
 49 | 	cudaMemcpy(gpu_q, q, size, cudaMemcpyHostToDevice);
 50 | 	*/
 51 | 
 52 | 	//INITIALIZE CUDA EVENTS
 53 | 	hipEvent_t start, stop;
 54 | 	float elapsedTime; 
 55 | 
 56 | 	//CREATING EVENTS
 57 | 	hipEventCreate(&start);
 58 | 	hipEventCreate(&stop);
 59 | 	hipEventRecord(start, 0);
 60 | 	cudaMemPrefetchAsync(p, N * sizeof(double), 0);
 61 | 	cudaMemPrefetchAsync(q, N * sizeof(double), 0);
 62 | 	hipDeviceSynchronize();
 63 | 
 64 | 	//CUDA KERNEL STUFF HERE...
 65 | 	// Launch multiply() kernel on GPU with N threads
 66 | 	hipLaunchKernelGGL(multiply, dim3((N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK), dim3(THREADS_PER_BLOCK), 0, 0, p, q, N);
 67 | 
 68 | 	//FINISH RECORDING
 69 | 	hipEventRecord(stop, 0);
 70 | 	hipDeviceSynchronize();
 71 | 	hipEventSynchronize(stop);
 72 | 
 73 | 	//CALCULATE ELAPSED TIME
 74 | 	hipEventElapsedTime(&elapsedTime, start, stop);
 75 | 
 76 | 	//DISPLAY COMPUTATION TIME
 77 | 	
 78 | 	hipDeviceProp_t prop;
 79 | 	int count;
 80 | 
 81 | 	hipGetDeviceCount(&count);
 82 | 
 83 | 	for (int igtx = 0; igtx < count; igtx++) {
 84 | 		hipGetDeviceProperties(&prop, igtx);
 85 | 		printf("\nGPU Device used for computation: %s\n", prop.name);
 86 | 		printf("\nMultiplication on GPU computed in: %f milliseconds", elapsedTime);
 87 | 	}
 88 | 
 89 | 	
 90 | 	/*
 91 | 	// Copy device result back to host copy of q
 92 | 	cudaMemcpy(q, gpu_q, size, cudaMemcpyDeviceToHost);
 93 | 	*/
 94 | 	
 95 |   	// Verifying all values to be 288.0
 96 | 	// fabs(q[i]-288) (absolute value) should be 0
 97 | 	double maxError = 0.0;
 98 | 	for (int i = 0; i < N-1; ++i){
 99 |     		maxError = fmax(maxError, fabs(q[i]-288.0));
100 | 	}
101 |   	std::cout << "\nMax error: " << maxError << std::endl;
102 | 
103 | 	// Clean unified memory allocations
104 | 	hipFree(p);
105 | 	hipFree(q);
106 | 
107 | 	return 0;
108 | }
109 | 


--------------------------------------------------------------------------------
/Chapter07/7.1. Understanding How ROCm-C-C++ Works with HIPify,  HIP and OpenCL/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <CL/cl.h>
  4 | #include <math.h>
  5 | #include <iostream>
  6 | using namespace std;
  7 | 
  8 | #define N (0x15000000) //15 Million Elements
  9 |  
 10 | int main(void) {
 11 |     // Creating two input arrays with two values on each
 12 |     double *p = (double*)malloc(sizeof(double)*N);
 13 |     double *q = (double*)malloc(sizeof(double)*N);
 14 |     for(int i = 0; i < N-1; ++i) {
 15 |         p[i] = 23;
 16 |         q[i] = 12;
 17 |     }
 18 |  
 19 |     // Loading source code from .cl file into the array cl_source
 20 |     FILE *opencl_file;
 21 |     char *cl_source;
 22 |     size_t source_size; 
 23 | 
 24 |     opencl_file = fopen("gpu_multiply_kernel.cl", "r");
 25 |     if (!opencl_file) {
 26 |         fprintf(stderr, "Failed to load opencl_kernel.\n");
 27 |         exit(1);
 28 |     }
 29 |     cl_source = (char*)malloc(N);
 30 |     source_size = fread( cl_source, 1, N, opencl_file);
 31 |     fclose( opencl_file );
 32 |  
 33 |     // Fetching platform and device information
 34 |     cl_platform_id platform_id = NULL;
 35 |     cl_device_id device_id = NULL;   
 36 |     cl_uint get_num_devices;
 37 |     cl_uint get_num_platforms;
 38 |     cl_int for_kernel = clGetPlatformIDs(1, &platform_id, &get_num_platforms);
 39 |     for_kernel = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, &get_num_devices);
 40 |  
 41 |     // Creating an OpenCL context
 42 |     cl_context opencl_context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &for_kernel);
 43 |  
 44 |     // Creating a command queue and enabling profiling to find computation time
 45 | 
 46 |     cl_command_queue_properties profiling_on[] {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
 47 |     cl_command_queue command_queue = clCreateCommandQueueWithProperties(opencl_context, device_id, profiling_on, &for_kernel);
 48 |     
 49 |     // Creating memory buffers on the device for each array - similar to cudaMalloc on CUDA 
 50 |     cl_mem p_gpu = clCreateBuffer(opencl_context, CL_MEM_READ_ONLY, N * sizeof(double), NULL, &for_kernel);
 51 |     cl_mem q_gpu = clCreateBuffer(opencl_context, CL_MEM_READ_ONLY, N * sizeof(double), NULL, &for_kernel);
 52 |     cl_mem r_gpu = clCreateBuffer(opencl_context, CL_MEM_WRITE_ONLY, N * sizeof(double), NULL, &for_kernel);
 53 |  
 54 |     // Transferring p and q to their respective memory buffers on the device for multiplication - similar to cudaMemcpyHostToDevice on CUDA
 55 |     for_kernel = clEnqueueWriteBuffer(command_queue, p_gpu, CL_TRUE, 0, N * sizeof(double), p, 0, NULL, NULL);
 56 |     for_kernel = clEnqueueWriteBuffer(command_queue, q_gpu, CL_TRUE, 0, N * sizeof(double), q, 0, NULL, NULL);
 57 |  
 58 |     // Creating an OpenCL program from the opencl_kernel source
 59 |     cl_program opencl_program = clCreateProgramWithSource(opencl_context, 1, (const char **)&cl_source, (const size_t *)&source_size, &for_kernel);
 60 |  
 61 |     // Building the OpenCL program
 62 |     for_kernel = clBuildProgram(opencl_program, 1, &device_id, NULL, NULL, NULL);
 63 |  
 64 |     // Creating the OpenCL kernel
 65 |     cl_kernel opencl_kernel = clCreateKernel(opencl_program, "multiply", &for_kernel);
 66 |  
 67 |     // Arguments of the OpenCL kernel for the device
 68 |     for_kernel = clSetKernelArg(opencl_kernel, 0, sizeof(cl_mem), (void *)&p_gpu);
 69 |     for_kernel = clSetKernelArg(opencl_kernel, 1, sizeof(cl_mem), (void *)&q_gpu);
 70 |     for_kernel = clSetKernelArg(opencl_kernel, 2, sizeof(cl_mem), (void *)&r_gpu);
 71 |  
 72 |     // Allocation of work items and groups - work items are similar to threads and groups are similar to blocks as on CUDA.
 73 |     size_t global_item_size = N; // Setting the global item size - similar to maximum number of threads' usage
 74 |     size_t local_item_size = 1024; // Dividing work items into groups of 1024
 75 | 
 76 |     // C++ and OpenCL allocations for displaying device name
 77 |     int pf_index, dev_index;
 78 |     char* device_name;
 79 |     size_t nameSize;
 80 |     cl_uint platform_count;
 81 |     cl_platform_id* platforms;
 82 |     cl_uint device_count;
 83 |     cl_device_id* devices;
 84 | 
 85 |     // Fetching all platforms to display device name
 86 |     clGetPlatformIDs(0, NULL, &platform_count);
 87 |     platforms = (cl_platform_id*) malloc(sizeof(cl_platform_id) * platform_count);
 88 |     clGetPlatformIDs(platform_count, platforms, NULL);
 89 | 
 90 |     for (pf_index = 0; pf_index < platform_count; pf_index++) {
 91 | 
 92 |         // Fetching all OpenCL supported devices in the system
 93 |         clGetDeviceIDs(platforms[pf_index], CL_DEVICE_TYPE_ALL, 0, NULL, &device_count);
 94 |         devices = (cl_device_id*) malloc(sizeof(cl_device_id) * device_count);
 95 |         clGetDeviceIDs(platforms[pf_index], CL_DEVICE_TYPE_ALL, device_count, devices, NULL);
 96 | 
 97 |         // Display critical attributes for each device (just one here in our case)
 98 |         for (dev_index = 0; dev_index < device_count; dev_index++) {
 99 | 
100 |             // Display the device name
101 |             clGetDeviceInfo(devices[dev_index], CL_DEVICE_NAME, 0, NULL, &nameSize);
102 |             device_name = (char*) malloc(nameSize);
103 |             clGetDeviceInfo(devices[dev_index], CL_DEVICE_NAME, nameSize, device_name, NULL);
104 |             printf("Device used for computation: %s\n", device_name);
105 |             free(device_name);
106 | 
107 |         }
108 | 
109 |         free(devices);
110 | 
111 |     }
112 | 
113 |     free(platforms);
114 |     
115 |     cl_event event;  // Creating an event variable for timing 
116 | 
117 |     	for_kernel = clEnqueueNDRangeKernel(command_queue, opencl_kernel, 1, NULL, &global_item_size, &local_item_size, 0, NULL, &event);
118 | 
119 |     clWaitForEvents (1, &event); // Waiting for the event
120 | 
121 |     clFinish(command_queue); //Waiting until all commands have completed
122 | 
123 |     // Obtaining the start and end time for the event
124 |     cl_ulong begin;
125 |     cl_ulong end;
126 | 
127 |     clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(begin), &begin, NULL);
128 |     clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(end), &end, NULL);
129 | 
130 |     double duration = end - begin;
131 | 
132 |     // Printing the device computation time - note that on OpenCL, the default unit is nanoseconds in contrast to milliseconds on CUDA.
133 |     printf("Multiplication on device computed in: %lf nanoseconds = %lf milliseconds\n", duration, duration/1000000);
134 | 
135 | 
136 |     // Transferring r_gpu to its respective memory buffer on the host - similar to cudaMemcpyDeviceToHost on CUDA
137 |     double *r = (double*)malloc(sizeof(double)*N);
138 |     for_kernel = clEnqueueReadBuffer(command_queue, r_gpu, CL_TRUE, 0, N * sizeof(double), r, 0, NULL, NULL);
139 |  
140 |     // Verifying all values to be 276.0
141 |     // fabs(q[i]-288) (absolute value) should be 0
142 |     double maxError = 0.0;
143 |     for (int i = 0; i < N-1; ++i){
144 |         maxError = fmax(maxError, fabs(r[i]-276.0));
145 |     }
146 |     std::cout<<"\nMax error: "<<maxError<<std::endl;
147 | 
148 |     // Cleaning up memory allocations
149 |     for_kernel = clFlush(command_queue);
150 |     for_kernel = clFinish(command_queue);
151 |     for_kernel = clReleaseKernel(opencl_kernel);
152 |     for_kernel = clReleaseProgram(opencl_program);
153 |     for_kernel = clReleaseCommandQueue(command_queue);
154 |     for_kernel = clReleaseContext(opencl_context);
155 |     // clReleaseMemObject on OpenCL is similar to cudaFree on CUDA.
156 |     for_kernel = clReleaseMemObject(p_gpu);
157 |     for_kernel = clReleaseMemObject(q_gpu);
158 |     for_kernel = clReleaseMemObject(r_gpu);
159 | 
160 |     free(p);
161 |     free(q);
162 |     free(r);
163 |     return 0;
164 | }
165 | 


--------------------------------------------------------------------------------
/Chapter07/7.4. How Computing in PyOpenCL Works on Python/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter07/7.4. How Computing in PyOpenCL Works on Python/pyopencl_based_python_code.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl
 2 | import numpy as np
 3 | import pyopencl.array as clarray
 4 | from time import time
 5 | from pyopencl.elementwise import ElementwiseKernel
 6 | 
 7 | N = 500000000 #500 Million Elements
 8 | 
 9 | gpu_start_time = time()  # Noting GPU start time
10 | 
11 | #In contrast to PyCUDA, note that in PyOpenCL, we have to initialize a Context first.
12 | pyopencl_context = cl.create_some_context()
13 | #Now we instantiate a Command Queue with the PyOpenCL Context and also enable profiling to report computation time.
14 | command_queue = cl.CommandQueue(pyopencl_context, properties=cl.command_queue_properties.PROFILING_ENABLE)
15 | 
16 | #Here, we multiply the two values and store the product on all the elements of a third array
17 | #Note that we pass C syntax into the ElementwiseKernel. The difference here with PyCUDA is that we have
18 | #to specify the Context first as an argument to the ElementWiseKernel
19 | multiply = ElementwiseKernel(
20 |         pyopencl_context,
21 |         "double *a_gpu, double *b_gpu, double *c_gpu",
22 |         "c_gpu[i] = a_gpu[i] * b_gpu[i]",
23 |         "multiply")
24 | 
25 | #Initialize three PyOpenCL arrays all with zeroes
26 | a_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
27 | b_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
28 | c_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
29 | 
30 | #Update the first two arrays with values 23 and 12 respectively
31 | a_gpu.fill(23.0)
32 | b_gpu.fill(12.0)
33 | 
34 | event = multiply(a_gpu, b_gpu, c_gpu)
35 | 
36 | event.wait()  # Waiting until the event completes
37 | 
38 | elapsed = 1e-6 * (event.profile.end - event.profile.start)  # Calculating execution time (Multiplying by 10^6 to get value in milliseconds from nanoseconds)
39 | 
40 | print("GPU Kernel Function took {0} milliseconds".format(elapsed))  # Reporting kernel execution time
41 | 
42 | gpu_end_time = time()  # Get the GPU end time
43 | 
44 | print("GPU Time(Inclusive of memory transfer between host and device (GPU)): {0} seconds".format(gpu_end_time - gpu_start_time))  # Reporting GPU execution time, including memory transfers between host and device
45 | 
46 | random = np.random.randint(0,N)
47 | 
48 | #Randomly choose index from second array to confirm changes to the third array
49 | print("New value of third array element with random index", random, "is", c_gpu[random])


--------------------------------------------------------------------------------
/Chapter07/7.4. How Computing in PyOpenCL Works on Python/pyopencl_version_of_pycuda_example.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl
 2 | import numpy as np
 3 | import pyopencl.array as clarray
 4 | from time import time
 5 | from pyopencl.elementwise import ElementwiseKernel
 6 | 
 7 | N = 500000000 #500 Million Elements
 8 | 
 9 | gpu_start_time = time()  # Noting GPU start time
10 | 
11 | #In contrast to PyCUDA, note that in PyOpenCL, we have to initialize a Context first.
12 | pyopencl_context = cl.create_some_context()
13 | #Now we instantiate a Command Queue with the PyOpenCL Context and also enable profiling to report computation time.
14 | command_queue = cl.CommandQueue(pyopencl_context, properties=cl.command_queue_properties.PROFILING_ENABLE)
15 | 
16 | #Here, we multiply the two values and store the product on all the elements of a third array
17 | #Note that we pass C syntax into the ElementwiseKernel. The difference here with PyCUDA is that we have
18 | #to specify the Context first as an argument to the ElementWiseKernel
19 | multiply = ElementwiseKernel(
20 |         pyopencl_context,
21 |         "double *a_gpu, double *b_gpu",
22 |         "b_gpu[i] = a_gpu[i] * b_gpu[i]",
23 |         "multiply")
24 | 
25 | #Initialize three PyOpenCL arrays all with zeroes
26 | a_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
27 | b_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
28 | 
29 | #Update the first two arrays with values 23 and 12 respectively
30 | a_gpu.fill(23.0)
31 | b_gpu.fill(12.0)
32 | 
33 | event = multiply(a_gpu, b_gpu)
34 | 
35 | event.wait()  # Waiting until the event completes
36 | 
37 | elapsed = 1e-6 * (event.profile.end - event.profile.start)  # Calculating execution time (Multiplying by 10^6 to get value in milliseconds from nanoseconds)
38 | 
39 | print("GPU Kernel Function took {0} milliseconds".format(elapsed))  # Reporting kernel execution time
40 | 
41 | gpu_end_time = time()  # Get the GPU end time
42 | 
43 | print("GPU Time(Inclusive of memory transfer between host and device (GPU)): {0} seconds".format(gpu_end_time - gpu_start_time))  # Reporting GPU execution time, including memory transfers between host and device
44 | 
45 | random = np.random.randint(0,N)
46 | 
47 | #Randomly choose index from second array to confirm its updated changes
48 | print("New value of third array element with random index", random, "is", b_gpu[random])


--------------------------------------------------------------------------------
/Chapter07/7.4. How Computing in PyOpenCL Works on Python/testing_pyopencl_without_opencl_code.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl
 2 | import pyopencl.array as clarray
 3 | from time import time
 4 | import numpy as np
 5 | 
 6 | N = 500000000 #500 Million Elements
 7 | 
 8 | begin1 = time()
 9 | 
10 | #In contrast to PyCUDA, note that in PyOpenCL, we have to initialize a Context first.
11 | pyopencl_context = cl.create_some_context()
12 | #Now we instantiate a Command Queue with the PyOpenCL Context
13 | command_queue = cl.CommandQueue(pyopencl_context)
14 | 
15 | a_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
16 | a_gpu.fill(23.0)
17 | begin2 = time()
18 | b_gpu=a_gpu*12.0
19 | end = time()
20 | 
21 | pyopencl_gpu_time = (end-begin2)/1e-3
22 | 
23 | total_gpu_time = end-begin1
24 | 
25 | random = np.random.randint(0,N)
26 | 
27 | print("\nGPU multiplication of array took %f milliseconds." % pyopencl_gpu_time)
28 | 
29 | print("\nGPU Time including dependent code %f seconds." % total_gpu_time)
30 | 
31 | print("\nChoosing second array element with index", random, "at random:", b_gpu[random])
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | 


--------------------------------------------------------------------------------
/Chapter07/7.6. Writing your first PyOpenCL Programs to Compute a General Purpose Solution/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter07/7.6. Writing your first PyOpenCL Programs to Compute a General Purpose Solution/pyopencl_shortened_kernel_with_python.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl  # Importing the OpenCL API
 2 | import numpy  # Importing tools to work with numbers
 3 | from time import time  # Enabling access to the current time
 4 | 
 5 | N = 500000000  # 500 Million Elements
 6 | 
 7 | a = numpy.zeros(N).astype(numpy.double)  # Create a numpy array with all zeroes
 8 | b = numpy.zeros(N).astype(numpy.double)  # Create a second numpy array with all zeroes
 9 | c_gpu = numpy.empty_like(a)  # Creating an empty array the same size as array a to receive computed results from the GPU device
10 | 
11 | a.fill(23.0)  # set all values as 23
12 | b.fill(12.0)  # set all values as 12
13 | 
14 | opencl_context = cl.create_some_context()  # Initialize the Context
15 | 
16 | command_queue = cl.CommandQueue(opencl_context, properties=cl.command_queue_properties.PROFILING_ENABLE)  # Instantiate a Queue and enable profiling to report computation time
17 | 
18 | a_buffer = cl.Buffer(opencl_context, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=a)
19 | 
20 | b_buffer = cl.Buffer(opencl_context, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=b)
21 | 
22 | c_buffer = cl.Buffer(opencl_context, cl.mem_flags.WRITE_ONLY, b.nbytes)  # Creating three memory buffers on the device (GPU)
23 | 
24 | opencl_program = cl.Program(opencl_context, """
25 | // GPU kernel function to multiply two array elements and also update the results on a third array
26 | 
27 | __kernel void multiply(__global double *p, __global double *q, __global double *r)
28 | {
29 |     // Indexing the current element to process - equivalent to int index = threadIdx.x + blockIdx.x * blockDim.x in CUDA
30 | 
31 |     int index = get_global_id(0);
32 | 
33 |     // Simultaneous multiplication within this OpenCL kernel
34 | 
35 |     r[index] = p[index] * q[index];
36 | 
37 | }""").build()  # Compiling the device program by directly defining kernel content.
38 | 
39 | gpu_start_time = time()  # Get the GPU start time
40 | 
41 | event = opencl_program.multiply(command_queue, a.shape, None, a_buffer, b_buffer, c_buffer)  # Enqueue the multiply program on the GPU device
42 | 
43 | event.wait()  # Waiting until event completion
44 | 
45 | elapsed = 1e-6 * (event.profile.end - event.profile.start)  # Calculating execution time (Multiplying by 10^6 to get value in milliseconds from nanoseconds)
46 | 
47 | print("GPU Kernel Function took: {0} milliseconds".format(elapsed))  # Reporting kernel execution time
48 | 
49 | cl.enqueue_copy(command_queue, c_gpu, c_buffer).wait()  # Get back the data from GPU device memory into array c_gpu
50 | 
51 | gpu_end_time = time()  # Stores time point at the end of GPU computation
52 | 
53 | print("GPU Time(Inclusive of memory transfer between host and device (GPU)): {0} seconds".format(gpu_end_time - gpu_start_time))  # Reporting GPU execution time, including memory transfers between host and device
54 | 
55 | random = numpy.random.randint(0, N)
56 | 
57 | # Randomly choose index from second array to confirm changes to second array
58 | print("New value of third array element with random index", random, "is", c_gpu[random])
59 | 


--------------------------------------------------------------------------------
/Chapter07/7.6. Writing your first PyOpenCL Programs to Compute a General Purpose Solution/pyopencl_simplified_opencl_with_python.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl  # Importing the OpenCL API
 2 | import numpy  # Importing tools to work with numbers
 3 | from time import time  # Enabling access to the current time
 4 | 
 5 | N = 500000000 # 500 Million Elements
 6 | 
 7 | a = numpy.zeros(N).astype(numpy.double)  # Create a numpy array with all zeroes
 8 | b = numpy.zeros(N).astype(numpy.double)  # Create a second numpy array with all zeroes
 9 | c_gpu = numpy.empty_like(a)  # Creating an empty array the same size as array a to receive computed results from the GPU device
10 | 
11 | a.fill(23.0)  # set all values as 23
12 | b.fill(12.0)  # set all values as 12
13 | 
14 | opencl_context = cl.create_some_context()  # Initialize the Context
15 | 
16 | command_queue = cl.CommandQueue(opencl_context, properties=cl.command_queue_properties.PROFILING_ENABLE)  # Instantiate a Queue and enable profiling to report computation time
17 | 
18 | a_buffer = cl.Buffer(opencl_context, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=a)
19 | 
20 | b_buffer = cl.Buffer(opencl_context, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=b)
21 | 
22 | c_buffer = cl.Buffer(opencl_context, cl.mem_flags.WRITE_ONLY, b.nbytes)  # Creating three memory buffers on the device (GPU)
23 | 
24 | opencl_kernel = """
25 | // GPU kernel function to multiply two array elements and also update the results on a third array
26 | 
27 | __kernel void multiply(__global double *p, __global double *q, __global double *r) 
28 | {
29 |     // Indexing the current element to process - equivalent to int index = threadIdx.x + blockIdx.x * blockDim.x in CUDA
30 | 
31 |     int index = get_global_id(0);
32 | 
33 |     // Simultaneous multiplication within this OpenCL kernel
34 | 
35 |     r[index] = p[index] * q[index];
36 | 
37 | }"""  # OpenCL Kernel Creation: Note these are the exact same contents as we saw on our .cl file
38 | 
39 | opencl_program = cl.Program(opencl_context, opencl_kernel).build()
40 | 
41 | gpu_start_time = time()  # Get the GPU start time
42 | 
43 | event = opencl_program.multiply(command_queue, a.shape, None, a_buffer, b_buffer, c_buffer)  # Enqueue the multiply program on the GPU device
44 | 
45 | event.wait()  # Waiting until event completion
46 | 
47 | elapsed = 1e-6 * (event.profile.end - event.profile.start)  # Calculating execution time (Multiplying by 10^6 to get value in milliseconds from nanoseconds)
48 | 
49 | print("GPU Kernel Function took: {0} milliseconds".format(elapsed))  # Reporting kernel execution time
50 | 
51 | cl.enqueue_copy(command_queue, c_gpu, c_buffer).wait()  # Get back the data from GPU device memory into array c_gpu
52 | 
53 | gpu_end_time = time()  # Stores time point at the end of GPU computation
54 | 
55 | print("GPU Time(Inclusive of memory transfer between host and device (GPU)): {0} seconds".format(gpu_end_time - gpu_start_time))  # Reporting GPU execution time, including memory transfers between host and device
56 | 
57 | random = numpy.random.randint(0, N)
58 | 
59 | # Randomly choose index from second array to confirm changes to second array
60 | print("New value of third array element with random index", random, "is", c_gpu[random])
61 | 
62 | 
63 | 


--------------------------------------------------------------------------------
/Chapter07/7.6. Writing your first PyOpenCL Programs to Compute a General Purpose Solution/simultaneous_division.py:
--------------------------------------------------------------------------------
 1 | import pyopencl as cl
 2 | import numpy as np
 3 | import pyopencl.array as clarray
 4 | from time import time
 5 | from pyopencl.elementwise import ElementwiseKernel
 6 | 
 7 | N = 500000000 #500 Million Elements
 8 | 
 9 | gpu_start_time = time()  # Noting GPU start time
10 | 
11 | #In contrast to PyCUDA, note that in PyOpenCL, we have to initialize a Context first.
12 | pyopencl_context = cl.create_some_context()
13 | #Now we instantiate a Command Queue with the PyOpenCL Context and also enable profiling to report computation time.
14 | command_queue = cl.CommandQueue(pyopencl_context, properties=cl.command_queue_properties.PROFILING_ENABLE)
15 | 
16 | #Here, we multiply the two values and store the product on all the elements of a third array
17 | #Note that we pass C syntax into the ElementwiseKernel. The difference here with PyCUDA is that we have
18 | #to specify the Context first as an argument to the ElementWiseKernel
19 | multiply = ElementwiseKernel(
20 |         pyopencl_context,
21 |         "double *a_gpu, double *b_gpu, double *c_gpu",
22 |         "c_gpu[i] = a_gpu[i] / b_gpu[i]",
23 |         "multiply")
24 | 
25 | #Initialize the first two arrays with random values and the third as zeroes
26 | a_gpu = clarray.to_device(command_queue, np.random.rand(N).astype(np.double))
27 | b_gpu = clarray.to_device(command_queue, np.random.rand(N).astype(np.double))
28 | c_gpu = clarray.to_device(command_queue, np.zeros(N).astype(np.double))
29 | 
30 | event = multiply(a_gpu, b_gpu, c_gpu)
31 | 
32 | event.wait()  # Waiting until the event completes
33 | 
34 | elapsed = 1e-6 * (event.profile.end - event.profile.start)  # Calculating execution time (Multiplying by 10^6 to get value in milliseconds from nanoseconds)
35 | 
36 | print("GPU Kernel Function took {0} milliseconds".format(elapsed))  # Reporting kernel execution time
37 | 
38 | gpu_end_time = time()  # Get the GPU end time
39 | 
40 | print("GPU Time(Inclusive of memory transfer between host and device (GPU)): {0} seconds".format(gpu_end_time - gpu_start_time))  # Reporting GPU execution time, including memory transfers between host and device
41 | 
42 | random = np.random.randint(0,N)
43 | 
44 | #Randomly choose index from second array to confirm changes to the third array
45 | print("New value of third array element with random index", random, "is", c_gpu[random])


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/CuPy/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/CuPy/raw_cuda_kernel_on_cupy.py:
--------------------------------------------------------------------------------
 1 | import cupy as cp #Importing CuPy
 2 | 
 3 | #Defining the CUDA kernel
 4 | multiply = cp.RawKernel(r'''
 5 | extern "C" __global__
 6 | void multiply(const int* p, const int* q, int* z) {
 7 |     int tid = blockDim.x * blockIdx.x + threadIdx.x;
 8 |     z[tid] = p[tid] * q[tid];
 9 |  }
10 | ''', 'multiply')
11 | 
12 | #First two arrays are set as 0,1,2,3....upto 300
13 | p = cp.arange(300, dtype=cp.int)
14 | q = cp.arange(300, dtype=cp.int)
15 | 
16 | #Setting a new array with zeros to pass to kernel for computation
17 | z = cp.zeros(300, dtype=cp.int)
18 | 
19 | #Invoking the kernel with a grid of 250 blocks, each consisting of 1024 threads
20 | multiply((250,1), (1024,1), (p, q, z))  # grid, block and arguments
21 | 
22 | #Displaying the output computed on the kernel
23 | print(z)
24 | 
25 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/CuPy/replacing_numpy_code_with_cupy.py:
--------------------------------------------------------------------------------
 1 | import cupy as cp #Importing CuPy
 2 | from timeit import default_timer as timer #To record computation time
 3 | 
 4 | N = 500000000 #500 million elements
 5 | 
 6 | #Starting timer to record GPU computation time
 7 | start = timer()
 8 | 
 9 | #Setting two arrays all with zero values
10 | a_cp = cp.zeros(N).astype(cp.double)
11 | b_cp = cp.zeros(N).astype(cp.double)
12 | 
13 | #Initializing two values for each array
14 | a_cp.fill(23.0)
15 | b_cp.fill(12.0)
16 | 
17 | #Updating second array as a product of both arrays
18 | b_cp  = a_cp * b_cp
19 | 
20 | #Choosing a random index
21 | random = cp.random.randint(0,N)
22 | 
23 | #Displaying random element
24 | print("Choosing array element %d at random:" % random)
25 | print("Random array element value is %lf" % b_cp[random])
26 | 
27 | #Displaying current GPU device
28 | print(b_cp.device)
29 | 
30 | #GPU computation time
31 | cupy_gpu_time = timer() - start
32 | 
33 | #Displaying GPU computation time
34 | print("CuPy on GPU took %f seconds." % cupy_gpu_time)
35 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/Numba/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/Numba/numba_cuda_kernel_with_numpy.py:
--------------------------------------------------------------------------------
 1 | from numba import cuda #Importing cuda module from Numba
 2 | import numpy as np #Importing NumPy
 3 | from timeit import default_timer as timer #To record computation time
 4 | N = 500000000 #500 million elements
 5 | 
 6 | @cuda.jit
 7 | def multiply(p, q):
 8 |     # Thread id in a 1D block
 9 |     tx = cuda.threadIdx.x
10 |     # Block id in a 1D grid
11 |     ty = cuda.blockIdx.x
12 |     # Number of threads per block
13 |     bw = cuda.blockDim.x
14 |     # Computing flattened index inside the array
15 |     index = tx + ty * bw
16 |     if index < N:  # Check array size limit
17 |         q[index]=p[index]*q[index]
18 | 
19 | def main():
20 |     #Initialize the two arrays of double data type all with 0.0 values upto N
21 |     a_source = np.zeros(N, dtype=np.double)
22 |     b_source = np.zeros(N, dtype=np.double)
23 | 
24 |     a_source.fill(23)
25 |     b_source.fill(12)
26 | 
27 |     # Time the GPU function
28 |     threadsperblock = 1024
29 |     blockspergrid = (N + (threadsperblock - 1)) // threadsperblock
30 |     start = timer()
31 |     multiply[blockspergrid, threadsperblock](a_source,b_source)
32 |     vector_multiply_gpu_time = timer() - start
33 | 
34 |     # Report times
35 |     print("GPU function took %f seconds." % vector_multiply_gpu_time)
36 |     random = np.random.randint(0,N)
37 | 
38 |     print("Choosing array element %d at random:" % random)
39 |     print("Random array element value is %lf" % b_source[random])
40 | 
41 | if __name__ == "__main__":
42 |     main()
43 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/Numba/using_jit_with_numba.py:
--------------------------------------------------------------------------------
 1 | import numpy as np #Importing NumPy
 2 | from numba import njit #Importing njit module from Numba
 3 | from timeit import default_timer as timer #To record computation time
 4 | 
 5 | N = 500000000 #500 Million Elements
 6 | 
 7 | # Function to multiply two array elements and also update the results on the second array
 8 | @njit #Equivalent to @jit(nopython=True)
 9 | def multiply(p_cpu, q_cpu):
10 |     for i in range(N):
11 |         q_cpu[i] = p_cpu[i] * q_cpu[i]
12 | 
13 | def main():
14 |     #Initialize the two arrays of double data type all with 0.0 values upto N
15 |     p = np.zeros(N, dtype=np.double)
16 |     q = np.zeros(N, dtype=np.double)
17 |     #Update all the elements in the two arrays with 23.0 and 12.0 respectively
18 |     p.fill(23.0)
19 |     q.fill(12.0)
20 | 
21 |     #Time the Function
22 |     begin = timer()
23 |     multiply(p, q)
24 |     numpy_cpu_time = timer() - begin
25 | 
26 |     #Report Computation Time
27 |     print("Function took %f seconds." % numpy_cpu_time)
28 | 
29 |     #Choose a random integer index value between 0 to N
30 |     random = np.random.randint(0, N)
31 | 
32 |     #Verify all values to be 276.0 for second array by random selection
33 |     print("New value of second array element with random index", random, "is", q[random])
34 | 
35 |     return 0
36 | 
37 | if __name__ == "__main__":
38 |     main()
39 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/Numba/using_numba_with_vectorized_cuda_target.py:
--------------------------------------------------------------------------------
 1 | import numpy as np #Importing NumPy
 2 | from timeit import default_timer as timer #To record computation time
 3 | from numba import vectorize #Importing vectorize module from Numba
 4 | 
 5 | N = 500000000 #500 million elements
 6 | 
 7 | #The @vectorize decorator turns the function into a GPU-based vectorized function.
 8 | @vectorize(["double(double, double)"], target='cuda')
 9 | def vector_multiply_gpu(a, b):
10 |     return a * b
11 | 
12 | def main():
13 |     #Initialize the two arrays of double data type all with 0.0 values upto N
14 |     p = np.zeros(N, dtype=np.double)
15 |     q = np.zeros(N, dtype=np.double)
16 | 
17 |     #Update all the elements in the two arrays with 23.0 and 12.0 respectively
18 |     p.fill(23.0)
19 |     q.fill(12.0)
20 | 
21 |     # Time the GPU function
22 |     start = timer()
23 |     #Display computed array
24 |     print(vector_multiply_gpu(p, q))
25 |     vector_multiply_gpu_time = timer() - start
26 | 
27 |     #Report Computation Time
28 |     print("GPU function took %f seconds." % vector_multiply_gpu_time)
29 | 
30 |     return 0
31 | 
32 | 
33 | if __name__ == "__main__":
34 |     main()
35 | 


--------------------------------------------------------------------------------
/Chapter08/8.7. Writing your first CuPy and Numba enabled 'Accelerate'd Programs to Compute GPGPU Solutions/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter08/8.8. Interoperability between CuPy and Numba within a Single Python Program/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter08/8.8. Interoperability between CuPy and Numba within a Single Python Program/numba_cuda_kernel_with_cupy_interoperability.py:
--------------------------------------------------------------------------------
 1 | from numba import cuda #Using Numba
 2 | import cupy as cp #Using CuPy
 3 | from timeit import default_timer as timer
 4 | N = 500000000
 5 | @cuda.jit
 6 | def multiply(p, q):
 7 |     # Thread id in a 1D block
 8 |     tx = cuda.threadIdx.x
 9 |     # Block id in a 1D grid
10 |     ty = cuda.blockIdx.x
11 |     # Number of threads per block
12 |     bw = cuda.blockDim.x
13 |     # Compute flattened index inside the array
14 |     index = tx + ty * bw
15 |     if index < N:  # Check array size limit
16 |         q[index]=p[index]*q[index]
17 | 
18 | def main():
19 |     a_source = cp.zeros(N, dtype=cp.double)
20 |     b_source = cp.zeros(N, dtype=cp.double)
21 | 
22 |     a_source.fill(23)
23 |     b_source.fill(12)
24 | 
25 |     # Time the GPU function
26 |     threadsperblock = 1024
27 |     blockspergrid = (N + (threadsperblock - 1)) // threadsperblock
28 |     start = timer()
29 |     multiply[blockspergrid, threadsperblock](a_source,b_source)
30 |     vector_multiply_gpu_time = timer() - start
31 | 
32 |     # Report times
33 |     print("GPU function took %f seconds." % vector_multiply_gpu_time)
34 |     random = cp.random.randint(0,N)
35 | 
36 |     print("Choosing array element %d at random:" % random)
37 |     print("Random array element value is %lf" % b_source[random])
38 | 
39 | if __name__ == "__main__":
40 |     main()
41 | 


--------------------------------------------------------------------------------
/Chapter10/10.10. Writing your first GPU accelerated machine learning programs/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter10/10.10. Writing your first GPU accelerated machine learning programs/pytorch_cifar-10.py:
--------------------------------------------------------------------------------
  1 | import torch
  2 | import torchvision
  3 | import torchvision.transforms as transforms
  4 | 
  5 | device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  6 | 
  7 | # Assuming that we are on a CUDA machine, this should print a CUDA device:
  8 | 
  9 | current_device=torch.cuda.current_device()
 10 | 
 11 | print('Device used:',torch.cuda.get_device_name(current_device))
 12 | 
 13 | 
 14 | 
 15 | normalize = transforms.Compose(
 16 |     [transforms.ToTensor(),
 17 |      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
 18 | 
 19 | trainset = torchvision.datasets.CIFAR10(root='./pytorch', train=True,
 20 |                                         download=True, transform=normalize)
 21 | trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
 22 |                                           shuffle=True, num_workers=2)
 23 | 
 24 | testset = torchvision.datasets.CIFAR10(root='./pytorch', train=False,
 25 |                                        download=True, transform=normalize)
 26 | testloader = torch.utils.data.DataLoader(testset, batch_size=4,
 27 |                                          shuffle=False, num_workers=2)
 28 | 
 29 | classes = ('plane', 'car', 'bird', 'cat',
 30 |            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
 31 | 
 32 | 
 33 | import matplotlib.pyplot as plot
 34 | import numpy as np
 35 | 
 36 | # functions to show an image
 37 | 
 38 | 
 39 | def imshow(img):
 40 |     img = img / 2 + 0.5     # unnormalize
 41 |     npimg = img.numpy()
 42 |     plot.imshow(np.transpose(npimg, (1, 2, 0)))
 43 |     plot.show()
 44 | 
 45 | 
 46 | # get some random training images
 47 | dataiter = iter(trainloader)
 48 | images, labels = dataiter.next()
 49 | 
 50 | # show images
 51 | imshow(torchvision.utils.make_grid(images))
 52 | # print labels
 53 | print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
 54 | 
 55 | import torch.nn as nn
 56 | import torch.nn.functional as F
 57 | 
 58 | #Define a convolutional neural network to take 3-channel images
 59 | class Net(nn.Module):
 60 |     def __init__(self):
 61 |         super(Net, self).__init__()
 62 |         self.conv1 = nn.Conv2d(3, 6, 5).cuda()
 63 |         self.pool = nn.MaxPool2d(2, 2).cuda()
 64 |         self.conv2 = nn.Conv2d(6, 16, 5).cuda()
 65 |         self.fc1 = nn.Linear(16 * 5 * 5, 120).cuda()
 66 |         self.fc2 = nn.Linear(120, 84).cuda()
 67 |         self.fc3 = nn.Linear(84, 10).cuda()
 68 | 
 69 |     def forward(self, x):
 70 |         x = x.to(device)
 71 |         x = self.pool(F.relu(self.conv1(x)))
 72 |         x = self.pool(F.relu(self.conv2(x)))
 73 |         x = x.view(-1, 16 * 5 * 5)
 74 |         x = F.relu(self.fc1(x))
 75 |         x = F.relu(self.fc2(x))
 76 |         x = self.fc3(x)
 77 |         return x
 78 | 
 79 | 
 80 | net = Net()
 81 | net.to(device)
 82 | 
 83 | 
 84 | 
 85 | 
 86 | import torch.optim as optim
 87 | 
 88 | criterion = nn.CrossEntropyLoss()
 89 | optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
 90 | 
 91 | 
 92 | for epoch in range(2):  # loop over the dataset multiple times
 93 | 
 94 |     running_loss = 0.0
 95 |     for i, (inputs, labels) in enumerate(trainloader, 0):
 96 |         # get the inputs
 97 |         inputs, labels = inputs.to(device), labels.to(device)
 98 | 
 99 | 
100 |         # zero the parameter gradients
101 |         optimizer.zero_grad()
102 | 
103 |         # forward + backward + optimize
104 |         outputs = net(inputs)
105 |         loss = criterion(outputs, labels)
106 |         loss.backward()
107 |         optimizer.step()
108 | 
109 |         # print statistics
110 |         running_loss += loss.item()
111 |         if i % 2000 == 1999:    # print every 2000 mini-batches
112 |             print('[%d, %5d] loss: %.3f' %
113 |                   (epoch + 1, i + 1, running_loss / 2000))
114 |             running_loss = 0.0
115 | 
116 | print('Finished Training')
117 | 
118 | 
119 | 
120 | 
121 | 
122 | 
123 | dataiter = iter(testloader)
124 | images, labels = dataiter.next()
125 | 
126 | 
127 | # print images
128 | imshow(torchvision.utils.make_grid(images))
129 | print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
130 | 
131 | 
132 | outputs = net(images)
133 | 
134 | _, predicted = torch.max(outputs, 1)
135 | 
136 | print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
137 |                               for j in range(4)))
138 | 
139 | 
140 | correct = 0
141 | total = 0
142 | with torch.no_grad():
143 |     for (images, labels) in testloader:
144 |         images, labels = images.to(device), labels.to(device)
145 |         outputs = net(images)
146 |         _, predicted = torch.max(outputs.data, 1)
147 |         total += labels.size(0)
148 |         correct += (predicted == labels).sum().item()
149 | 
150 | print('Accuracy of the network on the 10000 test images: %d %%' % (
151 |     100 * correct / total))
152 | 
153 | 
154 | 
155 | 
156 | class_correct = list(0. for i in range(10))
157 | class_total = list(0. for i in range(10))
158 | with torch.no_grad():
159 |     for (images, labels) in testloader:
160 |         images, labels = images.to(device), labels.to(device)
161 | 
162 |         outputs = net(images)
163 |         _, predicted = torch.max(outputs, 1)
164 |         c = (predicted == labels).squeeze()
165 |         for i in range(4):
166 |             label = labels[i]
167 |             class_correct[label] += c[i].item()
168 |             class_total[label] += 1
169 | 
170 | 
171 | for i in range(10):
172 |     print('Accuracy of %5s : %2d %%' % (
173 |         classes[i], 100 * class_correct[i] / class_total[i]))
174 | 
175 | 


--------------------------------------------------------------------------------
/Chapter10/10.10. Writing your first GPU accelerated machine learning programs/tensorflow_fashion-mnist.py:
--------------------------------------------------------------------------------
  1 | from __future__ import absolute_import, division, print_function
  2 | 
  3 | import tensorflow as tf
  4 | 
  5 | import numpy as np
  6 | import matplotlib.pyplot as plot
  7 | 
  8 | from tensorflow import keras
  9 | 
 10 | 
 11 | fashion_mnist = keras.datasets.fashion_mnist
 12 | (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
 13 | 
 14 | class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
 15 |                'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
 16 | 
 17 | plot.figure()
 18 | plot.imshow(train_images[0])
 19 | plot.colorbar()
 20 | plot.grid(False)
 21 | plot.show()
 22 | 
 23 | train_images = train_images / 255.0
 24 | 
 25 | test_images = test_images / 255.0
 26 | 
 27 | plot.figure(figsize=(10,10))
 28 | for i in range(25):
 29 |     plot.subplot(5,5,i+1)
 30 |     plot.xticks([])
 31 |     plot.yticks([])
 32 |     plot.grid(False)
 33 |     plot.imshow(train_images[i], cmap=plot.cm.binary)
 34 |     plot.xlabel(class_names[train_labels[i]])
 35 | plot.show()
 36 | 
 37 | 
 38 | model = keras.Sequential([
 39 |     keras.layers.Flatten(input_shape=(28, 28)),
 40 |     keras.layers.Dense(128, activation=tf.nn.relu),
 41 |     keras.layers.Dense(10, activation=tf.nn.softmax)
 42 | ])
 43 | 
 44 | model.compile(optimizer='adam',
 45 |               loss='sparse_categorical_crossentropy',
 46 |               metrics=['accuracy'])
 47 | 
 48 | model.fit(train_images, train_labels, epochs=100)
 49 | 
 50 | test_loss, test_acc = model.evaluate(test_images, test_labels)
 51 | 
 52 | print('Test accuracy:', test_acc)
 53 | 
 54 | predictions = model.predict(test_images)
 55 | 
 56 | print(predictions[0])
 57 | 
 58 | print(np.argmax(predictions[0]))
 59 | 
 60 | print(test_labels[0])
 61 | 
 62 | 
 63 | 
 64 | 
 65 | def plot_image(i, predictions_array, true_label, img):
 66 |   predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
 67 |   plot.grid(False)
 68 |   plot.xticks([])
 69 |   plot.yticks([])
 70 | 
 71 |   plot.imshow(img, cmap=plot.cm.binary)
 72 | 
 73 |   predicted_label = np.argmax(predictions_array)
 74 |   if predicted_label == true_label:
 75 |     color = 'blue'
 76 |   else:
 77 |     color = 'red'
 78 | 
 79 |   plot.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
 80 |                                 100*np.max(predictions_array),
 81 |                                 class_names[true_label]),
 82 |                                 color=color)
 83 | 
 84 | def plot_value_array(i, predictions_array, true_label):
 85 |   predictions_array, true_label = predictions_array[i], true_label[i]
 86 |   plot.grid(False)
 87 |   plot.xticks([])
 88 |   plot.yticks([])
 89 |   thisplot = plot.bar(range(10), predictions_array, color="#777777")
 90 |   plot.ylim([0, 1])
 91 |   predicted_label = np.argmax(predictions_array)
 92 | 
 93 |   thisplot[predicted_label].set_color('red')
 94 |   thisplot[true_label].set_color('blue')
 95 | 
 96 | 
 97 | i = 0
 98 | plot.figure(figsize=(6,3))
 99 | plot.subplot(1,2,1)
100 | plot_image(i, predictions, test_labels, test_images)
101 | plot.subplot(1,2,2)
102 | plot_value_array(i, predictions,  test_labels)
103 | plot.show()
104 | 
105 | 
106 | 
107 | i = 12
108 | plot.figure(figsize=(6,3))
109 | plot.subplot(1,2,1)
110 | plot_image(i, predictions, test_labels, test_images)
111 | plot.subplot(1,2,2)
112 | plot_value_array(i, predictions,  test_labels)
113 | plot.show()
114 | 
115 | 
116 | # Plot the first X test images, their predicted label, and the true label
117 | # Color correct predictions in blue, incorrect predictions in red
118 | num_rows = 5
119 | num_cols = 3
120 | num_images = num_rows*num_cols
121 | plot.figure(figsize=(2*2*num_cols, 2*num_rows))
122 | for i in range(num_images):
123 |   plot.subplot(num_rows, 2*num_cols, 2*i+1)
124 |   plot_image(i, predictions, test_labels, test_images)
125 |   plot.subplot(num_rows, 2*num_cols, 2*i+2)
126 |   plot_value_array(i, predictions, test_labels)
127 | plot.show()
128 | 
129 | 
130 | 
131 | # Grab an image from the test dataset
132 | img = test_images[0]
133 | 
134 | print(img.shape)
135 | 
136 | 
137 | # Add the image to a batch where it's the only member.
138 | img = (np.expand_dims(img,0))
139 | 
140 | print(img.shape)
141 | 
142 | predictions_single = model.predict(img)
143 | 
144 | print(predictions_single)
145 | 
146 | 
147 | 
148 | plot_value_array(0, predictions_single, test_labels)
149 | _ = plot.xticks(range(10), class_names, rotation=45)
150 | plot.show()
151 | 
152 | print(np.argmax(predictions_single[0]))
153 | 
154 | 
155 | 


--------------------------------------------------------------------------------
/Chapter11/11.4. Testing an Example from the Deepchem Repository/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/Chapter11/11.4. Testing an Example from the Deepchem Repository/deepchem_predicting_a_ki_ligand_for_a_protein.py:
--------------------------------------------------------------------------------
  1 | #Copyright 2019 Pande Lab, Stanford University
  2 | 
  3 | #Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
  4 | # to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
  5 | # and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  6 | 
  7 | #The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  8 | 
  9 | #THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 10 | #FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 11 | # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 12 | 
 13 | 
 14 | #In this program, we analyze the BACE enyzme and build machine learning models for predicting the Ki of ligands to the protein.
 15 | #We will use the deepchem library to load this data into memory, split into train/test/validation folds, build and cross-validate models, and report statistics.
 16 | 
 17 | import os
 18 | import sys
 19 | import deepchem as dc
 20 | from deepchem.utils.save import load_from_disk
 21 | 
 22 | current_dir = os.path.dirname(os.path.realpath("__file__"))
 23 | dc.utils.download_url("https://s3-us-west-1.amazonaws.com/deepchem.io/datasets/desc_canvas_aug30.csv",
 24 |                       current_dir)
 25 | dataset_file = "desc_canvas_aug30.csv"
 26 | dataset = load_from_disk(dataset_file)
 27 | num_display=10
 28 | pretty_columns = (
 29 |     "[" + ",".join(["'%s'" % column for column in dataset.columns.values[:num_display]])
 30 |     + ",...]")
 31 | 
 32 | dc.utils.download_url("https://s3-us-west-1.amazonaws.com/deepchem.io/datasets/crystal_desc_canvas_aug30.csv",
 33 |                       current_dir)
 34 | crystal_dataset_file = "crystal_desc_canvas_aug30.csv"
 35 | crystal_dataset = load_from_disk(crystal_dataset_file)
 36 | 
 37 | print("Columns of dataset: %s" % pretty_columns)
 38 | print("Number of examples in dataset: %s" % str(dataset.shape[0]))
 39 | print("Number of examples in crystal dataset: %s" % str(crystal_dataset.shape[0]))
 40 | 
 41 | 
 42 | #To gain a visual understanding of compounds in our dataset, let’s draw them using rdkit. We define a couple of helper functions to get started.
 43 | 
 44 | import tempfile
 45 | from rdkit import Chem
 46 | from rdkit.Chem import Draw
 47 | from itertools import islice
 48 | from IPython.display import Image, display, HTML
 49 | 
 50 | def display_images(filenames):
 51 |     """Helper to pretty-print images."""
 52 |     for filename in filenames:
 53 |         display(Image(filename))
 54 | 
 55 | def mols_to_pngs(mols, basename="test"):
 56 |     """Helper to write RDKit mols to png files."""
 57 |     filenames = []
 58 |     for i, mol in enumerate(mols):
 59 |         filename = "BACE_%s%d.png" % (basename, i)
 60 |         Draw.MolToFile(mol, filename)
 61 |         filenames.append(filename)
 62 |     return filenames
 63 | 
 64 | 
 65 | 
 66 | #Now, we display a compound from the dataset. Note the complex ring structures and polar structures.
 67 | 
 68 | num_to_display = 12
 69 | molecules = []
 70 | for _, data in islice(dataset.iterrows(), num_to_display):
 71 |     molecules.append(Chem.MolFromSmiles(data["mol"]))
 72 | display_images(mols_to_pngs(molecules, basename="dataset"))
 73 | 
 74 | #Now let’s picture the compounds in the crystal structure collection
 75 | 
 76 | num_to_display = 12
 77 | molecules = []
 78 | for _, data in islice(crystal_dataset.iterrows(), num_to_display):
 79 |     molecules.append(Chem.MolFromSmiles(data["mol"]))
 80 | display_images(mols_to_pngs(molecules, basename="crystal_dataset"))
 81 | 
 82 | 
 83 | #Analyzing the distribution of pIC50 values in the dataset gives us a nice spread.
 84 | 
 85 | import matplotlib
 86 | 
 87 | import matplotlib.pyplot as plot
 88 | 
 89 | #import cupy as np
 90 | #pIC50s = np.array_str(dataset["pIC50"], suppress_small=True)
 91 | 
 92 | import numpy as np
 93 | pIC50s = np.array(dataset["pIC50"])
 94 | 
 95 | # Remove some dirty data from the dataset
 96 | pIC50s = [pIC50 for pIC50 in pIC50s if pIC50 != '']
 97 | n, bins, patches = plot.hist(pIC50s, 50, facecolor='green', alpha=0.75)
 98 | plot.xlabel('Measured pIC50')
 99 | plot.ylabel('Number of compounds')
100 | plot.title(r'Histogram of pIC50 Values')
101 | plot.grid(True)
102 | plot.show()
103 | 
104 | #We now featurize the data using the Canvas samples. To do so, we must specify the columns in the data input that correspond to the features. (Note that CanvasUID is excluded!)
105 | 
106 | user_specified_features = ['MW','AlogP','HBA','HBD','RB','HeavyAtomCount','ChiralCenterCount','ChiralCenterCountAllPossible','RingCount','PSA','Estate','MR','Polar','sLi_Key','ssBe_Key','ssssBem_Key','sBH2_Key','ssBH_Key','sssB_Key','ssssBm_Key','sCH3_Key','dCH2_Key','ssCH2_Key','tCH_Key','dsCH_Key','aaCH_Key','sssCH_Key','ddC_Key','tsC_Key','dssC_Key','aasC_Key','aaaC_Key','ssssC_Key','sNH3_Key','sNH2_Key','ssNH2_Key','dNH_Key','ssNH_Key','aaNH_Key','tN_Key','sssNH_Key','dsN_Key','aaN_Key','sssN_Key','ddsN_Key','aasN_Key','ssssN_Key','daaN_Key','sOH_Key','dO_Key','ssO_Key','aaO_Key','aOm_Key','sOm_Key','sF_Key','sSiH3_Key','ssSiH2_Key','sssSiH_Key','ssssSi_Key','sPH2_Key','ssPH_Key','sssP_Key','dsssP_Key','ddsP_Key','sssssP_Key','sSH_Key','dS_Key','ssS_Key','aaS_Key','dssS_Key','ddssS_Key','ssssssS_Key','Sm_Key','sCl_Key','sGeH3_Key','ssGeH2_Key','sssGeH_Key','ssssGe_Key','sAsH2_Key','ssAsH_Key','sssAs_Key','dsssAs_Key','ddsAs_Key','sssssAs_Key','sSeH_Key','dSe_Key','ssSe_Key','aaSe_Key','dssSe_Key','ssssssSe_Key','ddssSe_Key','sBr_Key','sSnH3_Key','ssSnH2_Key','sssSnH_Key','ssssSn_Key','sI_Key','sPbH3_Key','ssPbH2_Key','sssPbH_Key','ssssPb_Key','sLi_Cnt','ssBe_Cnt','ssssBem_Cnt','sBH2_Cnt','ssBH_Cnt','sssB_Cnt','ssssBm_Cnt','sCH3_Cnt','dCH2_Cnt','ssCH2_Cnt','tCH_Cnt','dsCH_Cnt','aaCH_Cnt','sssCH_Cnt','ddC_Cnt','tsC_Cnt','dssC_Cnt','aasC_Cnt','aaaC_Cnt','ssssC_Cnt','sNH3_Cnt','sNH2_Cnt','ssNH2_Cnt','dNH_Cnt','ssNH_Cnt','aaNH_Cnt','tN_Cnt','sssNH_Cnt','dsN_Cnt','aaN_Cnt','sssN_Cnt','ddsN_Cnt','aasN_Cnt','ssssN_Cnt','daaN_Cnt','sOH_Cnt','dO_Cnt','ssO_Cnt','aaO_Cnt','aOm_Cnt','sOm_Cnt','sF_Cnt','sSiH3_Cnt','ssSiH2_Cnt','sssSiH_Cnt','ssssSi_Cnt','sPH2_Cnt','ssPH_Cnt','sssP_Cnt','dsssP_Cnt','ddsP_Cnt','sssssP_Cnt','sSH_Cnt','dS_Cnt','ssS_Cnt','aaS_Cnt','dssS_Cnt','ddssS_Cnt','ssssssS_Cnt','Sm_Cnt','sCl_Cnt','sGeH3_Cnt','ssGeH2_Cnt','sssGeH_Cnt','ssssGe_Cnt','sAsH2_Cnt','ssAsH_Cnt','sssAs_Cnt','dsssAs_Cnt','ddsAs_Cnt','sssssAs_Cnt','sSeH_Cnt','dSe_Cnt','ssSe_Cnt','aaSe_Cnt','dssSe_Cnt','ssssssSe_Cnt','ddssSe_Cnt','sBr_Cnt','sSnH3_Cnt','ssSnH2_Cnt','sssSnH_Cnt','ssssSn_Cnt','sI_Cnt','sPbH3_Cnt','ssPbH2_Cnt','sssPbH_Cnt','ssssPb_Cnt','sLi_Sum','ssBe_Sum','ssssBem_Sum','sBH2_Sum','ssBH_Sum','sssB_Sum','ssssBm_Sum','sCH3_Sum','dCH2_Sum','ssCH2_Sum','tCH_Sum','dsCH_Sum','aaCH_Sum','sssCH_Sum','ddC_Sum','tsC_Sum','dssC_Sum','aasC_Sum','aaaC_Sum','ssssC_Sum','sNH3_Sum','sNH2_Sum','ssNH2_Sum','dNH_Sum','ssNH_Sum','aaNH_Sum','tN_Sum','sssNH_Sum','dsN_Sum','aaN_Sum','sssN_Sum','ddsN_Sum','aasN_Sum','ssssN_Sum','daaN_Sum','sOH_Sum','dO_Sum','ssO_Sum','aaO_Sum','aOm_Sum','sOm_Sum','sF_Sum','sSiH3_Sum','ssSiH2_Sum','sssSiH_Sum','ssssSi_Sum','sPH2_Sum','ssPH_Sum','sssP_Sum','dsssP_Sum','ddsP_Sum','sssssP_Sum','sSH_Sum','dS_Sum','ssS_Sum','aaS_Sum','dssS_Sum','ddssS_Sum','ssssssS_Sum','Sm_Sum','sCl_Sum','sGeH3_Sum','ssGeH2_Sum','sssGeH_Sum','ssssGe_Sum','sAsH2_Sum','ssAsH_Sum','sssAs_Sum','dsssAs_Sum','ddsAs_Sum','sssssAs_Sum','sSeH_Sum','dSe_Sum','ssSe_Sum','aaSe_Sum','dssSe_Sum','ssssssSe_Sum','ddssSe_Sum','sBr_Sum','sSnH3_Sum','ssSnH2_Sum','sssSnH_Sum','ssssSn_Sum','sI_Sum','sPbH3_Sum','ssPbH2_Sum','sssPbH_Sum','ssssPb_Sum','sLi_Avg','ssBe_Avg','ssssBem_Avg','sBH2_Avg','ssBH_Avg','sssB_Avg','ssssBm_Avg','sCH3_Avg','dCH2_Avg','ssCH2_Avg','tCH_Avg','dsCH_Avg','aaCH_Avg','sssCH_Avg','ddC_Avg','tsC_Avg','dssC_Avg','aasC_Avg','aaaC_Avg','ssssC_Avg','sNH3_Avg','sNH2_Avg','ssNH2_Avg','dNH_Avg','ssNH_Avg','aaNH_Avg','tN_Avg','sssNH_Avg','dsN_Avg','aaN_Avg','sssN_Avg','ddsN_Avg','aasN_Avg','ssssN_Avg','daaN_Avg','sOH_Avg','dO_Avg','ssO_Avg','aaO_Avg','aOm_Avg','sOm_Avg','sF_Avg','sSiH3_Avg','ssSiH2_Avg','sssSiH_Avg','ssssSi_Avg','sPH2_Avg','ssPH_Avg','sssP_Avg','dsssP_Avg','ddsP_Avg','sssssP_Avg','sSH_Avg','dS_Avg','ssS_Avg','aaS_Avg','dssS_Avg','ddssS_Avg','ssssssS_Avg','Sm_Avg','sCl_Avg','sGeH3_Avg','ssGeH2_Avg','sssGeH_Avg','ssssGe_Avg','sAsH2_Avg','ssAsH_Avg','sssAs_Avg','dsssAs_Avg','ddsAs_Avg','sssssAs_Avg','sSeH_Avg','dSe_Avg','ssSe_Avg','aaSe_Avg','dssSe_Avg','ssssssSe_Avg','ddssSe_Avg','sBr_Avg','sSnH3_Avg','ssSnH2_Avg','sssSnH_Avg','ssssSn_Avg','sI_Avg','sPbH3_Avg','ssPbH2_Avg','sssPbH_Avg','ssssPb_Avg','First Zagreb (ZM1)','First Zagreb index by valence vertex degrees (ZM1V)','Second Zagreb (ZM2)','Second Zagreb index by valence vertex degrees (ZM2V)','Polarity (Pol)','Narumi Simple Topological (NST)','Narumi Harmonic Topological (NHT)','Narumi Geometric Topological (NGT)','Total structure connectivity (TSC)','Wiener (W)','Mean Wiener (MW)','Xu (Xu)','Quadratic (QIndex)','Radial centric (RC)','Mean Square Distance Balaban (MSDB)','Superpendentic (SP)','Harary (Har)','Log of product of row sums (LPRS)','Pogliani (Pog)','Schultz Molecular Topological (SMT)','Schultz Molecular Topological by valence vertex degrees (SMTV)','Mean Distance Degree Deviation (MDDD)','Ramification (Ram)','Gutman Molecular Topological (GMT)','Gutman MTI by valence vertex degrees (GMTV)','Average vertex distance degree (AVDD)','Unipolarity (UP)','Centralization (CENT)','Variation (VAR)','Molecular electrotopological variation (MEV)','Maximal electrotopological positive variation (MEPV)','Maximal electrotopological negative variation (MENV)','Eccentric connectivity (ECCc)','Eccentricity (ECC)','Average eccentricity (AECC)','Eccentric (DECC)','Valence connectivity index chi-0 (vX0)','Valence connectivity index chi-1 (vX1)','Valence connectivity index chi-2 (vX2)','Valence connectivity index chi-3 (vX3)','Valence connectivity index chi-4 (vX4)','Valence connectivity index chi-5 (vX5)','Average valence connectivity index chi-0 (AvX0)','Average valence connectivity index chi-1 (AvX1)','Average valence connectivity index chi-2 (AvX2)','Average valence connectivity index chi-3 (AvX3)','Average valence connectivity index chi-4 (AvX4)','Average valence connectivity index chi-5 (AvX5)','Quasi Wiener (QW)','First Mohar (FM)','Second Mohar (SM)','Spanning tree number (STN)','Kier benzene-likeliness index (KBLI)','Topological charge index of order 1 (TCI1)','Topological charge index of order 2 (TCI2)','Topological charge index of order 3 (TCI3)','Topological charge index of order 4 (TCI4)','Topological charge index of order 5 (TCI5)','Topological charge index of order 6 (TCI6)','Topological charge index of order 7 (TCI7)','Topological charge index of order 8 (TCI8)','Topological charge index of order 9 (TCI9)','Topological charge index of order 10 (TCI10)','Mean topological charge index of order 1 (MTCI1)','Mean topological charge index of order 2 (MTCI2)','Mean topological charge index of order 3 (MTCI3)','Mean topological charge index of order 4 (MTCI4)','Mean topological charge index of order 5 (MTCI5)','Mean topological charge index of order 6 (MTCI6)','Mean topological charge index of order 7 (MTCI7)','Mean topological charge index of order 8 (MTCI8)','Mean topological charge index of order 9 (MTCI9)','Mean topological charge index of order 10 (MTCI10)','Global topological charge (GTC)','Hyper-distance-path index (HDPI)','Reciprocal hyper-distance-path index (RHDPI)','Square reciprocal distance sum (SRDS)','Modified Randic connectivity (MRC)','Balaban centric (BC)','Lopping centric (LC)','Kier Hall electronegativity (KHE)','Sum of topological distances between N..N (STD(N N))','Sum of topological distances between N..O (STD(N O))','Sum of topological distances between N..S (STD(N S))','Sum of topological distances between N..P (STD(N P))','Sum of topological distances between N..F (STD(N F))','Sum of topological distances between N..Cl (STD(N Cl))','Sum of topological distances between N..Br (STD(N Br))','Sum of topological distances between N..I (STD(N I))','Sum of topological distances between O..O (STD(O O))','Sum of topological distances between O..S (STD(O S))','Sum of topological distances between O..P (STD(O P))','Sum of topological distances between O..F (STD(O F))','Sum of topological distances between O..Cl (STD(O Cl))','Sum of topological distances between O..Br (STD(O Br))','Sum of topological distances between O..I (STD(O I))','Sum of topological distances between S..S (STD(S S))','Sum of topological distances between S..P (STD(S P))','Sum of topological distances between S..F (STD(S F))','Sum of topological distances between S..Cl (STD(S Cl))','Sum of topological distances between S..Br (STD(S Br))','Sum of topological distances between S..I (STD(S I))','Sum of topological distances between P..P (STD(P P))','Sum of topological distances between P..F (STD(P F))','Sum of topological distances between P..Cl (STD(P Cl))','Sum of topological distances between P..Br (STD(P Br))','Sum of topological distances between P..I (STD(P I))','Sum of topological distances between F..F (STD(F F))','Sum of topological distances between F..Cl (STD(F Cl))','Sum of topological distances between F..Br (STD(F Br))','Sum of topological distances between F..I (STD(F I))','Sum of topological distances between Cl..Cl (STD(Cl Cl))','Sum of topological distances between Cl..Br (STD(Cl Br))','Sum of topological distances between Cl..I (STD(Cl I))','Sum of topological distances between Br..Br (STD(Br Br))','Sum of topological distances between Br..I (STD(Br I))','Sum of topological distances between I..I (STD(I I))','Wiener-type index from Z weighted distance matrix - Barysz matrix (WhetZ)','Wiener-type index from electronegativity weighted distance matrix (Whete)','Wiener-type index from mass weighted distance matrix (Whetm)','Wiener-type index from van der waals weighted distance matrix (Whetv)','Wiener-type index from polarizability weighted distance matrix (Whetp)','Balaban-type index from Z weighted distance matrix - Barysz matrix (JhetZ)','Balaban-type index from electronegativity weighted distance matrix (Jhete)','Balaban-type index from mass weighted distance matrix (Jhetm)','Balaban-type index from van der waals weighted distance matrix (Jhetv)','Balaban-type index from polarizability weighted distance matrix (Jhetp)','Topological diameter (TD)','Topological radius (TR)','Petitjean 2D shape (PJ2DS)','Balaban distance connectivity index (J)','Solvation connectivity index chi-0 (SCIX0)','Solvation connectivity index chi-1 (SCIX1)','Solvation connectivity index chi-2 (SCIX2)','Solvation connectivity index chi-3 (SCIX3)','Solvation connectivity index chi-4 (SCIX4)','Solvation connectivity index chi-5 (SCIX5)','Connectivity index chi-0 (CIX0)','Connectivity chi-1 [Randic connectivity] (CIX1)','Connectivity index chi-2 (CIX2)','Connectivity index chi-3 (CIX3)','Connectivity index chi-4 (CIX4)','Connectivity index chi-5 (CIX5)','Average connectivity index chi-0 (ACIX0)','Average connectivity index chi-1 (ACIX1)','Average connectivity index chi-2 (ACIX2)','Average connectivity index chi-3 (ACIX3)','Average connectivity index chi-4 (ACIX4)','Average connectivity index chi-5 (ACIX5)','reciprocal distance Randic-type index (RDR)','reciprocal distance square Randic-type index (RDSR)','1-path Kier alpha-modified shape index (KAMS1)','2-path Kier alpha-modified shape index (KAMS2)','3-path Kier alpha-modified shape index (KAMS3)','Kier flexibility (KF)','path/walk 2 - Randic shape index (RSIpw2)','path/walk 3 - Randic shape index (RSIpw3)','path/walk 4 - Randic shape index (RSIpw4)','path/walk 5 - Randic shape index (RSIpw5)','E-state topological parameter (ETP)','Ring Count 3 (RNGCNT3)','Ring Count 4 (RNGCNT4)','Ring Count 5 (RNGCNT5)','Ring Count 6 (RNGCNT6)','Ring Count 7 (RNGCNT7)','Ring Count 8 (RNGCNT8)','Ring Count 9 (RNGCNT9)','Ring Count 10 (RNGCNT10)','Ring Count 11 (RNGCNT11)','Ring Count 12 (RNGCNT12)','Ring Count 13 (RNGCNT13)','Ring Count 14 (RNGCNT14)','Ring Count 15 (RNGCNT15)','Ring Count 16 (RNGCNT16)','Ring Count 17 (RNGCNT17)','Ring Count 18 (RNGCNT18)','Ring Count 19 (RNGCNT19)','Ring Count 20 (RNGCNT20)','Atom Count (ATMCNT)','Bond Count (BNDCNT)','Atoms in Ring System (ATMRNGCNT)','Bonds in Ring System (BNDRNGCNT)','Cyclomatic number (CYCLONUM)','Number of ring systems (NRS)','Normalized number of ring systems (NNRS)','Ring Fusion degree (RFD)','Ring perimeter (RNGPERM)','Ring bridge count (RNGBDGE)','Molecule cyclized degree (MCD)','Ring Fusion density (RFDELTA)','Ring complexity index (RCI)','Van der Waals surface area (VSA)','MR1 (MR1)','MR2 (MR2)','MR3 (MR3)','MR4 (MR4)','MR5 (MR5)','MR6 (MR6)','MR7 (MR7)','MR8 (MR8)','ALOGP1 (ALOGP1)','ALOGP2 (ALOGP2)','ALOGP3 (ALOGP3)','ALOGP4 (ALOGP4)','ALOGP5 (ALOGP5)','ALOGP6 (ALOGP6)','ALOGP7 (ALOGP7)','ALOGP8 (ALOGP8)','ALOGP9 (ALOGP9)','ALOGP10 (ALOGP10)','PEOE1 (PEOE1)','PEOE2 (PEOE2)','PEOE3 (PEOE3)','PEOE4 (PEOE4)','PEOE5 (PEOE5)','PEOE6 (PEOE6)','PEOE7 (PEOE7)','PEOE8 (PEOE8)','PEOE9 (PEOE9)','PEOE10 (PEOE10)','PEOE11 (PEOE11)','PEOE12 (PEOE12)','PEOE13 (PEOE13)','PEOE14 (PEOE14)']
107 | 
108 | import shutil
109 | 
110 | featurizer = dc.feat.UserDefinedFeaturizer(user_specified_features)
111 | loader = dc.data.UserCSVLoader(
112 |       tasks=["Class"], smiles_field="mol", id_field="mol",
113 |       featurizer=featurizer)
114 | dataset = loader.featurize(dataset_file)
115 | crystal_dataset = loader.featurize(crystal_dataset_file)
116 | 
117 | #This data is already split into three subsets “Train” and “Test” with 20% and 80% respectively of the total data from the BACE enzyme.
118 | #There is also a “Validation” set that contains data from a separate (but related assay). (Note that these names are really misnomers.
119 | #The “Test” set would be called a validation set in standard machine-learning practice and the “Validation” set would typically be called an external test set.)
120 | #Hence, we will rename the datasets after loading them.
121 | 
122 | splitter = dc.splits.SpecifiedSplitter(dataset_file, "Model")
123 | train_dataset, valid_dataset, test_dataset = splitter.train_valid_test_split(
124 |     dataset)
125 | #NOTE THE RENAMING:
126 | valid_dataset, test_dataset = test_dataset, valid_dataset
127 | 
128 | #Let’s quickly take a look at a compound in the validation set. (The compound displayed earlier was drawn from the train set).
129 | 
130 | print(valid_dataset.ids)
131 | valid_mols = [Chem.MolFromSmiles(compound)
132 |               for compound in islice(valid_dataset.ids, num_to_display)]
133 | display_images(mols_to_pngs(valid_mols, basename="valid_set"))
134 | 
135 | #Let’s now write these datasets to disk
136 | 
137 | print("Number of compounds in train set")
138 | print(len(train_dataset))
139 | print("Number of compounds in validation set")
140 | print(len(valid_dataset))
141 | print("Number of compounds in test set")
142 | print(len(test_dataset))
143 | print("Number of compounds in crystal set")
144 | print(len(crystal_dataset))
145 | 
146 | #The performance of common machine-learning algorithms can be very sensitive to preprocessing of the data.
147 | #One common transformation applied to data is to normalize it to have zero-mean and unit-standard-deviation.
148 | # We will apply this transformation to the pIC50 values (as seen above, the pIC50s range from 2 to 11).
149 | 
150 | transformers = [
151 |     dc.trans.NormalizationTransformer(transform_X=True, dataset=train_dataset),
152 |     dc.trans.ClippingTransformer(transform_X=True, dataset=train_dataset)]
153 | 
154 | datasets = [train_dataset, valid_dataset, test_dataset, crystal_dataset]
155 | for i, dataset in enumerate(datasets):
156 |   for transformer in transformers:
157 |       datasets[i] = transformer.transform(dataset)
158 | train_dataset, valid_dataset, test_dataset, crystal_dataset = datasets
159 | 
160 | 
161 | #We now fit simple random forest models to our datasets.
162 | 
163 | from sklearn.ensemble import RandomForestClassifier
164 | 
165 | def rf_model_builder(model_params, model_dir):
166 |   sklearn_model = RandomForestClassifier(**model_params)
167 |   return dc.models.SklearnModel(sklearn_model, model_dir)
168 | params_dict = {
169 |     "n_estimators": [10, 100],
170 |     "max_features": ["auto", "sqrt", "log2", None],
171 | }
172 | 
173 | metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
174 | optimizer = dc.hyper.HyperparamOpt(rf_model_builder)
175 | best_rf, best_rf_hyperparams, all_rf_results = optimizer.hyperparam_search(
176 |     params_dict, train_dataset, valid_dataset, transformers,
177 |     metric=metric)
178 | 
179 | 
180 | 
181 | params_dict = {"learning_rate": np.power(10., np.random.uniform(-5, -3, size=1)),
182 |                "weight_decay_penalty": np.power(10, np.random.uniform(-6, -4, size=1)),
183 |                "nb_epoch": [40] }
184 | n_features = train_dataset.get_data_shape()[0]
185 | def model_builder(model_params, model_dir):
186 |   model = dc.models.MultitaskClassifier(
187 |     1, n_features, layer_sizes=[1000], dropouts=.25,
188 |     batch_size=50, **model_params)
189 |   return model
190 | 
191 | optimizer = dc.hyper.HyperparamOpt(model_builder)
192 | best_dnn, best_dnn_hyperparams, all_dnn_results = optimizer.hyperparam_search(
193 |     params_dict, train_dataset, valid_dataset, transformers,
194 |     metric=metric)
195 | 
196 | #Now let’s evaluate the best model on the validation and test sets and save the results to a new .csv dataset.
197 | 
198 | from deepchem.utils.evaluate import Evaluator
199 | 
200 | rf_train_csv_out = "rf_train_regressor.csv"
201 | rf_train_stats_out = "rf_train_stats_regressor.txt"
202 | rf_train_evaluator = Evaluator(best_rf, train_dataset, transformers)
203 | rf_train_score = rf_train_evaluator.compute_model_performance(
204 |     [metric], rf_train_csv_out, rf_train_stats_out)
205 | print("RF Train set AUC %f" % (rf_train_score["roc_auc_score"]))
206 | 
207 | rf_valid_csv_out = "rf_valid_regressor.csv"
208 | rf_valid_stats_out = "rf_valid_stats_regressor.txt"
209 | rf_valid_evaluator = Evaluator(best_rf, valid_dataset, transformers)
210 | rf_valid_score = rf_valid_evaluator.compute_model_performance(
211 |     [metric], rf_valid_csv_out, rf_valid_stats_out)
212 | print("RF Valid set AUC %f" % (rf_valid_score["roc_auc_score"]))
213 | 
214 | rf_test_csv_out = "rf_test_regressor.csv"
215 | rf_test_stats_out = "rf_test_stats_regressor.txt"
216 | rf_test_evaluator = Evaluator(best_rf, test_dataset, transformers)
217 | rf_test_score = rf_test_evaluator.compute_model_performance(
218 |     [metric], rf_test_csv_out, rf_test_stats_out)
219 | print("RF Test set AUC %f" % (rf_test_score["roc_auc_score"]))
220 | 
221 | rf_crystal_csv_out = "rf_crystal_regressor.csv"
222 | rf_crystal_stats_out = "rf_crystal_stats_regressor.txt"
223 | rf_crystal_evaluator = Evaluator(best_rf, crystal_dataset, transformers)
224 | rf_crystal_score = rf_crystal_evaluator.compute_model_performance(
225 |     [metric], rf_crystal_csv_out, rf_crystal_stats_out)
226 | print("RF Crystal set R^2 %f" % (rf_crystal_score["roc_auc_score"]))
227 | 
228 | 
229 | 
230 | dnn_train_csv_out = "dnn_train_classifier.csv"
231 | dnn_train_stats_out = "dnn_train_classifier_stats.txt"
232 | dnn_train_evaluator = Evaluator(best_dnn, train_dataset, transformers)
233 | dnn_train_score = dnn_train_evaluator.compute_model_performance(
234 |     [metric], dnn_train_csv_out, dnn_train_stats_out)
235 | print("DNN Train set AUC %f" % (dnn_train_score["roc_auc_score"]))
236 | 
237 | dnn_valid_csv_out = "dnn_valid_classifier.csv"
238 | dnn_valid_stats_out = "dnn_valid_classifier_stats.txt"
239 | dnn_valid_evaluator = Evaluator(best_dnn, valid_dataset, transformers)
240 | dnn_valid_score = dnn_valid_evaluator.compute_model_performance(
241 |     [metric], dnn_valid_csv_out, dnn_valid_stats_out)
242 | print("DNN Valid set AUC %f" % (dnn_valid_score["roc_auc_score"]))
243 | 
244 | dnn_test_csv_out = "dnn_test_classifier.csv"
245 | dnn_test_stats_out = "dnn_test_classifier_stats.txt"
246 | dnn_test_evaluator = Evaluator(best_dnn, test_dataset, transformers)
247 | dnn_test_score = dnn_test_evaluator.compute_model_performance(
248 |     [metric], dnn_test_csv_out, dnn_test_stats_out)
249 | print("DNN Test set AUC %f" % (dnn_test_score["roc_auc_score"]))
250 | 
251 | dnn_crystal_csv_out = "dnn_crystal_classifier.csv"
252 | dnn_crystal_stats_out = "dnn_crystal_stats_classifier.txt"
253 | dnn_crystal_evaluator = Evaluator(best_dnn, crystal_dataset, transformers)
254 | dnn_crystal_score = dnn_crystal_evaluator.compute_model_performance(
255 |     [metric], dnn_crystal_csv_out, dnn_crystal_stats_out)
256 | print("DNN Crystal set AUC %f" % (dnn_crystal_score["roc_auc_score"]))
257 | 
258 | 
259 | #Make directories store the raw and featurized datasets.
260 | featurizer = dc.feat.UserDefinedFeaturizer(user_specified_features)
261 | loader = dc.data.UserCSVLoader(
262 |     tasks=["pIC50"], smiles_field="mol", id_field="CID",
263 |     featurizer=featurizer)
264 | dataset = loader.featurize(dataset_file)
265 | crystal_dataset = loader.featurize(crystal_dataset_file)
266 | 
267 | 
268 | splitter = dc.splits.SpecifiedSplitter(dataset_file, "Model")
269 | train_dataset, valid_dataset, test_dataset = splitter.train_valid_test_split(
270 |     dataset)
271 | #NOTE THE RENAMING:
272 | valid_dataset, test_dataset = test_dataset, valid_dataset
273 | 
274 | print("Number of compounds in train set")
275 | print(len(train_dataset))
276 | print("Number of compounds in validation set")
277 | print(len(valid_dataset))
278 | print("Number of compounds in test set")
279 | print(len(test_dataset))
280 | print("Number of compounds in crystal set")
281 | print(len(crystal_dataset))
282 | 
283 | 
284 | 
285 | transformers = [
286 |     dc.trans.NormalizationTransformer(transform_X=True, dataset=train_dataset),
287 |     dc.trans.ClippingTransformer(transform_X=True, dataset=train_dataset)]
288 | 
289 | datasets = [train_dataset, valid_dataset, test_dataset, crystal_dataset]
290 | for i, dataset in enumerate(datasets):
291 |   for transformer in transformers:
292 |       datasets[i] = transformer.transform(dataset)
293 | train_dataset, valid_dataset, test_dataset, crystal_dataset = datasets
294 | 
295 | 
296 | 
297 | 
298 | from sklearn.ensemble import RandomForestRegressor
299 | 
300 | def rf_model_builder(model_params, model_dir):
301 |   sklearn_model = RandomForestRegressor(**model_params)
302 |   return dc.models.SklearnModel(sklearn_model, model_dir)
303 | params_dict = {
304 |     "n_estimators": [10, 100],
305 |     "max_features": ["auto", "sqrt", "log2", None],
306 | }
307 | 
308 | metric = dc.metrics.Metric(dc.metrics.r2_score)
309 | optimizer = dc.hyper.HyperparamOpt(rf_model_builder)
310 | best_rf, best_rf_hyperparams, all_rf_results = optimizer.hyperparam_search(
311 |     params_dict, train_dataset, valid_dataset, transformers,
312 |     metric=metric)
313 | 
314 | 
315 | params_dict = {"learning_rate": np.power(10., np.random.uniform(-5, -3, size=2)),
316 |                "weight_decay_penalty": np.power(10, np.random.uniform(-6, -4, size=2)),
317 |                "nb_epoch": [20] }
318 | n_features = train_dataset.get_data_shape()[0]
319 | def model_builder(model_params, model_dir):
320 |   model = dc.models.MultitaskRegressor(
321 |     1, n_features, layer_sizes=[1000], dropouts=[.25],
322 |     batch_size=50, **model_params)
323 |   return model
324 | 
325 | optimizer = dc.hyper.HyperparamOpt(model_builder)
326 | best_dnn, best_dnn_hyperparams, all_dnn_results = optimizer.hyperparam_search(
327 |     params_dict, train_dataset, valid_dataset, transformers,
328 |     metric=metric)
329 | 
330 | 
331 | 
332 | 
333 | 
334 | rf_train_csv_out = "rf_train_regressor.csv"
335 | rf_train_stats_out = "rf_train_stats_regressor.txt"
336 | rf_train_evaluator = Evaluator(best_rf, train_dataset, transformers)
337 | rf_train_score = rf_train_evaluator.compute_model_performance(
338 |     [metric], rf_train_csv_out, rf_train_stats_out)
339 | print("RF Train set R^2 %f" % (rf_train_score["r2_score"]))
340 | 
341 | rf_valid_csv_out = "rf_valid_regressor.csv"
342 | rf_valid_stats_out = "rf_valid_stats_regressor.txt"
343 | rf_valid_evaluator = Evaluator(best_rf, valid_dataset, transformers)
344 | rf_valid_score = rf_valid_evaluator.compute_model_performance(
345 |     [metric], rf_valid_csv_out, rf_valid_stats_out)
346 | print("RF Valid set R^2 %f" % (rf_valid_score["r2_score"]))
347 | 
348 | rf_test_csv_out = "rf_test_regressor.csv"
349 | rf_test_stats_out = "rf_test_stats_regressor.txt"
350 | rf_test_evaluator = Evaluator(best_rf, test_dataset, transformers)
351 | rf_test_score = rf_test_evaluator.compute_model_performance(
352 |     [metric], rf_test_csv_out, rf_test_stats_out)
353 | print("RF Test set R^2 %f" % (rf_test_score["r2_score"]))
354 | 
355 | rf_crystal_csv_out = "rf_crystal_regressor.csv"
356 | rf_crystal_stats_out = "rf_crystal_stats_regressor.txt"
357 | rf_crystal_evaluator = Evaluator(best_rf, crystal_dataset, transformers)
358 | rf_crystal_score = rf_crystal_evaluator.compute_model_performance(
359 |     [metric], rf_crystal_csv_out, rf_crystal_stats_out)
360 | print("RF Crystal set R^2 %f" % (rf_crystal_score["r2_score"]))
361 | 
362 | 
363 | 
364 | 
365 | dnn_train_csv_out = "dnn_train_regressor.csv"
366 | dnn_train_stats_out = "dnn_train_regressor_stats.txt"
367 | dnn_train_evaluator = Evaluator(best_dnn, train_dataset, transformers)
368 | dnn_train_score = dnn_train_evaluator.compute_model_performance(
369 |     [metric], dnn_train_csv_out, dnn_train_stats_out)
370 | print("DNN Train set R^2 %f" % (dnn_train_score["r2_score"]))
371 | 
372 | dnn_valid_csv_out = "dnn_valid_regressor.csv"
373 | dnn_valid_stats_out = "dnn_valid_regressor_stats.txt"
374 | dnn_valid_evaluator = Evaluator(best_dnn, valid_dataset, transformers)
375 | dnn_valid_score = dnn_valid_evaluator.compute_model_performance(
376 |     [metric], dnn_valid_csv_out, dnn_valid_stats_out)
377 | print("DNN Valid set R^2 %f" % (dnn_valid_score["r2_score"]))
378 | 
379 | dnn_test_csv_out = "dnn_test_regressor.csv"
380 | dnn_test_stats_out = "dnn_test_regressor_stats.txt"
381 | dnn_test_evaluator = Evaluator(best_dnn, test_dataset, transformers)
382 | dnn_test_score = dnn_test_evaluator.compute_model_performance(
383 |     [metric], dnn_test_csv_out, dnn_test_stats_out)
384 | print("DNN Test set R^2 %f" % (dnn_test_score["r2_score"]))
385 | 
386 | dnn_crystal_csv_out = "dnn_crystal_regressor.csv"
387 | dnn_crystal_stats_out = "dnn_crystal_stats_regressor.txt"
388 | dnn_crystal_evaluator = Evaluator(best_dnn, crystal_dataset, transformers)
389 | dnn_crystal_score = dnn_crystal_evaluator.compute_model_performance(
390 |     [metric], dnn_crystal_csv_out, dnn_crystal_stats_out)
391 | print("DNN Crystal set R^2 %f" % (dnn_crystal_score["r2_score"]))
392 | 
393 | 
394 | 
395 | 
396 | task = "pIC50"
397 | rf_predicted_test = best_rf.predict(test_dataset)
398 | rf_true_test = test_dataset.y
399 | plot.scatter(rf_predicted_test, rf_true_test)
400 | plot.xlabel('Predicted pIC50s')
401 | plot.ylabel('Secondary Assay')
402 | plot.title(r'RF predicted IC50 vs. Secondary Assay')
403 | plot.xlim([2, 11])
404 | plot.ylim([2, 11])
405 | plot.plot([2, 11], [2, 11], color='k')
406 | plot.show()
407 | 
408 | 
409 | 
410 | dnn_predicted_test = best_dnn.predict(test_dataset, transformers)
411 | dnn_true_test = test_dataset.y
412 | plot.scatter(dnn_predicted_test, dnn_true_test)
413 | plot.xlabel('Predicted pIC50s')
414 | plot.ylabel('Secondary Assay')
415 | plot.title(r'DNN predicted IC50 vs. Secondary Assay')
416 | plot.xlim([2, 11])
417 | plot.ylim([2, 11])
418 | plot.plot([2, 11], [2, 11], color='k')
419 | plot.show()
420 | 
421 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Packt
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | # Hands-On GPU Computing with Python
 5 | 
 6 | <a href="https://www.packtpub.com/in/big-data-and-business-intelligence/hands-gpu-computing-python?utm_source=github&utm_medium=repository&utm_campaign="><img src="https://www.packtpub.com/media/catalog/product/cache/e4d64343b1bc593f1c5348fe05efa4a6/b/1/b11179_0.png" alt="Hands-On GPU Computing with Python" height="256px" align="right"></a>
 7 | 
 8 | This is the code repository for [Hands-On GPU Computing with Python](https://www.packtpub.com/in/big-data-and-business-intelligence/hands-gpu-computing-python?utm_source=github&utm_medium=repository&utm_campaign=), published by Packt.
 9 | 
10 | **Explore the capabilities of GPUs for solving high performance computational problems**
11 | 
12 | ## What is this book about?
13 | GPUs are proving to be excellent general purpose-parallel computing solutions for high performance tasks such as deep learning and scientific computing.
14 | 
15 | This book will be your guide to getting started with GPU computing. It will start with introducing GPU computing and explain the architecture and programming models for GPUs. You will learn, by example, how to perform GPU programming with Python, and you’ll look at using integrations such as PyCUDA, PyOpenCL, CuPy, Numba, Tensorflow, Keras and PyTorch with Anaconda for various tasks such as machine learning, data mining and scientific computing. Going further, you will get to grips with GPU work flows, management, and deployment using modern containerization solutions. Toward the end of the book, you will get familiar with the principles of distributed computing for training machine learning models and enhancing efficiency and performance.
16 | 
17 | This book covers the following exciting features:
18 | * Utilize Python libraries and frameworks for GPU acceleration
19 | * Set up a GPU-enabled programmable machine learning environment on your system with Anaconda
20 | * Deploy your machine learning system on cloud containers with illustrated examples
21 | * Explore PyCUDA and PyOpenCL and compare them with platforms such as CUDA, OpenCL and ROCm.
22 | * Perform data mining tasks with machine learning models on GPUs
23 | * Extend your knowledge of GPU computing in scientific applications
24 | 
25 | 
26 | If you feel this book is for you, get your [copy](https://www.amazon.com/dp/1789341078) today!
27 | 
28 | <a href="https://www.packtpub.com/?utm_source=github&utm_medium=banner&utm_campaign=GitHubBanner"><img src="https://raw.githubusercontent.com/PacktPublishing/GitHub/master/GitHub.png" 
29 | alt="https://www.packtpub.com/" border="5" /></a>
30 | 
31 | ## Instructions and Navigations
32 | All of the code is organized into folders. For example, Chapter02.
33 | 
34 | The code will look like the following:
35 | ```
36 | // Run function on 500 Million elements on the CPU
37 |   begin = clock();
38 |   multiply(N, p, q);
39 |   end = clock();
40 |   cpu_time_used = ((double) (end - begin)) / CLOCKS_PER_SEC;
41 | ```
42 | 
43 | **Following is what you need for this book:**
44 | Data Scientist, Machine Learning enthusiasts and professionals who wants to get started with GPU computation and perform the complex tasks with low-latency. Intermediate knowledge of Python programming is assumed.
45 | 
46 | With the following software list you can run all code files present in the book (Chapter 1-11).
47 | ### Software List
48 | | Chapter | Software required | OS required |
49 | | -------- | ------------------------------------ | ----------------------------------- |
50 | | 2 - 11 | PyCharm Community Edition, PyCharm Educational Edition, PyCharm for Anaconda Community Edition, PyCharm Professional Edition, PyCharm for Anaconda Professional Edition, PyDev, Jupyter Notebook, Jupyter Lab, Eric, CUDA, ROCm, Anaconda, CuPy, Numba, Google Colaboratory, Tensorflow, PyTorch,  DeepChem | Linux (preferably Ubuntu) |
51 | 
52 | We also provide a PDF file that has color images of the screenshots/diagrams used in this book. [Click here to download it](https://www.packtpub.com/sites/default/files/downloads/9781789341072_ColorImages.pdf).
53 | 
54 | ### Related products
55 | * Hands-On GPU-Accelerated Computer Vision with OpenCV and CUDA [[Packt]](https://www.packtpub.com/application-development/hands-gpu-accelerated-computer-vision-opencv-and-cuda?utm_source=github&utm_medium=repository&utm_campaign=) [[Amazon]](https://www.amazon.com/dp/1789348293)
56 | 
57 | * Learn OpenCV 4 By Building Projects - Second Edition [[Packt]](https://www.packtpub.com/application-development/learn-opencv-4-building-projects-second-edition?utm_source=github&utm_medium=repository&utm_campaign=) [[Amazon]](https://www.amazon.com/dp/1789341221)
58 | 
59 | ## Get to Know the Author
60 | **Avimanyu Bandyopadhyay**
61 | is currently pursuing a PhD degree in Bioinformatics based on applied GPU computing in Computational Biology at Heritage Institute of Technology, Kolkata, India. Since 2014, he developed a keen interest in GPU computing, and used CUDA for his master's thesis. He has experience as a systems administrator as well, particularly on the Linux platform.
62 | Avimanyu is also a scientific writer, technology communicator, and a passionate gamer. He has published technical writing on open source computing and has actively participated in NVIDIA's GPU computing conferences since 2016. A big-time Linux fan, he strongly believes in the significance of Linux and an open source approach in scientific research. Deep learning with GPUs is his new passion!
63 | 
64 | ### Suggestions and Feedback
65 | [Click here](https://docs.google.com/forms/d/e/1FAIpQLSdy7dATC6QmEL81FIUuymZ0Wy9vH1jHkvpY57OiMeKGqib_Ow/viewform) if you have any feedback or suggestions.
66 | 
67 | 
68 | ### Download a free PDF
69 | 
70 |  <i>If you have already purchased a print or Kindle version of this book, you can get a DRM-free PDF version at no cost.<br>Simply click on the link to claim your free PDF.</i>
71 | <p align="center"> <a href="https://packt.link/free-ebook/9781789341072">https://packt.link/free-ebook/9781789341072 </a> </p>


--------------------------------------------------------------------------------