Judul
DOKUMENTASI PEMROGRAMAN GPU KELOMPOK : 1 Kelas : A Oleh: Ditya Enandini Palupi 145150201111080 145150201111080 Muhammad Yudha Yusi Putra 145150201111080 145150201111080 Shinta Aprilisia 145150200111 145150200111100 100
PENGANTAR MK Pemrograman GPU berfokus pada konsep dasar GPU Programming, bagaimana menggunakan teknik parallel berbasis GPU, mengimplementasikan terkait beberapa kebutuhan teknologi terkini, yang meliputi deep learning , self -driving cars driving cars,, virtual reality, reality, game development development , accelerated computing , design & visualization, visualization, automous machines, machines, dengan melakukan komputasi secara cepat dan tepat, serta mampu mengintegrasikan teknik parallel terhadap kebutuhan teknologi masa depan dengan mengambil potensi dari pengolahan data yang cepat untuk membantu meningkatkan hasil yang lebih akurat. Imam Cholissodin S.Si., M.Kom Dosen Pengampu MK Pemrograman GPU FILKOM UB
2018
Daftar Isi
Judul ...................................................................................................... i Daftar Isi .................................. ................. ................................... .................................... .................................... ......................... ....... ii Daftar Tabel................................... ................. ..................................... .................................... ................................... .................. iii Daftar Gambar .................................. ................ ..................................... .................................... ................................ ............... iv Daftar Source Code .............................................................................. v BAB 1
Tugas Kelompok K elompok .................................. ................ .................................... ............................ .......... 1 Tugas 1 (Introduction to GPU Programming) ................. 1
Tugas 2 (Tuliskan Judul Materi Di sini) ................. Error! Bookmark not defined. BAB 2 Final Project Project : [Tuliskan Judul FP Disini] ............. Error! Bookmark not defined. Pendahuluan ................... .................. . Error! Bookmark not defined. 2.1.1 Latar Belakang Bela kang (min. 1,5 halaman) h alaman)............. Error! Bookmark not defined. 2.1.2 Tujuan dan Manfaat FP..... Error! Bookmark not defined. Landasan Kepustakaan .. Error! Bookmark not defined. 2.2.1
Kajian Pustaka ... Error! Bookmark not defined.
2.2.2
Alur dari FP ....... Error! Bookmark not defined.
Implementasi & Pengujian P engujian............ Error! Bookmark not defined. 2.3.1 Implementasi Program ...... Error! Bookmark not defined. 2.3.1.1 Implementasi Proses Data ................ Error! Bookmark not defined. 2.3.2 Implementasi Antarmuka .. Error! Bookmark not defined. 2.3.2.1 Tampilan Halaman Data Error! Bookmark not defined. 2.3.3 Pengujian Kinerja CPU vs GPU ................. Error! Bookmark not defined. ii
Daftar Isi
Judul ...................................................................................................... i Daftar Isi .................................. ................. ................................... .................................... .................................... ......................... ....... ii Daftar Tabel................................... ................. ..................................... .................................... ................................... .................. iii Daftar Gambar .................................. ................ ..................................... .................................... ................................ ............... iv Daftar Source Code .............................................................................. v BAB 1
Tugas Kelompok K elompok .................................. ................ .................................... ............................ .......... 1 Tugas 1 (Introduction to GPU Programming) ................. 1
Tugas 2 (Tuliskan Judul Materi Di sini) ................. Error! Bookmark not defined. BAB 2 Final Project Project : [Tuliskan Judul FP Disini] ............. Error! Bookmark not defined. Pendahuluan ................... .................. . Error! Bookmark not defined. 2.1.1 Latar Belakang Bela kang (min. 1,5 halaman) h alaman)............. Error! Bookmark not defined. 2.1.2 Tujuan dan Manfaat FP..... Error! Bookmark not defined. Landasan Kepustakaan .. Error! Bookmark not defined. 2.2.1
Kajian Pustaka ... Error! Bookmark not defined.
2.2.2
Alur dari FP ....... Error! Bookmark not defined.
Implementasi & Pengujian P engujian............ Error! Bookmark not defined. 2.3.1 Implementasi Program ...... Error! Bookmark not defined. 2.3.1.1 Implementasi Proses Data ................ Error! Bookmark not defined. 2.3.2 Implementasi Antarmuka .. Error! Bookmark not defined. 2.3.2.1 Tampilan Halaman Data Error! Bookmark not defined. 2.3.3 Pengujian Kinerja CPU vs GPU ................. Error! Bookmark not defined. ii
Penutup .......................... Error! Bookmark not defined. 2.4.1
Kesimpulan ........ Error! Bookmark not defined.
2.4.2
Saran .................. Error! Bookmark not defined.
Daftar Pustaka .................................................................................... 42 Biografi Kelompok Kel ompok .................................... ................... .................................... .................................... ...................... ..... 43
iii
Daftar Tabel
Tabel 3.1 Perbedaan Penelitian Sebelumnya dengan Final Project ............................................................ Error! Bookmark not defined. Tabel 3.15 Hasil Pengujian Range Ruang Pencarian Dimensi Sigma ............................................................ Error! Bookmark not defined.
iv
Daftar Gambar
Gambar 1.1 Capture Login di NVIDIA............ Error! Bookmark not defined. Gambar 1.2 Hasil running segitigaCuda.cu ....... Error! Bookmark not defined. Gambar 2.1 Antarmuka Halaman Data ............. Error! Bookmark not defined.
v
Daftar Source Code
Source Code 1.1 segitigaCuda.cu ...... Error! Bookmark not defined. Source Code 2.1 Proses Data ............. Error! Bookmark not defined.
vi
BAB 1
Tugas Kelompok
Tugas 1 Soal no. 1:
Buat capture step by step dari konfigurasi CUDA (Nvidia) + Visual Studio 2013/2015/2017/2018,dan mencoba run kode SISD.cu atau SIMD Jawaban :
Melakukan pengecekan command CL apakah sudah terdaftar atau belum.
1
Melakukan pendaftaran command CL di dalam sistem variable.
Pendaftaran command CL dengan menambahkan path folder VC\bin pada Visual Studio sesuai versi yang digunakan.
2
Download query.cu di link berikut https://goo.gl/JCTKY8 lalu extract pada folder tertentu, setelah itu pindahkan folder kedalam folder query.cu yang sebelumnya telah di download lalu jalankan command “nvcc query.cu –o query” jika terdapat log “Creating library query.lib and object query.exp” artinya proses be rhasil.
Menjalankan command query untuk pengecekan apakah CUDA berhasil di implementasikan dalam PC.
3
Percobaan hasil run coding program SISD.cu
4
Soal no. 2:
2. Menjelaskan konsep Grid, Block dan Thread dari bagian kode: dim3 grid(3, 1, 1); dim3 block(4, 1, 1); int tid = blockDim.x*blockIdx.x + threadIdx.x; if (tid < 5){ printf("\n blockDim.x*blockIdx.x + threadIdx.x = %d*%d + %d = %d", tid1, tid2, tid3, tid); } *device_a = blockDim.x*blockIdx.x + threadIdx.x;
Jawaban: Grid (3,1,1) artinya GridDim.x mempunyai nilai 3, GridDim.y mempunyai nilai 1, dan GridDim.z mempunyai nilai 1. Dari nilai tersebut, kita mendapatkan nilai banyak Block dengan rumus = Grid Dim.x * GridDim.y * GridDim.z = 3. Banyak anggota block index pada X adalah 3 (0,1,2) karena memiliki rumus GridDim.x-1. Banyak anggota block index pada Y adalah 1 (0) karena memiliki rumus GridDim.y-1. Banyak anggota block index pada Z adalah 1 (0) karena memiliki rumus GridDim.z-1. Block (4,1,1) artinya BlockDim.x mempunyai nilai 4, BlockDim.y mempunyai nilai 1, dan BlockDim.z mempunyai nilai 1. Dari nilai tersebut, kita mendapatkan nilai banyak Thread dengan rumus = Block Dim.x * BlockDim.y * BlockDim.z = 4. Banyak anggota thread index pada X adalah 4 (0,1,2,3) karena memiliki rumus BlockDim.x-1. Banyak anggota thread index pada Y adalah 1 (0) karena memiliki rumus BlockDim.y-1. Banyak anggota thread index pada Z adalah 1 (0) karena memiliki rumus BlockDim.z-1. int tid = blockDim.x * blockIdx.x + threadIdx.x artinya mendeklarasikan tid bernilai integer dan menginisialisasikan bahwa tid yaitu rumus dari blockDim.x * blockIdx.x + threadIdx.x. if (tid < 5) artinya mencetak tid kurang dari 5 kali. printf("\n blockDim.x* blockIdx.x + threadIdx.x = %d*%d + %d = %d", tid1, tid2, tid3, tid) artinya mencetak blockDim.x * blockIdx.x + threadIdx.x serta menampilkan hasil nilai integer desimal.
5
Soal no. 3:
3. Dalam folder solution utama kelompok, misal “VSCudaKel[..]”, buat folder solution “001_ImageProcessingKel[..]”, dan didalamnya buat project dengan nama “0DisplayRGBKel[..]”, link kode “https://goo.gl/Q7JALn” dari demo program “Display Image + Cimg” dan setiap kelompok harus mengubah baris kode: CimgDisplay main_disp(img_out, "After Processing");
Menjadi CImgDisplay main_disp(img_out, Kel-[..] Kelas-[..]");
"After
Processing
Jawaban : //A simple program to copy and display a .bmp image //Written by Dr. Ahmed Sallam, 27 July 2016, http://sallamah.weebly.com #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "CImg.h" using namespace cimg_library; //CImg.h v1.6.9 header enable you to manipulate bmp images easly //don't update to heighr versions to avoid depences issues //For FQ and how to use it visit http://cimg.eu __global__ void gpu_task(unsigned char * d_in, unsigned char * d_out, int img_width, int img_height) { unsigned unsigned threadIdx.x; unsigned unsigned
long scale = img_width*img_height; long r = blockIdx.x * blockDim.x + long g = r + scale; long b = g + scale;
//copy the d_out[r] = d_out[b] = d_out[g] =
input image to the output image d_in[r]; d_in[b]; d_in[g];
//printf("%d\t%d\t%d\n",r,g,b); }
6
int main(int argc, char ** argv) { //In this template there are 2 bmp images available "mountain.bmp" and "flower.bmp" use one of them to test your task //To understand CImg structure visit http://cimg.eu/reference/group__cimg__storage.html //CImg
img("flower.bmp"); // Define a 640x400 color image with 8 bits per color component. CImg img("ics.bmp"); // Define a 720x720 color image with 8 bits per color component. unsigned long img_size = img.size(); int img_width = img.width(); int img_height = img.height(); int img_depth = img.depth(); int img_dim = img.spectrum(); unsigned char *h_in = img.data(); CImg img_out(img_width, img_height, img_depth, img_dim); //define image with same features of the original unsigned char *h_out = img_out.data(); //printf("%d", sizeof(unsigned char)); //for (int i = 0; i < img_size; i++) //h_out[i] = h_in[i]; // declare GPU memory pointers unsigned char * d_in; unsigned char * d_out; // allocate GPU memory cudaMalloc(( void**)&d_in, img_size); cudaMalloc(( void**)&d_out, img_size); // transfer the array to the GPU cudaMemcpy(d_in, h_in, img_size, cudaMemcpyHostToDevice); // launch the kernel gpu_task << > >(d_in, d_out, img_width, img_height);
7
//force the printf()s to flush cudaDeviceSynchronize(); // copy back the result array to the CPU cudaMemcpy(h_out, d_out, img_size, cudaMemcpyDeviceToHost); CImgDisplay main_disp(img_out, "After Processing Kel-1 Kelas-A"); while (!main_disp.is_closed()) main_disp.wait(); cudaFree(d_in); cudaFree(d_out); return 0; }
8
Soal no. 4:
4. Modif dari soal no. 1, dalam folder solution utama kelompok, misal “VSCudaKel[..]”, dalam folder solution “001_ImageProcessingKel[..]”, buat project dengan nama “1RGB2GrayKel[..]”, link kode “https://goo.gl/Q7JALn” dari demo program “Display Image + Cimg” dan ubah menjadi rumus Luminosit Method I = 0.2126 * R + 0.7152 * G + 0.0722 * B Jawaban : //A simple program to copy and display a .bmp image //Written by Dr. Ahmed Sallam, 27 July 2016, http://sallamah.weebly.com #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "CImg.h" using namespace cimg_library; //CImg.h v1.6.9 header enable you to manipulate bmp images easly //don't update to heighr versions to avoid depences issues //For FQ and how to use it visit http://cimg.eu __global__ void gpu_task(unsigned char * d_in, unsigned char * d_out, int img_width, int img_height) { unsigned long scale = img_width*img_height; unsigned long r = blockIdx.x * blockDim.x + threadIdx.x; unsigned long g = r + scale; unsigned long b = g + scale; unsigned long I = 0.2126 * r + 0.7152 * g + 0.0722 * b; //copy the input image to the output image d_out[r] = d_in[I]; d_out[b] = d_in[I]; d_out[g] = d_in[I]; //printf("%d\t%d\t%d\n",r,g,b); }
9
int main(int argc, char ** argv) { //In this template there are 2 bmp images available "mountain.bmp" and "flower.bmp" use one of them to test your task //To understand CImg structure visit http://cimg.eu/reference/group__cimg__storage.html //CImg img("flower.bmp"); // Define a 640x400 color image with 8 bits per color component. CImg img("ics.bmp"); // Define a 720x720 color image with 8 bits per color component. unsigned long img_size = img.size(); int img_width = img.width(); int img_height = img.height(); int img_depth = img.depth(); int img_dim = img.spectrum(); unsigned char *h_in = img.data(); CImg img_out(img_width, img_height, img_depth, img_dim); //define image with same features of the original unsigned char *h_out = img_out.data(); //printf("%d", sizeof(unsigned char)); //for (int i = 0; i < img_size; i++) //h_out[i] = h_in[i]; // declare GPU memory pointers unsigned char * d_in; unsigned char * d_out; // allocate GPU memory cudaMalloc(( void**)&d_in, img_size); cudaMalloc(( void**)&d_out, img_size); // transfer the array to the GPU cudaMemcpy(d_in, h_in, img_size, cudaMemcpyHostToDevice ); // launch the kernel gpu_task << > >(d_in, d_out, img_width, img_height); //force the printf()s to flush cudaDeviceSynchronize(); // copy back the result array to the CPU
10
cudaMemcpy(h_out, d_out, img_size, cudaMemcpyDeviceToHost); CImgDisplay main_disp(img_out, "After Processing Kel-1 Kelas-A"); while (!main_disp.is_closed()) main_disp.wait(); cudaFree(d_in); cudaFree(d_out); return 0; }
11
Soal no. 5:
5. Dari soal no. 1 di atas, ganti file citra "flower.bmp“ dengan citra foto selfie kelompok (1 file citra ada semua anggota), misal dengan nama “selfiekel[..]kelas[..].bmp”: Jawaban : //A simple program to copy and display a .bmp image //Written by Dr. Ahmed Sallam, 27 July 2016, http://sallamah.weebly.com #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "CImg.h" using namespace cimg_library; //CImg.h v1.6.9 header enable you to manipulate bmp images easly //don't update to heighr versions to avoid depences issues //For FQ and how to use it visit http://cimg.eu __global__ void gpu_task(unsigned char * d_in, unsigned char * d_out, int img_width, int img_height) { unsigned long scale = img_width*img_height; unsigned long r = blockIdx.x * blockDim.x + threadIdx.x; unsigned long g = r + scale; unsigned long b = g + scale; unsigned long I = 0.2126 * r + 0.7152 * g + 0.0722 * b; //copy the input image to the output image d_out[r] = d_in[r]; d_out[b] = d_in[g]; d_out[g] = d_in[b]; //printf("%d\t%d\t%d\n",r,g,b); } int main(int argc, char ** argv) { //In this template there are 2 bmp images available "mountain.bmp" and "flower.bmp" use one of them to test your task
12
//To understand CImg structure visit http://cimg.eu/reference/group__cimg__storage.html //CImg img("flower.bmp"); // Define a 640x400 color image with 8 bits per color component. CImg img("cobadong.bmp"); // Define a 720x720 color image with 8 bits per color component. unsigned long img_size = img.size(); int img_width = img.width(); int img_height = img.height(); int img_depth = img.depth(); int img_dim = img.spectrum(); unsigned char *h_in = img.data(); CImg img_out(img_width, img_height, img_depth, img_dim); //define image with same features of the original unsigned char *h_out = img_out.data(); //printf("%d", sizeof(unsigned char)); //for (int i = 0; i < img_size; i++) //h_out[i] = h_in[i]; // declare GPU memory pointers unsigned char * d_in; unsigned char * d_out; // allocate GPU memory cudaMalloc(( void**)&d_in, img_size); cudaMalloc(( void**)&d_out, img_size); // transfer the array to the GPU cudaMemcpy(d_in, h_in, img_size, cudaMemcpyHostToDevice ); // launch the kernel gpu_task << > >(d_in, d_out, img_width, img_height); //force the printf()s to flush cudaDeviceSynchronize(); // copy back the result array to the CPU cudaMemcpy(h_out, d_out, img_size, cudaMemcpyDeviceToHost); CImgDisplay main_disp(img_out, "After Processing Kel-1 Kelas-A");
13
while (!main_disp.is_closed()) main_disp.wait(); cudaFree(d_in); cudaFree(d_out); return 0; }
14
Soal no. 6: 6. Modif soal no. 3 di atas, dalam folder solution utama kelompok, misal “VSCudaKel[..]”, dalam folder solution “001_ImageProcessingKel[..]”, buat project dengan nama “10RGB2GrayKel[..]”, link kode “https://goo.gl/Q7JALn” dari demo program “Display Image + Cimg” ub ah menjadi rumus Lightness Method atau Average Method Jawaban : //A simple program to copy and display a .bmp image //Written by Dr. Ahmed Sallam, 27 July 2016, http://sallamah.weebly.com #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "CImg.h" using namespace cimg_library; //CImg.h v1.6.9 header enable you to manipulate bmp images easly //don't update to heighr versions to avoid depences issues //For FQ and how to use it visit http://cimg.eu __global__ void gpu_task(unsigned char * d_in, unsigned char * d_out, int img_width, int img_height) { unsigned long scale = img_width*img_height; unsigned long r = blockIdx.x * blockDim.x + threadIdx.x; unsigned long g = r + scale; unsigned long b = g + scale; unsigned long grey = (r+g+b)/3 //copy the input image to the output image d_out[r] = d_in[grey]; d_out[b] = d_in[grey]; d_out[g] = d_in[grey]; //printf("%d\t%d\t%d\n",r,g,b); } int main(int argc, char ** argv) {
15
//In this template there are 2 bmp images available "mountain.bmp" and "flower.bmp" use one of them to test your task //To understand CImg structure visit http://cimg.eu/reference/group__cimg__storage.html //CImg img("flower.bmp"); // Define a 640x400 color image with 8 bits per c olor component. CImg img("cobadong.bmp"); // Define a 720x720 color image with 8 bits per color component. unsigned long img_size = img.size(); int img_width = img.width(); int img_height = img.height(); int img_depth = img.depth(); int img_dim = img.spectrum(); unsigned char *h_in = img.data(); CImg img_out(img_width, img_height, img_depth, img_dim); //define image with same features of the original unsigned char *h_out = img_out.data(); //printf("%d", sizeof(unsigned char)); //for (int i = 0; i < img_size; i++) //h_out[i] = h_in[i]; // declare GPU memory pointers unsigned char * d_in; unsigned char * d_out; // allocate GPU memory cudaMalloc(( void**)&d_in, img_size); cudaMalloc(( void**)&d_out, img_size); // transfer the array to the GPU cudaMemcpy(d_in, h_in, img_size, cudaMemcpyHostToDevice ); // launch the kernel gpu_task << > >(d_in, d_out, img_width, img_height); //force the printf()s to flush cudaDeviceSynchronize(); // copy back the result array to the CPU cudaMemcpy(h_out, d_out, img_size, cudaMemcpyDeviceToHost);
16
CImgDisplay main_disp(img_out, "After Processing Kel-1 Kelas-A"); while (!main_disp.is_closed()) main_disp.wait(); cudaFree(d_in); cudaFree(d_out); return 0; }
17
Soal no. 7: 7. Modif soal no. 4 di atas, dalam folder solution utama kelompok, misal “VSCudaKel[..]”, dalam folder solution “001_ImageProcessingKel[..]”, buat project dengan nama “11RGB2BinerKel[..]”, link kode “https://goo.gl/Q7JALn” dari demo program “Display Image + Cimg” dan ubah men jadi misal dengan rumus konversi citra warna ke biner If R atau G atau B > 128, return 0, else 255 Jawaban : //A simple program to copy and display a .bmp image //Written by Dr. Ahmed Sallam, 27 July 2016, http://sallamah.weebly.com #include "cuda_runtime.h" #include "device_launch_parameters.h" #include "CImg.h" using namespace cimg_library; //CImg.h v1.6.9 header enable you to manipulate bmp images easly //don't update to heighr versions to avoid depences issues //For FQ and how to use it visit http://cimg.eu __global__ void gpu_task(unsigned char * d_in, unsigned char * d_out, int img_width, int img_height) { unsigned long scale = img_width*img_height; unsigned long r = blockIdx.x * blockDim.x + threadIdx.x; unsigned long g = r + scale; unsigned long b = g + scale; //copy the input image to the output image if (r > 128 || g > 128 || b > 128) { r, g, b = 0; } else { r, g, b = 255; } d_out[r] = d_in[r]; d_out[b] = d_in[b]; d_out[g] = d_in[g];
18
//printf("%d\t%d\t%d\n",r,g,b); } int main(int argc, char ** argv) { //In this template there are 2 bmp images available "mountain.bmp" and "flower.bmp" use one of them to test your task //To understand CImg structure visit http://cimg.eu/reference/group__cimg__storage.html //CImg img("flower.bmp"); // Define a 640x400 color image with 8 bits per color component. CImg img("cobadong.bmp"); // Define a 720x720 color image with 8 bits per color component. unsigned long img_size = img.size(); int img_width = img.width(); int img_height = img.height(); int img_depth = img.depth(); int img_dim = img.spectrum(); unsigned char *h_in = img.data(); CImg img_out(img_width, img_height, img_depth, img_dim); //define image with same features of the original unsigned char *h_out = img_out.data(); //printf("%d", sizeof(unsigned char)); //for (int i = 0; i < img_size; i++) //h_out[i] = h_in[i]; // declare GPU memory pointers unsigned char * d_in; unsigned char * d_out; // allocate GPU memory cudaMalloc(( void**)&d_in, img_size); cudaMalloc(( void**)&d_out, img_size); // transfer the array to the GPU cudaMemcpy(d_in, h_in, img_size, cudaMemcpyHostToDevice ); // launch the kernel gpu_task << > >(d_in, d_out, img_width, img_height);
19
//force the printf()s to flush cudaDeviceSynchronize(); // copy back the result array to the CPU cudaMemcpy(h_out, d_out, img_size, cudaMemcpyDeviceToHost); CImgDisplay main_disp(img_out, "After Processing Kel-1 Kelas-A"); while (!main_disp.is_closed()) main_disp.wait(); cudaFree(d_in); cudaFree(d_out); return 0; }
20
BAB 2 Tugas Kelompok Tugas 2 Soal no. 1:
Buatlah main project dengan nama “VSCudaCLKel -[..]-Kelas-[..]”, lalu dalam project terdapat folder, misal “03_Vector_n_MatrixCL”, yang didalamnya terdapat project OpenCL “031SimdCLKel-[..]Kelas-[..]” dengan work_dim dan kode dibawahnya serta kernel berikut. Capture hasil running dari VS! Jawaban :
21
Soal no. 2:
Buatlah main project dengan nama “VSCudaCLKel -[..]-Kelas-[..]”, lalu didalam project terdapat folder, misal “03_Vector_n_MatrixCL”, yang didalamnya terdapat beberapa project OpenCL yang terdiri dari: – 032findMin_n_MaxArrayCLKel-[..]-Kelas-[..] Jawaban :
#include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" __global__ void FnMyFirstGPU(float *device_a) { //Single Instruction, Single Data (SISD) *device_a = 100; } int main() { printf("MinMaxArray \n"); printf("====================================== \n"); float host_a = 1; float *device_a; // mengalokasikan memori //host_a = (float)malloc(sizeof(float)*jumlahElemen); // tidak perlu dialokasikan, karena variabel tunggal cudaMalloc((void **)&device_a, sizeof(float)); // salin data host ke device cudaMemcpy(device_a, &host_a, sizeof(float) , cudaMemcpyHostToDevice); int array[100], maximum, minimum, size, c, locationmin = 1, locationmax = 1; printf("Enter the number of elements in array\n"); scanf("%d", &size); printf("Enter %d integers\n", size); for (c = 0; c < size; c++)
22
scanf("%d", &array[c]); minimum = array[0]; maximum = array[0]; for (c = 1; c < size; c++) { if (array[c] < minimum) { minimum = array[c]; locationmin = c + 1; } } for (c = 1; c < size; c++) { if (array[c] > maximum) { maximum = array[c]; locationmax = c + 1; } } printf("Minimum element is at array %d with value of %d.\n", locationmin, minimum); printf("Maximum element is at array %d with value of %d.\n", locationmax, maximum); return 0; }
Soal no. 3:
Buatlah koding di GPU (dengan CUDA atau OpenCL) untuk mendapatkan hasil transpose pada matriks yang bukan persegi dgn ordo 5x3 berikut: Jawaban :
23
#include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" __global__ void FnMyFirstGPU(float *device_a) { //Single Instruction, Single Data (SISD) *device_a = 100; } int main() { printf("Matrix Transpose \n"); printf("====================================== \n"); float host_a = 1; float *device_a; // mengalokasikan memori //host_a = (float)malloc(sizeof(float)*jumlahElemen); // tidak perlu dialokasikan, karena variabel tunggal cudaMalloc((void **)&device_a, sizeof(float)); // salin data host ke device cudaMemcpy(device_a, &host_a, sizeof(float) , cudaMemcpyHostToDevice); int m, n, c, d, matrix[10][10], transpose[10][10]; printf("Enter the number of rows and columns of matrix\n"); scanf("%d%d", &m, &n); printf("Enter elements of the matrix\n"); for (c = 0; c < m; c++) for (d = 0; d < n; d++) scanf("%d", &matrix[c][d]); for (c = 0; c < m; c++) for (d = 0; d < n; d++) transpose[d][c] = matrix[c][d]; printf("Transpose of the matrix:\n"); for (c = 0; c < n; c++) { for (d = 0; d < m; d++) printf("%d\t", transpose[c][d]); printf("\n"); } return 0;
Soal no. 4:
Buatlah koding di GPU (dengan CUDA atau OpenCL) untuk mendapatkan hasil perkalian pada matriks yang bukan persegi dgn ordo A5x2 dengan B2x3 :
24
Jawaban :
#include #include #include #include
"cuda_runtime.h" "device_launch_parameters.h"
__global__ void FnMyFirstGPU(float *device_a) { //Single Instruction, Single Data (SISD) *device_a = 100; } int main() { printf("Matrix Multiplication \n"); printf("====================================== \n"); float host_a = 1; float *device_a; // mengalokasikan memori //host_a = (float)malloc(sizeof(float)*jumlahElemen); // tidak perlu dialokasikan, karena variabel tunggal cudaMalloc((void **)&device_a, sizeof(float)); // salin data host ke device cudaMemcpy(device_a, &host_a, sizeof(float) , cudaMemcpyHostToDevice); int m, n, p, q, c, d, k, sum = 0; int first[10][10], second[10][10], multiply[10][10];
25
printf("Enter number of rows and columns of first matrix\n"); scanf("%d%d", &m, &n); printf("Enter elements of first matrix\n"); for (c = 0; c < m; c++) for (d = 0; d < n; d++) scanf("%d", &first[c][d]); printf("Enter number of rows and columns of second matrix\n"); scanf("%d%d", &p, &q); if (n != p) printf("The matrices can't be multiplied with each other.\n"); else { printf("Enter elements of second matrix\n"); for (c = 0; c < p; c++) for (d = 0; d < q; d++) scanf("%d", &second[c][d]); for (c = 0; c < m; c++) { for (d = 0; d < q; d++) { for (k = 0; k < p; k++) { sum = sum + first[c][k] * second[k][d]; } multiply[c][d] = sum; sum = 0; } } printf("Product of the matrices:\n"); for (c = 0; c < m; c++) { for (d = 0; d < q; d++) printf("%d\t", multiply[c][d]); printf("\n"); } } return 0;
26
Soal no. 5:
Buatlah koding di GPU (dengan CUDA atau OpenCL) untuk mendapatkan hasil sorting pada array A dan B berikut: Jawaban :
#include #include #include #include
"cuda_runtime.h" "device_launch_parameters.h"
__global__ void FnMyFirstGPU(float *device_a) { //Single Instruction, Single Data (SISD) *device_a = 100; } int main()
27
{ printf("Bubble Sort Array \n"); printf("====================================== \n"); float host_a = 1; float *device_a; // mengalokasikan memori //host_a = (float)malloc(sizeof(float)*jumlahElemen); // tidak perlu dialokasikan, karena variabel tunggal cudaMalloc((void **)&device_a, sizeof(float)); // salin data host ke device cudaMemcpy(device_a, &host_a, sizeof(float) , cudaMemcpyHostToDevice); int array[100], n, c, d, swap; printf("Enter number of elements\n"); scanf("%d", &n); printf("Enter %d integers\n", n); for (c = 0; c < n; c++) scanf("%d", &array[c]); for (c = 0; c < (n - 1); c++) { for (d = 0; d < n - c - 1; d++) { if (array[d] > array[d + 1]) /* For decreasing order use < */ { swap = array[d]; array[d] = array[d + 1]; array[d + 1] = swap; } } } printf("Sorted list ascending :\n"); for (c = 0; c < n; c++) printf("%d\n", array[c]); return 0; }
Soal no. 6:
Buatlah koding (dengan CUDA atau OpenCL) untuk dapat titik terdekat (closest pair) dari data point (x,y) random (minimal 5 titik 2D), dengan Euclidean Distance: Jawaban :
28
y a
#include #include #include #include #include
"cuda_runtime.h" "device_launch_parameters.h"
__global__ void FnMyFirstGPU(float *device_a) { //Single Instruction, Single Data (SISD) *device_a = 100; } struct Point { int x, y; int a = rand(); int b = rand(); int c = rand(); int d = rand(); int e = rand(); }; double getDistance(struct Point a, struct Point b, struct Point c, struct Point d, struct Point e) { int i, location; char coor; double distance; double distance1 = sqrt((a.x - b.x) * (a.x - b.x) + (a.y b.y) *(a.y - b.y)); double distance2 = sqrt((a.x - c.x) * (a.x - c.x) + (a.y c.y) *(a.y - c.y)); double distance3 = sqrt((a.x - d.x) * (a.x - d.x) + (a.y d.y) *(a.y - d.y)); double distance4 = sqrt((a.x - e.x) * (a.x - e.x) + (a.y e.y) *(a.y - e.y)); double distance5 = sqrt((b.x - c.x) * (b.x - c.x) + (b.y c.y) *(b.y - c.y)); double distance6 = sqrt((b.x - d.x) * (b.x - d.x) + (b.y d.y) *(b.y - d.y)); double distance7 = sqrt((b.x - e.x) * (b.x - e.x) + (b.y e.y) *(b.y - e.y)); double distance8 = sqrt((c.x - d.x) * (c.x - d.x) + (c.y d.y) *(c.y - d.y)); double distance9 = sqrt((c.x - e.x) * (c.x - e.x) + (c.y e.y) *(c.y - e.y)); double distance10 = sqrt((d.x - e.x) * (d.x - e.x) + (d.y - e.y) *(d.y - e.y)); int distances[10] = { distance1,distance2,distance3,distance4,distance5,distance6,distance7 ,distance8,distance9,distance10 }; distance = distances[0]; for (i = 1; i < 10; i++) { if (distances[i] < distance) { distance = distances[i]; } }
29
return distance; } int main() { printf("Bubble Sort Array \n"); printf("====================================== \n"); float host_a = 1; float *device_a; // mengalokasikan memori //host_a = (float)malloc(sizeof(float)*jumlahElemen); // tidak perlu dialokasikan, karena variabel tunggal cudaMalloc((void **)&device_a, sizeof(float)); // salin data host ke device cudaMemcpy(device_a, &host_a, sizeof(float) , cudaMemcpyHostToDevice); struct Point a, b, c, d, e; printf("Enter coordinate of point a: "); scanf("%d %d", &a.x, &a.y); printf("Enter coordinate of point b: "); scanf("%d %d", &b.x, &b.y); printf("Enter coordinate of point c: "); scanf("%d %d", &c.x, &c.y); printf("Enter coordinate of point d: "); scanf("%d %d", &d.x, &d.y); printf("Enter coordinate of point e: "); scanf("%d %d", &e.x, &e.y); printf("Closest pair coordinates of a,b,c,d,e are : %lf\n", getDistance(a, b, c, d, e)); return 0; }
Soal no. 7:
Review Paper (Deskripsi dalam bentuk paragraf dari point-point berikut), hasil review tiap 1 judul paper minimal 1 halaman template, buat seringkas-ringkasnya:
Problem Base (hal apa saja yang mendasari penulis kenapa mengangkat judul tersebut) Alur Sistem/ Potongan Kode Program/ Algoritma (alur general) pada GPU vs (CPU jika ada) Hasil & Evaluasi (dari keseluruhan isi paper, hal-hal apa saja yang menjadi kelebihan dan kekurangan/ keterbatasan penelitian tersebut)
Jawaban : Judul Jurnal : Optimasi Proses Rendering Objek Game 3D Menggunakan Pemrograman Cuda Pada Game Sandbox Craft
30
Problem Base : Hal yang mendasari penulis mengangkat judul tersebut karena membutuhkan sebuah optimasi pada game berjenis sandbox yang memiliki tipikal rendering environment yang luas serta detail. Game jenis sandbox adalah game yang membebaskan pemain untuk melakukan apapun dan menjelajahi dunia dalam game tersebut sesuka hati. Seperti pada game Minecraft, terdapat blok-blok yang disusun secara rapi untuk membentuk dunia dari game tersebut. Sama layaknya pada game The Elder Scroll Skyrim. Pemain dihadapkan dengan dunia masa lalu/medieval, yang mana pemain dapat menelusuri game tersebut tanpa ada batas. Melalui pengamatan dari game-game terse but, dalam penelitian ini mengambil kata kunci dari game berjenis sandbox yaitu dunia atau dalam kata lain game environment. Game environment adalah dunia yang dikembangkan dalam game untuk dijelajahi. Hal ini merupakan gabungan dari banyak elemen yang saling bekerja sama untuk dapat membangun sebuah kedalaman desain serta perasaan bahwa dunia ini layaknya nyata. Komponen tersebut antara lain desain environment, proyeksi cahaya, bayangan, tekstur teraplikasi, partikel, serta material dari objek dalam environment. Dengan komponen tersebut, CPU mengalami kesulitan dalam mengelola semua komponen di atas. Maka dibutuhkannya kerja sama antar CPU dengan perangkat pada GPU sehingga kerja pada CPU dalam pertukaran data dapat lebih mudah dan proses rendering dapat dilakukan dengan proses yang lebih cepat dan terasa real-time.
31
Potongan Kode Program : void mat_vec_multiply(float *vector, float *a, float *b) {
__global__ void mat_vec_multiply(float *vector, float *a, float *b) {
float result[4];
int kolom = threadIdx.x; // threadIdx adalah thread Index
for (int i = 0; i < 4; i++) { float total = 0;
int baris = threadIdx.y;
for (int j = 0; j < 4; j++) {
float c = 0;
int p = j * 4 + i;
int ordoMat = 4;
int q = j;
for (int k = 0; k < ordoMat; k++)
total += a[p] * b[q];
{
}
c += a[baris*ordoMat + k] * b[k*ordoMat + kolom];
result[i] = total;
}
}
vector[baris*ordoMat + kolom] = c;
for (int i = 0; i < 4; i++) {
}
vector[i] = result[i]; } }
Potongan Kode Program GPU Pertama Potongan Kode Program CPU
int jumlahBlock = 1; dim3 threadPerBlock(2, 2);
……… cudaMemcpy(d_A, h_A, sizeof(float) jumlahElemen, cudaMemcpyHostToDevice);
*
cudaMemcpy(d_B, h_B, sizeof(float) jumlahElemen, cudaMemcpyHostToDevice);
*
mat_vec_multiply threadPerBlock >> d_B);
<< >
< jumlahBlock, (d_HasilPerkalian, d_A,
cudaThreadSynchronize(); cudaMemcpy(h_HasilRef, sizeof(float) * cudaMemcpyDeviceToHost);
d_HasilPerkalian, jumlahElemen,
Potongan Kode Program GPU Kedua
32
Hasil & Evaluasi : Berdasarkan hasil pengujian terhadap kinerja dari CPU dan GPU berdasarkan nilai-nilai variabel pada task manager didapatkan per bandingan-perbandingan data utilization, clock speed , processes, threads dan handles. Jenis Pengujian CPU & GPU Gambar
Utilization
Clock Speed
Processes
GPU menggunakan utilization cenderung lebih rendah, yaitu sekitar 16%, jika dibandingkan dengan hanya dijalankan pada CPU.
GPU menggunakan clock speed lebih rendah 34% dibandingkan dengan CPU.
GPU menggunakan processes lebih rendah 1.8% dibandingkan dengan CPU.
33
Thread
GPU menggunakan threads lebih rendah 0.7% dibandingkan dengan CPU.
Handles
GPU menggunakan 0.03% handles lebih rendah dibandingkan CPU.
Komputasi GPU terbukti hanya menggunakan resource lebih rendah dibandingkan dengan CPU. Game sandbox berhasil berjalan sesuai dengan optimasi yang diharapkan. Pada pengujian dapat diihat bahwa clock speed yang digunakan pada GPU jauh lebih rendah dibandingkan yang digunakan pada CPU hingga 34%. Tingkat kerendahan tersebut cukup besar dalam hasil optimasi game sandbox ini. Penelitian tersebut hanya mengubah salah satu dari fungsi yang ada pada game untuk dioptimasi dengan menggunakan pemrograman GPU CUDA, yang mana masih terdapat banyak fungsi lain yang dapat di panggil dalam device GPU. Pengoptimasian tersebut hanya pada kartu grafis Nvidia.
34
Judul Jurnal : Klasifikasi Citra Menggunakan Convolutional Neural Network (Cnn) pada Caltech 101 Problem Base : Hal yang mendasari penulis mengangkat judul tersebut karena mem butuhkan suatu penyelesaian untuk menduplikasi kemampuan manusia dalam memahami informasi citra, agar komputer dapat mengenali objek pada citra selayaknya manusia menggunakan suatu cabang ilmu yang bernama Deep Learning. Deep Learning telah menjadi salah satu topik hangat dalam dunia Machine Learning karena kapabilitasnya yang signifikan dalam memodelkan berbagai data kompleks seperti citra dan suara. Metode dari Deep Learning yang saat ini memiliki hasil paling signifikan dalam pengenalan citra adalah Convolutional Neural Network (CNN). Hal tersebut dikarenakan CNN berusaha meniru sistem pengenalan citra pada visual cortex manusia sehingga memiliki kemampuan mengolah informasi citra. Namun CNN, seperti metode Deep Learning lainnya, memiliki kelemahan yaitu proses pelatihan model yang lama. Dengan perkembangan perangkat keras, hal tersebut dapat diatasi menggunakan teknologi General Purpose Graphical Processing Unit (GPGPU). Alur Sistem : Citra masukan akan diolah ke dalam pra proses yaitu proses wrapping dan cropping . Pada wrapping , citra masukan dilakukan pengecekan terhadap edge dari objek utama pada citra tersebut. Dari edge pada citra tersebut ditentukan edge maksimalnya sehingga saat hasil cropping objek pada citra tersebut tetap utuh dan mengubah citra tersebut menjadi vektor. Proses pengolahan data citra dimulai dengan citra ukuran sembarang yang kemudian dirubah ukurannya menjadi 140 x 140. Citra tersebut dijadikan grey scale. Proses selanjutnya yaitu tahapan dimana CNN dilatih untuk memperoleh akurasi yang tinggi dari klasifikasi yang dilakukan. Tahapan ini terdiri dari proses feed forward dan proses backpropagation. Untuk memulai proses feedforward diperlukan jumlah dan ukuran layer yang akan dibentuk, ukuran subsam pling . Hasil dari proses feedforward berupa bobot yang akan digunakan untuk mengevaluasi proses neural network tadi. Proses terakhir yaitu proses klasifikasi menggunakan bobot dan bias dari hasil proses training . Proses ini tidak jauh berbeda dengan proses training yang membedakannya tidak terdapat proses backpropagation setelah proses feedforward . Dengan bobot dan bias yang baru proses feedforward diterapkan yang kemudian
35
menghasilkan lapisan output . Lapisan output sudah fully connected dengan label yang disediakan. Hasil fully connected tersebut diperoleh data yang gagal dan berhasil diklasifikasi. Hasil & Evaluasi : Dari hasil pengujian terhadap 5 kategori unggas yaitu: Emu, Flamingo, Ibis, Pigeon, dan Rooster yang terdiri dari 150 citra. Selain Kategori tersebut terdapat 3 Kategori lainnya, yaitu: Cougar (Cougar Body dan Cougar Face), Crocodile (Crocodile dan Crocodile Head) dan Face (Face dan Face Easy).
Persentase keberhasilan 20%
Persentase keberhasilan 50%
Secara gabungan, klasifikasi citra yang dilakukan menghasilkan persentase kebenaran antara 20% sampai 50%. Hal ini membuktikan bahwa klasifikasi menggunakan metode CNN relatif handal terhadap perubahan parameter yang dilakukan. Dengan menggunakan data training yang baik dan optimal, maka subset dari data training tersebut juga akan menghasilkan klasifikasi yang baik.
36
Judul Jurnal: Deteksi Kebakaran pada Video Berbasis Pengolahan Citra dengan Dukungan GPU Problem Base:
Hal yang mendasari penulis mengangkat judul tersebut yaitu untuk memudahkan kita memperkirakan lokasi dan waktu terjadinya kebakaran dengan memaksimalkan fungsi CCTV yang sudah banyak terpasang di bangunan dan tempat umum dan ini sangat efektif untuk memantau lokasi setiap waktu. Sistem ini dapat mendeteksi kebakaran pada video berbasis pengolahan citra dengan dukungan GPU. GPU digunakan agar metode yang di gunakan pada sistem deteksi kebakaran dapat di lakukan secara real time. Mendeteksi kebakaran pada video dengan pengolahan citra telah di kembangkan dan menghasilkan hasil yang baik diantaranya yang relevan dengan penilitian ini adalah dengan menggunakan nya deteksi pada gerakan yang digabungkan dengan statistik warna api untuk mendeteksi kebakaran. Pada penelitian ini, penulis menggunakan kombinasi deteksi gerakan dengan Adaptive-Gauissan Mixture Model dengan statistik warna api pada ruang warna HVS untuk mendeteksi kebakaran. Untuk mendeteksi kebakaran secara real time, penulis menggunakan GPU didalam penerapan metodenya. Pengolahan citra pada GPU terutama yang menggunakan CUDA seperti penerapan filter dan konvolusi pada citra mengalami peningkatan kecepatan yang signifikan dibandingkan dengan proses pada CPU tanpa mengurangi presisi dari perhitungannya. GPU mempunyai fitur komputasi paralel yang tinggi, memori yang besar dan mendukung pemrosesan dengan menggunakan banyak kartu grafis. Alur Sistem:
Secara umum, rancangan sistem deteksi kebakaran pada video berbasis pengolahan citra dengan dukungan GPU terdiri dari pembacaan data frame video, inisialisasi model untuk Adaptive-GMM , membuat tabel warna, praproses frame video, deteksi gerakan dengan Adaptive-GMM , segmentasi warna api, mendeteksi kebakaran dari kombinasi hasil deteksi gerakan dan segmentasi warna api, dan menampilkan hasil deteksi pada layar. Masukan sistem berupa data video beresolusi 320x240, 640x480, dan 800x600 yang masing-masing berjumlah 30 video dengan fps 30. Data video berupa hasil rekaman kebakaran dari kamera CCTV dan rekaman kamera amatir yang mempunyai kriteria 37
berdurasi rata-rata 10 detik. Deteksi gerakan menggunakan metode Adaptive-Gaussian Mixture Model [5]. Metode ini mendeteksi gerakan dengan memodelkan setiap piksel ke dalam M komponen distribusi Gaussian serta melakukan perbaikan bobot ( ), rata-rata (µ) dan standar deviasi ( ) pada masing-masing komponen. Kemudian akan dikombinasikan dengan hasil segmentasi warna api yang akan dilakukan pada ruang HSV. Kriteria warna api antara lain memiliki warna merah oranye kuning dengan kecerahan yang tinggi. Dari kriteria tersebut, warna api dapat dengan mudah dikenali dari Hue. Saturation dan Value digunakan untuk mencari kecerahan warnanya. Untuk mempermudah dalam melakukan segmentasi warna api maka dilakukan penggolongan warna pada ruang HSV. Nilai Hue dari 0-360 dibagi menjadi 16 kelompok gradasi warna yang didapatkan, satu kondisi yang belum terdaftar dalam label warna yaitu Saturation ≥ 12.5% dengan Value antara 12.5% - 87.5%.
Hasil dan Evaluasi:
Pengujian ini dilakukan untuk menguji akurasi dan kesalahan sistem dalam mendeteksi kebakaran. Sampel video yang diujikan beresolusi 640x480 dengan 3 kelompok berdasarkan lokasi kebakaran yaitu kebakaran hutan, kebakaran di luar ruangan misalnya gedung, pom bensin, mobil, dan lain-lain. Tabel 1 menunjukkan hasil perhitungan akurasi dan kesalahan deteksi kebakaran pada siang hari sedangkan Tabel 2 menunjukkan hasil perhitungan akurasi dan kesalahan deteksi kebakaran pada malam hari.
38
Tabel 1. Hasil deteksi kebakaran pada siang hari
Berdasarkan Tabel 1, akurasi rata-rata yang didapatkan dari deteksi kebakaran pada siang hari yaitu 97,96% dengan kesalahan 0,25%. Kesalahan terutama disebabkan karena pantulan cahaya api pada dinding atau obyek yang lain yang terdeteksi sebagai kebakaran. Perubahan cahaya mendadak karena kebakaran yang membesar juga menyebabkan terjadinya kesalahan deteksi.
39
Tabel 2. Hasil deteksi kebakaran pada malam hari
Berdasarkan Tabel 3, akurasi deteksi kebakaran pada malam hari meningkat menjadi 98,65% karena warna api yang dominan dari sekitarnya. Akan tetapi kesalahan deteksi juga semakin besar menjadi 0,85% dengan adanya sumber cahaya dari kebakaran menyebabkan lingkungan sekitarnya akan memantulkan cahaya tersebut.
40
Pengujian ini dilakukan untuk menguji performa metode yang menggunakan GPU dibandingkan dengan CPU. Kecepatan diukur dalam milidetik dan jumlah frame yang dieksekusi per detik ( fps). Pada setiap kategori resolusi digunakan 3 video dengan fps 30 berdurasi rata-rata 10 detik untuk diukur kecepatan eksekusi metodenya selama 5 kali percobaan. Tabel 4 menunjukkan perbandingan kecepatan ratarata eksekusi metode yang menggunakan CPU dan GPU pada sampel video dengan variasi resolusi video. Dapat dilihat bahwa pemrosesan metode deteksi kebakaran pada video pada GPU lebih cepat daripada CPU. Pada resolusi 800x600 pemrosesan video pada GPU masih mendekati fps video aslinya sedangkan pada CPU pemrosesan video sudah jauh lebih lambat dari fps video aslinya. Tabel 3. Kecepatan eksekusi metode dengan CPU dan GPU
Hasil pengujian menghasilkan akurasi sebesar 97,96% dengan kesalahan sebesar 0,25% untuk deteksi kebakaran pada siang hari dan akurasi sebesar 98,65% dengan kesalahan sebesar 0,85% untuk deteksi kebakaran pada malam hari. Sistem mampu mendeteksi kebakaran secara real time yaitu sekitar 35,46 fps pada resolusi video 800x600 dan lebih cepat pada resolusi yang lebih kecil. Kesalahan deteksi terutama disebabkan adanya perubahan cahaya yang mendadak dari sumber api terhadap lingkungan sekitar dan pantulan cahaya kebakaran pada permukaan yang mengkilap.
41
Daftar Pustaka
Hastie, T., Tibshirani, R. & Friedman, J., 2009. The Elements of Statistical Learning Second., New York: Springer-Verlag. Hu, G. et al., 2010. Grid Resources Prediction With Support Vector Regression and Particle Swarm Optimization. 3rd International Joint Conference on Computational Sciences and Optimization, CSO 2010: Theoretical Development and Engineering Practice , 1, pp.417 – 422. Hughes, B. & Cotterell, M., 1999. Software Project Management 2nd ed., Berkshire: Mc Graw- Hill Publishing Company. Jiang, M. et al., 2013. Study on Parameter Optimization for Support Vector Regression in Solving the Inverse ECG Problem. Computational and Mathematical Methods in Medicine , 2013, pp.1 – 9. Kohavi, R., 1995. A Study of Cross-Validation and Bootstrap for Accuracy Estimation and Model Selection. In International Joiint Conference on Artificial Intelligence (IJCAI). pp. 1137 – 1143. Kumari, S. & Pushkar, S., 2013. Performance Analysis of the Software Cost Estimation Methods : A Review. International Journal of Advanced Research in Computer Science and Software Engineering Research, 3(7), pp.229 – 238. Martin, P., 2012. Dispel Tutorial 0.8 Documentation. Available at: http://homepages.inf.ed.ac.uk/pmartin/tutorial/_images/threefold.png [Accessed May 12, 2015].
. .
42
