BAB 4 Kesimpulan

BAB 4

Kesimpulan

 Nama           :  Chairunnisaa

 NPM            :  52414319

·         Sistem game Pong dapat diimplementasikan menggunakan Arduino Uno, layar OLED, dan dua joystick. Sistem ini adalah permainan saling berusaha memasukkan bola ke area lawan menggunakan paddle masing-masing player, yang diatur dengan dua joystick.

·         Sistem game Pong dapat diimplementasikan menggunakan arsitektur FreeRTOS dengan lima task, yaitu draw, readJoystick, drawCentralLine, drawBall, dan drawPlayer.

·         Untuk menghindari terjadinya deadlock pada penggunaan shared resources, diimplementasikan semaphore dengan delay di masing-masing task

BAB 3 Implementasi

BAB 3

Implementasi

 Nama           :  Chairunnisaa

 NPM            :  52414319

1.  Pembuatan Game Pong Berbasis Arduino

Pong adalah videogame pertama yang sampai di pasar massal. Untuk pertama kalinya dalam sejarah, konsep "video game" dibawa ke rumah keluarga, berkat Atari 2600 - jadi kita dapat melestarikan game bersejarah ini. Sekarang, Anda bisa menghidupkan kembali gameplay (yang memang agak membosankan) menggunakan Arduino dan beberapa komponen umum.

Tidak mungkin anak perempuan Anda akan melepaskan Nintendo DS-nya, dan ini tidak hanya akan memberikan kesenangan bagi seluruh keluarga - tapi ini adalah perminan yang mengagumkan dan mudah untuk memperbaiki pengkodean Arduino Anda.

Kami akan membuat dua pengendali dasar, dan video akan menampilkan TV Anda melalui kabel video komposit standar.

Alat yang dibutuhkan:

·         470 ohm resistor x1

·         1k ohm resistor x1

·         10k ohm Potentiometer (twiddly variable resistor) x2

·         Arduino x1 (any version)

·         RCA plug x1 

·         Pushbutton switch x1

·         10k ohm resistor x1

Ambil steker RCA Anda dan lepaskan lapisan luarnya. Kumpulkan perisai, putar dan tempelkan ke satu sisi. Ini adalah medanmu. Di tengahnya harus ada kabel lain dengan pelindung plastik - sekali lagi, strip ini sehingga Anda memiliki garis sinyal Anda.

Solder resistor 470 ohm dan 1k ohm ke garis sinyal tengah steker RCA Anda - ini memberikan sinyal sinkronisasi dan sinyal video yang sebenarnya, digabungkan untuk menghasilkan input video analog. The 470 ohm resistor harus slot ke pin IO digital D07, sedangkan 1k ohm resistor pergi ke pin D09.

Pin ini diatur oleh perpustakaan yang kita impor, jadi Anda tidak bisa mengubahnya. Salah satu pin GND Arduino Anda harus masuk ke perisai (di luar) RCA.

Sekarang Anda bisa terus maju dan memasukkan contoh; Walaupun keduanya PAL dan NTSC disediakan, seharusnya tidak terlalu penting dengan TV digital modern - demo NTSC bekerja dengan baik. Tancapkan ke TV Anda, dan harus mendapatkan kubus 3D retro yang cocok

.

Test Analog Potentiometer Inputs

Setelah output TV bekerja, sekarang mari kita pergi dengan pengendali. Kabel dari "pot" tidak begitu penting - masing-masing harus memiliki 3 pin, dan yang sentral hampir selalu menghasilkan sinyal output. Kawat itu ke A0 dan A1 (satu untuk masing-masing pot). Pada salah satu sisi pin - tidak masalah yang - kawat atas 5 V. Pin lainnya di sisi lain harus di ground.

Di sini setelah menempatkan mereka berdua menghadap masing-masing di papan tempat pemotongan, karena hanya memiliki kabel pendek. Untuk produk yang dipoles, Anda pasti ingin menggunakan beberapa kabel jaringan lama untuk memberi jarak sedikit (sehingga Anda bisa benar-benar duduk di sofa untuk dimainkan).

Selanjutnya, muatkan salah satu sketsa contoh dasar yang menyertai Arduino - masukan analog satu. Demo ini akan menyalakan LED onboard lebih cepat atau lebih lambat, tergantung pada input pada A0.

Ini tidak menguji bagian A1 lainnya, tapi jika Anda memasang A0 dengan benar maka kami tidak dapat melihat bagaimana Anda akan membuat kesalahan pada A1, jadi anggap itu bagus dan terus berlanjut.

Menambahkan Start Switch

Akhirnya, kita akan menambahkan tombol start pada D02. Lihat diagram pengkabelan di sini untuk bagaimana melakukannya. Peralihan ini akan digunakan untuk memulai permainan saat berada di menu.

The Pong Code

Kami menggunakan beberapa kode yang aslinya ditulis oleh Lamonica, dimodifikasi oleh duboisvb untuk dua pemain, dan diperbarui sendiri untuk menggunakan versi terbaru perpustakaan TV out terbaru. Anda bisa melihat dan mendownload kode dari pastebin ini.

Ini cukup panjang tapi kode sederhana yang seharusnya tidak memerlukan penjelasan. Seperti kebanyakan game, game ini bergantung pada status permainan (menu, game dalam game, game over), dan membaca nilai masukan dari kedua pengendali dan setiap perulangan loop. Di luar itu adalah metode untuk menggambar layar, bola, dayung, dan logika permainan.

Perhatikan bahwa kode tersebut mencakup keluaran audio juga: Kami tidak dapat menemukan colokan RCA lagi untuk mengujinya, namun jika Anda memilikinya, maka pasang pin sinyal langsung ke D11, dan Anda harus mendapatkan nada retro yang cocok.

Arduino bahkan bisa melakukan TV tanpa pengkodean yang sangat rumit; TV out library membuatnya sangat mudah. Bahkan jika Anda tidak memasuki game retro, menggunakan TV dasar ini adalah cara yang bagus untuk memanfaatkan peralatan yang ada sebagai perangkat monitor murah. Tentu saja Anda bisa mengeluarkan warna output.

2. Reinforcement Learning (RL)

Reinforcement Learning (RL) sering digunakan. Anda mungkin telah memperhatikan bahwa komputer sekarang dapat secara otomatis belajar bermain game ATARI (dari piksel permainan mentah!), Mereka mengalahkan juara dunia di Go, simulasi quadruped belajar berlari dan melompat, dan robot belajar bagaimana melakukan tugas manipulasi yang rumit. Ternyata semua kemajuan ini berada di bawah penelitian RL. Kami juga tertarik pada RL sendiri selama tahun terakhir: Kami bekerja melalui buku Richard Sutton, membaca kursus David Silver, menyaksikan ceramah John Schulmann, menulis sebuah perpustakaan RL di Javascript, selama musim panas yang diadakan di DeepMind yang bekerja di kelompok DeepRL, Dan yang paling baru bernada sedikit dengan desain / pengembangan OpenAI Gym, toolkit benchmarking RL baru. Jadi, sudah pasti mengasyikkan setidaknya selama satu tahun ini,

Contoh RL di alam bebas. Dari kiri ke kanan: Deep Q Belajar jaringan bermain ATARI, AlphaGo, Berkeley menumpuk robot Legos, simulasi melompati quadruped secara fisik di atas medan.

Menarik untuk memikirkan sifat kemajuan terkini dalam RL. Kami secara luas ingin memikirkan empat faktor terpisah yang menahan AI:

a.     Hitung (yang jelas: Hukum Moore, GPU, ASIC),

b.     Data (dalam bentuk yang bagus, tidak hanya di luar sana di suatu tempat di internet - misalnya ImageNet),

c.      Algoritma (penelitian dan gagasan, misalnya backprop, CNN, LSTM), dan

d.     Infrastruktur (perangkat lunak di bawah Anda - Linux, TCP / IP, Git, ROS, PR2, AWS, AMT, TensorFlow, dll.).

Mirip dengan apa yang terjadi di Computer Vision, kemajuan dalam RL tidak didorong sebanyak yang mungkin Anda anggap sebagai ide baru yang menakjubkan. Di Computer Vision, AlexNet 2012 sebagian besar merupakan varian Convnets tahun 1990 yang lebih kecil dan lebih luas. Demikian pula, makalah ATARI Deep Q Learning dari tahun 2013 adalah implementasi dari algoritma standar (Q Learning with function approximation, yang dapat Anda temukan di buku RL standar Sutton 1998), di mana perkiraan fungsi menjadi ConvNet. AlphaGo menggunakan gradien kebijakan dengan Monte Carlo Tree Search (MCT) - ini juga merupakan komponen standar. Tentu saja, dibutuhkan banyak keterampilan dan kesabaran untuk membuatnya bekerja, dan beberapa tweak cerdas di atas algoritma lama telah dikembangkan, namun sampai pada urutan pertama, pendorong utama kemajuan terakhir bukanlah algoritme tapi (serupa Untuk Computer Vision) menghitung / data / infrastruktur.

Sekarang kembali ke RL. Kapan pun ada keterputusan antara bagaimana sesuatu yang ajaib terlihat dan betapa sederhananya berada di bawah tenda, kami mendapatkan semua gelisah dan sangat ingin menulis posting blog. Dalam hal ini kami telah melihat banyak orang yang tidak percaya bahwa kita dapat secara otomatis belajar bermain game ATARI paling banyak di tingkat manusia, dengan satu algoritma, dari piksel, dan dari awal - dan ini menakjubkan, dan kami pernah ke sana. diri! Tapi pada intinya pendekatan yang kami gunakan juga benar-benar sangat sangat bodoh (walaupun kami mengerti mudah membuat klaim semacam itu dalam retrospeksi). Lagi pula, kami ingin memandu Anda melalui Gradien Kebijakan (PG), pilihan default favorit kami untuk menyerang masalah RL saat ini. Jika Anda berasal dari luar RL, Anda mungkin penasaran mengapa kami tidak menghadirkan DQN sebagai gantinya, yang merupakan algoritma RL alternatif dan lebih dikenal, dipopulerkan secara luas oleh permainan ATARI yang bermain. Ternyata Q-Learning bukanlah algoritma yang hebat (bisa dibilang DQN jadi 2013 (oke kami 50% bercanda)). Sebenarnya kebanyakan orang lebih suka menggunakan Gradien Kebijakan, termasuk penulis naskah DQN asli yang telah menunjukkan Gradien Kebijakan agar bekerja lebih baik daripada Q Learning saat menyetel dengan baik. PG lebih disukai karena bersifat end-to-end: ada kebijakan eksplisit dan pendekatan berprinsip yang secara langsung mengoptimalkan penghargaan yang diharapkan. Bagaimanapun, sebagai contoh yang berjalan, kita akan belajar memainkan game ATARI (Pong!) Dengan PG, dari nol, dari piksel, dengan jaringan syaraf yang dalam, dan semuanya 130 baris Python hanya menggunakan numpy sebagai ketergantungan.

Pong dari piksel

Kiri: Pertandingan Pong. Kanan: Pong adalah kasus khusus dari Markov Decision Process (MDP): Grafik di mana setiap simpul adalah negara permainan tertentu dan setiap tepi adalah transisi kemungkinan (pada umumnya probabilistik). Setiap sisi juga memberi poin, dan tujuannya adalah untuk menghitung cara bertindak yang optimal dalam keadaan apapun untuk memaksimalkan penghargaan.

Permainan Pong adalah contoh bagus dari tugas RL sederhana. Dalam versi ATARI 2600 kami akan mengajak Anda bermain sebagai salah satu dayung (yang lainnya dikendalikan oleh AI yang layak) dan Anda harus memantul bola melewati pemain lain. Pada tingkat rendah permainan bekerja sebagai berikut: kita menerima bingkai gambar (array 210x160x3 byte (bilangan bulat dari 0 sampai 255 memberikan nilai piksel)) dan kita dapat memutuskan apakah kita ingin memindahkan dayung ke atas atau ke bawah (misalnya biner pilihan). Setelah setiap pilihan simulator permainan menjalankan tindakan dan memberi kami poin: Entah imbalan +1 jika bola melewati lawan, poin -1 jika kami melewatkan bola, atau 0 sebaliknya. Dan tentu saja, tujuannya adalah menggerakkan dayung sehingga mendapatkan banyak poin.

Ketika kita melalui solusi ini, ingatlah bahwa kita akan mencoba membuat asumsi yang sangat sedikit tentang Pong karena kita diam-diam tidak terlalu peduli dengan Pong; Kami peduli dengan masalah kompleks dan berdimensi tinggi seperti manipulasi robot, perakitan dan navigasi. Pong hanyalah sebuah mainan yang menyenangkan, sesuatu yang kita mainkan sementara kita mencari tahu bagaimana menulis sistem AI yang sangat umum yang suatu hari bisa melakukan tugas-tugas bermanfaat yang sewenang-wenang.

Jaringan kebijakan Pertama, kita akan menentukan jaringan kebijakan yang mengimplementasikan pemain kita (atau "agen"). Jaringan ini akan mengambil keadaan permainan dan memutuskan apa yang harus kita lakukan (bergerak ke atas atau bawah). Sebagai blok sederhana favorit kami, kami akan menggunakan jaringan syaraf 2 lapisan yang mengambil piksel gambar mentah (100.800 nomor total (210 * 160 * 3)), dan menghasilkan satu angka yang menunjukkan probabilitas untuk naik UP. Perhatikan bahwa itu adalah standar untuk menggunakan kebijakan stokastik, yang berarti bahwa kita hanya menghasilkan probabilitas untuk bergerak ke atas. Setiap iterasi kita akan sampel dari distribusi ini (yaitu melempar koin yang bias) untuk mendapatkan pergerakan sebenarnya. Alasan untuk ini akan menjadi lebih jelas begitu kita berbicara tentang pelatihan.

Dan untuk membuat hal-hal yang konkret di sini adalah bagaimana Anda bisa menerapkan jaringan kebijakan ini dengan Python / numpy. Misalkan kita diberi vektor x yang menyimpan informasi pixel (preprocessed). Kami akan menghitung:H = np.dot (W1, x) # menghitung aktivasi neuron lapisan tersembunyi

H [h <0] = 0 # ReLU nonlinier: ambang di nol

Logp = np.dot (W2, h) # menghitung probabilitas log naik

P = 1.0 / (1.0 + np.exp (-logp)) # fungsi sigmoid (memberi kemungkinan naik)

Di mana dalam potongan ini W1 dan W2 adalah dua matriks yang kita inisialisasi secara acak. Perhatikan bahwa kita menggunakan sigmoid non-linearity di akhir, yang squashes probabilitas output ke kisaran [0,1]. Secara intuitif, neuron di lapisan tersembunyi (yang memiliki bobot yang diatur di sepanjang barisan W1) dapat mendeteksi berbagai skenario permainan (misalnya bola ada di atas, dan dayung kita ada di tengah), dan bobot di W2 kemudian dapat Putuskan jika dalam setiap kasus kita harus pergi UP atau DOWN. Sekarang, W1 dan W2 acak awal tentu saja menyebabkan pemain tersebut tersadar. Jadi satu-satunya masalah sekarang adalah menemukan W1 dan W2 yang mengarah pada permainan ahli Pong!

Cetak halus: preprocessing. Idealnya Anda ingin memberi makan minimal 2 frame ke jaringan kebijakan sehingga bisa mendeteksi gerakan. Untuk membuat hal-hal sedikit lebih sederhana kami akan melakukan sedikit persiapan ulang. Kami benar-benar akan memberi umpan pada frame perbedaan ke jaringan (yaitu pengurangan bingkai saat ini dan yang terakhir).

Kedengarannya tidak mungkin. Pada titik ini kami ingin Anda menghargai betapa sulitnya masalah RL. Kami mendapatkan 100.800 nomor (210 * 160 * 3) dan meneruskan jaringan kebijakan kami (yang dengan mudah melibatkan pesanan satu juta parameter di W1 dan W2). Misalkan kita memutuskan untuk pergi ke UP. Permainan mungkin merespons bahwa kita mendapatkan 0 poin saat ini dan memberi kami 100.800 nomor lagi untuk frame berikutnya. Kita bisa mengulangi proses ini selama seratus timesteps sebelum kita mendapatkan poin tanpa nol! Misalnya. Misalkan kita akhirnya mendapatkan +1. Itu bagus, tapi bagaimana kita bisa tahu apa yang terjadi? Apakah itu sesuatu yang kita lakukan sekarang? Atau mungkin 76 frame lalu? Atau mungkin ada kaitannya dengan frame 10 dan kemudian frame 90? Dan bagaimana kita mengetahui mana dari jutaan tombol yang harus diubah dan bagaimana, agar bisa lebih baik di masa depan? Kami menyebutnya masalah penugasan kredit. Dalam kasus spesifik Pong kita tahu bahwa kita mendapatkan +1 jika bola berhasil melewati lawan. Penyebab sebenarnya adalah bahwa kita kebetulan memantulkan bola pada lintasan yang bagus, namun sebenarnya kita sudah melakukan banyak bingkai lalu - mis. Mungkin sekitar 20 dalam kasus Pong, dan setiap tindakan yang kami lakukan kemudian tidak berpengaruh pada apakah kami akan mendapatkan pahala atau tidak. Dengan kata lain kita dihadapkan pada masalah yang sangat sulit dan hal-hal yang terlihat sangat suram.

Pembelajaran yang perlu diperhatikan. Sebelum kita terjun ke solusi Gradien Kebijakan, kami ingin mengingatkan Anda secara singkat tentang pembelajaran yang diawasi karena, seperti yang akan kita lihat, RL sangat mirip. Lihat diagram di bawah ini. Dalam pembelajaran yang diawasi biasa, kami akan memberi umpan pada jaringan dan mendapatkan beberapa kemungkinan, mis. Untuk dua kelas UP dan DOWN. Kami menunjukkan probabilitas log (-1,2, -0,36) untuk UP dan DOWN daripada probabilitas mentah (30% dan 70% dalam kasus ini) karena kami selalu mengoptimalkan probabilitas log dari label yang benar (ini membuat matematika menjadi lebih baik, dan Adalah setara dengan mengoptimalkan probabilitas mentah karena log monotonik). Sekarang, dalam pembelajaran yang diawasi kita akan memiliki akses ke label. Misalnya, kita mungkin diberitahu bahwa hal yang benar untuk dilakukan saat ini adalah pergi ke UP (label 0). Dalam sebuah implementasi kita akan memasukkan gradien 1.0 pada probabilitas log UP dan menjalankan backprop untuk menghitung vektor gradien ∇Wlogp(y=UP∣x). Gradien ini akan memberi tahu kita bagaimana kita mengubah setiap parameter dari juta kita untuk membuat jaringan sedikit lebih cenderung memprediksi UP. Misalnya, salah satu dari jutaan parameter dalam jaringan mungkin memiliki gradien -2,1, yang berarti bahwa jika kita ingin meningkatkan parameter tersebut dengan jumlah positif kecil (misalnya 0,001), probabilitas log UP akan turun sebesar 2,1 * 0,001 (Penurunan karena tanda negatif). Jika kemudian kami melakukan update parameter, yay, jaringan kami sekarang akan sedikit lebih cenderung memprediksi UP ketika melihat gambar yang sangat mirip di masa depan.

Gradien Kebijakan Oke, tapi apa yang kita lakukan jika kita tidak memiliki label yang benar dalam pengaturan Belajar Penguatan? Inilah solusi Gradien Kebijakan (sekali lagi lihat diagram di bawah ini). Jaringan kebijakan kami menghitung probabilitas naik UP sebesar 30% (logprob -1.2) dan DOWN 70% (logprob -0.36). Sekarang kita akan mengambil contoh tindakan dari distribusi ini; Misalnya. Misalkan kita sampel DOWN, dan kita akan menjalankannya dalam game. Pada titik ini perhatikan satu fakta menarik: Kita dapat segera mengisi gradien 1,0 untuk DOWN seperti yang kita lakukan dalam pembelajaran di bawah pengawasan, dan menemukan vektor gradien yang akan mendorong jaringan untuk sedikit lebih mungkin melakukan aksi DOWN di masa depan. Jadi kita bisa langsung mengevaluasi gradien ini dan itu bagus, tapi masalahnya adalah setidaknya untuk saat ini kita belum tahu apakah akan DOWN itu bagus. Tapi yang penting adalah tidak apa-apa, karena kita bisa menunggu sebentar dan melihat! Misalnya di Pong kita bisa menunggu sampai akhir permainan, lalu ambil reward yang kita dapatkan (baik +1 jika kita menang atau -1 jika kita kalah), dan masukkan skalar itu sebagai gradien untuk tindakan yang telah kita ambil (DOWN pada kasus ini). Pada contoh di bawah ini, DOWN akan berakhir sampai kalah game (-1 reward). Jadi jika kita mengisi -1 untuk probabilitas log DOWN dan melakukan backprop kita akan menemukan gradien yang menghambat jaringan untuk mengambil aksi DOWN untuk masukan itu di masa depan (dan memang begitu, karena mengambil tindakan tersebut menyebabkan kita kehilangan permainan ).

Dan begitulah: kami memiliki kebijakan stokastik yang melakukan tindakan sampel dan kemudian tindakan yang pada akhirnya menghasilkan hasil yang baik didorong di masa depan, dan tindakan yang dilakukan yang mengarah pada hasil yang buruk berkecil hati. Juga, pahala bahkan tidak perlu menjadi +1 atau -1 jika kita memenangkan permainan pada akhirnya. Ini bisa menjadi ukuran yang sewenang-wenang dari beberapa jenis kualitas akhirnya. Misalnya jika semuanya berjalan dengan baik, itu bisa jadi 10.0, yang kemudian akan kita masukkan sebagai gradien dan bukan -1 untuk memulai backprop. Itulah keindahan jaring saraf; Menggunakannya bisa terasa seperti kecurangan: Anda diperbolehkan memiliki 1 juta parameter yang disatukan dalam 1 teraflop perhitungan dan Anda dapat membuatnya melakukan hal-hal yang sewenang-wenang dengan SGD. Seharusnya tidak bekerja, tapi menggelikan kita hidup di alam semesta dimana hal itu terjadi.

Protokol pelatihan di sini adalah bagaimana pelatihan akan bekerja secara rinci. Kami akan menginisialisasi jaringan kebijakan dengan beberapa W1, W2 dan memainkan 100 game Pong (kami menyebut "rollouts" kebijakan ini). Mari kita asumsikan bahwa setiap permainan terdiri dari 200 frame jadi totalnya kita telah membuat 20.000 keputusan untuk naik ke atas atau ke bawah dan untuk masing-masing kita mengetahui parameter gradien, yang memberitahu kita bagaimana kita harus mengubah parameter jika kita ingin Dorong keputusan itu di negara bagian itu di masa depan. Yang tersisa sekarang adalah memberi label pada setiap keputusan yang telah kita buat sebagai baik atau buruk. Misalnya anggaplah kita memenangkan 12 pertandingan dan kalah pada tahun 88. Kami akan mengambil semua 200 * 12 = 2400 keputusan yang kami buat di dalam permainan yang menang dan melakukan pembaruan positif (mengisi +1,0 dalam gradien untuk tindakan sampel, melakukan backprop, Dan update parameter mendorong tindakan yang kami ambil di semua negara bagian tersebut). Dan kita akan mengambil 200 lain lagi: 17600 keputusan yang kita buat dalam permainan kalah dan melakukan pembaruan negatif (mengecilkan hati apa pun yang kita lakukan). Dan ... itu dia. Jaringan sekarang akan menjadi sedikit lebih mungkin untuk mengulang tindakan yang berhasil, dan sedikit lebih kecil kemungkinannya untuk mengulangi tindakan yang tidak berhasil. Sekarang kami memainkan 100 game lagi dengan kebijakan baru kami yang sedikit membaik dan berkumur dan diulang.

Gradien Kebijakan: Jalankan sebuah kebijakan untuk sementara waktu. Lihatlah tindakan apa yang menghasilkan penghargaan tinggi. Tingkatkan probabilitasnya.

Ini adalah diagram dari 4 game. Setiap lingkaran hitam adalah beberapa status permainan (tiga contoh keadaan divisualisasikan di bagian bawah), dan setiap panah adalah transisi, yang diberi catatan dengan tindakan yang dijadikan sampel. Dalam hal ini kita memenangkan 2 game dan kalah 2 game. Dengan Gradien Kebijakan, kami akan mengambil dua pertandingan yang kami menangi dan sedikit mendorong setiap tindakan yang kami lakukan di episode itu. Sebaliknya, kita juga akan mengambil dua pertandingan yang kita hilang dan sedikit mengecilkan hati setiap tindakan yang kita buat di episode itu.

Jika Anda memikirkan proses ini, Anda akan mulai menemukan beberapa sifat lucu. Misalnya bagaimana jika kita melakukan aksi yang baik di frame 50 (memantulkan bola kembali dengan benar), tapi kemudian merindukan bola di frame 150? Jika setiap tindakan sekarang dicantumkan sebagai buruk (karena kita kalah), bukankah itu akan mengecilkan mental yang benar pada frame 50? Anda benar - itu akan terjadi. Namun, bila Anda mempertimbangkan proses lebih dari ribuan juta game, kemudian melakukan bouncing pertama benar membuat Anda sedikit lebih mungkin untuk menang di jalan, jadi rata-rata Anda akan melihat lebih positif daripada pembaruan negatif untuk mental yang benar dan kebijakan Anda. Akan berakhir melakukan hal yang benar.

Dalam penjelasan kami di atas, kami menggunakan istilah seperti "mengisi gradien dan backprop", yang kami sadari adalah tipe pemikiran khusus jika Anda terbiasa menulis kode backprop Anda sendiri, atau menggunakan Torch di mana gradiennya eksplisit dan terbuka. Untuk bermain-main. Namun, jika Anda terbiasa dengan Theano atau TensorFlow Anda mungkin sedikit bingung karena kode tersebut disatukan di sekitar menentukan fungsi kehilangan dan backprop sepenuhnya otomatis dan sulit dipecahkan. Dalam kasus ini, pandangan alternatif berikut mungkin lebih intuitif. Dalam pembelajaran vanili yang diawasi, tujuannya adalah untuk memaksimalkan Σilogp (yi|xi)
∑ilogp(yi∣xi)∑ilog⁡p(yi∣xi) dimana xi,yixi,yiadalah contoh pelatihan (seperti gambar dan labelnya). Gradien kebijakan sama persis dengan pembelajaran yang diawasi dengan dua perbedaan kecil: 1) Kami tidak memiliki label yiyi yang benar sehingga sebagai "label palsu" kami mengganti tindakan yang kami lakukan untuk mengambil contoh dari kebijakan saat melihat xixi, dan 2 ) Kami memodulasi kerugian untuk setiap contoh secara multiplisatif berdasarkan hasil akhirnya, karena kami ingin meningkatkan probabilitas log untuk tindakan yang berhasil dan menurunkannya bagi yang tidak melakukannya. Jadi, dalam ringkasan kerugian kita sekarang terlihat seperti ∑iAilogp(yi∣xi)∑iAilog⁡p(yi∣xi),di mana yiyi adalah tindakan yang kita lakukan untuk sampel dan AiAi adalah angka yang kita sebut keuntungan. Dalam kasus Pong, misalnya, AiAi bisa menjadi 1,0 jika kita akhirnya menang dalam episode yang mengandung xixi dan -1,0 jika kita kalah. Ini akan memastikan bahwa kita memaksimalkan probabilitas log tindakan yang menghasilkan hasil yang baik dan meminimalkan probabilitas log dari yang tidak. Jadi, pembelajaran penguatan sama persis dengan pembelajaran yang diawasi, namun pada kumpulan data yang terus berubah (episode), diperkecil oleh keuntungan, dan kami hanya ingin melakukan satu (atau sangat sedikit) pembaruan berdasarkan masing-masing kumpulan data sampel.

Kami juga sedikit lebih banyak membahas pengembalian. Sejauh ini kita telah menilai kebaikan setiap tindakan individu berdasarkan pada apakah kita memenangkan pertandingan atau tidak. Dalam setting RL yang lebih umum kita akan menerima beberapa reward rtrt setiap saat. Salah satu pilihan yang umum adalah menggunakan poin diskon, jadi "poin akhir" pada diagram di atas akan menjadi Rt=∑∞k=0γkrt+kRt=∑k=0∞γkrt+k,di mana γγ adalah angka antara 0 dan 1 Disebut faktor diskon (misalnya 0,99). Ungkapan tersebut menyatakan bahwa kekuatan yang digunakan untuk mendorong tindakan sampel adalah jumlah tertimbang dari semua penghargaan setelahnya, namun penghargaan selanjutnya secara eksponensial kurang penting. Dalam prakteknya, penting juga untuk menormalkan hal ini. Sebagai contoh, anggaplah kita menghitung RtRt untuk semua 20.000 tindakan dalam batch 100 rollthrough game Pong di atas. Salah satu ide bagus adalah "membakukan" pengembalian ini (misal: kurangi mean, bagi dengan standar deviasi) sebelum kita menghubungkannya ke backprop. Dengan cara ini kami selalu memberi semangat dan mengurangi kira-kira setengah dari tindakan yang dilakukan. Secara matematis Anda juga bisa menafsirkan trik ini sebagai cara untuk mengendalikan varians estimator gradien kebijakan. Eksplorasi yang lebih mendalam dapat ditemukan di sini.

Kami juga ingin memberikan sketsa dari mana Gradien Kebijakan berasal secara matematis. Gradien Kebijakan adalah kasus khusus dari estimator gradien fungsi skor yang lebih umum. Kasus umum adalah bahwa ketika kita memiliki ekspresi dari bentuk Ex∼p(x∣θ)[f(x)]Ex∼p(x∣θ)[f(x)] - i.e. yaitu harapan beberapa skor bernilai skalar Fungsi f (x) f (x) di bawah beberapa distribusi probabilitas p (x; θ) p (x; θ) yang ditentukan oleh beberapa θθ. Petunjuk singkat, f (x) f (x) akan menjadi fungsi reward kita (atau fungsi keuntungan lebih umum) dan p (x) p (x) akan menjadi jaringan kebijakan kita, yang benar-benar merupakan model untuk p (a|I) P (a|I), memberikan distribusi atas tindakan untuk setiap gambar II. Kemudian kami tertarik untuk menemukan bagaimana kita harus mengalihkan distribusi (melalui parameternya θθ) untuk meningkatkan nilai sampelnya, seperti yang dinilai oleh ff (yaitu bagaimana kita mengubah parameter jaringan sehingga sampel tindakan mendapat imbalan lebih tinggi).

Kami memilikinya:

∇θEx[f(x)]       =∇θ∑xp(x)f(x)                    Definisi harapan

=∑x∇θp(x)f(x)                     Jumlah wap dan gradien

=∑xp(x)∇θp(x)p(x)f(x)         Keduanya mengalikan dan membagi dengan p (x)

=∑xp(x)∇θlogp(x)f(x)          Gunakan fakta bahwa ∇θlog (z) = 1z∇θz

Definisi harapan

Untuk memasukkan ini ke dalam bahasa Inggris, kita memiliki beberapa distribusi p (x; θ) p (x; θ) (kami menggunakan steno p (x) p (x) untuk mengurangi kekacauan) yang dapat kita contoh (misalnya ini bisa menjadi gaussian ). Untuk setiap sampel, kami juga dapat mengevaluasi fungsi skor yang mengambil sampel dan memberi kami beberapa nilai skalar. Persamaan ini memberi tahu kita bagaimana kita harus mengalihkan distribusi (melalui parameternya θθ) jika kita ingin sampelnya mencapai nilai yang lebih tinggi, seperti yang dinilai oleh ff. Secara khusus, ia mengatakan bahwa tampilan: menggambar beberapa sampel xx, mengevaluasi nilai f (x) f (x), dan untuk setiap xx juga mengevaluasi istilah kedua
∇θlogp(x;θ)∇θlog⁡p(x;θ).Apa istilah kedua ini? Ini adalah vektor - gradien yang memberi kita arah di ruang parameter yang akan menyebabkan peningkatan probabilitas yang ditetapkan ke xx. Dengan kata lain, jika kita ingin menyenggol θθ ke arah ∇θlogp(x;θ)∇θlog⁡p(x;θ)kita akan melihat probabilitas baru yang diberikan pada beberapa xx sedikit meningkat. Jika Anda melihat kembali rumusnya, ini memberi tahu kita bahwa kita harus mengambil arah ini dan mengalikannya dengan nilai skor skalar f (x) f (x). Hal ini akan membuatnya sehingga sampel yang memiliki skor lebih tinggi akan "menarik" pada kerapatan probabilitas lebih kuat daripada sampel yang memiliki skor lebih rendah, jadi jika kita melakukan update berdasarkan beberapa sampel dari pp maka kerapatan probabilitas akan bergeser sekitar Arah skor yang lebih tinggi, membuat sampel dengan skor tinggi lebih mungkin terjadi.

Sebuah visualisasi dari skor fungsi gradient estimator. Kiri: Distribusi gaussian dan beberapa contoh darinya (titik biru). Pada setiap titik biru kita juga memplot gradien probabilitas log berkenaan dengan parameter mean gaussian. Panah menunjukkan arah di mana rata-rata distribusi harus didorong untuk meningkatkan probabilitas sampel tersebut. Tengah: Overlay beberapa fungsi skor memberi -1 di mana-mana kecuali +1 di beberapa wilayah kecil (perhatikan ini bisa menjadi fungsi skalar bernilai sewenang-wenang dan tidak harus terdiferensialkan). Anak panah sekarang diberi kode warna karena karena perbanyakan di update kita akan rata-rata menaiki semua panah hijau, dan tanda panah merah negatif. Kanan: setelah update parameter, panah hijau dan panah merah terbalik mendorong kita ke kiri dan ke arah bawah. Sampel dari distribusi ini sekarang akan memiliki nilai harapan yang lebih tinggi, sesuai keinginan.

Kami harap koneksi ke RL jelas. Jaringan kebijakan kami memberi kita contoh tindakan, dan beberapa di antaranya bekerja lebih baik daripada yang lain (seperti yang dinilai oleh fungsi keuntungan). Bagian kecil matematika ini memberi tahu kami bahwa cara untuk mengubah parameter kebijakan adalah melakukan beberapa peluncuran, mengambil gradien dari tindakan sampel, memperbanyaknya dengan skor dan menambahkan semuanya, itulah yang telah kami lakukan di atas. Untuk derivasi dan diskusi yang lebih menyeluruh, kami merekomendasikan ceramah John Schulman.

Baiklah, kami telah mengembangkan intuisi untuk gradien kebijakan dan melihat sketsa derivasi mereka. Kami menerapkan keseluruhan pendekatan dalam skrip Python 130 baris, yang menggunakan ATARI 2600 PANDA OpenAI Gym. Kami melatih jaringan kebijakan 2 layer dengan 200 unit lapisan tersembunyi menggunakan RMSProp pada batch 10 episode (setiap episode adalah beberapa lusin game, karena permainannya menghasilkan skor 21 untuk kedua pemain). Kami tidak menyetel hiperparameter terlalu banyak dan menjalankan eksperimen di Macbook kami yang lamban, namun setelah berlatih selama 3 malam, kami berakhir dengan sebuah kebijakan yang sedikit lebih baik daripada pemain AI. Jumlah total episode kira-kira 8.000 sehingga algoritma tersebut memainkan kira-kira 200.000 game Pong (cukup banyak bukan!) Dan menghasilkan total 800 update. Kami diberitahu oleh teman bahwa jika Anda melatih GPU dengan ConvNets selama beberapa hari, Anda dapat mengalahkan pemain AI lebih sering, dan jika Anda juga mengoptimalkan hyperparameters dengan hati-hati, Anda juga dapat secara konsisten mendominasi pemain AI (yaitu memenangkan setiap pertandingan tunggal). Namun, kami tidak menghabiskan terlalu banyak waktu untuk melakukan komputasi atau tweaking, jadi kita akan berakhir dengan AI Pong yang menggambarkan gagasan utama dan bekerja dengan baik:

Bobot yang dipelajari. Kita juga bisa melihat bobot yang dipelajari. Karena preprocessing setiap masukan kita adalah gambar perbedaan 80x80 (frame saat ini dikurangi frame terakhir). Kita sekarang bisa mengambil setiap baris W1, merentangnya hingga 80x80 dan memvisualisasikannya. Berikut adalah koleksi 40 (dari 200) neuron dalam kotak. Pixel putih adalah bobot positif dan piksel hitam adalah bobot negatif. Perhatikan bahwa beberapa neuron disetel ke jejak bola bouncing tertentu, dikodekan dengan bolak hitam dan putih sepanjang garis. Bola hanya bisa berada di satu titik, jadi neuron ini multitasking dan akan "memecat" beberapa lokasi bola sepanjang garis itu. Bolak hitam dan putih menarik karena saat bola bergerak sepanjang jejak, aktivitas neuron akan berfluktuasi sebagai gelombang sinus dan karena ReLU itu akan "menyala" pada posisi terpisah dan terpisah di sepanjang jejak. Ada sedikit kebisingan dalam gambar, yang kami asumsikan telah dikurangi jika kami menggunakan regularisasi L2.

Kami belajar memainkan Pong dari piksel mentah dengan Gradien Kebijakan dan hasilnya cukup baik. Pendekatannya adalah bentuk tebakan dan cek yang bagus, di mana "tebakan" mengacu pada penggolongan sampling dari kebijakan kami saat ini, dan "cek" tersebut mengacu pada tindakan yang mendorong hasil yang baik. Modulo beberapa rincian, ini merupakan keadaan seni dalam bagaimana kita saat ini mendekati masalah belajar penguatan. Yang mengesankan bahwa kita dapat mempelajari perilaku ini, namun jika Anda memahami algoritme secara intuitif dan Anda tahu cara kerjanya, Anda setidaknya harus sedikit kecewa. Secara khusus, bagaimana cara kerjanya?

Bandingkan dengan bagaimana manusia bisa belajar bermain Pong. Anda menunjukkan permainan mereka dan mengatakan sesuatu di sepanjang baris "Anda memegang kendali dayung dan Anda dapat memindahkannya ke atas dan ke bawah, dan tugas Anda adalah memantul bola melewati pemain lain yang dikendalikan oleh AI", dan Anda ' Kembali siap dan siap untuk pergi Perhatikan beberapa perbedaannya:

Dalam pengaturan praktis, biasanya kami mengkomunikasikan tugas dengan cara tertentu (misalnya bahasa Inggris di atas), namun dalam masalah RL standar, Anda menganggap fungsi penghargaan sewenang-wenang yang harus Anda temukan melalui interaksi lingkungan. Dapat dikatakan bahwa jika seorang manusia masuk dalam permainan Pong tapi tanpa mengetahui apapun tentang fungsi penghargaan (memang, terutama jika fungsi penghargaan bersifat statis tapi acak), manusia akan memiliki banyak kesulitan untuk belajar apa yang harus dilakukan kecuali Gradien Kebijakan akan acuh tak acuh, dan kemungkinan bekerja lebih baik. Demikian pula, jika kita mengambil frame dan mengubah piksel secara acak maka manusia kemungkinan besar akan gagal, namun solusi Gradient Policy kita bahkan tidak bisa membedakannya (jika menggunakan jaringan yang terhubung sepenuhnya seperti yang dilakukan di sini).

Seseorang membawa sejumlah besar pengetahuan sebelumnya, seperti fisika intuitif (bola memantul, tidak mungkin melakukan teleport, tidak mungkin tiba-tiba berhenti, ia mempertahankan kecepatan konstan, dll.), Dan psikologi intuitif (lawan AI) menginginkan "Untuk menang, kemungkinan mengikuti strategi yang jelas untuk bergerak menuju bola, dll.). Anda juga memahami konsep "mengendalikan" dayung, dan itu merespons perintah tombol UP / DOWN Anda. Sebaliknya, algoritma kita mulai dari nol yang secara bersamaan mengesankan (karena berhasil) dan menekan (karena kita kekurangan ide konkret untuk bagaimana tidak).

Gradien Kebijakan adalah solusi brute force, di mana tindakan yang benar akhirnya ditemukan dan diinternalisasi menjadi sebuah kebijakan. Manusia membangun model, kaya abstrak dan rencana di dalamnya. Di Pong, kami bisa beralasan lawan cukup lamban sehingga bisa jadi strategi bagus untuk memantulkan bola dengan kecepatan vertikal tinggi, yang akan menyebabkan lawan tidak menangkapnya tepat pada waktunya. Namun, rasanya juga kita juga akhirnya "menginternalisasi" solusi yang baik menjadi apa yang terasa lebih mirip dengan kebijakan memori otot reaktif. Misalnya jika Anda mempelajari tugas motor baru (misalnya mengendarai mobil dengan tongkat bergeser?) Anda sering merasa diri Anda banyak berpikir di awal tapi pada akhirnya tugas menjadi otomatis dan tidak berperasaan.

Gradien Kebijakan harus benar-benar mengalami penghargaan positif, dan mengalaminya dengan sangat sering agar akhirnya dan secara perlahan mengubah parameter kebijakan menjadi pengulangan pergerakan yang memberi penghargaan tinggi. Dengan model abstrak kita, manusia dapat mengetahui apa yang mungkin memberi penghargaan tanpa pernah benar-benar mengalami transisi yang menguntungkan atau tidak menguntungkan. Kami menabrak mobil ke dinding beberapa ratus kali sebelum kami perlahan-lahan mulai menghindari untuk melakukannya.

Kiri: Montezuma's Revenge: permainan yang sulit untuk algoritma RL kami. Pemain harus melompat turun, memanjat, mendapatkan kunci, dan membuka pintu. Seorang manusia mengerti bahwa memperoleh sebuah kunci berguna. Contoh komputer miliaran gerakan acak dan 99% waktunya jatuh ke kematiannya atau terbunuh oleh monster tersebut. Dengan kata lain sulit untuk "tersandung ke dalam" situasi yang menguntungkan. Benar: Game lain yang sulit disebut Frostbite, di mana manusia mengerti bahwa segala sesuatunya bergerak, ada beberapa hal yang bagus untuk disentuh, beberapa hal buruk untuk disentuh, dan tujuannya adalah membangun bata igloo dari batu bata. Analisis yang bagus tentang permainan ini dan diskusi tentang perbedaan antara pendekatan manusia dan komputer dapat ditemukan di Mesin Bangunan yang Mempelajari dan Berpikir Seperti Orang.

Kami juga ingin menekankan maksudnya, sebaliknya, ada banyak permainan di mana Gradien Kebijakan akan dengan mudah mengalahkan manusia. Secara khusus, apapun dengan sinyal poin yang sering dibutuhkan, refleks yang cepat, dan perencanaan jangka panjang yang tidak terlalu banyak akan ideal, karena korelasi jangka pendek antara penghargaan dan tindakan dapat dengan mudah "diperhatikan" oleh pendekatan, dan Eksekusi dengan cermat disempurnakan oleh polis. Anda dapat melihat petunjuk tentang hal ini yang sudah terjadi pada agen Pong kami: ia mengembangkan strategi di mana ia menunggu bola dan kemudian dengan cepat berlari untuk menangkapnya tepat di tepi, yang meluncurkannya dengan cepat dan dengan kecepatan vertikal tinggi. Agen tersebut mencatat beberapa poin berturut-turut untuk mengulangi strategi ini. Ada banyak game ATARI dimana Deep Q Learning menghancurkan kinerja dasar manusia dengan cara ini - mis. Pinball, Breakout, dll.

Sebagai kesimpulan, setelah Anda memahami "trik" yang digunakan algoritma ini, Anda dapat memberi alasan melalui kekuatan dan kelemahan mereka. Secara khusus, kita tidak berada di dekat manusia dalam membangun representasi permainan yang abstrak dan kaya yang dapat kita rencanakan di dalam dan digunakan untuk pembelajaran cepat. Suatu hari komputer akan melihat array piksel dan melihat sebuah kunci, sebuah pintu, dan berpikir untuk dirinya sendiri bahwa mungkin ide yang bagus untuk mengambil kunci dan mencapai pintu. Untuk saat ini tidak ada yang dekat dengan ini, dan mencoba untuk sampai ke sana adalah area penelitian yang aktif.

Perhitungan yang tidak dapat dibedakan dalam Neural Networks

Kami ingin menyebutkan satu aplikasi menarik dari Gradien Kebijakan yang tidak terkait dengan permainan: Ini memungkinkan kita merancang dan melatih jaringan syaraf tiruan dengan komponen yang melakukan (atau berinteraksi dengan) perhitungan yang tidak dapat dibedakan. Idenya pertama kali diperkenalkan di Williams 1992 dan baru-baru ini dipopulerkan oleh Recurrent Models of Visual Attention dengan nama "perhatian keras", dalam konteks model yang mengolah gambar dengan urutan sekilas jarak pandang rendah (terinspirasi oleh kita sendiri Mata manusia). Secara khusus, pada setiap iterasi, RNN akan menerima sepotong kecil gambar dan sampel lokasi untuk melihat berikutnya. Misalnya RNN mungkin melihat posisi (5,30), menerima sepotong kecil gambar, lalu memutuskan untuk melihat (24, 50), dan lain-lain. Masalahnya dengan gagasan ini adalah ada sepotong jaringan yang menghasilkan Distribusi kemana harus mencari selanjutnya dan kemudian sampel darinya. Kamingnya, operasi ini tidak dapat dibedakan karena, secara intuitif, kita tidak tahu apa yang akan terjadi jika kita mencicipi lokasi yang berbeda. Secara umum, perhatikan jaringan saraf dari beberapa input ke output:

Perhatikan bahwa sebagian besar panah (berwarna biru) dapat didiferensiasi seperti biasa, namun beberapa transformasi representasi secara opsional juga mencakup operasi sampling yang tidak dapat didiferensiasi (berwarna merah). Kita bisa membalikkan melalui panah biru dengan baik, tapi panah merah mewakili ketergantungan yang tidak dapat kita perbaiki.

Kita akan memikirkan bagian jaringan yang melakukan sampling sebagai kebijakan stokastik kecil yang tertanam di jaringan yang lebih luas. Oleh karena itu, selama pelatihan kami akan menghasilkan beberapa sampel (ditunjukkan oleh cabang di bawah), dan kemudian kami akan mendorong sampel yang akhirnya menghasilkan hasil yang baik (dalam hal ini misalnya diukur dengan kerugian pada akhirnya). Dengan kata lain, kita akan melatih parameter yang terkait dengan panah biru dengan backprop seperti biasa, namun parameter yang terkait dengan panah merah sekarang akan diperbarui secara independen dari arus balik dengan menggunakan gradien kebijakan, mendorong sampel yang menyebabkan kerugian rendah. Ide ini juga baru saja diformalkan dengan baik dalam Estimasi Gradien Menggunakan Grafik Perhitungan Stokastik.

Memori Pelatih I / O.

Anda juga akan menemukan ide ini di banyak makalah lainnya. Sebagai contoh, Neural Turing Machine memiliki pita memori yang mereka baca dan tulis. Untuk melakukan operasi tulis seseorang ingin melakukan sesuatu seperti m [i] = x, di mana i dan x diprediksi oleh jaringan pengendali RNN. Namun, operasi ini tidak dapat dibedakan karena tidak ada sinyal yang memberitahu kita apa yang akan terjadi pada kerugian jika kita menulis ke lokasi yang berbeda j! = I. Oleh karena itu, NTM harus melakukan operasi baca dan tulis yang lunak. Ini memprediksikan distribusi perhatian (dengan elemen antara 0 dan 1 dan menjumlahkan ke 1, dan memuncak di sekitar indeks yang ingin kita tulis), dan kemudian melakukan semua i: m [i] = a [i] * x . Ini sekarang bisa dibedakan, tapi kita harus membayar harga komputasi yang berat karena kita harus menyentuh setiap sel memori hanya untuk menulis ke satu posisi. Bayangkan jika setiap tugas di komputer kita harus menyentuh keseluruhan RAM!

Namun, kita bisa menggunakan gradien kebijakan untuk menghindari masalah ini (secara teori), seperti yang dilakukan di RL-NTM. Kami masih meramalkan distribusi perhatian, tapi alih-alih menulis dengan lembut, kami sampel lokasi untuk ditulis ke: i = sampel (a); M [i] = x. Selama pelatihan, kami akan melakukan ini untuk sekelompok kecil kami, dan pada akhirnya membuat cabang apa pun yang bekerja paling baik. Keuntungan komputasi yang besar adalah kita sekarang hanya perlu membaca / menulis di satu lokasi pada saat uji. Namun, seperti yang ditunjukkan dalam makalah ini strategi ini sangat sulit untuk bisa bekerja karena seseorang harus secara tidak sengaja tersandung oleh algoritma kerja melalui sampling. Konsensus saat ini adalah bahwa PG bekerja dengan baik hanya dalam pengaturan di mana ada beberapa pilihan diskrit sehingga tidak ada pengambilan keputusan dengan cepat melalui ruang pencarian yang sangat besar.

Namun, dengan Gradien Kebijakan dan dalam kasus di mana banyak data / perhitungan tersedia, kita pada prinsipnya dapat bersikap besar - misalnya kita dapat merancang jaringan syaraf tiruan yang belajar berinteraksi dengan modul besar dan tidak terdiferensiasi seperti kompiler Lateks (misalnya jika Anda Seperti char-rnn untuk menghasilkan lateks yang dikompilasi), atau sistem SLAM, atau pemecah LQR, atau sejenisnya. Atau, misalnya, sebuah superintelligence mungkin ingin belajar berinteraksi dengan internet melalui TCP / IP (yang kamingnya tidak dapat dibedakan) untuk mengakses informasi penting yang dibutuhkan untuk menguasai dunia. Itu contoh bagus.

Kami melihat bahwa Gradien Kebijakan adalah algoritma umum yang kuat dan sebagai contoh, kami melatih agen ATARI Pong dari piksel mentah, dari awal, dalam 130 baris Python. Secara umum algoritma yang sama dapat digunakan untuk melatih agen untuk permainan sewenang-wenang dan suatu hari mudah-mudahan pada banyak masalah pengendalian dunia nyata yang berharga. Kami ingin menambahkan beberapa catatan lagi sebagai penutup:

Saat memajukan AI. Kami melihat bahwa algoritma tersebut bekerja melalui pencarian brute force dimana Anda berkelana secara acak pada awalnya dan tanpa sengaja harus tersandung pada situasi yang menguntungkan setidaknya sekali, dan idealnya sering dan berulang kali sebelum distribusi kebijakan menggeser parameternya untuk mengulangi tindakan yang bertanggung jawab. Kita juga melihat bahwa manusia mendekati masalah ini dengan sangat berbeda, dalam apa yang terasa lebih mirip bangunan model abstrak yang cepat - sesuatu yang hampir saja kita gores permukaan penelitian (walaupun banyak orang mencoba). Karena model abstrak ini sangat sulit (jika tidak mungkin) untuk secara eksplisit memberi anotasi, inilah mengapa ada begitu banyak minat baru-baru ini dalam model generatif dan induksi program yang tidak diawasi.

Di gunakan di setting robotika yang kompleks. Algoritma ini tidak berskala naif dengan setting dimana eksplorasi dalam jumlah besar sulit didapat. Misalnya, dalam pengaturan robot, seseorang mungkin memiliki robot tunggal (atau sedikit), berinteraksi dengan dunia secara real time. Ini melarang aplikasi algoritma naif karena kami mempresentasikannya di posting ini. Salah satu bidang pekerjaan yang dimaksudkan untuk mengurangi masalah ini adalah gradien kebijakan deterministik - alih-alih mensyaratkan sampel dari kebijakan stokastik dan mendorong yang mendapatkan nilai lebih tinggi, pendekatan menggunakan kebijakan deterministik dan mendapatkan informasi gradien langsung dari jaringan kedua (disebut Seorang kritikus) yang memodelkan fungsi skor. Pendekatan ini pada prinsipnya dapat lebih efisien dalam pengaturan dengan tindakan berdimensi sangat tinggi di mana tindakan pengambilan sampel memberikan cakupan yang buruk, namun sejauh ini tampaknya agak sulit untuk bekerja dengan giat. Pendekatan lain yang terkait adalah meningkatkan robotika, karena kita mulai melihat dengan ladang robot robot milik Google, atau mungkin juga model Tes S + Autopilot Tesla.

Ada juga sederet pekerjaan yang mencoba membuat proses pencarian kurang putus asa dengan menambah pengawasan tambahan. Dalam banyak kasus praktis, misalnya, seseorang dapat memperoleh lintasan ahli dari manusia. Misalnya AlphaGo pertama menggunakan pembelajaran yang diawasi untuk memprediksi pergerakan manusia dari permainan Go yang ahli dan kebijakan menirukan manusia yang dihasilkan kemudian disempurnakan dengan gradien kebijakan pada tujuan "nyata" untuk memenangkan permainan. Dalam beberapa kasus, seseorang mungkin memiliki lebih sedikit lintasan pakar (misalnya dari teleoperasi robot) dan ada teknik untuk memanfaatkan data ini di bawah payung pembelajaran magang. Akhirnya, jika tidak ada data yang diawasi disediakan oleh manusia, hal itu juga dapat dalam beberapa kasus dihitung dengan teknik pengoptimalan yang mahal, mis. Dengan optimasi lintasan dalam model dinamika yang diketahui (seperti F = maF = ma dalam simulator fisik), atau dalam kasus di mana seseorang mempelajari model dinamika lokal perkiraan (seperti yang terlihat pada kerangka Pencarian Kebijakan Terpandu yang sangat menjanjikan).

Saat menggunakan PG dalam praktek. Sebagai catatan terakhir, kami ingin melakukan sesuatu yang kami harap telah kami lakukan di pos blog RNN kami. Kami rasa kami mungkin telah memberi kesan bahwa RNN adalah sihir dan secara otomatis melakukan masalah berurutan yang sewenang-wenang. Yang benar adalah bahwa membuat model ini bekerja dapat menjadi rumit, membutuhkan perawatan dan keahlian, dan dalam banyak kasus juga bisa menjadi berlebihan, di mana metode sederhana bisa membuat Anda 90% + jalan ke sana. Hal yang sama berlaku untuk Gradien Kebijakan. Mereka tidak otomatis: Anda memerlukan banyak sampel, itu akan melatih selamanya, sulit untuk melakukan debug saat tidak bekerja. Kita harus selalu mencoba pistol BB sebelum meraih Bazooka. Dalam kasus Reinforcement Learning misalnya, satu dasar kuat yang harus selalu dicoba terlebih dahulu adalah metode cross-entropy (CEM), pendekatan "tebak dan cek tebakan stokastik yang sederhana yang terinspirasi secara longgar oleh evolusi. Dan jika Anda bersikeras mencoba Gradien Kebijakan untuk masalah Anda, pastikan Anda memperhatikan bagian trik di kertas, mulailah yang sederhana dulu, dan gunakan variasi PG yang disebut TRPO, yang hampir selalu bekerja lebih baik dan lebih konsisten daripada vanilla PG di praktek. Gagasan utamanya adalah untuk menghindari perubahan parameter yang mengubah kebijakan Anda terlalu banyak, karena ditegakkan oleh kendala pada perbedaan KL antara distribusi yang diprediksi oleh kebijakan lama dan baru pada sekumpulan data (bukan gradien konjugasi Instansiasi sederhana dari ini Ide bisa diimplementasikan dengan melakukan pencarian garis dan pengecekan KL di sepanjang jalan).

Karakter/objek pada game pong berbasis arduino.

Spesifikasi sistem yang akan dibuat adalah sebagai berikut:

·         Menggunakan development board Arduino Uno

·         Menggunakan FreeRTOS sebagai operating system pada konsol

·         Menggunakan joystick sebagai input, dimana player menggerakkan joystick ke atas atau ke bawah

·         Menggunakan layar OLED untuk menampilkan game Pong yang dijalankan

·         Permainan terdiri dari dua buah paddle, dimainkan oleh dua orang player, yang saling memantulkan bola, dengan objektif menggolkan bola ke arah lawan sebanyak-banyaknya, ke daerah lawan yang tidak ber-paddle

·         Skor bertambah setiap bola berhasil mencapai daerah lawan

·         Permainan selesai ketika skor salah satu pemain mencapai 10

Mengimplementasikan Mekanisme Karakter Game Pong

Setelah objek muncul, maka kita perlu mengimplementasikan mekanisme dasar game yang kira-kira sebagai berikut:

1.    Objek bola bergerak di koordinat x dan y

2.    Objek player bergerak mengikuti perintah dari joystick

3.    Jika bola menyentuh player, maka ia akan memantul

4.    Jika bola berjalan melewati player, maka bola dikembalikan ke posisi awal dan permainan dimulai lagi

Semua mekanisme ini akan berjalan berulang-ulang selama game dimainkan. Oleh karena itu, ini semua akan dilakukan di dalam fungsi yang belum kita sentuh sebelumnya.

Menampilkan Aset Grafik

Permainan Pong setidaknya membutuhkan 3 aset grafik:

1.    Grafik untuk player 1

2.    Grafik untuk player 2

3.    Grafik untuk bola

Menggunakan aset persegi panjang untuk kedua player, serta sebuah aset titik sebagai grafik untuk bola.

2.    Pemodelan Sistem

Pemodelan sistem dilakukan untuk mempermudah proses desain game sehingga memudahkan pengertian desain yang dirancang. Pemodelan terdiri dari flowchart, state chart, context diagram, dan data flow diagram.

Gambar 2.1 Context diagram dari game Pong

Terdapat satu buah proses dan tiga buah terminator pada context diagram game Pong dengan masing-masing flow yang menghubungkan terminator dan flow. Terminatornya adalah input dari kedua player dan output di layar OLED, sedangkan prosesornya adalah sistem game Pong tersebut dengan flow antar komponen seperti Gambar 2.1 di atas.

Gambar 2.2 Data flow diagram dari game Pong

Sistem game Pong yang kami rancang memiliki dua buah input dari joystick masing masing player. Player mengarahkan joystick ke atas atau ke bawah sesuai keinginan dengan tujuan untuk mengontrol paddle menghindari bola masuk ke daerahnya. Ketika bola mengenai paddle, bola akan memantul, akan tetapi, ketika bola memasuki daerah lawan, skor akan bertambah. Pembacaan dari joystick menghasilkan range angka 0 – 1024, dengan 0 berarti sangat ke bawah, 1024 sangat ke atas, dan 511 dibiarkan di tengah. Prosesor mengambil angka ini dan menerjemahkan range 0 – 510 menjadi player mengarahkan paddle  ke bawah, 512 – 1024 ke atas, dan 511 berarti paddle diam saja.

Output dari proses penggambaran adalah keluaran keseluruhan permainan yang mencakup pergerakan paddle, bola, dan skor.

Gambar 2.3 Flowchart task readJoystick pada game Pong

Task readJoystick berfungsi untuk membaca gerakan yang diberikan player pada penggerak joystick. Joystick sendiri adalah resistor pembatas yang dapat memberikan nilai 0 – 1024 pada dua sumbu. Sebelum task dapat diimplementasikan, task ini diinisiasi dengan meng-assign pin dari joystick di Arduino. Jangka nilai dari joysticktersebut, pada mikrokontroler, akan diterjemahkan menjadi perintah ke mikrokontroler.

Gambar 2.4 Flowchart task draw pada game Pong

Pada task ini, layar OLED diinisiasi dengan library U8GLIB yang terdapat di website referensi Arduino. Setelah menginisiasi layar dengan resolusi yang tepat, keluaran dari mikrokontroler akan tampil di layar OLED.

Task draw pada FreeRTOS Arduino diimplementasikan dalam loop do – while. Pertama, base statis dari game digambar pada layar OLED, yaitu garis tengah pembatas area dua player. Selanjutnya, bola berupa piksel juga digambar pada layar OLED, bersama dengan dua paddle player.

Gambar 2.5 Flowchart task drawPlayer pada game Pong

Task drawPlayer1 dan drawPlayer2 berfungsi untuk menggambar paddle kedua player yang dapat digerakkan ke atas dan ke bawah sesuai arahan joystick. Task drawPlayer akan diimplementasikan oleh task draw ke layar OLED.

Gambar 2.6 Flowchart task drawBall pada game Pong

Task drawBall berfungsi untuk menggambar bola berupa piksel yang akan memantul jika terkena paddle player dan menambah skor jika memasuki area lawan.

Gambar 2.7 Flowchart task drawCentralLine pada game Pong

Task drawCentralLine berfungsi untuk menggambar garis putus-putus di tengah layar yang membatasi dua area player.

Gambar 2.8 Flowchart game Pong

Ketika sistem mulai dijalankan, dilakukan pendefinisian library, konstanta, dan variabel yang digunakan. Setelah itu, dilakukan pendefinisian variabel dan task yang digunakan untuk membuat task, mengatur task, dan semaphore. Dilakukan inisiasi penggunaan joystick, layar OLED, dan variabel-variabel yang berhubungan dengan game lainnya.

Setelah inisiasi keseluruhan selesai, pada layar OLED digambar dasar permainan, yaitu paddle masing-masing pemain, bola, dan garis pembatas. Masing-masing gambar memiliki task secara independen, yaitu drawPlayer1, drawPlayer2, drawBall, dan drawCentralLine. Fungsi setiap task akan dijelaskan melalui masing-masing flowchart-nya. Untuk menghindari deadlock semua task, dibuat semaphore sebagai tanda pergantian keberjalanan task.

Implementasi Sistem

Algoritma diimplementasikan dengan arsitektur FreeRTOS, sehingga task­–task dieksekusi bergantian.

1.    Task draw (ke layar OLED)

Task yang dijalankan secara iteratif ini berfungsi untuk memanggil ketiga task draw lainnya setelah delay-delay yang ditentukan. Sebelum task ini dapat dijalankan, diperlukan inisiasi dengan library U8GLIB yang disesuaikan dengan layar OLED.

2.    Task readJoystick

Task ini akan membaca pergerakan player oleh joystick, menghasilkan angka sebagai masukan, dan mengirim angka tersebut ke mikrokontroler. Oleh mikrokontroler, perintah berupa angka tersebut diterjemahkan sebagai ‘paddle ke atas’ atau ‘paddle ke bawah’.

3.    Task drawCentralLine

Task ini adalah rangkaian piksel yang ditampilkan persis di tengah layar sebagai pembatas area player 1 dengan player 2.

4.    Task drawBall

Task ini akan menggambar sebuah piksel yang berlaku sebagai bola. Bola akan bergerak ke arah paddle player acak pada permulaan permainan. Bola akan memantul jika mengenai paddle player dan akan menambah skor player lawan jika tidak mengenai paddle di areanya.

5.    Task drawPlayer

Task ini akan menggambar dua buah garis, berlaku sebagai paddle untuk memantulkan bola, yang masing-masing dapat dikontrol secara independen oleh dua player melalui dua buah joystick.

4.    Analisis Sistem

Pada proyek ini, shared resources-nya adalah variabel-variabel global untuk masukan dan keluaran. Variabel-variabel tersebut utamanya adalah integer yang akan diisi dengan nilai dari joystick dan akan diteruskan ke layar OLED, integer yang merupakan posisi bola di layar, dan integer posisi paddle di layar.

Karena oleh sistem, masukan dan keluaran dibutuhkan untuk bekerja secara simultan, variabel yang digunakan yang ditempatkan lokal di dalam task akan membutuhkan parameter global untuk kontinuitas perubahan nilainya. Untuk meng-handle shared resources agar tidak terjadi deadlock pada keberjalanan task-task, digunakan semaphore yang diimplementasikan di tiap task.