Loading...
All post

Konsep Pembuatan Script Game (Softskill)

Admin 11:25 AM Add Comment
Admin
Pengantar Teknologi Game
Script dan Skenario
Perkembangan teknologi komputer sangat mempengaruhi perkembangan yang ada dalam dunia game. Pembentukan karakter pada game semakin mendekati dengan keadaan sebenarnya pada dunia nyata. Ketika proses pembuatan game membutuhkan susunan yang lebih kompleks, timbullah kebutuhan untuk memisahkan konten (desain perilaku) dari mesin. Kehandalan seorang desainer game benar-benar dibutuhkan untuk merancang perilaku yang luas dari karakter. Banyak tersedia berbagai macam bentuk bahasa pemrograman yang ada. Tentunya dari kesemuanya itu memiliki kelebihan dan kekurangan masing-masing. Maka game developer harus benar-benar teliti dalam memilih bahasa dan menyusun script untuk membuat suatu game, agar nantinya game dapat berjalan lancar, tanpa bug, dan mampu menjalankan script dengan kebutuhan hardware seminimum mungkin.
Konsep Pembuatan Scripting pada game
·         Pemilihan Bahasa Pemrograman
Pemrograman suatu game bisa menggunakan berbagai macam jenis bahasa pemrograman. Diantaranya yang terkenal adalah C++, C dan Java.
Proses pembuatan game modern bisa memakan waktu 1-3 tahun untuk menyelesaikannya. Lamanya suatu pengembangan bergantung pada sejumlah faktor, seperti genre, skala, platform pengembangan dan jumlah aset.
Sebagai contoh, sebuah game puzzle yang sederhana dengan menggunakan grafik 2D akan jauh lebih sedikit memakan waktu untuk dikembangkan daripada game role-playing komputer 3D.
Walaupun terdapat banyak sekali pilihan bahasa pemrograman untuk membuat game, namun pada intinya bahasa tersebut harus memenuhi syarat sebagai berikut :
a)         Speed
Bahasa scripting untuk game harus mampu berjalan secepat mungkin. Jika kita berniat untuk menggunakan banyak script untuk perilaku karakter dan kejadian di level game, maka script akan perlu untuk mengeksekusi sebagai bagian dari loop game utama. Ini berarti bahwa script yang lambat akan memakan waktu yang kita butuhkan untuk membuat suatu adegan, menjalankan mesin fisika, atau menyiapkan audio.
b)         Kompilasi dan Interpretasi (penyusunan dan penafsiran)
Bahasa scripting secara luas diinterpretasikan,melalui susunan serangkaian byte. Penafsiran bahasa diambil melalui format teks. Interpreter melihat setiap baris, penyusunan bekerja sesuai yang maksud dari script, dan melakukan tindakan yang spesifik.
Bahasa byte-terkompilasi dikonversi dari teks ke format internal, yang disebut byte code. Kode byte biasanya jauh lebih padat daripada format teks. Karena kode byte dalam suatu format dioptimalkan ketika dieksekusi, agar dapat berjalan lebih cepat.
c)         Ekstensibilitas dan Integrasi
Bahasa scripting perlu memiliki akses ke fungsi yang signifikan ke dalam game. Sebuah script yang mengendalikan karakter, misalnya, harus mampu untuk menanyai game untuk mencari tahu apa yang bisa dilihat dan kemudian membiarkan game tahu apa yang akan dilakukan sebagai aksinya.
Serangkaian fungsi yang dibutuhkan untuk mengakses ini jarang diketahui ketika bahasa scripting telah diimplementasikan atau dipilih. Hal ini penting untuk memiliki sebuah bahasa yang dapat dengan mudah memanggil fungsi-fungsi atau menggunakan kelas main code dalam game. Biasanya, itu adalah penting bagi programmer untuk dapat mengekspos fungsi baru atau kelas yang dengan mudah ketika pembuat script memintanya.
d)         Re-Entrancy (ikut serta ulang)
Fungsi ini sering berguna untuk memanggil script menjadi diikutsertakan ulang. Mereka dapat berjalan untuk sementara waktu, dan ketika anggaran waktu telah habis script akan dapat ditunda. Ketika script selanjutnya mendapatkan beberapa waktu kembali, maka akan dapat menjalankan kembali script yang ditunda sebelumnya.
Hal ini sering membantu untuk membiarkan kontrol hasil script saat mencapai jeda normal. Kemudian sebuah algoritma penjadwalan dapat memberikan lebih banyak waktu untuk meminimalisasi penggunaan sumber daya.
Sebuah script untuk mengendalikan sebuah karakter, misalnya, mungkin memiliki lima tahapan yang berbeda (memeriksa situasi, memeriksa kesehatan, menentukan gerakan, rencana rute, dan melaksanakan gerakan). Ini semua dapat dimasukkan dalam satu script yang menghasilkan penyekat antara setiap bagian. Kemudian masing-masing akan berjalan dengan setiap lima frame, dan beban dari eksekusi AI akan didistribusikan.
Re-entrancy yang lebih canggih harus memungkinkan penulis script untuk menandai bagian yang tidak boleh terputus.
·         Embedding (penanaman)
Embedding berhubungan dengan ekstensibilitas. Sebuah bahasa yang tertanam dirancang untuk dimasukkan ke dalam program lain. Ketika kita menjalankan bahasa scripting dari workstation, biasanya akan menjalankan program khusus untuk menafsirkan file source code. Dalam game, sistem scripting perlu dikontrol dari dalam program utama. Game yang menentukan jalannya script harus dijalankan dan harus dapat memberitahu mesin terkait bahasa scripting yang cocok untuk memproses script tersebut.
·         Bahasa Open Source
Banyak bahasa scripting game populer yang dirilis di bawah lisensi open source. Software open-source dirilis di bawah lisensi yang memberikan hak user untuk memasukkannya ke dalam perangkat lunak mereka sendiri tanpa membayar biaya tambahan.
Memulai sebagai teks dalam sebuah file teks, script biasanya melewati empat tahap:
1. Tokenization :
Tokenizing mengidentifikasi unsur-unsur dalam teks. Sebuah file teks hanya berisi serangkaian karakter (dalam pengertian karakter ASCII). Hasil tokenizer keluar sebagai kumpulan byte tertentu dan jenis dari kelompok tertentu yang membentuk mereka.
2. Parsing (penguraian) :  
Makna dari sebuah program adalah sangat hirarkis: nama variabel dapat ditemukan dalam sebuah statement pemberian nilai, ditemukan di dalam pernyataan IF-, yang ada di dalam tubuh fungsi, di dalam definisi kelas, maupun di dalam sebuah deklarasi namespace, misalnya. Parser mengambil urutan token, mengidentifikasi peran masing-masing kode dalam program, dan mengidentifikasi struktur hirarkis keseluruhan program.
Contoh1          :  if (a < b) return;
dapat dilakukan proses parsing seperti pada bagan di bawah ini :
 
3. Compiler :
mengubah parse tree ke dalam kode byte yang dapat dijalankan oleh interpreter. Kode byte biasanya berbentuk data biner berurutan. Compiler non-optimasi biasanya berisi output kode byte sebagai terjemahan literal dari parse tree.
4. Interpreting :
Tahap akhir dari serangkaian ini ialah menjalankan kode byte. Dalam sebuah compiler untuk bahasa seperti C atau C++, produk akhir akan menjadi mesin instruksi yang dapat langsung dijalankan oleh prosesor. Dalam bahasa scripting, anda sering perlu untuk menyediakan layanan (seperti re-entrancy dan eksekusi yang aman) yang tidak mudah dicapai dengan bahasa mesin.Kode byte akhir dijalankan pada sebuah “mesin virtual”. Ini secara efektif menjadi sebuah emulator untuk sebuah mesin yang belum pernah ada di hardware. Anda menentukan instruksi agar mesin dapat mengeksekusi, dengan instruksi kode byte.
Contoh Pembuatan game mengunakan script bahasa C.
Disini kami mengunakan game snake mengunakan script bahasa C
Langkah pertama maskan sintaks library
1.      #include <stdio.h>
2.      #include <stdlib.h>
3.      #include <time.h>
4.      #include <sys\timeb.h>
5.      #include <Windows.h>
Dalam sintaks digunakan Array dimana Array ini kita gunakan untuk menampung ular. Satu elemen pada array sama dengan satu segmen ular. Tiap elemen berisi posisi koordinat (x,y) segmen di layar. Berikut ini bentuk strukturnya. Kita beri nama Segment.
1.      /** Struktur **********/
2.       
3.      /**
4.          Struktur untuk menampung data tiap segment dari snake 
5.          (array)
6.       */
7.      struct Segment {
8.          int x, y;
9.      };
Kita tambahkan dua variabel global, yaitu array snake, dan length untuk menyimpan panjangnya.
1.      /** Variabel global **********/
2.       
3.      // Array untuk menampung data ular
4.      struct Segment snake[2000];
5.       
6.      // Variabel untuk menyimpan panjang ular (array snake)
7.      int length = 0;
Untuk game ini, kita menggunakan konsep queue. Artinya, elemen pada array akan ditambahkan di awal (head), dan ketika dihapus, yang hilang adalah bagian akhir (tail). Istilahnya first in first out.
Berikut ini fungsi untuk melakukan penambahan push() dan penghapusan pop().
1.      /** Fungsi-fungsi **********/
2.       
3.      /**
4.          Push segment ke snake (pada bagian head).
5.       */
6.      void push(int x, int y) {
7.          for(int i = length; i > 0; i--) {
8.              snake[i] = snake[i-1];
9.          }
10.      snake[0].x = x;
11.      snake[0].y = y;
12.      length++;
13.  }
14.   
15.  /**
16.      Pop bagian ekor snake.
17.   */
18.  void pop() {
19.      length--;
20.  }

 

Ular 3 Segment

Sekarang mari kita coba buat ular sepanjang 3 segmen pada bagian main(). Oke, supaya mudah untuk mengubah-ubah pengaturan panjang awalnya, kita simpan nilai 3 tersebut di variabel globalsnake_size. Ketiga segmen ini kita tempatkan di baris pertama (y = 0), di kolom ke 1, 2, dan 3 (x = 0 s.d. 2).
1.      /** Konfigurasi permainan **********/
2.       
3.      // Panjang segment snake saat awal permainan
4.      int snake_size = 3;
5.       
6.      /**
7.          Program utama
8.       */
9.      int main() {
10.      // Pertama-tama, push segment (node) ke kanan 
11.      // sebanyak 3 segment (sesuai nilai variable snake_size)
12.      for (int i = 0; i < snake_size; i++) {
13.          push(i, 0);
14.      }
15.   
16.      return 0;
17.  }

Rendering

Setelah ular dibuat, kita akan mencetak ular tersebut di layar. Untuk mencetak, kita buat fungsidisplay(). Fungsi display() ini akan membaca nilai x dan y setiap element lalu mencetak satu karakter ‘O’ di posisi tersebut.
Untuk bisa mencetak di posisi (x,y), kita harus memindahkan kursor ke posisi tersebut. Untuk itu kita buat juga fungsi gotoxy().
1.      /**
2.          Pindahkan posisi kursor di layar
3.          Fungsi ini spesifik untuk OS windows.
4.      */
5.      void gotoxy(int x, int y) {
6.          COORD pos;
7.          pos.X = x;
8.          pos.Y = y;
9.          SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
10.  }
11.   
12.  /**
13.      Gambar snake (array) di layar
14.   */
15.  void display() {
16.      for(int i = 0; i < length; i++) {
17.          // Cetak di posisi x,y
18.          gotoxy(snake[i].x, snake[i].y);
19.          printf("O");
20.      }
21.  }
Sekarang, mari panggil display() di main(), jalankan program dan lihat hasilnya (lihat baris 11-19).
1.      /**
2.          Program utama
3.       */
4.      int main() {
5.          // Pertama-tama, push segment (node) ke kanan 
6.          // sebanyak 3 segment (sesuai nilai variable snake_size)
7.          for (int i = 0; i < snake_size; i++) {
8.              push(i, 0);
9.          }
10.   
11.      // Tampilkan kondisi permainan saat ini di layar...
12.   
13.      // Bersihkan layar
14.      system("cls");
15.   
16.      // Cetak (render) snake di layar
17.      display();
18.   
19.      getchar();
20.      return 0;
21.  }

 

Game Loop

Bagaimana caranya agar ular bisa bergerak? Caranya, adalah dengan membuat infinite loop untuk me-render ulang layar setiap putarannya. Dengan demikian, setiap ada perubahan situasi (state) pada arraysnake, entah itu jumlah element (length) atau nilai x dan y nya, perubahan itu akan langsung tercermin di layar.
Mari kita taruh bagian rendering tadi ke dalam infinite loop (lihat baris 11-20).
1.      /** 
2.          Program utama 
3.       */ 
4.      int main() { 
5.          // Pertama-tama, push segment (node) ke kanan  
6.          // sebanyak 3 segment (sesuai nilai variable snake_size) 
7.          for (int i = 0; i < snake_size; i++) { 
8.              push(i, 0); 
9.          } 
10.    
11.      // Game loop. Bagian di dalam while akan dieksekusi terus menerus 
12.      while (true) { 
13.          // Tampilkan kondisi permainan saat ini di layar... 
14.   
15.          // Bersihkan layar 
16.          system("cls"); 
17.   
18.          // Cetak (render) snake di layar 
19.          display(); 
20.      }
21.   
22.      getchar(); 
23.      return 0;
24.  }
Untuk menggerakkan ular ke kanan setiap 200ms, pertama-tama, di dalam game loop kita menghitung berapa waktu yang sudah terlewati, jika waktu yang berlalu sudah lebih atau sama dengan 200ms, maka kita geser ular. Sama dengan sebelumnya, agar nilai 200 ini mudah diubah-ubah, kita simpan dalam variabel global snake_speed.
1.      // Kecepatan gerakan snake dalam ms 
2.      int snake_speed = 200;
Untuk menghitung interval waktu yang berlalu, kita gunakan fungsi ftime() untuk mendapat kan penanda waktu.
Cara menggeser ular, adalah dengan melakukan pop(), lalu push() kembali di posisi koordinat headdengan nilai x ditambah 1 karena saat ini kepala ular mengarah ke kanan.
(Lihat baris 6-8, 17-40)
1.      /** 
2.          Program utama 
3.       */ 
4.      int main() {  
5.       
6.          // Untuk menyimpan penanda waktu saat snake bergerak 
7.          struct timeb last_timestamp; 
8.          ftime(&last_timestamp); // Set nilai awal 
9.       
10.      // Pertama-tama, push segment (node) ke kanan  
11.      // sebanyak 3 segment (sesuai nilai variable snake_size) 
12.      for (int i = 0; i < snake_size; i++) { 
13.          push(i, 0); 
14.      } 
15.      // Game loop. Bagian di dalam while akan dieksekusi terus menerus 
16.      while (true) { 
17.          // Ambil penanda waktu saat ini 
18.          struct timeb current_timestamp; 
19.          ftime(&current_timestamp); 
20.   
21.          // Selisih waktu terakhir dengan waktu sekarang dalam ms 
22.          int interval = 1000 * (current_timestamp.time - last_timestamp.time) + (current_timestamp.millitm - last_timestamp.millitm); 
23.   
24.          // Snake bergerak setiap 200 ms (sesuai nilai variable snake_speed) 
25.          // Dihitung dengan membandingkan selisih waktu sekarang dengan waktu  
26.          // terakhir kali snake bergerak. 
27.          if (interval >= snake_speed) { 
28.              // Tentukan posisi x,y ke mana snake akan bergerak. 
29.              int x, y; 
30.              x = snake[0].x + 1; 
31.              y = snake[0].y;
32.    
33.              // Pop ekor, lalu push segment ke depan head sehingga  
34.              // snake tampak bergerak maju.  
35.              pop(); 
36.              push(x, y);
37.   
38.              // Perbarui penanda waktu 
39.              last_timestamp = current_timestamp;
40.          }
41.   
42.          // Tampilkan kondisi permainan saat ini di layar... 
43.   
44.          // Bersihkan layar 
45.          system("cls"); 
46.   
47.          // Cetak (render) snake di layar 
48.          display(); 
49.      }
50.   
51.      ...
52.  }
Coba jalankan lagi. Sekarang ular sudah bisa bergerak!
Tapi layar tampaknya berkedip-kedip. Hal ini terjadi karena program mencoba mengosongkan layar dengan system(“cls”); sebelum menggambar lagi. Umumnya pembuat game akan melakukan teknik double buffering untuk menghindari layar berkedip (flicker). Namun untuk menyederhanakan tutorial ini, kita akan lakukan pendekatan lain, yaitu dengan me-render ulang layar hanya ketika ular bergerak. Sehingga rendering hanya terjadi setiap 200ms sekali (5 FPS).
Caranya mudah, kita pindahkan baris-baris rendering ke dalam blok if(interval >= snake_speed) { } (lihat baris 30-37).
1.      /** 
2.          Program utama 
3.       */ 
4.      int main() { 
5.          ...
6.       
7.          // Game loop. Bagian di dalam while akan dieksekusi terus menerus 
8.          while (true) { 
9.              // Ambil penanda waktu saat ini 
10.          struct timeb current_timestamp; 
11.          ftime(&current_timestamp); 
12.   
13.          // Selisih waktu terakhir dengan waktu sekarang dalam ms 
14.          int interval = 1000 * (current_timestamp.time - last_timestamp.time) + (current_timestamp.millitm - last_timestamp.millitm); 
15.   
16.          // Snake bergerak setiap 200 ms (sesuai nilai variable snake_speed) 
17.          // Dihitung dengan membandingkan selisih waktu sekarang dengan waktu  
18.          // terakhir kali snake bergerak. 
19.          if (interval >= snake_speed) { 
20.              // Tentukan posisi x,y ke mana snake akan bergerak. 
21.              int x, y; 
22.              x = snake[0].x + 1; 
23.              y = snake[0].y;
24.    
25.              // Pop ekor, lalu push segment ke depan head sehingga  
26.              // snake tampak bergerak maju.  
27.              pop(); 
28.              push(x, y); 
29.   
30.              // Tampilkan kondisi permainan saat ini di layar... 
31.   
32.              // Bersihkan layar 
33.              system("cls"); 
34.   
35.              // Cetak (render) snake di layar 
36.              display();
37.   
38.              // Perbarui penanda waktu 
39.              last_timestamp = current_timestamp;
40.          }
41.      }
42.   
43.      ...
44.  }

 

Mengontrol Arah Gerakan Ular

Untuk bisa mengontrol arah gerakan ular, kita membuat sebuah variabel global tambahan bernamadir. Variabel ini memberitahu arah push() berikutnya, apakah ke kanan, bawah, kiri, atau atas. Arah ini akan ditentukan berdasarkan input tombol panah yang ditekan.
Pertama-tama, buat variabel global dir, dengan nilai awal ke arah kanan. VK_RIGHT adalah konstanta berisi kode untuk tombol panah kanan.
1.      // Arah kepala saat awal permainan 
2.      int dir = VK_RIGHT;
Sekarang kita modifikasi penentuan nilai x dan y untuk melakukan push() berdasarkan variabel dir. Lalu di dalam game loop, dilakukan juga pengecekan tombol yang sedang ditekan. Jika merupakan salah satu dari empat tombol panah di keyboard, maka ubah nilai dir (lihat baris 17-37, 56-73).
1.      /** 
2.          Program utama 
3.       */ 
4.      int main() { 
5.          ...
6.       
7.          // Game loop. Bagian di dalam while akan dieksekusi terus menerus 
8.          while (true) { 
9.       
10.          ...
11.   
12.          // Snake bergerak setiap 200 ms (sesuai nilai variable snake_speed) 
13.          // Dihitung dengan membandingkan selisih waktu sekarang dengan waktu  
14.          // terakhir kali snake bergerak. 
15.          if (interval >= snake_speed) { 
16.              // Tentukan posisi x,y ke mana snake akan bergerak.  
17.              // Posisi dilihat dari koordinat segment kepala (head)  
18.              // dan arah (variable dir)
19.              int x, y;  
20.              switch (dir) { 
21.              case VK_LEFT: 
22.                  x = snake[0].x - 1; 
23.                  y = snake[0].y; 
24.                  break; 
25.              case VK_RIGHT: 
26.                  x = snake[0].x + 1; 
27.                  y = snake[0].y; 
28.                  break; 
29.              case VK_UP: 
30.                  x = snake[0].x; 
31.                  y = snake[0].y - 1; 
32.                  break; 
33.              case VK_DOWN: 
34.                  x = snake[0].x; 
35.                  y = snake[0].y + 1; 
36.                  break; 
37.              }
38.    
39.              // Pop ekor, lalu push segment ke depan head sehingga  
40.              // snake tampak bergerak maju.  
41.              pop(); 
42.              push(x, y); 
43.   
44.              // Tampilkan kondisi permainan saat ini di layar... 
45.   
46.              // Bersihkan layar 
47.              system("cls"); 
48.   
49.              // Cetak (render) snake di layar 
50.              display(); 
51.   
52.              // Perbarui penanda waktu 
53.              last_timestamp = current_timestamp;
54.          }
55.   
56.          // Ubah arah jika tombol panah ditekan 
57.          if (GetKeyState(VK_LEFT) < 0) { 
58.              dir = VK_LEFT; 
59.          } 
60.          if (GetKeyState(VK_RIGHT) < 0) { 
61.              dir = VK_RIGHT; 
62.          } 
63.          if (GetKeyState(VK_UP) < 0) { 
64.              dir = VK_UP; 
65.          } 
66.          if (GetKeyState(VK_DOWN) < 0) { 
67.              dir = VK_DOWN; 
68.          } 
69.   
70.          // Keluar dari program jika menekan tombol ESC 
71.          if (GetKeyState(VK_ESCAPE) < 0) { 
72.              return 0; 
73.          }
74.      }
75.   
76.      ...
77.  }
Kita juga bisa menambahkan pengecekan untuk keluar dari program jika pemain menekan tombol ESC.
Coba jalankan lagi program, sekarang kita bisa menggerakan ular dengan bebas

Collision Detection

Salah satu aspek yang penting dalam permainan ini adalah pengecekan apakah kepala ular bertabrakan dengan dinding atau dirinya sendiri. Di sini kita bisa melakukan pengecekan saat program memeroleh posisi x dan y yang baru, sebelum melakukan pop() dan push().
Jika posisi x berada di luar batasan 0-79 (panjang console) atau posisi y berada diluar batasan 0-24 (tinggi console), maka ular telah menabrak dinding, dan permainan berakhir. Sama seperti sebelum-sebelumnya, untuk nilai panjang dan lebar console bisa kita simpan di variabel global console_widthdan console_height.
1.      // Panjang console 
2.      int console_width = 80; 
3.       
4.      // Tinggi console 
5.      int console_height = 25;
Pengecekan berikutnya yaitu mengecek apabila posisi x dan y sama dengan posisi salah satu node, yang artinya ular menabrak dirinya sendiri. Untuk mengeceknya, kita buat fungsi check_collision().
1.      /** 
2.          Memeriksa apakah terdapat salah satu segment 
3.          snake (array) di koordinat x,y. 
4.          Return 0 artinya tidak bertumpuk, 1 artinya bertumpuk. 
5.       */ 
6.      int check_collision(int x, int y) { 
7.          for(int i = 0; i < length; i++) {
8.              if (snake[i].x == x && snake[i].y == y) { 
9.                  return 1; 
10.          } 
11.      } 
12.      return 0; 
13.  }
Berikut ini baris-baris yang ditambahkan di main() untuk melakukan pengecekan tadi, serta tambahan baris yang dilakukan di luar game loop, setelah permainan berakhir (game over) (lihat baris 18-32, 44-48).
1.      /** 
2.          Program utama 
3.       */ 
4.      int main() { 
5.          ...
6.       
7.          // Game loop. Bagian di dalam while akan dieksekusi terus menerus 
8.          while (true) { 
9.       
10.          ...
11.          // Snake bergerak setiap 200 ms (sesuai nilai variable snake_speed) 
12.          // Dihitung dengan membandingkan selisih waktu sekarang dengan waktu  
13.          // terakhir kali snake bergerak. 
14.          if (interval >= snake_speed) { 
15.   
16.              ...
17.   
18.              // Jika posisi kepala (head) menabrak tembok pembatas,  
19.              // maka permainan berakhir (keluar dari game loop) 
20.              if (x < 0 || x >= console_width || y < 0 || y >= console_height) { 
21.                  break; 
22.              } 
23.   
24.              // Jika posisi kepala (head) menabrak dirinya sendiri 
25.              // (posisi sama dengan salah satu segment), maka permainan  
26.              // berakhir (keluar dari game loop) 
27.              if (check_collision(x, y) == 1) { 
28.                  break; 
29.              } 
30.               
31.              // Jika tidak terjadi tabrakan (collision), maka snake  
32.              // boleh bergerak maju.. 
33.              // Pop ekor, lalu push segment ke depan head sehingga  
34.              // snake tampak bergerak maju.  
35.              pop(); 
36.              push(x, y); 
37.   
38.              // Tampilkan kondisi permainan saat ini di layar... 
39.              ...
40.          }
41.          ...
42.      }
43.   
44.      // Setelah keluar dari game loop, berarti permainan berakhir (game over) 
45.      system("cls"); 
46.      printf("GAME OVER\n"); 
47.   
48.      printf("Press ENTER to exit..."); 
49.      getchar(); 
50.      return 0;
51.  }
Jalankan program sekali lagi, lalu coba arahkan ular ke dinding. Untuk pengetesan tabrakan terhadap diri sendiri, bisa dilakukan dengan mengubah snake_size dengan nilai yang lebih besar, agar ular cukup panjang untuk menabrak dirinya sendiri.
Tampilan layar saat terjadi tabrakan. Permainan berakhir.

Makanan!!!

Ini adalah bagian terakhir dari tutorial ini, makanan! Ular perlu melahap makanan untuk menjadi lebih panjang. Untuk itu, kita perlu menempatkan makanan di koordinat acak. Untuk menaruh koordinat makanan, kita tambahkan dua variabel global food_x dan food_y.
1.      // Posisi makanan
2.      int food_x, food_y;
Meskipun makanan ditaruh secara acak, ada dua hal yang perlu diperhatikan:
  1. Makanan harus berada di dalam layar console berukuran 80×25.
  2. Makanan tidak boleh bertumpuk dengan ular saat ditempatkan.
Maka dari itu, kita buat sebuah fungsi place_food() untuk menaruh makanan dengan memerhatikan kedua syarat tersebut. Untuk syarat nomor 2, kita bisa memanfaatkan fungsi check_collision() yang baru saja dibuat.
1.      /**
2.          Taruh makanan secara acak, namun memastikan 
3.          makanan tidak bertumpuk dengan salah satu segment 
4.          snake (array)
5.       */
6.      void place_food() {
7.          // Jika makanan bertumpuk dengan salah satu segment
8.          // snake, ulangi penempatan makanan secara acak.
9.          do {
10.          food_x = rand() % console_width;
11.          food_y = rand() % console_height;
12.      } while (check_collision(food_x, food_y) == 1);
13.  }
Di awal program sebelum memasuki game loop, kita menempatkan makanan pertama. Berikutnya, makanan akan ditempatkan ulang jika posisi x dan y baru dari ular sama dengan koordinat makanan, yang artinya ular memakan makanan. Dalam hal ini, kita hanya melakukan push() tanpa melakukanpop(), sehingga jumlah elemen bertambah.
Jangan lupa pula untuk melakukan rendering makanan di layar.
Di samping itu, kita juga bisa menerapkan sistem penilaian, misalnya nilai bertambah 100 jika ular memakan makanan. Lalu pada akhir permainan (saat game over), nilai yang sudah terkumpul ditampilkan kepada pemain.
(Lihat baris 5-6, 12-13, 21-22, 41-53, 64-67, 80)
1.      /**
2.          Program utama
3.       */
4.      int main() {
5.          // Randomize
6.          srand(time(NULL));
7.       
8.          // Untuk menyimpan penanda waktu saat snake bergerak
9.          struct timeb last_timestamp;
10.      ftime(&last_timestamp); // Set nilai awal
11.   
12.      // Untuk menyimpan nilai
13.      int score = 0;
14.   
15.      // Pertama-tama, push segment (node) ke kanan 
16.      // sebanyak 3 segment (sesuai nilai variable snake_size)
17.      for (int i = 0; i < snake_size; i++) {
18.          push(i, 0);
19.      }
20.   
21.      // Tempatkan makanan secara acak
22.      place_food();
23.   
24.      // Game loop. Bagian di dalam while akan dieksekusi terus menerus
25.      while (true) {
26.   
27.          ...
28.   
29.          // Snake bergerak setiap 500 ms (sesuai nilai variable snake_speed)
30.          // Dihitung dengan membandingkan selisih waktu sekarang dengan waktu 
31.          // terakhir kali snake bergerak.
32.          if (interval >= snake_speed) {
33.   
34.              ...
35.   
36.              // Jika tidak terjadi tabrakan (collision), maka snake 
37.              // boleh bergerak maju..
38.   
39.              // Pop ekor, lalu push segment ke depan head sehingga 
40.              // snake tampak bergerak maju. 
41.              // Namun jika posisi x,y ke mana kepala (head) snake akan 
42.              // bergerak berada di posisi makanan, tidak perlu pop 
43.              // sehingga segment bertambah panjang. 
44.              if (x == food_x && y == food_y) {
45.                  // Dalam hal snake memakan makanan, maka nilai bertambah
46.                  score += 100;
47.   
48.                  // Lalu makanan ditempatkan ulang secara acak
49.                  place_food();
50.              }
51.              else {
52.                  pop();
53.              }
54.              push(x, y);
55.    
56.              // Tampilkan kondisi permainan saat ini di layar...
57.   
58.              // Bersihkan layar
59.              system("cls");
60.   
61.              // Cetak (render) snake di layar
62.              display();
63.   
64.              // Cetak (render) makanan di layar
65.              gotoxy(food_x, food_y);
66.              printf("X");
67.   
68.              // Perbarui penanda waktu
69.              last_timestamp = current_timestamp;
70.          }
71.   
72.          ...
73.   
74.      }
75.   
76.      // Setelah keluar dari game loop, berarti permainan berakhir (game over)
77.      // Tampilkan nilai yang diraih pemain
78.      system("cls");
79.      printf("GAME OVER\n");
80.      printf("Your score : %d\n\n", score);
81.   
82.      printf("Press ENTER to exit...");
83.      getchar();
84.   
85.      ...
86.   
87.  }
Selesai! Uji coba program untuk terakhir kalinya, dan game sudah siap dimainkan!
Layar game over menunjukkan permainan berakhir beserta nilai yang diperoleh.
StoryBoard
Referensi         :
http://meramukoding.jar2.net/membuat-game-snake-dengan-bahasa-c-array/
https://wikishare27.wordpress.com/pengantar-teknologi-game1/
https://www.academia.edu/3875722/Scripting_dalam_Pembuatan_Game
https://www.script-tutorials.com/snake-game-using-html5-canvas-and-kineticjs/
Kelompok 2 “JOINT KERNEL DENSITY ESTIMATE” (TUGAS SOFTSKIL)

Kelompok 2 “JOINT KERNEL DENSITY ESTIMATE” (TUGAS SOFTSKIL)

Admin 8:14 AM Add Comment
Admin
KATA PENGANTAR
Alhamdulillah, puji dan syukur kehadirat Allah SWT atas semua berkah dan rahmat yang senantiasa diberikan sehingga penulis dapat menyelesaikan buku ini dengan baik dan lancar. Salawat serSebelumnya , penulis memanjatkanta salam kita panjatkan pula terhadap nabi besar muhammad SAW.
Buku ini ditulis untuk melengkapi tugas dari mata kuliah Desain Pemodelan Grafik (Softskill) yang diajar oleh Pak Dr. Rer. Nat. I Made Wiryana, Skom, SSi, MappSc. Tujuan dari penulisan buku ini diharapkan, agar pembaca dapat memahami teori permodelan grafik ,perangkat lunak yang berkaitan dengan Joint Kernel Density Estimate.
Tujuan penulisan buku ini untuk melatih kami untuk memiliki knowledge, skill menulis, mendengar, berbicara, beragumen dan berdiskusi dengan kelompok. Pembahasan buku ini akan dimulai dari hal sederhana, yaitu pemahaman konsep visualisasi, instalasi software yang di butuhkan, bagaimana langkah atau cara yang diperlukan untuk instalasi software tersebut, contoh kasus software yang menggunakan teori joint kernel density estimate dalam pemodelan grafik.
Sebagai kata kata terakhir, penulis ucapkan terimakasih kepada semua pihak dan tempat yang telah memberikan kontribusi bantuan dan dukungan terhadap proses penulisan dan pencetakan buku ini
Semoga bermanfaat
Depok, Januari 2015
Penulis
Kupersembahkan buku ini untuk teman temanku tercinta; terimakasih atas usaha dan jerih payah atas pembuatan buku ini -Fadlillah Ramdhani
Kupersembahkan buku ini untuk pak made tercinta selaku dosen saya yang telah memberikan tugas penulisan buku ini, karena dengan tugas ini membuatku saya bertambah skill dalam penulisan dan teamwork dalam pengerjaan nya -Parulian Tambunan
Kupersembahkan buku ini untuk kedua orangtuaku tersayang; terimakasih untuk semuanya dan doanya selama ini sehingga kami dapat menyelesaikan buku ini -Ika Yunita Anggraeni
Kupersembahkan buku ini untuk orangtua atas semua pemberian yang diberikan; sangat membantuku dalam menjalani proses hidup dan juga untuk teman seperjuangan yang sudah berusaha dengan tekun dalam proses penulisan buku ini -Sutri Hartono
BAB 1 PENDAHULUAN
A. Latar Belakang
Kualitas hasil produksi menjadi salah satu faktor dasar keputusan konsumen dalam memilih sebuah produk. Sebuah pengendalian kualitas sangat dibutuhkan dalam proses produksi guna menjaga kestabilan suatu produk. Dalam pengendalian kualitas sering digunakan pengendalian proses statistik. Salah satu teknik pengendalian proses statistik adalah grafik pengendali (control chart). Mengingat karakteristik kualitas proses produksi tidak selalu berdistribusi normal, maka dikembangkan alternatif grafik pengendali dengan metode non-parametrik . Salah satunya adalah menggunakan estimasi fungsi densitas kernel (kernel density estimation).
Dalam makalah ini di jelaskan tentang penerapan grafik pengendali berdasarkan estimasi fungsi densitas kernel bivariat pada data bivariat k, pencapaian dari tugas ini mahasiswa dapat memilki kemampuan teamwork yang dapat berguna di dalam dunia kerja. arakteristik pH dan berat jenis sabun sirih (Pattihahuan et al., 2012). m menduga selang kepercayaan dari kurva dugaan. Selanjutnya, makalah ini akan membahas tentang bagaimana menerapkan grafik pengendali non-parametrik berdasarkan pendekatan fungsi densitas kernel bivariat untuk dua titik dan untuk data simulasi bivariat. Tujuan dari penelitian ini adalah menerapkan grafik menduga selang kepercayaan dari kurva dugaan. pengendali non-parametrik berdasarkan pendekatan kernel untuk data simulasi bivariat dan mengidentifikasi titik sampel yang berada di luar grafik pengendali.
Pengendalian kualitas secara statistik dapat dilakukan dengan menggunakan grafik pengendali, Salah satunya adalah penggunaan grafik pengendali berdasarkan Estimasi Fungsi Densitas Kernel. Data yang digunakan adal
KATA PENGANTAR
Alhamdulillah, puji dan syukur kehadirat Allah SWT atas semua berkah dan rahmat yang senantiasa diberikan sehingga penulis dapat menyelesaikan buku ini dengan baik dan lancar. Salawat serSebelumnya , penulis memanjatkanta salam kita panjatkan pula terhadap nabi besar muhammad SAW.
Buku ini ditulis untuk melengkapi tugas dari mata kuliah Desain Pemodelan Grafik (Softskill) yang diajar oleh Pak Dr. Rer. Nat. I Made Wiryana, Skom, SSi, MappSc. Tujuan dari penulisan buku ini diharapkan, agar pembaca dapat memahami teori permodelan grafik ,perangkat lunak yang berkaitan dengan Joint Kernel Density Estimate.
Tujuan penulisan buku ini untuk melatih kami untuk memiliki knowledge, skill menulis, mendengar, berbicara, beragumen dan berdiskusi dengan kelompok. Pembahasan buku ini akan dimulai dari hal sederhana, yaitu pemahaman konsep visualisasi, instalasi software yang di butuhkan, bagaimana langkah atau cara yang diperlukan untuk instalasi software tersebut, contoh kasus software yang menggunakan teori joint kernel density estimate dalam pemodelan grafik.
Sebagai kata kata terakhir, penulis ucapkan terimakasih kepada semua pihak dan tempat yang telah memberikan kontribusi bantuan dan dukungan terhadap proses penulisan dan pencetakan buku ini
Semoga bermanfaat
Depok, Januari 2015
Penulis
Kupersembahkan buku ini untuk teman temanku tercinta; terimakasih atas usaha dan jerih payah atas pembuatan buku ini -Fadlillah Ramdhani
Kupersembahkan buku ini untuk pak made tercinta selaku dosen saya yang telah memberikan tugas penulisan buku ini, karena dengan tugas ini membuatku saya bertambah skill dalam penulisan dan teamwork dalam pengerjaan nya -Parulian Tambunan
Kupersembahkan buku ini untuk kedua orangtuaku tersayang; terimakasih untuk semuanya dan doanya selama ini sehingga kami dapat menyelesaikan buku ini -Ika Yunita Anggraeni
Kupersembahkan buku ini untuk orangtua atas semua pemberian yang diberikan; sangat membantuku dalam menjalani proses hidup dan juga untuk teman seperjuangan yang sudah berusaha dengan tekun dalam proses penulisan buku ini -Sutri Hartono
BAB 1PENDAHULUAN
A. Latar Belakang
Kualitas hasil produksi menjadi salah satu faktor dasar keputusan konsumen dalam memilih sebuah produk. Sebuah pengendalian kualitas sangat dibutuhkan dalam proses produksi guna menjaga kestabilan suatu produk. Dalam pengendalian kualitas sering digunakan pengendalian proses statistik. Salah satu teknik pengendalian proses statistik adalah grafik pengendali (control chart). Mengingat karakteristik kualitas proses produksi tidak selalu berdistribusi normal, maka dikembangkan alternatif grafik pengendali dengan metode non-parametrik . Salah satunya adalah menggunakan estimasi fungsi densitas kernel (kernel density estimation).
Dalam makalah ini di jelaskan tentang penerapan grafik pengendali berdasarkan estimasi fungsi densitas kernel bivariat pada data bivariat k, pencapaian dari tugas ini mahasiswa dapat memilki kemampuan teamwork yang dapat berguna di dalam dunia kerja. arakteristik pH dan berat jenis sabun sirih (Pattihahuan et al., 2012). m menduga selang kepercayaan dari kurva dugaan. Selanjutnya, makalah ini akan membahas tentang bagaimana menerapkan grafik pengendali non-parametrik berdasarkan pendekatan fungsi densitas kernel bivariat untuk dua titik dan untuk data simulasi bivariat. Tujuan dari penelitian ini adalah menerapkan grafik menduga selang kepercayaan dari kurva dugaan. pengendali non-parametrik berdasarkan pendekatan kernel untuk data simulasi bivariat dan mengidentifikasi titik sampel yang berada di luar grafik pengendali.
Pengendalian kualitas secara statistik dapat dilakukan dengan menggunakan grafik pengendali, Salah satunya adalah penggunaan grafik pengendali berdasarkan Estimasi Fungsi Densitas Kernel. Data yang digunakan adalah dua titik sampel bivariat yaitu 2,11 x ,4,32 x dan data simulasi bivariat yang dibangkitkan dari kombinasi dua distribusi normal bivariat dengan ukuran sampel (sample size) tertentu. Berdasarkan data tersebut dapat ditentukan estimasi densitas kernelnya (kernel density estimation) selanjutnya digunakan untuk membuat grafik pengendali dalam menentukan titik sampel yang out of control. Dari studi simulasi dapat dibangkitkan sampel dengan ukuran n berbeda- beda dan diperoleh hasil proporsi titik sampel out of control cenderung mendekati nilai batas kesalahan (level of significance).
KENAPA MENGGUNAKAN KERNEL DENSITY ESTIMATE?
Kualitas hasil produksi menjadi salah satu faktor dasar keputusan konsumen dalam memilih sebuah produk
Seperti yang kita ketahui, histogram dapat secara visual frustasi dan menyesatkan, terutama ketika sampah atau midpoints tidak appropriatel y ukuran d atau ditempatkan (l s o dibahas dalam bagian teori karya ini). Perkiraan kepadatan kernel menyediakan garis halus untuk mengikuti; Namun-mirip dengan “ukuran bin” yang dapat mengubah distribusi data di histogram – bandwidth seleksi adalah bagian penting dari kernel kepadatan estima te. Namun, ada beberapa metode seleksi bandwidth otomatis tersedia di SAS \circledR
perangkat lunak; ini dibahas pada bagian berikutnya.
DASAR TEORI
Grafik Pengendali
Grafik pengendali adalah teknik pengendali proses pada jalur yang digunakan secara luas yang biasanya digunakan untuk menaksir parameter suatu proses produksi menentukan kemampuan dan memberikan informasi yang berguna dalam meningkatkan proses itu (Montgomery, 1990). Berdasarkan banyaknya karakteristik kualitas yang diukur, grafik pengendali dibedakan menjadi 2 jenis yaitu grafik pengendali univariat dan grafik pengendali bivariat atau multivariat. Grafik pengendali univariat digunakan jika hanya ada satu karakteristik kualitas yang diukur, sedangkan grafik pengendali bivariat atau multivariat digunakan jika diperlukan pengendalian dua atau lebih karakteristik kualitas yang berhubungan secara bersama-sama.
Estimasi Fungsi Densitas Bivariat
Estimasi fungsi densitas merupakan salah satu bagian dalam analisis data statistik, dimana estimasi fungsi densitas adalah suatu gambaran tentang sebuah sebaran data. Dalam statistik, estimasi fungsi densitas kernel merupakan salah satu metode non-parametrik untuk menduga fungsi kepadatan probabilitas dari suatu variabel acak (WEB1).
Memahami bagaimana kernel estimasi bekerja membantu analis data yang menghasilkan histogram lebih efektif. Bagian ini berjalan melalui komponen dasar dan perhitungan untuk proses KDE yang disediakan oleh perangkat lunak SAS ®. Perkiraan kepadatan kernel KERNEL kepadatan memperkirakan adalah NONPARAMETRIC metode A yang adalah grafik nonparametric — berarti bahwa ia tidak memiliki fungsi kepekatan probabilitas yang mendasari (Yeh, Shi-Tao, 2004). Sebaliknya, itu diambil berdasarkan pada pengamatan data. Dengan kata lain, perkiraan kepadatan kernel yang tidak menggunakan regresi agar sesuai dengan garis data. Metode grafik lain akrab, nonparametric dalam perangkat lunak SAS ® termasuk pilihan HISTOGRAM dalam prosedur UNIVARIAT, BOXPLOT dan prosedur LOESS. Sebagai lawan untuk contoh-contoh di atas, parametrik regresi SAS ® software termasuk prosedur GLM, REG dan NLIN.
METODE PENELITIAN
Dalam penelitian ini digunakan langkah-langkah yang dijelaskan sebagai berikut:
• Membuat grafik pengendali dengan estimasi densitas kernel untuk dua titik sampel
• Menghitung estimasi fungsi densitas kernel dari data simulasi berdasarkan nilai H bandwidth optimal.
• Membuat grafik pengendali untuk data simulasi bivariat berdasarkan estimasi fungsi densitas kernel. Menentukan banyaknya titik sampel yang out of control.
• Menentukan banyaknya titik yang out of control untuk n=500, n=1000, n=1500 dan p=0.5.
• Melakukan pengulangan dengan p yang berbeda-beda yaitu p=0.1, p=0.8.
B. RUMUSAN MASALAH
Dalam makalah ini dijelaskan proses pembentukan grafik pengendali bivariat berdasarkan estimasi densitas kernel untuk dua titik sampel dan untuk banyaknya sampel dengan n yang berbeda-beda sehingga dapat digunakan untuk mengidentifikasi titik-titik sampel yang out of control.
C.TUJUAN PENULISAN
Dengan Memilih tema dan Menyusun buku ini diharapkan agar para pembaca ,serta penulis sendiri mampu memahami apa itu Joint kernel Density Estimate serta teknik-teknik dalam meningkatkan pemahaman Joint Kernel Density Estimate. Sekaligus, buku ini dibuat untuk memenuhi tugas perkuliahan, yaitu Mata kuliah Softskill Desain Permodelan Grafik. Kami sebagai mahasiswa dari jurusan teknologi industry.
BAB II Teori Tentang Konsep Visualisasi
Kernels
Kita telah mengetahui Gaussian kernel, tetapi hal ini tidak hanya tersedia pilihan. Estimasi Densitas Kernel (KDE) dapat digunakan dengan fungsi kernel apapun, dan kernel yang berbeda menyebabkan perkiraan kepadatan dengan karakteristik yang berbeda. Scipy KDE implementasi berisi hanya Kernel Gaussian umum. Statsmodels berisi tujuh kernel, sementara belajar Scikit berisi kernel enam, yang masing-masing dapat digunakan dengan satu dari sekitar selusin jarak metrik, mengakibatkan berbagai sangat fleksibel bentuk efektif kernel.
Berikut ini visualisasi cepat bentuk enam kernel yang tersedia di Scikit-belajar. Untuk kejelasan, fungsi plot_kernels() yang digunakan di sini didefinisikan pada akhir notebook:
In [8]:
plot_kernels()
Kernel berbagai bentuk menyebabkan penduga dengan karakteristik yang sangat berbeda. Untuk beberapa contoh ini dalam tindakan, lihat dokumentasi Scikit-belajar atau contoh-contoh AstroML.
Estimasi densitas kernel
Dalam statistik, estimasi densitas kernel (KDE) adalah cara untuk memperkirakan dengan fungsi kepadatan probabilitas dari variabel acak. Estimasi densitas kernel adalah masalah penghalusan data mendasar di mana kesimpulan tentang populasi yang dibuat berdasarkan data yang terbatas sampel. Dalam beberapa bidang seperti pemrosesan sinyal dan ekonometrik disebut juga metode window Parzen-Rosenblatt, setelah Emanuel Parzen dan Murray Rosenblatt, yang biasanya dikreditkan dengan mandiri menciptakan itu dalam bentuk yang sekarang.
Gambar diatas: Estimasi densitas kernel dari 100 terdistribusi normal nomor acak menggunakan bandwidth smoothing yang berbeda.
Definisi
Biarkan (x 1, x 2, …, x n) menjadi independen dan terdistribusi secara identik sampel yang diambil dari beberapa distribusi dengan tidak diketahui kepadatan f
. Kami tertarik dalam memperkirakan bentuk fungsi f
ini. Its kepadatan kernel estimator adalah
\overset{\mathcircumflex}{f}_{h}\left(x\right)=\frac{1}{n}\stackrel{[}{i}=1]{n}{\sum}K_{h}\left(x-x_{i}\right)=\frac{1}{nh}\stackrel{[}{i}=1]{n}{\sum}K\left(\frac{x-x_{i}}{h}\right)
dimana K (\bullet
) adalah kernel – fungsi non-negatif yang mengintegrasikan ke satu dan memiliki berarti nol – dan h> 0 adalah smoothing parameter yang disebut bandwidth. Sebuah kernel dengan subscript h disebut kernel skala dan didefinisikan sebagai K h (x) = 1 / h K (x / h). Intuitif seseorang ingin memilih h sekecil data memungkinkan, namun selalu ada trade-off antara bias estimator dan varians nya; lebih pada pilihan bandwidth bawah.
Berbagai fungsi kernel yang umum digunakan: seragam, segitiga, biweight, triweight, Epanechnikov, yang normal, dan lain-lain. The Epanechnikov kernel optimal dalam arti kesalahan berarti persegi, [3] meskipun hilangnya efisiensi kecil untuk kernel terdaftar sebelumnya, [4] dan karena sifat matematika yang strategis, kernel normal sering digunakan K (x) = \varphi
(x), di mana \varphi
adalah normal standar fungsi kepadatan.
Pembangunan perkiraan kepadatan kernel menemukan interpretasi dalam bidang luar estimasi kepadatan. [5] Sebagai contoh, dalam termodinamika, ini setara dengan jumlah panas yang dihasilkan ketika kernel panas (solusi mendasar untuk persamaan panas) ditempatkan pada setiap lokasi data titik x i. Metode serupa digunakan untuk membangun operator Laplace diskrit pada awan titik untuk belajar berjenis.
Estimasi densitas kernel yang erat kaitannya dengan histogram, tetapi dapat memiliki sifat-sifat seperti kehalusan atau kontinuitas dengan menggunakan kernel yang cocok. Untuk melihat ini, kita membandingkan pembangunan histogram dan kepadatan kernel estimator, menggunakan titik data 6 ini: x 1 = -2,1, x 2 = -1,3, x 3 = -0,4, x 4 = 1,9, x 5 = 5.1, x 6 = 6.2. Untuk histogram, pertama sumbu horisontal dibagi menjadi sub-interval atau sampah yang mencakup rentang data. Dalam hal ini, kami memiliki 6 tempat sampah masing-masing lebar 2. Setiap kali sebuah titik data berada di dalam interval ini, kami menempatkan kotak tinggi 12/1. Jika lebih dari satu titik data jatuh di dalam bin sama, kita tumpukan kotak di atas satu sama lain.
Untuk estimasi densitas kernel, kita menempatkan sebuah kernel normal dengan varians 2,25 (ditandai dengan garis putus-putus merah) pada masing-masing titik data x i. Kernel dijumlahkan untuk membuat estimasi densitas kernel (kurva biru solid). Kelancaran estimasi densitas kernel jelas dibandingkan dengan discreteness histogram, seperti perkiraan kepadatan kernel konvergen lebih cepat untuk kepadatan yang mendasari berlaku untuk variabel acak kontinu.
Perbandingan histogram (kiri) dan kepadatan kernel perkiraan (kanan) dibangun menggunakan data yang sama. 6 kernel individu merah putus-putus kurva, kepadatan kernel memperkirakan kurva biru. Titik data yang plot karpet pada sumbu horisontal.
Kernel estimasi dengan Python
Ada beberapa pilihan yang tersedia untuk komputasi perkiraan kepadatan kernel dengan Python. Pertanyaannya pelaksanaan KDE optimal untuk setiap situasi, bagaimanapun, tidak sepenuhnya langsung, dan banyak tergantung pada apa tujuan tertentu. Berikut ini adalah implementasi KDE empat yang aku sadar dalam tumpukan SciPy Scikits:
• Di SciPy: gaussian_kde.
• Di Statsmodels: KDEUnivariate dan KDEMultivariate .
• Di Scikit-belajar: KernelDensity .
Masing-masing memiliki keuntungan dan kerugian, dan masing-masing memiliki area penerapan. Saya akan mulai dengan sebuah table rangkuman kekuatan dan kelemahan masing-masing, sebelum membahas setiap fitur secara lebih rinci dan menjalankan beberapa benchmark sederhana untuk mengukur biaya komputasi mereka:
Implementasi empat yang disebutkan di atas memiliki antarmuka yang sangat berbeda. Untuk contoh dan benchmark di bawah ini, kita akan mulai dengan mendefinisikan antarmuka yang seragam untuk semua empat, dengan asumsi dimensi data input. Fungsi-fungsi berikut harus membuat jelas bagaimana membandingkan antarmuka:
In [1]:
from sklearn.neighbors import KernelDensity
from scipy.stats import gaussian_kde
from statsmodels.nonparametric.kde import KDEUnivariate
from statsmodels.nonparametric.kernel_density import KDEMultivariate
def kde_scipy(x, x_grid, bandwidth=0.2, **kwargs):
“””Kernel Density Estimation with Scipy”””
# Note that scipy weights its bandwidth by the covariance of the
# input data. To make the results comparable to the other methods,
# we divide the bandwidth by the sample standard deviation here.
kde = gaussian_kde(x, bw_method=bandwidth / x.std(ddof=1), **kwargs)
return kde.evaluate(x_grid)
def kde_statsmodels_u(x, x_grid, bandwidth=0.2, **kwargs):
“””Univariate Kernel Density Estimation with Statsmodels”””
kde = KDEUnivariate(x) kde.fit(bw=bandwidth, **kwargs)
return kde.evaluate(x_grid)
def kde_statsmodels_m(x, x_grid, bandwidth=0.2, **kwargs):
“””Multivariate Kernel Density Estimation with Statsmodels”””
kde = KDEMultivariate(x, bw=bandwidth * np.ones_like(x),
var_type=’c’, **kwargs)
return kde.pdf(x_grid)
def kde_sklearn(x, x_grid, bandwidth=0.2, **kwargs):
“””Kernel Density Estimation with Scikit-learn”””
kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)
kde_skl.fit(x[:, np.newaxis])
# score_samples() returns the log-likelihood of the samples
log_pdf = kde_skl.score_samples(x_grid[:, np.newaxis])
return np.exp(log_pdf)
kde_funcs = [kde_statsmodels_u, kde_statsmodels_m, kde_scipy, kde_sklearn]
kde_funcnames = [‘Statsmodels-U’, ‘Statsmodels-M’, ‘Scipy’, ‘Scikit-learn’]
print “Package Versions:”
import sklearn; print ” scikit-learn:”, sklearn.__version__
import scipy; print ” scipy:”, scipy.__version__
import statsmodels; print ” statsmodels:”, statsmodels.__version__
Package Versions:
scikit-learn: 0.14.1
scipy: 0.13.1
statsmodels: 0.5.0
Karena beberapa dari fungsi baru (secara khusus, KernelDensity pengukur ditambahkan dalam versi 0.14 Scikit-belajar), saya menambahkan eksplisit cetak-keluar dari versi yang digunakan dalam menjalankan notebook ini. Sekarang bahwa kita sudah didefinisikan antarmuka ini, mari kita lihat hasil dari pendekatan KDE empat. Kita akan mulai dengan perintah backend normal matplotlib, dan kemudian plot visualisasi dari hasil empat pada data yang sama 1 Dimensi bimodal:
In [2]: %matplotlib inline import numpy as np import matplotlib.pyplot as plt
In [3]: from scipy.stats.distributions import norm
# The grid we’ll use for plotting x_grid = np.linspace(-4.5, 3.5, 1000)
# Draw points from a bimodal distribution in 1D np.random.seed(0) x = np.concatenate([norm(-1,1.).rvs(400), norm(1, 0.3).rvs(100)])
pdf_true = (0.8 * norm(-1,1).pdf(x_grid) + 0.2 * norm(1,0.3).pdf(x_grid))
# Plot the three kernel density estimates fig, ax = plt.subplots(1, 4, sharey=True, figsize=(13, 3)) fig.subplots_adjust(wspace=0)
for i in range(4):
pdf = kde_funcs[i](x, x_grid, bandwidth=0.2)ax[i].plot(x_grid, pdf, color=’blue’, alpha=0.5, lw=3)ax[i].fill(x_grid, pdf_true, ec=’gray’, fc=’gray’, alpha=0.4)ax[i].set_title(kde_funcnames[i]) ax[i].set_xlim(-4.5, 3.5)
from IPython.display import HTML HTML(“<font color=’#666666′>Gray = True underlying distribution</font><br>” “<font color=’6666ff’>Blue = KDE model distribution (500 pts)</font>”)
Out[3]:
Gray = True underlying distribution Blue = KDE model distribution (500 pts)
Hasil sama, seperti yang kita harapkan: semua empat algoritma efektif komputasi hasil yang sama dengan cara yang berbeda.
Fitur dari algoritma
Temukan Bandwidth
Kernel density perkiraan (KDE) dengan bandwidth yang berbeda dari sampel acak dari 100 poin dari distribusi normal standar. Grey: density benar (standar normal). Red: KDE dengan h = 0,05. Black: KDE dengan h = 0,337. Hijau: KDE dengan h = 2.
Bandwidth dari kernel adalah parameter bebas yang menunjukkan pengaruh yang kuat pada perkiraan yang dihasilkan. Untuk menggambarkan efeknya, kita mengambil simulasi sampel acak dari standar distribusi normal (diplot pada paku biru di petak karpet pada sumbu horizontal). Kurva abu-abu adalah densitas benar (kepadatan normal dengan mean 0 dan varians 1). Sebagai perbandingan, kurva merah undersmoothed karena mengandung terlalu banyak artefak Data palsu yang timbul dari menggunakan h bandwith = 0,05, yang terlalu kecil. Kurva hijau oversmoothed karena menggunakan bandwidth h = 2 mengaburkan banyak struktur dasar. Kurva hitam dengan bandwidth h = 0,337 dianggap optimal merapikan sejak estimasi densitas dekat dengan kepadatan yang benar.
Kriteria optimalitas yang paling umum digunakan untuk memilih parameter ini adalah yang diharapkan L_{2}
fungsi risiko, juga disebut berarti terintegrasi kesalahan kuadrat:
MISE\left(h\right)=E\int\left(\overset{\mathcircumflex}{f}_{h}\left(x\right)-f\left(x\right)\right)^{2}dx.
Di bawah asumsi lemah pada f
dan K, [1] [2] MISE (h) = AMISE (h) + o (1 / (nh) + h 4) di mana o adalah sedikit notasi o. AMISE adalah MISE Asymptotic yang terdiri dari dua istilah terkemuka
AMISE\left(h\right)=\frac{R\left(K\right)}{nh}+\frac{1}{4}m_{2}\left(K\right)^{2}h^{4}R\left(f^{\prime\prime}\right)
dimanaR\left(g\right)=\int g\left(x\right)^{2}dx
untuk fungsi g, m_{2}\left(K\right)=\int x^{2}K\left(x\right)dx
dan f^{\prime\prime}
adalah turunan kedua f
. Minimum AMISE ini adalah solusi untuk persamaan diferensial ini
\frac{\partial}{\partial h}AMISE\left(h\right)=-\frac{R\left(K\right)}{nh^{2}}+m_{2}\left(K\right)^{2}h^{3}R\left(f^{\prime\prime}\right)=0
atau
h_{AMISE}=\frac{R\left(K\right)^{1/5}}{m_{2}\left(K\right)^{2/5}R\left(f^{\prime\prime}\right)^{1/5}n^{1/5}}
Baik AMISE maupun formula h AMISE dapat digunakan secara langsung karena mereka melibatkan diketahui fungsi kepadatan f
atau turunan f
kedua ”, sehingga berbagai, metode berbasis data otomatis telah dikembangkan untuk memilih bandwidth. Banyak penelitian tinjauan telah dilakukan untuk membandingkan efficacities mereka, [7] [8] [9] [10] [11] [12] [13] dengan konsensus umum bahwa plug-in pemilih yang [5] [14] dan validasi silang penyeleksi [15] [16] [17] yang paling berguna atas berbagai data set.
Mengganti setiap h bandwith yang memiliki urutan asimtotik yang sama \left(n^{-1/5}\right)
sebagai h AMISE ke AMISE memberikan yang AMISE (h) = O \left(n^{-4/5}\right)
, di mana O adalah notasi o besar. Hal ini dapat menunjukkan bahwa, di bawah asumsi yang lemah, tidak bisa eksis estimator non-parametrik yang menyatu pada tingkat yang lebih cepat daripada estimator kernel. [18] Perhatikan bahwa \left(n^{-4/5}\right)
tingkat lebih lambat dibandingkan dengan khas \left(n^{-1}\right)
konvergensi tingkat metode parametrik.
Jika bandwidth tidak diadakan tetap, tetapi bervariasi tergantung lokasi baik estimasi (balon estimator) atau sampel (pointwise estimator), ini menghasilkan metode sangat kuat disebut adaptif atau variabel estimasi kepadatan kernel bandwith.
Estimasi praktis bandwidth
Jika fungsi dasar Gaussian digunakan untuk mendekati univariat data, dan kepadatan yang mendasari yang diperkirakan adalah Gaussian maka dapat ditunjukkan bahwa pilihan optimal untuk h adalah [19]
h=\left(\frac{4\overset{\mathcircumflex}{\sigma^{5}}}{3n}\right)^{\frac{1}{5}}\thickapprox1.06\overset{\mathcircumflex}{\sigma}n^{-1/5},
dimana\overset{\mathcircumflex}{\sigma}
adalah standar deviasi dari sampel. Pendekatan ini disebut pendekatan normal distribusi, pendekatan Gaussian, atau Silverman aturan ‘s praktis.
Temukan bandwidth untuk estimasi kepadatan kernel distribusi berat ekor dikatakan relatif sulit.
Kaitannya dengan estimator densitas fungsi karakteristik
Mengingat sampel (x 1, x 2, …, x n), adalah wajar untuk memperkirakan fungsi karakteristik \varphi
(t) = E \left[e^{ITX}\right]
sebagai
\overset{\mathcircumflex}{\varphi}\left(t\right)=\frac{1}{n}\stackrel{[}{j}=1]{n}{\sum}e^{itxj}
Mengetahui fungsi karakteristik, adalah mungkin untuk menemukan yang sesuai fungsi kepadatan probabilitas melalui Fourier transform rumus. Salah satu kesulitan dengan menerapkan rumus inversi ini adalah bahwa hal itu mengarah ke divergen terpisahkan, karena perkiraan \overset{\mathcircumflex}{\varphi}\left(t\right)
tidak dapat diandalkan untuk t besar ‘s. Untuk menghindari masalah ini, estimator \overset{\mathcircumflex}{\varphi}\left(t\right)
dikalikan dengan fungsi redaman \psi
h (t) = \psi
(ht), yang sama dengan 1 pada asal dan kemudian jatuh ke 0 di tak terhingga. The “parameter bandwidth” h kontrol seberapa cepat kita mencoba untuk meredam fungsi \overset{\mathcircumflex}{\varphi}\left(t\right)
. Khususnya ketika h kecil, maka \psi
h (t) akan menjadi sekitar satu untuk berbagai macam t ‘s, yang berarti bahwa \overset{\mathcircumflex}{\varphi}\left(t\right)
tetap praktis tidak berubah di wilayah yang paling penting dari t ‘s.
Pilihan yang paling umum untuk fungsi \psi
adalah baik fungsi seragam \psi
(t) = 1 \left\{ -1\leq t\leq1\right\}
, yang secara efektif berarti truncating interval integrasi dalam rumus inversi untuk [-1 / jam, 1 / h] , atau fungsi gaussian \psi
(t) = e^{-xt2}
. Setelah fungsi \psi
telah dipilih, rumus inversi dapat diterapkan, dan estimator densitas akan
\overset{\mathcircumflex}{f}\left(x\right)=\sideset{\frac{1}{2\pi}}{_{-\infty}^{+\infty}}\int\overset{\mathcircumflex}{\varphi}\left(t\right)\psi_{h}\left(t\right)e^{-itx}dt=\sideset{\frac{1}{2\pi}}{_{-\infty}^{+\infty}}\int\frac{1}{n}\stackrel{[}{j}=1]{n}{\sum}e^{it\left(x_{j}-x\right)}\psi\left(ht\right)dt
=\frac{1}{nh}\stackrel{[}{j}=1]{n}{\sum}\sideset{\frac{1}{2\pi}}{_{-\infty}^{+\infty}}\int e^{-i\left(ht\right)\frac{x-x_{j}}{h}}\psi\left(ht\right)d\left(ht\right)=\frac{1}{nh}\stackrel{[}{j}=1]{n}{\sum}K\left(\frac{x-x_{j}}{h}\right),
di mana K adalah Transformasi Fourier dari fungsi \psi
redaman. Dengan demikian estimator densitas kernel bertepatan dengan karakteristik kepadatan fungsi estimator.
Bandwidth seleksi
Pemilihan bandwidth adalah bagian penting dari KDE. Untuk data input yang sama, bandwidth yang berbeda dapat menghasilkan hasil yang sangat berbeda: In [4]:
fig, ax = plt.subplots()
for bandwidth in [0.1, 0.3, 1.0]:
ax.plot(x_grid, kde_sklearn(x, x_grid, bandwidth=bandwidth),
label=’bw={0}’.format(bandwidth), linewidth=3, alpha=0.5)
ax.hist(x, 30, fc=’gray’, histtype=’stepfilled’, alpha=0.3, normed=True)
ax.set_xlim(-4.5, 3.5) ax.legend(loc=’upper left’)
Out[4]:
<matplotlib.legend.Legend at 0x108b8c3d0>
Menggunakan bandwidth yang berbeda dapat menyebabkan ide-ide yang sama sekali berbeda dari sifat dasar data! Mengingat pentingnya bandwidth, bagaimana mungkin Anda menentukan bandwidth yang optimal untuk masalah tertentu? Ada dua kelas pendekatan untuk masalah ini: dalam masyarakat statistik, ini umum untuk menggunakan aturan referensi, mana optimal bandwidth diperkirakan dari bentuk-bentuk teoritis yang didasarkan pada asumsi tentang distribusi data. Aturan referensi umum adalah aturan Silverman’s, yang diturunkan untuk univariat KDE dan disertakan dalam implementasi Scipy dan Statsmodels. Aturan referensi lain potensi adalah yang berdasarkan kriteria informasi, terkenal AIC dan BIC. Dalam dunia pembelajaran mesin, penggunaan referensi aturan kurang umum. Sebaliknya, pendekatan empiris seperti lintas validasi sering digunakan. Di salib validasi, model adalah cocok untuk bagian dari data, dan kemudian kuantitatif metrik dihitung untuk menentukan seberapa baik model ini sesuai dengan data yang tersisa. Sebuah pendekatan empiris untuk model parameter pilihan sangat fleksibel, dan dapat digunakan tanpa distribusi data yang mendasarinya. Karena berbagai referensi aturan umumnya tergantung pada asumsi-asumsi (sering meragukan) tentang distribusi mendasari data, pemilihan bandwidth yang berbasis di kayu salib-validasi dapat menghasilkan lebih banyak hasil yang dapat dipercaya untuk dunia nyata dataset. Skema cross-validation meninggalkan-satu-out built-in Statsmodels KDEMultivariate kelas. Untuk dataset besar, namun, meninggalkan-satu-out cross-validation bisa sangat lambat. Scikit-Pelajari tidak saat ini menyediakan built-in lintas validasi dalam pengukur KernelDensity, tapi alat-alat standar lintas validasi dalam modul dapat diterapkan cukup mudah, seperti ditunjukkan pada contoh di bawah.
Belajar Bandwidth Cross-Validation di scikit
Menggunakan salib validasi dalam belajar Scikit mudah dengan GridSearchCV meta-pengukur :
In [5]:
from sklearn.grid_search import GridSearchCV
grid = GridSearchCV(KernelDensity(),
{‘bandwidth’: np.linspace(0.1, 1.0, 30)},
cv=20) # 20-fold cross-validation
grid.fit(x[:, None]) print grid.best_params_ {‘bandwidth’: 0.19310344827586207}
Menurut nilai cross-validation (yaitu kemungkinan maksimum), bandwidth yang terbaik adalah di sekitar 0.19. Mari kita plot hasil:
In [6]:
kde = grid.best_estimator_ pdf = np.exp(kde.score_samples(x_grid[:, None]))
fig, ax = plt.subplots()
ax.plot(x_grid, pdf, linewidth=3, alpha=0.5, label=’bw=%.2f’ % kde.bandwidth) ax.hist(x, 30, fc=’gray’, histtype=’stepfilled’, alpha=0.3, normed=True)
ax.legend(loc=’upper left’)
ax.set_xlim(-4.5, 3.5);
Kita melihat bahwa hasil cross-validation a bandwidth yang dekat dengan apa yang kita mungkin pilih oleh mata, dan perkiraan kepadatan dihasilkan erat mencerminkan distribusi data yang mendasarinya.
Heterogen Data
Salah satu keuntungan yang Statsmodels’ KDEMultivariate memiliki algoritma lainnya adalah kemampuannya untuk menangani data heterogen, yaitu campuran kontinyu, memerintahkan diskrit, dan unordered bijaksana variabel. Semua lain implementasi membutuhkan dataset homogen. Meskipun masalah heterogen menarik, saya tidak akan membahas lebih di sini. Untuk lebih jelasnya, lihat dokumentasi KDEMultivariate.
Perhitungan berbasis FFT
Untuk dataset besar, perkiraan kepadatan kernel yang dapat dihitung secara efisien melalui teorema lilitan menggunakan transformasi Fourier cepat. Hal ini memerlukan binning data, sehingga pendekatan yang dengan cepat menjadi tidak efisien dalam dimensi yang lebih tinggi. Algoritma empat yang dibahas di sini, hanya Statsmodels’ KDEUnivariate mengimplementasikan FFT berbasis KDE. Seperti yang akan kita lihat di bawah, FFT menyediakan beberapa keuntungan komputasi untuk sejumlah besar poin, tapi dalam kebanyakan situasi tidak seefektif berbasis pohon KDE implementasi.
Perhitungan berbasis pohon
Untuk M evaluasi N poin, perhitungan KDE naif memerlukan perhitungan O O [MN] [MN] (yaitu perhitungan jarak antara setiap pasangan input/output). Hal ini menempatkan KDE dalam kategori yang sama sebagai tetangga terdekat, N-titik fungsi korelasi dan regresi proses Gaussian, semuanya adalah contoh dari masalah Generalized N-tubuh yang dapat efisien dihitung menggunakan data khusus struktur seperti pohon KD (saya dibahas spasial pohon dalam konteks pencarian tetangga terdekat dalam posting blog sebelumnya).
Ide utama adalah ini: jika Anda dapat menunjukkan bahwa query titik Q0Q0 geometris jauh dari serangkaian pelatihan poin {Ti} {Ti}, maka Anda tidak perlu menghitung setiap kernel berat antara Q0Q0 dan poin di {Ti} {Ti}: cukup untuk menghitung satu kernel berat pada jarak rata-rata, dan menggunakannya sebagai proxy untuk yang lain. Dengan pertimbangan yang cermat dari batas-batas pada jarak dan toleransi kesalahan maksimum untuk hasil akhir, dimungkinkan untuk sangat mengurangi jumlah operasi diperlukan untuk perhitungan KDE.
Untuk rilis 0,14 Scikit-belajar, saya menulis sebuah implementasi KDE efisien yang dibangun di KD pohon dan pohon bola. Dengan menetapkan parameter dengan rtol (relatif toleransi) dan atol (mutlak toleransi), dimungkinkan untuk menghitung perkiraan kepadatan sangat cepat perkiraan kernel pada setiap tingkat yang diinginkan akurasi. Hasil akhir pp algorithmically dijamin akan memuaskan
abs(p−ptrue)<atol+rtolptrue
Skema ini secara efektif set up tradeoff antara waktu perhitungan dan akurasi. Seperti yang akan kita lihat di bawah, bahkan marjinal penurunan akurasi (katakanlah, memungkinkan kesalahan 1 bagian dalam 108108) dapat menyebabkan keuntungan yang mengesankan dalam efisiensi komputasi.
Efisiensi komputasi
Berikutnya datang menyenangkan bagian: membandingkan efisiensi komputasi berbagai algoritma. Di sini kita akan melihat waktu perhitungan sebagai fungsi dari jumlah poin dalam distribusi untuk kasus 1-dimensi. Seperti disebutkan di atas, beberapa algoritma juga menerapkan perhitungan yang multi-dimensi: skala dengan jumlah poin harus tidak mengubah lumayan dalam kasus multi-dimensi. Di sini dan seluruh, kita akan menghitung KDE untuk 5000 query poin. Untuk kejelasan, fungsi plot_scaling yang digunakan di sini didefinisikan pada akhir notebook: jika Anda men-download dan menjalankan notebook ini, silakan gulir ke bawah dan mengeksekusi sel pertama.
Scaling dengan jumlah poin
Pertama kita akan melihat skala dengan jumlah poin dalam distribusi masukan, menyebar dari 10 poin ke 10.000 poin:
In [9]:
plot_scaling(N=np.logspace(1, 4, 10),
kwds={‘Statsmodels-U’:{‘fft’:False}});
SciPy algoritma (jalur merah) pameran O diharapkan [N] O [N] scaling untuk implementasi KDE naif. Implementasi berbasis pohon di scikit-belajar sedikit lebih baik untuk sejumlah besar poin (untuk dataset kecil, overhead bangunan pohon mendominasi). Cara statsmodels kedua lumayan lambat: khususnya, implementasi KDEMultivariate menampilkan overhead komputasi yang relatif besar.
Namun, benchmark ini tidak sepenuhnya adil untuk algoritma univariat Statsmodels atau Scikit-belajar algoritma. Untuk KDEUnivariate, kami tidak menggunakan versi FFT perhitungan; untuk Scikit-belajar, kami telah menetapkan dengan rtol dan atol ke nol, efektif meminta algoritma untuk perhitungan sempurna tepat yang memungkinkan node pohon sangat sedikit untuk dipotong dari perhitungan.
Mari kita mengubah ini, menggunakan FFT perhitungan untuk statsmodels dan mengatur dengan rtol = 1E-4 untuk scikit-belajar. Pengaturan kedua mengatakan bahwa kita ingin komputasi lebih cepat, dengan mengorbankan menerima kesalahan 0,01% dalam hasil akhir:
In [10]:
plot_scaling(N=np.logspace(1, 4, 10),
rtol=1E-4,
kwds={‘Statsmodels-U’:{‘fft’:True}});
Perhitungan FFT secara signifikan kecepatan perhitungan univariat statsmodels dalam hal jumlah besar poin. Pemenang sebenarnya di sini, meskipun, adalah Scikit-Pelajari penerapan: dengan membiarkan kesalahan Bagian 1 dalam 10.000, kita telah melesat perhitungan untuk dataset terbesar oleh faktor tambahan 5 atau lebih, membuat urutan besarnya lebih cepat daripada algoritma terbaik berikutnya.
Ketergantungan pada dengan rtol
Anda mungkin bertanya-tanya apa efek dengan rtol pada kecepatan perhitungan. Dalam kebanyakan situasi untuk scikit-belajar pengukur, meningkatkan dengan rtol akan secara langsung mengarah pada peningkatan efisiensi komputasi, sebagai node pohon jauh dapat dipotong sebelumnya dalam perhitungan.
Untuk menggambarkan hal ini, kita akan memplot perhitungan waktu sebagai fungsi dari dengan rtol, dari 11 bagian dalam 10161016 (efektif yang mengambang titik presisi pada mesin 64-bit) sepanjang jalan hingga 11 bagian dalam 1010 (yakni 10% kesalahan pada hasil):
In [11]: plot_scaling(N=1E4,
rtol=np.logspace(-16, -1, 10),
bandwidth=0.2);
Plot ini menampilkan langsung tradeoff antara presisi dan efisiensi yang diaktifkan oleh Scikit-belajar dari algoritma berbasis pohon. Setiap variasi dalam waktu untuk algoritma lain adalah hanya Statistik kebisingan: mereka tidak bisa mengambil keuntungan dari dengan rtol.
Ketergantungan pada Bandwidth
Satu efek agak kontra-intuitif berbasis pohon KDE perkiraan adalah bahwa bandwidth menjadi pertimbangan penting dalam waktu untuk komputasi. Hal ini karena bandwidth efektif mengontrol seberapa “dekat” poin adalah satu sama lain.
Ketika poin sangat jauh terpisah dalam kaitannya dengan ukuran kernel, kontribusi mereka terhadap kepadatan adalah sangat mendekati nol. Dalam kisaran ini, seluruh rombongan poin tersebut akan dihapus dari perhitungan. Ketika poin sangat dekat bersama-sama dalam kaitannya dengan ukuran kernel, jarak efektif adalah nol, dan seluruh rombongan tersebut poin di pohon dapat dianggap, sebagai sebuah kelompok, berkontribusi kontribusi maksimal kernel.
Perhitungan KDE berbasis pohon di Scikit-belajar mengambil keuntungan dari situasi ini, menyebabkan ketergantungan yang kuat waktu perhitungan pada bandwidth: untuk bandwidth yang sangat besar dan sangat kecil, sangat cepat. Untuk bandwidth di suatu tempat di tengah, bisa lebih lambat dari algoritma lainnya, terutama karena overhead komputasi membangun dan melintasi pohon:
In [12]:
plot_scaling(N=1E4, rtol=1E-4,
bandwidth=np.logspace(-4, 3, 10));
Untungnya bandwidth tidak efisien umumnya terlalu besar untuk menjadi berguna dalam praktek, dan bandwidth di kisaran lebih cepat menguntungkan untuk sebagian besar masalah.
Perhatikan bahwa hanya hasil belajar Scikit sangat tergantung pada bandwidth: implementasi lain punya waktu perhitungan konstan untuk dalam kesalahan acak. Ini adalah karena implementasi KDE berbasis pohon yang digunakan oleh Scikit-belajar, karena alasan-alasan yang dibahas di atas. Bandwidth optimal dekat 0,15 terletak di wilayah komputasi relatif cepat, terutama dibandingkan dengan algoritma alternatif.
Ketergantungan pada Kernel
Seperti yang Anda duga, prinsip yang sama yang menyebabkan ketergantungan perhitungan waktu bandwidth juga menyebabkan ketergantungan perhitungan waktu pada bentuk kernel yang digunakan. Untuk jauh poin, kernel beberapa memiliki bobot lebih dekat ke nol daripada yang lain: dalam kasus kernel dengan celana pendek “keras” (seperti tophat kernel), jauh poin berkontribusi persis nol kepadatan, dan dengan demikian speedup akan menyadari bahkan jika dengan rtol dan atol adalah nol.
Pada ekstrem yang berlawanan, poin yang sangat dekat dibandingkan dengan ukuran kernel, kernel yang sangat “datar” (misalnya tophat kernel) akan memungkinkan seluruh rombongan poin untuk dipertimbangkan sekaligus, ketika kernel yang kurang datar (misalnya linear atau eksponensial kernel) tidak akan mengakui efisiensi tersebut.Kita bisa melihat ini di bawah ini: di sini kita akan plot waktu perhitungan sebagai fungsi dari lebar kernel untuk implementasi Scikit-belajar, menggunakan beberapa kernel:
In [13]:
plot_scaling_vs_kernel(kernels=[‘tophat’, ‘linear’, ‘exponential’,
‘gaussian’],
bandwidth=np.logspace(-4, 3, 10),
N=1E4, rtol=1E-4);
Melihat dua daerah menarik: untuk bandwidth yang sangat kecil, kernel dengan keras cutoff (tophat, linear) keluar melakukan kernel dengan sebuah lancip yang luas (gaussian, eksponensial). Dan tapered kernel yang jatuh lebih cepat (gaussian, dengan p∼exp p∼exp (−d2) (−d2)) yang lebih efisien dihitung dari kernel yang jatuh lebih perlahan-lahan (eksponensial, dengan p∼exp p∼exp (−d) (−d)).
Di ujung lain, kernel dengan sangat datar profil dekat nol (tophat, gaussian) menunjukkan peningkatan bandwidth besar, sementara kernel dengan profil yang sangat curam dekat zero (linier, eksponensial) menunjukkan tidak ada perbaikan: mereka mencapai batas asimtotik cara dimana O O [MN] [MN] jarak harus dihitung.
Untuk mengukur baik, berikut adalah scalings perhitungan dengan rtol dan dengan N:
In [14]: plot_scaling_vs_kernel(kernels=[‘tophat’, ‘linear’, ‘exponential’,
‘gaussian’],
bandwidth=0.15, N=1E4, rtol=np.logspace(-16, -1, 10));
Seperti yang kami harapkan, untuk ukuran wajar kernel, dengan rtol tidak signifikan untuk kernel dengan cutoff keras, dan menjadi lebih signifikan adalah “sayap” kernel yang lebih luas. Skala dengan N juga karena kami telah mengharapkan:
In [15]:
plot_scaling_vs_kernel(kernels=[‘tophat’, ‘linear’, ‘exponential’,
‘gaussian’], bandwidth=0.15, rtol=1E-4, N=np.logspace(1, 4, 10));
Ketergantungan ini waktu perhitungan bentuk bandwidth dan kernel adalah masalah untuk diingat ketika Anda memilih algoritma KDE: dalam kasus pendekatan berbasis pohon, bandwidth dan kernel dapat masalah untuk lagu beberapa kali lipat dalam perhitungan waktu.
MATLAB KDE Class Description
Kelas KDE adalah kelas matlab umum untuk k-dimensi kernel estimasi. Tertulis dalam campuran matlab “.m” file dan MEX C++ code. Dengan demikian, untuk menggunakannya Anda akan perlu untuk dapat mengkompilasi kode C++ code Matlab. Perhatikan bahwa default compiler untuk Windows tidak mendukung c + +, sehingga Anda akan membutuhkan GCC di Linux, atau GCC atau Visual C++ for Windows. Pertumpahan darah persediaan lingkungan pengembangan bagus bersama dengan kompilator MinGW. Lihat Halaman ini untuk membantu menyiapkan MEX dengan MinGW.
[Catatan: karena beberapa dikompilasi mexglx dan dll file disertakan, Anda mungkin tidak perlu untuk melakukan kompilasi ulang toolbox sekali; Namun, saya merekomendasikan hal ini jika mungkin alasan kompatibilitas.]
Kernel yang didukung adalah:
• Gaussian
• Epanetchnikov (truncated quadratic)
• Laplacian (Double-exponential)
Untuk perkiraan kepadatan multivarian, kode mendukung produk kernel–kernel yang produk fungsi kernel di masing-masing dimensi. Misalnya, untuk Gaussian kernel ini setara dengan memerlukan kovarians diagonal. Juga dapat mendukung bandwidth non-seragam kernel–yaitu bandwidth yang berbeda atas kernel pusat.
Implementasi menggunakan “kd-pohon”, representasi heirarchical set titik yang cache cukup statistik tentang lokasi jalur dll untuk mencapai potensi speedups dalam perhitungan. Untuk Epanetchnikov kernel ini dapat menerjemahkan ke dalam speedups dengan tidak kehilangan presisi; tetapi untuk kernel dengan dukungan yang tak terbatas memberikan perkiraan tingkat toleransi, yang memungkinkan timbal balik antara kecepatan evaluasi kualitas dan komputasi. Secara khusus, kami menerapkan Alex Gray’s “Dual pohon” evaluasi algoritma; Lihat abu-abu dan Moore, “sangat cepat multivarian Kernel estimasi menggunakan melalui komputasi geometri”, dalam proses, 2003 Rapat Manzanar bersama untuk lebih jelasnya.
Ini memberikan parameter toleransi yang merupakan kesalahan persen (dari yang tepat, N\mathcircumflex
2 perhitungan) pada nilai setiap dievaluasi titik. Dalam umum, “toleransi” parameter dalam kode matlab / catatan mengacu pada toleransi persen ini. Kesalahan persentase ini diterjemahkan menjadi mutlak kesalahan aditif pada log berarti-kemungkinan, misalnya. Pengecualian untuk ini adalah fungsi gradien calcuation, yang menghitung menggunakan nilai mutlak toleransi. Ini karena sulitnya mencari persentase pasti ketika fungsi dihitung tidak benar-benar positif.
Kami juga baru dilaksanakan disebut meningkat Fast Gauss mengubah, dijelaskan dalam [Yang, Duraiswami, dan Gumerov, “Peningkatan cepat Gauss mengubah”, dikirimkan ke Siam jurnal dari komputasi ilmiah]. Ini sering melakukan jauh lebih cepat daripada algoritma pohon ganda yang disebutkan di atas, tetapi batas-batas kesalahan yang mengendalikan perhitungan sering cukup longgar, dan agak berat (misalnya, sangat sulit untuk mendapatkan batas-batas kesalahan pecahan disediakan & digunakan oleh metode dual pohon dan fungsi lainnya dalam KDE toolbox). Dengan demikian untuk saat ini kami telah meninggalkan IFGT terpisah, dengan alternatif kontrol untuk kompleksitas komputasi (Lihat di bawah, dan file “evalIFGT.m”).
Definisi kelas KDE Matlab
Konstruktor:
Accesor: (akses data, yang sangat terbatas atau tidak ada pengolahan req data)
Display: (visualisasi / Keterangan)
Statistics: (manfaat statistik & operasi di kde)
Mixture products: (NBP stuff) ( HANYA KERNEL GAUSSIAN)
BAB III Perangkat Lunak
Definisi MATLAB (Matrix Laboratory)
MATLAB (Matrix Laboratory) adalah sebuah program untuk menganalisis dan mengkomputasi data numerik, dan MATLAB juga merupakan suatu bahasa pemrograman matematika lanjutan, yang dibentuk dengan dasar pemikiran yang menggunakan sifat dan bentuk matriks.
Dikembangkan oleh The Mathwork Inc. yang hadir dengan fungsi dan karakteristik yang berbeda dengan bahasa pemrograman lain yang sudah ada lebih dahulu seperti Delphi, Basic maupun C++.
Pengenalan dan program aplikasi MATLAB (Matrix Laboratory)
Awalnya program aplikasi MATLAB ini merupakan suatu interface untuk koleksi rutin-rutin numerik dari proyek LINPACK dan EISPACK, dan dikembangkan dengan menggunakan bahasa FORTRAN, namun sekarang ini MATLAB merupakan produk komersial dari perusahaan Mathworks, Inc.
Yang selanjutnya dikembangkan dengan menggunakan bahasa C++ dan assembler. MATLAB telah berkembang menjadi sebuah environment pemprograman yang canggih yang berisi fungsi-fungsi built-in untuk melakukan tugas pengolahan sinyal, aljabar linier, dan kalkulasi matematis lainnya. MATLAB juga menyediakan berbagai fungsi untuk menampilkan data, baik dalam bentuk dua dimensi maupun dalam bentuk tiga dimensi.
MATLAB juga bersifat extensible, dalam arti bahwa seorang pengguna dapat menulis fungsi baru untuk menambahkan pada library, ketika fungsi-fungsi built-in yang tersedia tidak dapat melakukan tugas tertentu. Kemampuan pemrograman yang dibutuhkan tidak terlalu sulit bila kita telah memiliki pengalaman dalam pemrograman bahasa lain seperti C, PASCAL, atau FORTRAN. (sumber; http://www.mathworks.com)
MATLAB juga merupakan bahasa pemrograman tingkat tinggi berbasis pada matriks, sering digunakan untuk teknik komputasi numerik, yang kita gunakan untuk menyelesaikan masalah-masalah yang melibatkan operasi matematika elemen, matrik, optimasi, aproksimasi dll. Sehingga Matlab banyak digunakan pada :
• Matematika dan komputansi,
• Pengembangan dan algoritma,
• Pemrograman modeling, simulasi, dan pembuatan prototipe,
• Analisa data , eksplorasi dan visualisasi,
• Analisis numerik dan statistik,
• Pengembangan aplikasi teknik.
Matlab juga merupakan bahasa pemrograman computer berbasis window dengan orientasi dasarnya adalah matrik, namun tidak menutup kemungkinan program ini untuk pengerjaan permasalahan non matrik. Selain itu matlab juga merupakan bahasa pemrograman yang berbasis pada obyek (OOP), namun karena matlab bukanlah type compiler, maka program yang dihasilkan tidak dapat berdiri sendiri.
Agar hasil program dapat berdiri sendiri maka harus dilakukan transfer pada bahasa pemrograman yang lain, misalnya C++. Pada matlab terdapat tiga windows yang digunakan dalam operasinya yaitu ;
• Command windows (layar perintah)
• Figure windows (layar gambar),
• Note Pad (sebagai editor program).
Fungsi dari setiap window MATLAB
A. MATLAB Command window/editor
• MATLAB Command window/editor merupakan window yang muncul ketika kita membuka pertama kali setiap kita menjalankan aplikasi MATLAB,
• Pada window kita dapat melakukan akses-akses ke command-command MATLAB dengan mengetikkan barisan-barisan ekpresi MATLAB, seperti mengakses help window dan lain-lainnya.
• Command Window digunakan untuk menjalankan program/perintah yang dibuat pada layar editor matlab. Pada windows ini kita dapat mengakses perintah maupun komponen pendukung (help file dll) yang ada di matlab secara langsung. Salah satu cirri dari command windows ditandai dengan tanda prompt \left(\gg\right)
.
B. MATLAB Editor/Debugger (Editor M-File/Pencarian Kesalahan)
Window ini merupakan tool yang disediakan oleh Matlab 5 keatas. Berfungsi sebagai editor script Matlab (M-file). Meskipun sebenarnya script ini untuk pemrograman Matlab dapat saja menggunakan editor yang lain seperi notepad, wordpad dan bahkan word.
Untuk mengakses window m-file ini dapat kita lakukan dengan cara :
1. Memilih menu File – kemudian pilih New
2. Pilih m-file, maka MATLAB akan menampilkan editor window
Untuk menampilkan editor M-file selain dengan cara diatas, kita dapat juga melakukanya dengan cara :
\gg edit
C. Figure Windows
Window ini merupakan hasil visualisasi dari script Matlab. Namun Matlab memberi kemudahan bagi programer untuk mengedit window ini juga memberikan program khusus untuk itu. Sehingga selain berfungsi sebagai visualisasi output dapat juga sekaligus menjadi media input yang interaktif.
D. MATLAB help window
MATLAB juga menyediakan sistem help yang dapat diakses dengan perintah help. Misalnya, untuk memperoleh informasi mengenai fungsi elfun yaitu fungsi untuk trigonometri, eksponensial, complex dan lain-lain, maka kita hanya perlu mengetikkan perintah berikut :
\gg
help elfun
kemudian menekan enter maka di layar akan muncul informasi dalam bentuk teks pada layar MATLAB yaitu : Elementary math functions.
Trigonometric.
• sin – Sine.
• sinh – Hyperbolic sine.
• asin – Inverse sine.
• asinh – Inverse hyperbolic sine.
• cos – Cosine.
• cosh – Hyperbolic cosine.
• acos – Inverse cosine.
• acosh – Inverse hyperbolic cosine.
• tan – Tangent.
• tanh – Hyperbolic tangent.
• atan – Inverse tangent.
• atan2 – Four quadrant inverse tangent.
• atanh – Inverse hyperbolic tangent.
• sec – Secant.
• sech – Hyperbolic secant.
• asec – Inverse secant.
• asech – Inverse hyperbolic secant.
• csc – Cosecant.
• csch – Hyperbolic cosecant.
• acsc – Inverse cosecant.
• acsch – Inverse hyperbolic cosecant.
• cot – Cotangent.
• coth – Hyperbolic cotangent.
• acot – Inverse cotangent.
• acoth – Inverse hyperbolic cotangent.
Exponential.
• exp – Exponential.
• log – Natural logarithm.
• log10 – Common (base 10) logarithm.
• log2 – Base 2 logarithm and dissect floating point number.
• pow2 – Base 2 power and scale floating point number.
• sqrt – Square root.
• nextpow2 – Next higher power of 2.
Complex.
• abs – Absolute value.
• angle – Phase angle.
• complex – Construct complex data from real and imaginary parts.
• conj – Complex conjugate.
• imag – Complex imaginary part.
• real – Complex real part.
• unwrap – Unwrap phase angle.
• isreal – True for real array.
• cplxpair – Sort numbers into complex conjugate pairs.
Rounding and remainder.
• fix – Round towards zero.
• floor – Round towards minus infinity.
• ceil – Round towards plus infinity.
• round – Round towards nearest integer.
• mod – Modulus (signed remainder after division).
• rem – Remainder after division.
• sign – Signum.
Perintah yang sangat berguna untuk mempelajari pemrograman MATLAB yaitu intro, yang membahas konsep-konsep dasar tentang bahasa MATLAB. Selain itu juga terdapat banyak program demonstrasi yang mengilustrasikan berbagai kapabilitas MATLAB, yang dapat dimulai dengan perintah demo.
Atau untuk lebih lengkapnya dapat kita lihat di tampilan MATLAB, dengan cara memilih menu Window kemudian pilih help window, dan untuk mengetahui informasi yang ada maka dapat dilakukan dengan mengeklik dua kali info yang ada di MATLAB Help Window, atau dengan mengetikkan informasi yang ingin didapatkan pada sudut sebelah kiri MATLAB Help Window.
Fungsi pengaturan file dalam MATLAB :
• dir / ls : Digunakan untuk melihat isi dari sebuah direktori aktif.
• cd : Digunakan untuk melakukan perpindahan dari direktori aktif.
• pwd : Digunakan untuk melihat direktori yang sedang aktif.
• mkdir : Digunakan untuk membuat sebuah direktori.
• what : Digunakan untuk melihat nama file m dalam direktori aktif.
• who : Digunakan untuk melihat variabel yang sedang aktif.
• whos : Digunakan untuk menampilkan nama setiap variabel.
• delete : Digunakan untuk menghapus file.
• clear : Digunakan untuk menghapus variabel.
• clc : Digunakan untuk membersihkan layar.
• doc : Digunakan untuk melihat dokumentasi The MathWorks, Inc. dalam format html secara online.
• demo : Digunakan untuk mencoba beberapa tampilan demo yang disediakan oleh Matlab.
Fungsi help plot di command window
• Function subplot digunakan untuk membuat suatu figure dapat memuat lebih dari satu gambar. Perintah subplot didefinisikan sebagai :
subplot(n,m,i)
Perintah ini membagi suatu figure menjadi suatu matriks m x n area grafik dan i, berfungsi sebagai indeks penomoran gambar. Subplot dinomori dari kiri ke kanan dimulai dari baris teratas.
• Function title digunakan untuk memberi judul pada gambar. Input dari perintah title berupa string. Syntax title sebagai berikut :
title(‘string’)
• Function xlabel digunakan untuk memberi label sumbu pada sumbu x. Input dari perintah xlabel berupa string. Syntax xlabel sebagai berikut :
xlabel(‘string’)
• Function ylabel digunakan untuk memberi label sumbu y. Input dari perintah ylabel berupa string. Syntax ylabel sebagai berikut :
ylabel(‘string’)
• Function axis digunakan untuk mengatur nilai minimum dan maksimum dari sumbu x dan sumbu y , function axis didefinisikan sebagai :
axis([ xmin xmax ymin ymax ])
• Function grid digunakan untuk memberi grid pada gambar kita (sumber: http://dir.yahoo.com/science/mathematics/software/matlab)
\begin{verbatim}
Syntax-syintax dasar Matlab :
Operasi Dasar Matematika
+ = tambah = penjumlahan
– = kurang = pengurangan
* = perkalian (vektor) = perkalian (vektor)
.* = perkalian (skalar) = perkalian (skalar)
/ = bagi = pembagian
^ = pangkat = perpangkatan
Fungsi syintax-syintax lainya:
>> eye(N) = matrix identitas NxN
>> inv(A) = invers matrix A
>> det(A) = determinan matrix A
>> A’ = transpose matrix A
>> Pi = phi = 3.14
>> exp(a) = e^a
>> sin(a) = sinus sudut a dalam rad
>> sinh(a) = fungsi hiperbolik sinus
>> log(a) = ln a
>> log2(a) = 2log a
>> log10(a) = 10log a
Ex :Membuat Persamaan Matriks:
>> [1 2 ; 3 4] =
Ex : Membuat Persamaan Quadrat
>> tf([a b],[c d e]) =
>> zpk([a -b],[-c d],k) =
Ex : Mencari Integral Fungsi
>> syms a b t = definisi variabel a, b, t
>> int(x) = integral fungsi x
>> int(x,t,a,b) =
Ex : Perintah Lain-lain
>> i=1:1:10 = membuat deret 1 s/d 10
>> max(A) = nilai max. pada matrix A
>> clear = clear workspace
>> clc = clear command window
>> help
Ex : Membuat Grafik
>> plot(a,b) = plot a (sb x) dan b (sb y)
>> figure = menambah figure baru
>> hold on = menimpa gambar lama
>> hold off = membersihkan figure
>> plot (x,y,’–rs’,’Linewidth’,2,’MarkerEdgeColor’,’k’,’MarkerFaceColor’,’g’, ’MarkerSize’,2)
artinya : — garis putus-putus, r red, s square, tebal garis 2, warna garis kotak hitam, warna didalam kotak hijau, ukuran kotak 2.
Fitur FiturPada MATLAB
Fitur-fitur MATLAB sudah banyak dikembangkan, yang lebih kita kenal dengan nama toolbox. Sangat penting bagi pengguna Matlab, toolbox mana yang mendukung untuk learn dan apply technologi yang sedang dipelajarinya. Toolbox tersebut merupakan kumpulan dari fungsi-fungsi MATLAB (M-files) yang dikembangkan ke suatu lingkungan kerja MATLAB untuk memecahkan masalah dalam kelas particular.
Area-area yang sudah dapat dipecahkan dengan toolbox saat ini meliputi pengolahan sinyal, system kontrol, neural networks, fuzzy logic, wavelets, dan lain-lain. Selain toolbox, matlab juga dilengakapi dengan Simulink yang sangat powerfull untuk mensimulasikan dan menyelesaikan masalah – masalah yang berhubungan dengan Pemodelan Matematika. Dengan Simulink, kita dapat dengan mudah mengecek kestabilan suatu model Matematika. Sebagai sebuah sistem, MATLAB tersusun dari 5 bagian utama:
1.Development Environment.
Merupakan sekumpulan perangkat yang membantu anda untuk menggunakan fungsi-fungsi dan file-file MATLAB. Perangkat ini merupakan sebuah graphical user interfaces (GUI). Termasuk di-dalamnya adalah MATLAB desktop dan Command Window, command history, sebuah editor dan debugger, dan browsers untuk melihat help, workspace, files, dan search path.
2.MATLAB Mathematical Function Library.
Merupakan sekumpulan algoritma komputasi mulai dari fungsi-fungsi dasar seperti: sum, sin, cos, dan complex arith-metic, sampai dengan fungsi-fungsi yang lebih komplek seperti matrix inverse, ma-trix eigenvalues, Bessel functions, dan fast Fourier transforms.
3.MATLAB Language.
Merupakan suatu high-level matrix/array language dengan control flow statements, functions, data structures, input/output, dan fitur-fitur object-oriented programming. Yang memungkinkan bagi kita untuk melakukan kedua hal baik “pemrograman dalam lingkup sederhana” untuk hasil yang cepat, dan “pemrograman dalam lingkup yang lebih besar” untuk hasil dan aplikasi yang komplek.
4.Graphics.
MATLAB memiliki fasilitas untuk menampilkan vector dan matrik sebagai suatu grafik. Di dalamnya melibatkan high-level functions (fungsi-fungsi level tinggi) untuk visualisasi data dua dimensi dan data tiga dimensi, image processing, animation, dan graphics presentation.Ini juga melibatkan fungsi level rendah yang memungkinkan bagi anda untuk membiasakan diri untuk memunculkan grafik mulai dari bentuk yang sederhana sampai dengan tingkatan graphical userinterfaces (GUI).
5.MATLAB Application Program Interface (API)
Merupakan suatu library yang memungkinkan program yang telah ditulis dalam bahasa C dan Fortran mampu berinterakasi dengan MATLAB. Melibatkan fasilitas untuk pemanggilan routines dari MATLAB (dynamic linking), pemanggilan MATLAB sebagai computational engine, dan membaca serta menuliskan MAT-files.
Memulai MATLAB
JIka computer sudah terinstal program Matlab, maka kita dapat dengan mudah membuka program Matlab. Dengan cara klik Menu Start pada Desktop, kemudian pilih All Program, lalu pilih program Matlab sesuai dengan versi yang sudah terinstal atau klik 2 kali pada shortcut program Matlab pada Desktop. Tampilan program Matlab seperti gambar di bawah ini :
Untuk percobaan pertama, kita akan membuat 2 variabel yakni panjang dan lebar dengan nilai tertentu. Kemudian akan di cari Luas dari 2 variabel yang disimpan tersebut.
>>panjang=10 (lalutekan “enter”)
panjang =
10
>>lebar=5
lebar =
5
>>Luas=panjang*lebar
Luas =
50
>> Untuk percobaan kedua, akan dicoba operasi matrik. Operasi yang akan dicoba adalah operasi penambahan.
>> a=[1 2 3 4]
a =
1 2 3 4
>> b=[8 7 6 5]
b =
8 7 6 5
>> c=a+b
c =
9 9 9 9
>> Untuk percobaan ketiga, akan dicoba program yang memanfaatkan fungsi – fungsi bawaan Matlab seperti Sinus, Cosinus, dan pi. Selain itu juga akan dicoba perintah dengan menambahkan;
Yang berfungsi untuk menyembunyikan hasil yang baru saja dikerjakan dengan Matlab.
>> A=pi/6;
>> sin(A)
ans =0.5000
>>cos(A)
ans =0.8660>>
BAB IV Contoh Kasus Pemanfaatan Perangkat Lunak
CONTOH KASUS 1
Jodi ingin mengajak Dina makan di restoran. Sebelum berangkat dinner, Jodi ingin membagi kebahagiaannya pada malam ini kepada pelayan restoran dengan memberikan uang tip. Dia akan memberikan uang tip sebesar 5-25% dari total belanjanya. Besarnya uang TIP akan dilihat dari kualitas MAKANAN (food) dan tingkat PELAYANAN(service). Bantulah Jodi untuk memutuskan besarnya uang tip yang akan diberikan kepada pelayan restoran, jika setelah menikmati hidangan dan fasilitas PELAYANAN Jodi memberi nilai, sebagai berikut :
PELAYANAN = 7
MAKANAN = 8
Penilaian PELAYANAN dan MAKANAN berada pada rentang nilai 0-10. Ingat, kisaran uang tip adalah 5 – 25%.
Adapun aturan pemberian tip yg ditetapkan oleh Jodi adalah sebagai berikut:
1. Jika PELAYANAN Jelek ATAU MAKANAN Tengik, maka TIP Murah
2. Jika PELAYANAN Sedang, maka TIP Standar
3. Jika PELAYANAN Bagus ATAU MAKANAN Lezat, maka TIP Mahal
Pembahasan:
Dapat kita simpulkan bahwa pasangan input-output dari kasus kita adalah sebagai berikut :
• INPUT: PELAYANAN (Jelek, Sedang, Bagus) dan MAKANAN (Tengik, Lezat)
• OUTPUT: TIP (Murah, Standar, Mahal)
Tahapan dalam desain fuzzy menggunakan bahasa pemrograman memiliki kemiripan dengan desain fuzzy menggunakan FIS Editor. Langkah awal adalah mendefinisikan apaa saja yang menjadi pasangan input dan output beserta fungsi keanggotaannya masing-masing. Pertama, kita buat nama file FIS kita. Langkah ini menggunakan sintaks newfis. FIS berarti Fuzzy Inference Systems. Misalkan saat ini kita beri nama projek kita DinnerForTwo.
a=newfis(‘DinnerForTwo’);
Selanjutnya, definisikan input pertama kita, yaitu PELAYANAN, yang memiliki rentang antara 0 sampai 10. Gunakanlah sintaks addvar.
a=addvar(a,’input’,’PELAYANAN’,[0 10]);
Tambahkan semua fungsi keanggotaan yang menyusun variabel input PELAYANAN. Misalkan kita beri nama jenis pelayanan berupa Jelek, Sedang, dan Bagus. Setiap fungsi keanggotaan harus dilengkapi dengan parameter pembentuknya. Karena berupa segitiga (trimf), maka wajib memiliki tiga input parameter, yaitu titik awal, puncak dan titik akhir. Untuk menambahkan fungsi keanggotaan (membership function), gunakanlah sintaks addmf.
a=addmf(a,’input’,1,’Jelek’,’trimf’,[-404]);
a=addmf(a,’input’,1,’Sedang’,’trimf’,[159]);
a=addmf(a,’input’,1,’Bagus’,’trimf’,[6 10 14]);
Untuk memastikan bagaimana bentuk dari input PELAYANAN dan masing-masing fungsi keanggotaannya, dapat kita plot dengan sintaks plotmf, sebagai berikut: plotmf(a,’input’,1)
Hasilnya tampak seperti berikut:
Gambar 1. Fungsi Keaanggotaan Input PELAYANAN
Lakukan hal yang sama untuk variabel input kedua, yaitu MAKANAN. MAKANAN memiliki rentang yang sama dengan PELAYANAN, yaitu dari 0 sampai dengan 10. Khusus untuk MAKANAN, fungsi keanggotaan yang dibentuk menggunakan keanggotaan trapesium (trapmf). Input parameter yang digunakan sebanyak empat titik, yaitu titik awal, titik puncak pertama, titik puncak kedua, dan titik akhir. Logikanya sama persis dengan bagaimana menggambarkan sebuah segitiga, hanya parameternya yang berbeda.
a=addvar(a,’input’,’MAKANAN’,[010]);
a=addmf(a,’input’,2,’Tengik’,’trapmf’,[0013]);
a=addmf(a,’input’,2,’Lezat’,’trapmf’,[7 9 10 10]);
Untuk melihat hasilnya, kita gunakan sintaks berikut: figure; plotmf(a,’input’,2)
Gambar 2. Fungsi Keaanggotaan Input MAKANAN
Definisi input beserta fungsi keanggotaannya telah selesai. Sekarang, saatnya kita buat untuk fungsi output, yaitu TIP. Langkahnya mirip dengan definisi kedua input tadi.
a=addvar(a,’output’,’TIP’,[030]);
a=addmf(a,’output’,1,’Murah’,’trimf’,[0510]);
a=addmf(a,’output’,1,’Standar’,’trimf’,[101520]);
a=addmf(a,’output’,1,’Mahal’,’trimf’,[20 25 30]);
Mari kita lihat hasilnya: figure; plotmf(a,’output’,1)
Gambar 3. Fungsi Keaanggotaan output TIP
Setelah pasangan input-output terdefinisi, langkah selanjutnya adalah menyusun aturan-aturan yang berlaku dalam sistem fuzzy kita.Penulisan aturan ini perlu diperhatikan dengan baik.Sebab, penulisannya berupa matriks, dan kesalahan kecil dapat berakibat sistem tidak sesuai yang kita inginkan. Jika kita memiliki m input dan n output, maka matriks yang disusun harus memiliki kolom m+n+2. Sebagai contoh jika kita merujuk pada kasus kita, maka kita memiliki dua input (PELAYANAN dan MAKANAN), dan satu output (TIP). Dengan demikian, total kolom yang digunakan adalah 2+1+2 = 5. Nilai m kolom pertama mewakili indeks dari input kita. Contoh, jika input PELAYANAN memiliki anggota: Jelek, Sedang dan Bagus, maka indeks 1 mewakili jelek, indeks 2 mewakili Sedang, dan indeks 3 meakili Bagus. Nilai n kolom berikutnya adalah indeks dari output kita. Nilai kolom m+n+1 mewakilipembobotan dari aturan kita.Bobot ini memiliki nilai antara 0 – 1.Umumnya, nilai ini kita biarkan menjadi 1.Nilai kolomm+n+1 mewakili operator dalam aturan fuzzy. Nilai 1 akan mewakili logika AND, sedangkan nilai 2 mewakili OR.
Aturan1: Jika PELAYANAN Jelek ATAU MAKANAN Tengik, maka TIP Murah aturan1 = [1 1 1 1 2];
Aturan2: Jika PELAYANAN Sedang, maka TIP Standar aturan2 = [2 0 2 1 0]; %
Aturan3: Jika PELAYANAN Bagus ATAU MAKANAN Lezat, maka TIP Mahal aturan3 = [3 2 3 1 2];
gabungkan semua aturan tersebut dengan sintaks: listAturan = [aturan1;aturan2;aturan3]; a = addrule(a,listAturan);
Untuk memastikan apakah aturan kita telah benar, mari gunakan sintaks berikut yang dieksekusi melalui Command Window: >>showrule(a)
ans =
1.If (PELAYANAN is Jelek) or (MAKANAN is Tengik) then (TIP is Murah) (1)
2.If (PELAYANAN is Sedang) then (TIP is Standar) (1)
3. If (PELAYANAN is Bagus) or (MAKANAN is Lezat) then (TIP is Mahal) (1)
Sekarang, kita sudah di penghujung pemrograman kita. Pada langkah terakhir, kita akan melakukan evaluasi hasil akhir dari sistem fuzzy kita. Seperti yang telah kita ketahui bahwa nilai PELAYANAN = 7, dan MAKANAN = 8
gunakalah sintaks evalfis, sebagai berikut:
>> evalfis([7 8], a) ans = 19.9980
Nilainya sama dengan menggunakan penurunan matematis dan FIS Editor, yaitu sebesar 20%.
Berikut koding selengkapnya:
1. Buatlah variabel FIS a=newfis(‘DinnerForTwo’);
2. Tambahkan input PELAYANAN a=addvar(a,’input’,’PELAYANAN’,[0 10]);
3. Tambahkan fungsi keanggotaan PELAYANAN: Jelek, Sedang, Bagus
4. a=addmf(a,’input’,1,’Jelek’,’trimf’,[-4 0 4]);
5. a=addmf(a,’input’,1,’Sedang’,’trimf’,[1 5 9]);
6. a=addmf(a,’input’,1,’Bagus’,’trimf’,[6 10 14]);
7. plot input PELAYANAN utk melihat hasilnya plotmf(a,’input’,1)
8. Tambahkan input MAKANAN
9. a=addvar(a,’input’,’MAKANAN’,[0 10]);
10. Tambahkan fungsi keanggotaan MAKANAN: Tengik, Lezat
11. a=addmf(a,’input’,2,’Tengik’,’trapmf’,[0 0 1 3]);
12. a=addmf(a,’input’,2,’Lezat’,’trapmf’,[7 9 10 10]);
13. plot input MAKANAN utk melihat hasilnya figure; plotmf(a,’input’,2)
14. Tambahkan output TIP
15. a=addvar(a,’output’,’TIP’,[0 30]);
16. Tambahkan fungsi keanggotaan TIP: Murah, Standar, Mahal
17. a=addmf(a,’output’,1,’Murah’,’trimf’,[0 5 10]);
18. a=addmf(a,’output’,1,’Standar’,’trimf’,[10 15 20]);
19. a=addmf(a,’output’,1,’Mahal’,’trimf’,[20 25 30]);
20. plot output TIP utk melihat hasilnya figure; plotmf(a,’output’,1)
21. Sekarang masukkan aturan-aturan
22. Aturan1: Jika PELAYANAN Jelek ATAU MAKANAN Tengik, maka TIP Murah
23. aturan1 = [1 1 1 1 2];
24. Aturan2: Jika PELAYANAN Sedang, maka TIP Standar
25. aturan2 = [2 0 2 1 0];
26. Aturan3: Jika PELAYANAN Bagus ATAU MAKANAN Lezat, maka TIP Mahal
27. aturan3 = [3 2 3 1 2];
28. Padukan semua aturan listAturan = [aturan1;aturan2;aturan3];
29. a = addrule(a,listAturan);
30. Perlihatkan aturan, apakah sudah sesuai?
31. showrule(a);
32. Lakukan evaluasi untuk PELAYANAN = 7 dan MAKANAN = 8
33. evalfis([7 8], a)
CONTOH KASUS 2
Pembahasan terkait logika fuzzy adalah untuk menyelesaikan permasalah suatu sistem yang sulit dimodelkan secara matematis.Untuk belajar tentang logika fuzzy membutuhkan tool untuk dapat menerapkan logika tersebut.Salah satu tool yang mudah dan umum digunakan adalah dengan menggunakan Matlab Fuzzy Logic Toolbox.Pada aplikasi logika fuzzy menggunakan Matlab ini yang perlu dipahami adalah bagian-bagian yang ada pada logika fuzzy.Bagian tersebut adalah fuzzifikasi, rule evaluasi dan defuzzyfikasi.
Langkah-langkah untuk membuat logika fuzzy pada Matlab adalah :
1. Buka program Matlab, dan ketik pada command window >> fuzzy.
2. Instruksi tersebut akan menampilkan fuzzy toolbox, seperti gambar dibawah ini :
3. Pada langkah ini, tentukan jumlah input dari fuzzy toolbox, dalam hal ini akan digunakan 2 buah input, caranya adalah pilih menu Edit > Add Variable pilih Input.
4. Dalam kasus disini akan diambil, tentang sistem penerimaan karyawan dimana inputnya adalah hasil tes potensi akademik dan psikologi.
5. Letakkan kursor pada kotak input 1 dan double click pada kotak tersebut atau pilih Edit > Membership Functions.
6. Atur Input 1 Range = 0..100, untuk MBF 1 : Name = Rendah, Type = trapmf (trapesium membership function), params = [0 0 20 50]. MBF2 : Name = Sedang, Type = trimf (triangle membership function), params = [20 50 80]. MBF 3 Name =Tinggi, Type = trapmf , params = [50 80 100 100]. Detail hasilnya seperti gambar dibawah ini :
7. Klik kotak input 2 dan ulangi langkah no.6.
8. Klik kotak output untuk mengatur nilai membership functions pada output.
9. Atur Range = 0..100, untuk MBF 1 : Name = Ditolak, Type = trapmf , params = [0 0 20 40]. MBF2 : Name = Dipertimbangkan, Type = trapmf, params = [10 40 60 90]. MBF 3 Name = Diterima, Type = trapmf , params = [60 80 100 100]. Detail hasilnya seperti gambar dibawah ini :
10. Setelah semua mbf input maupun output diatur sesuai dengan kebutuhan maka pengaturan terakhir adalah bagian rule evaluasi atau aturan fuzzy, caranya pilih menu Edit > Rules, deatil caranya seperti gambar dibawah ini :
11. Pada contoh kasus untuk sistem penerimaan karyawan disini rule evaluasinya adalah seperti ditunjukkan gambar dibawah ini, untuk mendapatkan rule evaluasi seperti ini adalah dengan memilih pasangan rule evaluasi untuk pasangan input 1, input 2 dan output. Caranya adalah pilih input 1,input 2 dan output kemudian klik Add rule, apabila terjadi kesalahan pilih rule evaluasi kemudian klik Delete rule.
12. Setelah selesai semua, pilih menu View > Rule.
13. Hasil dari sistem yang dibangun menggunakan fuzzy dapat, pada contoh kasus penerimaan karyawan ini adalah seperti gambar dibawah ini. Apabila ingin melihat hasil output logika
fuzzy, makagaris merah pada input 1 dan input 2 dapat digeser yang otomatis nilai output akan berubahmengikuti nilai-nilai input tersebut.
Pada buku ini nilai range, nilai mbf, type mbf dan susunan rule evaluasi hanya sebuah contoh kasus untuk sistem penerimaan karyawan dari dua jenis test. Jika dibuat dalam bentuk sistem yang berbeda perlu adanya penyesuaian komponen yang membangun logika fuzzy tersebut. Aplikasi logika fuzzy dengan menggunakan Matlab Fuzzy Toolbox sangat membantu bagi mereka yang baru belajar.Logika fuzzy sebagai pemrosesan disini berguna untuk membantu tugas dari manusia dimana tugas yang dibangun menggunakan sistem ini terkadang sulit untuk dibuat model matematisnya. Pada prakteknya sistem logika fuzzy ini akan ditanamkan dalam sebuah mesin, mesin yang dimaksud disini adalah komputer. Padahal tidak semua mesin yang dipergunakan berwujud komputer, bisa jadi dalam bentuk smartphone, microcomputer, microcontroller dan embedded system yang lain.
Contoh soal
Kami mengambil ilustrasi sintetis bivariat set data 50 poin untuk menggambarkan pembangunan histogram. Ini membutuhkan pilihan titik anchor (sudut kiri bawah histogram grid). Untuk histogram di sebelah kiri, kita pilih (-1.5, -1.5): untuk yang di sebelah kanan, kita menggeser titik anchor oleh 0.125 di kedua arah ke (-1,625, -1,625). Kedua histogram memiliki binwidth 0,5, sehingga setiap perbedaan adalah karena perubahan titik anchor saja. Warna-coding menunjukkan jumlah titik data yang jatuh ke dalam bin: 0 = putih, 1 = kuning pucat, 2 = kuning cerah, 3 = orange, 4 = merah. Histogram meninggalkan tampaknya menunjukkan bahwa bagian atas memiliki kepadatan lebih tinggi dari bagian bawah, sedangkan itu adalah sebaliknya adalah kasus untuk histogram kanan, mengkonfirmasikan bahwa histogram sangat sensitif terhadap penempatan titik jangkar.
Perbandingan histogram 2D. Kiri. Histogram dengan anchor titik di (-1,5, -1,5). Kanan. Histogram dengan anchor titik di (-1,625, -1,625). Kedua histogram memiliki lebar bin 0,5, sehingga perbedaan penampilan dari dua histogram adalah karena penempatan titik anchor.
Salah satu solusi untuk anchor masalah penempatan titik ini adalah untuk menghapus histogram Binning jaringan sepenuhnya. Pada gambar sebelah kiri bawah, kernel (diwakili oleh garis-garis abu-abu) berpusat di masing-masing 50 poin data di atas. Hasil menjumlahkan kernel ini diberikan pada sosok yang tepat, yang merupakan estimasi densitas kernel. Perbedaan yang paling mencolok antara perkiraan kepadatan kernel dan histogram adalah bahwa mantan lebih mudah untuk menafsirkan karena mereka tidak mengandung artifices disebabkan oleh grid Binning. Kontur berwarna sesuai dengan wilayah terkecil yang berisi massa probabilitas masing: merah = 25%, orange + merah = 50%, kuning + orange + merah = 75%, yang mengindikasikan bahwa wilayah pusat tunggal mengandung kepadatan tertinggi.
Pembangunan estimasi densitas kernel 2D. Kiri. Kernel individu. Kanan. Kernel density perkiraan.
Tujuan dari estimasi kepadatan adalah untuk mengambil sampel terbatas data dan membuat kesimpulan tentang mendasari fungsi kepadatan probabilitas di mana-mana, termasuk di mana tidak ada data yang diamati. Dalam estimasi densitas kernel, kontribusi masing-masing titik data merapikan dari satu titik ke daerah ruang sekitarnya. Menggabungkan kontribusi merapikan individual memberikan gambaran keseluruhan dari struktur data dan fungsi densitasnya. Dalam rincian untuk mengikuti, kita menunjukkan bahwa pendekatan ini mengarah ke perkiraan yang wajar dari fungsi kepadatan yang mendasari.
Definisi
Angka sebelumnya adalah representasi grafis dari kepadatan kernel estimasi, yang sekarang kita mendefinisikan secara tepat. Biarkan x 1, x 2, …, x n menjadi sampel dari d -variate vektor acak diambil dari distribusi yang umum dijelaskan oleh fungsi kepadatan f
. Estimasi densitas kernel didefinisikan sebagai
\overset{\mathcircumflex}{f}_{H}\left(X\right)=\frac{1}{n}\stackrel{[}{i}=1]{n}{\sum}K_{H}\left(x-x_{i}\right)
dimana
• x = (x 1, x 2, …, x d)^{T}
, x i = (x i 1, x i 2, …, x id)^{T}
, i = 1, 2, …, n yang d -vectors;
• H adalah bandwidth (atau smoothing) d × d matriks yang simetris dan definit positif;
• K adalah kernel fungsi yang kepadatan multivariat simetris;
• K H (x) = | H | -1/2 K (H -1/2 x).
Pilihan fungsi kernel K tidak penting untuk keakuratan estimator densitas kernel, jadi kami menggunakan standar multivariat yang normal kernel seluruh: K\left(x\right)=\left(2\pi\right)^{-d/2}exp\left(-1/2x^{t}x\right)
di mana H memainkan peran matriks kovarians. Di sisi lain, pilihan bandwidth matriks H adalah faktor paling penting yang mempengaruhi akurasi sejak itu mengontrol jumlah dan orientasi Smoothing diinduksi. [5]: 36-39 Bahwa matriks bandwidth yang juga menginduksi orientasi adalah dasar Perbedaan antara estimasi densitas kernel multivariat dari analog univariat sejak orientasi tidak didefinisikan untuk 1D kernel. Hal ini menyebabkan pilihan dari parametrisation bandwidth matriks ini. Tiga kelas parametrisation utama (dalam rangka meningkatkan kompleksitas) adalah S, kelas skalar positif kali matriks identitas; D, matriks diagonal dengan entri positif pada diagonal utama; dan F, simetris matriks definit positif. Kernel kelas S memiliki jumlah yang sama dari smoothing diterapkan dalam semua arah koordinat, D kernel memungkinkan jumlah yang berbeda dari smoothing di setiap koordinat, dan F kernel memungkinkan jumlah sewenang-wenang dan orientasi smoothing tersebut. Historis S dan D kernel yang paling luas karena alasan komputasi, tetapi penelitian menunjukkan bahwa keuntungan penting dalam akurasi dapat diperoleh dengan menggunakan lebih umum kernel kelas F. [6] [7]
Perbandingan dari tiga kelas parametrisation bandwith matriks utama. Meninggalkan S. Kali skalar positif matriks identitas. Pusat. Matriks diagonal D dengan entri positif pada diagonal utama. Tepat. F simetris matriks definit positif.
Temukan bandwidth yang optimal matriks
Kriteria optimalitas yang paling umum digunakan untuk memilih matriks bandwidth MISE atau berarti terintegrasi kesalahan kuadrat MISE\left(H\right)=E\left[\int\left(\overset{\mathcircumflex}{f}_{H}\left(x\right)-f\left(x\right)\right)^{2}dx\right].
Ini pada umumnya tidak memiliki sebuah ekspresi bentuk tertutup, sehingga sangat biasa untuk menggunakan pendekatan asimtotik nya (AMISE) sebagai proxy
AMISE\left(H\right)=n^{-1}\mid H\mid^{-1/2}R\left(K\right)+\frac{1}{4}m_{2}\left(K\right)^{2}\left(vec^{T}H\right)\varPsi_{4}\left(vecH\right)
dimana
• R (K) = \int
K \left(x\right)^{2}
dx, dengan R (K) = \left(4\pi\right)^{-d/2}
ketika K adalah kernel yang normal
• \int xx^{T}K\left(x\right)dx=m_{2}\left(K\right)I_{d}
dengan I_{d}
menjadi d x d matriks identistas, dengan m_{2}=
1 untuk kernel yang normal
• D^{2}f
adalah d × d Hessian matriks urutan kedua turunan parsial dari f
• \psi_{4}=\int\left(vecD^{2}f\left(x\right)\right)\left(vec^{T}D^{2}f\left(x\right)\right)dx
adalah d^{2}
x d^{2}
matriks agar keempat derivatif parsial terpadu f
• vec adalah operator vektor yang tumpukan kolom dari suatu matriks menjadi vektor tunggal misalnya vec\left[\begin{array}{cc}
a & c\\
b & d
\end{array}\right]=\left[\begin{array}{cccc}
a & b & c & d\end{array}\right]^{T}.
Kualitas pendekatan AMISE untuk MISE yang [5]: 97 diberikan oleh
MISE\left(H\right)=AMISE\left(H\right)+o\left(n^{-1}\mid H\mid^{-1/2}+trH^{2}\right)
di mana o menunjukkan biasa notasi o kecil. Heuristik pernyataan ini menyiratkan bahwa AMISE adalah ‘baik’ pendekatan dari MISE sebagai ukuran sampel n \rightarrow\infty
.
Hal ini dapat ditunjukkan bahwa setiap bandwidth yang wajar pemilih H memiliki H = O (n^{-2/\left(d+4\right)}
)) dimana notasi O besar diterapkan elementwise. Mengganti ini ke dalam hasil rumus MISE bahwa MISE optimal adalah O (n^{-4/\left(d+4\right)}
)). [5]: 99-100 demikian sebagai n \rightarrow\infty
, MISE yang \rightarrow
0, yaitu estimasi kepadatan kernel konvergen di berarti persegi dan dengan demikian juga dalam probabilitas untuk benar kepadatan f
. Mode konvergensi adalah konfirmasi pernyataan di bagian motivasi bahwa metode kernel menyebabkan estimator densitas wajar. Pemilih bandwidth yang optimal ideal adalah
H_{AMISE}=argmin_{H\epsilon F}AMISE\left(H\right).
Sejak pemilih yang ideal ini berisi diketahui fungsi kepadatan ƒ, tidak dapat digunakan secara langsung. Banyak jenis yang berbeda dari berbasis bandwidth data pemilih timbul dari estimator berbeda AMISE tersebut. Kami berkonsentrasi pada dua kelas selektor yang telah terbukti menjadi yang paling banyak diterapkan dalam praktek: merapikan lintas validasi dan plug-in pemilih.
Plug-in
Plug-in (PI) perkiraan AMISE yang dibentuk dengan mengganti \varPsi_{4}
oleh estimator yang \varPsi_{4}
PI\left(H\right)=n^{-1}\mid H\mid^{-1/2}R\left(K\right)+\frac{1}{4}m_{2}\left(K\right)^{2}\left(vec^{T}H\right)\varPsi_{4}\left(G\right)\left(vecH\right)
dimana \varPsi_{4}\left(G\right)=n^{-2}\stackrel{[}{i}=1]{n}{\sum}\stackrel{[}{i}=1]{n}{\sum}\left[\left(vecD^{2}\right)\left(vec^{T}D^{2}\right)\right]K_{G}\left(X_{i}-X_{j}\right)
demikian H_{PI}=argmin_{H\epsilon F}PI\left(H\right)
adalah plug-in pemilih. [8][9] referensi ini juga mengandung algoritma estimasi optimal dari matriks percontohan bandwith G dan menetapkan bahwa \overset{\mathcircumflex}{H}_{PI}
konvergen dalam probabilitas untuk H_{AMISE}
.
Merapikan lintas validasi
Merapikan lintas validasi (SCV) adalah bagian dari kelas yang lebih besar dari validasi silang teknik. The SCV estimator berbeda dari plug-in estimator dalam jangka kedua
SCV\left(H\right)=n^{-1}\mid H\mid^{-1/2}R\left(K\right)+n^{-2}\stackrel{[}{i}=1]{n}{\sum}\stackrel{[}{i}=1]{n}{\sum}\left(K_{2H+2G}-2K_{H+2G}+K_{2G}\right)\left(X_{i}-X_{j}\right)
Demikian adalah pemilih \overset{\mathcircumflex}{H}_{SCV}=argmin_{H\epsilon F}SCV\left(H\right)
adalah pemilih SCV. [9] [10] referensi ini juga mengandung algoritma estimasi optimal dari matriks percontohan bandwith G dan menetapkan bahwa \overset{\mathcircumflex}{H}_{SCV}
konvergen dalam probabilitas untuk H_{AMISE}
.
Rule of thumb
Aturan Silverman praktis menyarankan menggunakan \sqrt{H_{ii}}=\left(\frac{4}{d+2}\right)^{\frac{1}{d+4}}n\frac{-1}{d+4}\sigma_{i}
dimana \sigma
adalah standar deviasi dari variabel i dan H_{ij}=0,i\neq j
. Aturan Scott adalah \sqrt{H_{ii}}=n\frac{-1}{d+4}\sigma_{i}
Analisis asymptotic
Pada bagian pilihan bandwidth yang optimal, kami memperkenalkan MISE tersebut. Pembangunannya bergantung pada nilai yang diharapkan dan varians dari estimator densitas [5]: 97
E\overset{\mathcircumflex}{f}\left(x;H\right)=K_{H}*f\left(x\right)=f\left(x\right)+\frac{1}{2}m_{2}\left(K\right)\int tr\left(HD^{2}f\left(x\right)\right)dx+O\left(trH^{2}\right)
dimana * adalah lilitan Operator antara dua fungsi dan
Var\overset{\mathcircumflex}{f}\left(x;H\right)=n^{-1}\mid H\mid^{-1/2}R\left(K\right)+o\left(n^{-1}\mid H\mid^{-1/2}\right).
Selama dua ekspresi ini harus didefinisikan dengan baik, kami mengharuskan semua elemen H cenderung 0 dan n^{-1}\mid H\mid^{-1/2}
cenderung 0 sebagai n cenderung tak terhingga. Dengan asumsi kedua kondisi ini, kita melihat bahwa nilai yang diharapkan cenderung kepadatan f benar yaitu estimator densitas kernel adalah asimtotik berisi; dan bahwa varians cenderung nol. Menggunakan standar berarti kuadrat dekomposisi nilai
MSE\overset{\mathcircumflex}{f}\left(x;H\right)=Var\overset{\mathcircumflex}{f}\left(x;H\right)+\left[E\overset{\mathcircumflex}{f}\left(x;H\right)-f\left(x\right)\right]^{2}
kita memiliki bahwa MSE cenderung 0, menyiratkan bahwa estimator densitas kernel (mean square) yang konsisten dan karenanya konvergen dalam probabilitas untuk benar kepadatan f. Tingkat konvergensi dari MSE untuk 0 adalah tentu sama dengan tingkat MISE dicatat sebelumnya O\left(n^{-4/\left(d+4\right)}\right)
maka tingkat covergence dari estimator densitas untuk f adalah O_{p}\left(n^{-2/\left(d+4\right)}\right)
di mana O p menunjukkan urutan probabilitas. Ini menetapkan konvergensi pointwise. The covergence fungsional didirikan sama dengan mempertimbangkan perilaku MISE, dan mencatat bahwa di bawah keteraturan yang cukup, integrasi tidak mempengaruhi tingkat konvergensi.
Untuk pemilih berbasis bandwidth-data yang dianggap, target adalah matriks bandwidth yang AMISE. Kami mengatakan bahwa pemilih berbasis data yang konvergen ke pemilih AMISE di relatif tingkat O_{p}\left(n^{-a}\right),a>0
jika
vec\left(\overset{\mathcircumflex}{H}-H_{AMISE}\right)=O\left(n^{-2a}\right)vecH_{AMISE}.
Telah ditetapkan bahwa plug-in dan merapikan penyeleksi lintas validasi (diberikan pilot bandwith G tunggal) baik berkumpul pada tingkat relatif O_{p}\left(n^{-2/\left(d+6\right)}\right)
[9] [11] yaitu, baik selektor berbasis data ini estimator konsisten.
Estimasi kepadatan dengan matriks bandwidth penuh
Old Faithful Geyser kernel Data kepadatan estimasi dengan plug-in bandwith matriks.
The ks paket [12] di R mengimplementasikan plug-in dan merapikan penyeleksi validasi silang (antara lain). Dataset ini (termasuk dalam distribusi dasar R) mengandung 272 catatan dengan dua pengukuran setiap: waktu durasi letusan (menit) dan waktu menunggu sampai letusan berikutnya (menit) dari Old Faithful Geyser di Yellowstone National Park, Amerika Serikat .
Kode fragmen menghitung estimasi kepadatan kernel dengan bandwidth matriks plug-in
\overset{\mathcircumflex}{H}_{PI}=\left[\begin{array}{cc}
0.052 & 0.510\\
0.510 & 8.882
\end{array}\right]
. Sekali lagi, kontur berwarna sesuai dengan wilayah terkecil yang berisi massa probabilitas masing: merah = 25%, orange + merah = 50%, kuning + orange + merah = 75%. Untuk menghitung pemilih SCV, H_{pi}
diganti dengan H_{SCV}
Ini tidak ditampilkan di sini karena sebagian besar mirip dengan plug-in estimasi untuk contoh ini.
perpustakaan (ks)
Data (setia)
H <- Hpi (x = setia)
fhat <- kde (x = setia, H = H)
plot (fhat, display = “filled.contour2”)
poin (setia, CEX = 0,5, pch = 16)
Estimasi kepadatan dengan bandwidth matriks diagonal
Kernel density estimasi dengan bandwidth yang diagonal untuk data campuran yang normal sintetik.
Kami mempertimbangkan memperkirakan kepadatan campuran Gaussian \left(4\pi\right)^{-1}
exp \left(-1/2\left(x_{1}^{2}+x_{2}^{2}\right)\right)+\left(4\pi\right)^{-1}
exp \left(-1/2\left(\left(x_{1-3,5}\right)^{2}+x_{2}^{2}\right)\right)
, dari 500 acak poin. Kami mempekerjakan rutin Matlab untuk Data 2-dimensi. Rutin ini merupakan metode seleksi bandwidth yang otomatis yang dirancang khusus untuk urutan kernel Gaussian kedua. [13] Angka ini menunjukkan estimasi kepadatan gabungan yang dihasilkan dari menggunakan bandwidth otomatis dipilih.
Matlab skrip misalnya -1/2,
Ketik perintah berikut di Matlab setelah men-download dan menyimpan kde2d.m fungsi dalam direktori saat ini.
jelas semua
% Menghasilkan data sintetik
Data = [randn (500, 2);
randn (500, 1) + 3.5, randn (500, 1);];
% Memanggil rutin, yang telah disimpan di direktori saat ini
[Bandwidth, kepadatan, X, Y] = kde2d (data);
% Plot data dan estimasi kerapatan
contour3 (X, Y, kepadatan, 50), berpegang pada
plot (data (:, 1), data (: ‘. r’, 2),, ‘MarkerSize’, 5)
Kriteria optimalitas alternatif
MISE adalah diharapkan terintegrasi L_{2}
jarak antara estimasi kepadatan dan benar fungsi kepadatan f
. Ini adalah yang paling banyak digunakan, terutama karena tractability dan sebagian besar perangkat lunak menerapkan bandwidth yang selektor berbasis MISE. Ada kriteria optimalitas alternatif, yang mencoba untuk menutupi kasus-kasus dimana MISE bukan merupakan langkah yang tepat. [3]: 34-37,78 Setara L_{1}
ukuran, Kesalahan Berarti Terpadu Absolute, adalah
MIAE\left(H\right)=E\int\mid\overset{\mathcircumflex}{f}_{H}\left(x\right)-f\left(x\right)\mid dx.
Analisis matematis yang jauh lebih sulit daripada yang MISE. Dalam prakteknya, gain tampaknya tidak signifikan. [14] The L_{\infty}
norma adalah Mean Absolute Error Seragam
MUAE\left(H\right)=Esup_{x}\mid\overset{\mathcircumflex}{f}_{H}\left(x\right)-f\left(x\right)\mid.
yang telah diteliti hanya sebentar. [15] kriteria kesalahan Kemungkinan termasuk yang didasarkan pada Mean jarak Kullback-Leibler
MKL\left(H\right)=E\int\left(\overset{\mathcircumflex}{f}_{H}\left(x\right)^{1/2}-f\left(x\right)^{1/2}\right)^{2}dx.
KL dapat ditemukan dengan menggunakan metode cross-validasi, meskipun KL cross-validasi pemilih dapat sub-optimal bahkan jika itu tetap konsisten ntuk fungsi kepadatan terbatas. [16] MH penyeleksi telah diperiksa secara singkat dalam literatur. [17]
Semua kriteria optimalitas ini langkah-langkah jarak jauh, dan tidak selalu sesuai dengan pengertian yang lebih intuitif kedekatan, sehingga kriteria lebih visual telah dikembangkan dalam menanggapi keprihatinan ini. [18]
Bab 5 PENUTUP
Kesimpulan
• Grafik pengendali adalah teknik pengendali proses pada jalur yang digunakan secara luas yang biasanya digunakan untuk menaksir parameter suatu proses produksi menentukan kemampuan dan memberikan informasi yang berguna dalam meningkatkan proses itu.
• MATLAB(Matrix Laboratory) yaitu sebuah program untuk menganalisis dan mengkomputasi data numerik, dan MATLAB juga merupakan suatu bahasa pemrograman matematika lanjutan, yang dibentuk dengan dasar pemikiran yang menggunakan sifat dan bentuk matriks.
• Estimasi fungsi densitas merupakan salah satu bagian dalam analisis data statistik, dimana estimasi fungsi densitas adalah suatu gambaran tentang sebuah sebaran data.
• Kernel estimasi adalah alat untuk memvisualisasikan distribusi data. Misalnya, untuk gambaran. Kernel multivarian estimasi ketika dianggap itu adalah biasanya dalam konteks dibatasi dengan diagonal matriks, misalnya bandwidth. dalam paket R BC (Bowman & Azzalini, 2007) dan KernSmooth (tongkat, 2006). Kami memperkenalkan baru R ks paket yang mengimplementasikan matriks diagonal dan tidak dibatasi data-driven bandwidth untuk kernel estimasi, yang juga dapat digunakan untuk analisis multivarian diskriminan kernel. Paket KS.sys mengimplementasikan penyeleksi untuk 1 – untuk 6-dimensi.
• Dalam statistik, estimasi densitas kernel (KDE) adalah non-parametrik cara untuk memperkirakan dengan fungsi kepadatan probabilitas dari variabel acak. Estimasi densitas kernel adalah masalah penghalusan data mendasar di mana kesimpulan tentang populasi yang dibuat berdasarkan data yang terbatas sampel. Dalam beberapa bidang seperti pemrosesan sinyal dan ekonometrik itu juga disebut metode window Parzen-Rosenblatt, setelah Emanuel Parzen dan Murray Rosenblatt, yang biasanya dikreditkan dengan mandiri menciptakan itu dalam bentuk yang sekarang
• Grafik pengendali dibedakan menjadi 2 jenis yaitu grafik pengendali univariat dan grafik pengendali bivariat atau multivariat
Demikan yang dapat kami paparkan mengenai materi Joint Kernel Density Estimates yang menjadi pokok bahasan dalam buku ini, tentu masih banyak kekurangan dan kelemahan yang dapat ditemui didalam buku ini karena terbatasnya pengetahuan dari kami selaku penulis serta keterbatasan waktu yang diberikan oleh Dosen kepada kami untuk membuat buku ini lebih baik lagi.Penulis berharap para pembaca sudi memberikan kritik dan saran yang membangun kepada penulis demi sempurnanya buku kami inidan penulisan buku di kesempatan berikutnya.Semoga makalah ini berguna bagi penulis pada khususnya dan juga para pembaca pada umumnya.



Daftar Pustaka

https://books.google.co.id/books?id=VF5nXLvi_KUC&pg=PA132&dq=joint+ kernel+density+estimation&hl=id&sa=X&ved=0ahUKEwjf5ujv3sbKAhVVC44 KHeE7ARYQ6AEIGTAA#v=onepage&q=joint%20kernel%20density%20estimation&f=false
https://books.google.co.id/books?id=fycmsfkK6RQC&pg=PA611&dq=joint+k ernel+density+estimation&hl=id&sa=X&ved=0ahUKEwjf5ujv3sbKAhVVC44K HeE7ARYQ6AEIIDAB#v=onepage&q=joint%20kernel%20density%20estimation&f=false
https://books.google.co.id/books?id=C_2zCgAAQBAJ&pg=PA308&dq=joint+ kernel+density+estimation&hl=id&sa=X&ved=0ahUKEwiR5uOk4MbKAhXNc o4KHXpUBO8Q6AEIUjAH#v=onepage&q=joint%20kernel%20density%20estimation&f=false
https://books.google.co.id/books?id=FzvNfkMjvPwC&pg=PA120&dq=joint+ke rnel+density+estimation&hl=id&sa=X&ved=0ahUKEwiR5uOk4MbKAhXNco4K HXpUBO8Q6AEIOjAE#v=onepage&q=joint%20kernel%20density%20estimation&f=false
https://books.google.co.id/books?id=ZiwLCAAAQBAJ&pg=PA189&dq=joint+ke rnel+density+estimation&hl=id&sa=X&ved=0ahUKEwiR5uOk4MbKAhXNco4KH XpUBO8Q6AEISjAG#v=onepage&q=joint%20kernel%20density%20estimation&f=false
https://books.google.co.id/books?id=C5oj8bPtW6UC&pg=PA39&dq=pengertian+ matlab&hl=id&sa=X&ved=0ahUKEwjDgb_74MbKAhVXkI4KHVu6DFUQ6AEIIjA C#v=onepage&q=pengertian%20matlab&f=false
https://id.wikipedia.org/wiki/MATLAB
http://www.slideshare.net/vhieatietanic/modul-1-pengenalan-matlab
http://tutorkeren.com/artikel/tutorial-pemrograman-logika-fuzzy-menggunakan-matlab.htm
https://alvinburhani.wordpress.com/2014/05/25/aplikasi-logika-fuzzy-dengan-matlab/
https://www.scribd.com/doc/59018692/8/Contoh-Kasus-Penyelesaian-dengan-M-File
Subscribe to: Posts (Atom)
It's possible to trade profitably on the Forex, the nearly $2 trillion worldwide currency exchange market. But the odds are against you, even more so if you don't prepare and plan your trades. According to a 2014 Bloomberg report, several analyses of retail Forex trading, including one by the National Futures Association (NFA), the industry's regulatory body, concluded that more than two out of three Forex traders lose money. This suggests that self-education and caution are recommended. Here are some approaches that may improve your odds of taking a profit. Prepare Before You Begin Trading Because the Forex market is highly leveraged -- as much as 50 to 1 -- it can have the same appeal as buying a lottery ticket: some small chance of making a killing. This, however, isn't trading; it's gambling, with the odds long against you. A better way of entering the Forex market is to carefully prepare. Beginning with a practice account is helpful and risk-free. While you're trading in your practice account, read the most frequently recommended Forex trading books, among them Currency Forecasting: A Guide to Fundamental and Technical Models of Exchange Rate Determination, by Michael R. Rosenberg is short, not too sweet and highly admired introduction to the Forex market. Forex Strategies: Best Forex Strategies for High Profits and Reduced Risk, by Matthew Maybury is an excellent introduction to Forex trading. The Little Book of Currency Trading: How to Make Big Profits in the World of Forex, by Kathy Lien is another concise introduction that has stood the test of time. All three are available on Amazon. Rosenberg's book, unfortunately, is pricey, but it's widely available in public libraries. "Trading in the Zone: Master the Market with Confidence, Discipline and a Winning Attitude," by Mark Douglas is another good book that's available on Amazon, and, again, somewhat pricey, although the Kindle edition is not. Use the information gained from your reading to plan your trades before plunging in. The more you change your plan, the more you end up in trouble and the less likely that elusive forex profit will end up in your pocket. Diversify and Limit Your Risks Two strategies that belong in every trader's arsenal are: Diversification: Traders who execute many small traders, particularly in different markets where the correlation between markets is low, have a better chance of making a profit. Putting all your money in one big trade is always a bad idea. Familiarize yourself with ways guaranteeing a profit on an already profitable order, such as a trailing stop, and of limiting losses using stop and limit orders. These strategies and more are covered in the recommended books. Novice traders often make the mistake of concentrating on how to win; it's even more important to understand how to limit your losses. Be Patient Forex traders, particularly beginners, are prone to getting nervous if a trade does not go their way immediately, or if the trade goes into a little profit they get itchy to pull the plug and walk away with a small profit that could have been a significant profit with little downside risk using appropriate risk reduction strategies. In "On Any Given Sunday," Al Pacino reminds us that "football is a game of inches." That's a winning attitude in the Forex market as well. Remember that you are going to win some trades and lose others. Take satisfaction in the accumulation of a few more wins than losses. Over time, that could make you rich!
No car insurance resource would be complete without a comprehensive glossary of car insurance terms. We've compiled a list of terms and their definitions to better help you navigate the sometimes confusing world of insurance Accident - This is an unexpected sudden event that causes property damage to an automobile or bodily injury to a person. The event may be an at-fault or not-at fault and it may be report or unreported. An accident involving two vehicles may be termed a collision. Accident report form - This is the report filed by police, often called the police report, containing the important information regarding the vehicle collision. This report will include the names of all individuals involved, vehicles involved, property damaged and citations that were issued. Adjuster - This is the person who will evaluate the actual loss reported on the policy after an accident or other incident. They will make the determination on how much will be paid on the auto insurance policy by the Insurer. Agent - This is a licensed and trained individual who is authorized to sell and to service insurance policies for the auto insurance company. At Fault - This is the amount that you, the policy holder, contributed or caused the auto collision. This determines which insurance agency pays which portion of the losses. Auto Insurance Score - This is a score similar to credit score that evaluates the information in your consumer credit report. These scores are used when determining pricing for your auto insurance policy. Negative marks on your credit report can increase your auto insurance premiums. The use of this information to determine policy pricing does vary from state to state. Automobile Insurance - This is a type of insurance policy that covers and protect against losses involving automobiles. Auto Insurance policies include a wide range of coverage's depending on the policy holders needs. Liability for property damage and bodily injury, uninsured motorist, medical payments, comprehensive, and collision are some of the common coverage's offered under an auto insurance policy. Binder - This is a temporary short-term policy agreement put in place while a formal permanent policy is put into place or delivered. Bodily Injury Liability - This is the section of an insurance policy that covers the cost to anyone you may injure. It can include lost wages and medical expenses. Broker - This is a licensed individual who on your behalf sells and services various insurance policies. Claim - This is a formal notice made to your insurance company that a loss has occurred which may be covered under the terms of the auto insurance policy. Claims Adjuster - This person employed by the insurance agency will investigate and settle all claims and losses. A representative for the insurance agency to verify and ensure all parties involved with the loss, get compensated fairly and correctly. Collision - The portion of the insurance policy that covers damage to your vehicle from hitting another object. Objects can include but are not limited to; another vehicle, a building, curbs, guard rail, tree, telephone pole or fence. A deductible will apply. Your insurance company will go after the other parties insurance policy for these cost should they be at fault. Commission - This is the portion of the auto insurance policy that is paid to the insurance agent for selling and servicing the policy on behalf of the company. Comprehensive - This is a portion of the insurance policy that covers loss caused by anything other than a collision or running into another object. A deductible will apply. This includes but is not limited to vandalism, storm damage, fire, theft, etc. Covered loss - This is the damage to yourself, other people or property or your vehicle that is covered under the auto insurance policy. Declarations Page - This is the part of the insurance policy that includes the entire legal name of your insurance company, your full legal name, complete car information including vehicle identification numbers or VIN, policy information, policy number, deductible amounts. This page is usually the front page of the insurance policy. Deductible Amount - This is the portion of the auto insurance policy that is the amount the policy holder must pay up front before the Insurance Company contributes and is required to pay any benefits. This amount can be within a wide range in price and varies from approximately $100 - $1000. The larger amount you pay in a deductible the lower your normal monthly/yearly policy will cost. This is the portion of the auto insurance policy that would be applicable only to comprehensive or collision coverage. Discount - This is a reduction in the overall cost of your insurance policy. Deductions can be given for a variety of different reasons including a good driving record, grades, age, marital status, specific features and safety equipment on the automobile. Emergency Road Service - This is the part of an auto insurance policy that covers the cost of emergency services such as flat tires, keys locked in the car and towing services. Endorsement - This is any written change that is made to the auto insurance policy that is adding or removing coverage on the policy. Exclusion - This is the portion of the auto Insurance policy that includes any provision including people, places or things that are not covered under the insurance policy. First Party - This is the policyholder, the insured in an insurance policy. Gap Insurance - This is a type of auto insurance provided to people who lease or own a vehicle that is worth less than the amount of the loan. Gap auto Insurance will cover the amount between the actual cash value of the vehicle and the amount left on loan should the care be stolen or destroyed. High-Risk Driver - If you have a variety of negative marks on your insurance record including driving under the Influences, several traffic violations, etc. you may be labeled as a risk to the insurance company. This will increase your insurance policy or may make you ineligible for coverage. Insured - The policyholder (s) who are covered by the policy benefits in case of a loss or accident. Insurer - Is the Auto Insurance company who promises to pay the policy holder in case of loss or accident. Liability insurance - This part of an auto insurance policy which legally covers the damage and injuries you cause to other drivers and their vehicles when you are at fault in an accident. If you are sued and taken to court, liability coverage will apply to your legal costs that you incur. Most states will require drivers to carry some variation of liability coverage Insurance and this amount will vary state by state. Limits - This is the portion of the auto insurance policy that explains and lists the monetary limits the insurance company will pay out. In the situation you reach these limits the policy holder will be responsible for all other expenses. Medical Payments Coverage - This is the portion of an auto insurance policy that pays for medical expenses and lost wages to you and any passengers in your vehicle after an accident. It is also known as personal injury protection or PIP. Motor Vehicle Report - The motor vehicle report or MVR is a record issued by the state in which the policy holder resides in that will list the licensing status, any traffic violations, various suspensions and./ or refractions on your record. This is one of the tools used in determining the premium prices offered by the insurance agency. This is also used to determine the probability of you having a claim during your policy period. No-Fault Insurance - If you reside within a state with no-fault insurance laws and regulations, your auto insurance policy pays for your injuries no matter who caused the accident. No-fault insurance states include; Florida, Hawaii, Kansas, Kentucky, Massachusetts, Michigan, Minnesota, New Jersey, New York, North Dakota, Pennsylvania, Utah and Washington, DC.. Non-Renewal - This is the termination of an auto insurance policy on the given expiration date. All coverage will cease as of this date and insurer will be released of promised coverage. Personal Property Liability - This is the portion of the auto insurance policy that covers any damage or loss you cause to another person's personal property. Personal Injury Protection or PIP - This portion of an auto insurance policy pays for any lost wages or medical expenses to you and any passengers in your vehicle following an accident. PIP is also known as medical payments coverage. Premium - This is the amount charged to you monthly, yearly or any other duration agreed upon by insurance company and policy holder and paid directly to the auto insurance company. A premium is based on the type and amount of coverage you choose for your vehicle(s) and yourself. Other factors that will affect your insurance premium prices include your age, marital status, you're driving and credit report, the type of car you drive and whether you live in an urban or rural area. Premiums vary by insurance company and the location you live. Quotation - This is the amount or estimated amount the insurance will cost based on the information provided to the agent, broker or auto insurance company. Rescission.- This is the cancellation of the insurance policy dated back to its effective date. This would result in the full premium that was charged being returned. Rental Reimbursement - This is the portion of the auto insurance policy that covers the cost of an automobile rental of similar size should the covered vehicle be in repair from a reported incident. Replacement Cost - This is the amount of money it would cost to replace a lost or damaged item at it is actually new replacement value. This monetary amount would be based on a new identical item in the current local market. Salvage - This is the auto insurance policy holders property that is turned over tot eh insurance agency in a loss final settlement. Insurance companies will sell the salvage property in hopes to recoup some of its monetary loss due to the loss and settlement. Second Party - this is the actual insurance company in the auto insurance policy. Surcharge - This is the amount added to your auto insurance policy premium after a traffic violation or an accident in which you were found to be at fault. Third Party - This is another person other than the policy holder and auto insurance company who has faced a loss and may be able to collect and be compensated on behalf of the policy holder's negligence. Total Loss - This is complete destruction to the insured property of a policy holder. It has been determined that it would be a great sum of money to repair the item rather than replace the insured piece of property to its state prior to the loss. Towing Coverage - This is the portion of the auto insurance policy that covers a specified amount for towing services and related labor costs. Under insured Driver - This is the portion of an auto insurance policy which covers injuries to you caused by a driver without enough insurance to pay for the medical expenses you have incurred from the accident. This is portion of the policy can vary state by state as some states include damage to the car in this section. Uninsured Driver or Motorist - This is the portion of the auto insurance policy which covers injuries to you caused by a driver who was without liability insurance at the time of the accident. Uninsured driver or motorist coverage comes in two different sections; uninsured motorist bodily injury and uninsured motorist property damage. Uninsured motorist bodily injury coverage covers the injuries to you or any passenger in your vehicle when there is an accident with an uninsured driver. Uninsured motorist property damage coverage covers the cost for the property damage to your vehicle when there is an accident with an identified uninsured driver. Uninsured driver or motorist coverage must be offered when you purchase the required liability coverage for your vehicle. You must sign a declination waiver if you decline Uninsured driver or motorist coverage. The majority of states require drivers to carry some form of uninsured motorist coverage. Some states include damages to your car in this coverage. Vehicle Identification Number or VIN - A VIN is a 17 letter and number combination that is the identification of the specific vehicle. It will identify the make, modem and year of the automobile. This number is typically located on the driver's side window on the dash. It can also be found on the vehicles registration and title