Tentang proyek ini
Hambatan MENGHINDARI ROBOT MENGGUNAKAN AI/REINFORCEMENT LEARNING
Pernyataan Masalah: Tujuan utamanya adalah belajar menghindari rintangan di Episode "N" dan mempelajari tindakan yang optimal. Dalam hal ini, mari kita asumsikan kita membutuhkan Robot kita untuk mempelajari tindakan optimal sebagai 'Benar'.
Algoritma Penguatan yang Digunakan: Pembelajaran Q
Bagaimana L298N Menggerakkan Dua Motor DC: 
Bagaimana Sensor HC-SR04 menghitung jarak: 
Istilah Penting dalam Pembelajaran Penguatan:
1. NEGARA: Ini adalah situasi di mana Robot berada. Di sini untuk Robot Penghindar Rintangan dasar, totalnya ada 2 status ......status pertama adalah ketika tidak ada penghalang di dekatnya dan status kedua di mana ada penghalang di depannya. (ketika saya menulis kode, saya berasumsi 10 berbeda negara dapat di mana diharapkan tindakan yang sama. Alasan saya melakukan ini untuk menggambarkan lingkungan yang lebih kompleks.)
2. TINDAKAN: Dalam keadaan tertentu robot melakukan tindakan tertentu. Ada 4 tindakan yang dapat dilakukan robot dalam keadaan ke-2:“FORWARD”, “BACKWARD”, “LEFT”, “STOP”. Dalam keadaan pertama, robot dapat melakukan 4 tindakan tetapi untuk mempermudah saya berasumsi bahwa robot hanya dapat melakukan satu tindakan yaitu “FOWARD”( Ini karena lumpuh untuk mempertimbangkan tindakan seperti KIRI atau Mundur ketika tidak ada rintangan di dekatnya.
int TINDAKAN =[0,1,2,3]
/* DI SINI :
0 =MAJU
1 =Mundur
2 =BERHENTI
3 =KANAN*/
3. NEGARA BERIKUTNYA: Ini adalah status yang didapat robot saat melakukan “TINDAKAN” . tertentu dalam “NEGARA” saat ini. Dalam rintangan menghindari kotak robot, NEXT STATE dapat berupa “HANCUR” negara bagian atau “SURVIVED” Negara. (Di sini status SURVIVE sama dengan status awal robot saat episodenya dimulai.)
/*SETELAH MELAKUKAN TINDAKAN, ROBOT MASUK KE NEGARA BERIKUTNYA DALAM KASUS KENDALA INI
HINDARI ROBOT*/
int NEXT_STATE;
int STATE =0;
NEXT_STATE =STATE+1;
4. TABEL Q / MATRIKS Q: Tabel ini dibentuk oleh Jumlah "NEGARA" dan Jumlah "TINDAKAN". Dalam Kasus Robot Penghindar Rintangan, Tabel ini diberikan oleh:
float Q[N_STATES][NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0 ,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0},
{0.0,0.0,0.0,0.0 }};
Di sini N_STATES =10 AND N_ACTIONS =4. di sini "0.0" menunjukkan bahwa tindakan apa pun dapat dilakukan dari salah satu dari 4 tindakan yang mungkin. jika Anda ingin menghilangkan partikel aksi dalam keadaan cukup ganti "0.0" dengan "-1.0" dalam matriks. "-1.0" menunjukkan bahwa tindakan tidak dapat dilakukan dalam keadaan itu. di sini diasumsikan bahwa kita memiliki 10 keadaan berbeda dengan setiap keadaan mengharapkan tindakan yang sama. jika Anda ingin robot Anda mempelajari tindakan yang berbeda di setiap negara bagian, maka ubah hadiah dari matriks hadiah dalam kode
5. NEGARA TERMINAL: Ini adalah status terakhir di mana robot dapat berada. Untuk Robot Penghindar rintangan, status ini tidak ada karena kami tidak memiliki status terminal dan ingin agar Robot kami terus belajar selamanya.
6. MATRIKS HADIAH: Tabel atau matriks ini digunakan untuk memberikan reward kepada robot untuk tindakan tertentu. Hadiahnya positif atau negatif tergantung pada kualitas tindakannya.
int REWARDS[STATES][NUMBER_OF_ACTIONS] ={{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10},
{-10,-2,-1,10}};
7. LINGKUNGAN: Ini juga dapat diasumsikan atau dianggap sebagai dunia bagi Robot. Sebagai contoh, kita manusia hidup di bumi jadi pada dasarnya bumi adalah lingkungan kita.
Hyperparameters dalam Pembelajaran Penguatan:
1. TINGKAT BELAJAR (ALPHA): Tingkat pembelajaran atau ukuran langkah menentukan sejauh mana informasi yang baru diperoleh mengesampingkan informasi lama. Faktor 0 membuat agen tidak belajar apa-apa (mengeksploitasi pengetahuan sebelumnya secara eksklusif), sedangkan faktor 1 membuat agen hanya mempertimbangkan informasi terbaru (mengabaikan pengetahuan sebelumnya untuk mengeksplorasi kemungkinan). Dalam lingkungan yang sepenuhnya deterministik, tingkat pembelajaran ALPHA =1,0 optimal. Ketika masalahnya adalah stokastik, algoritme konvergen di bawah beberapa kondisi teknis pada kecepatan pembelajaran yang mengharuskannya turun ke nol. Dalam praktiknya, sering kali kecepatan pembelajaran konstan digunakan, seperti ALPHA =0,1 untuk semua skenario.
float ALPHA =0.2;
2. FAKTOR DISKON (GAMMA): Faktor diskon 0 menentukan pentingnya imbalan di masa depan. Faktor 0 akan membuat agen "rabun" (atau picik) dengan hanya mempertimbangkan hadiah saat ini, sedangkan faktor yang mendekati 1 akan membuatnya berusaha keras untuk mendapatkan hadiah tinggi jangka panjang. Jika faktor diskon memenuhi atau melebihi 1, nilai tindakan mungkin berbeda. Untuk GAMMA =1.0, tanpa status terminal, atau jika agen tidak pernah mencapainya, semua histori lingkungan menjadi panjang tak terhingga, dan utilitas dengan tambahan, imbalan tak terdiskonto umumnya menjadi tak terhingga. Bahkan dengan faktor diskon hanya sedikit lebih rendah dari 1, Q pembelajaran fungsi mengarah pada penyebaran kesalahan dan ketidakstabilan ketika fungsi nilai didekati dengan jaringan saraf tiruan. Dalam hal ini, memulai dengan faktor diskonto yang lebih rendah dan meningkatkannya ke nilai akhir akan mempercepat pembelajaran.
float GAMMA =0.9;
3. TINGKAT EKSPLORASI (EPSILON): Parameter ini memutuskan sejauh mana robot harus menjelajahi lingkungan. Menjelajahi lingkungan berarti melakukan tindakan acak dan menganalisis hasil melalui Nilai Q. Biasanya, dalam Q Learning (tidak seperti SARSA) kami akhirnya menyingkirkan parameter ini karena Robot terus belajar lebih banyak dan lebih banyak lagi. Tetapi Dalam proyek ini, kami tidak akan menyingkirkan Epsilon karena kami tidak memiliki status terminal. Epsilon dalam hal ini akan berkurang sampai batas tertentu dan kemudian kembali diatur ulang ketika berada di bawah nilai ambang batas. Ini akan memastikan bahwa robot terus menjelajah sampai masa hidupnya seperti yang kita manusia lakukan.
mengambang EPSILON =0.75;
ALGORITMA PEMBELAJARAN Q:
- Inisialisasi tabel nilai-Q, Q(s, a) . Saya telah menginisialisasi nilai-nilai ini ke 0.0.
- Amati keadaan saat ini, s .
- Pilih tindakan, a , untuk status tersebut berdasarkan salah satu kebijakan pemilihan tindakan yang dijelaskan di sini di halaman sebelumnya (📷-soft, -greedy atau softmax).
/////////////////////////Epsilon Greedy Policy////////////// ///////////////
PROB =RANDOM(EPSILON);
if (PROB<=EPSILON) //JELAJAHI TINDAKAN
{
ACTION =random(0,4);
FLAG =2;
}
else //EKSPLOIT TINDAKAN DARI Q TABLE
{
ACTION =ARGMAX(Q,STATE);
BENDERA =2;
}
- Ambil tindakan, dan amati imbalannya, r , serta status baru, s' .
- Perbarui nilai-Q untuk keadaan menggunakan hadiah yang diamati dan hadiah maksimum yang mungkin untuk keadaan berikutnya. Pembaruan dilakukan sesuai dengan rumus dan parameter yang dijelaskan di atas.
- Setel status ke status baru, dan ulangi proses hingga status terminal tercapai.
- Untuk memahami Pembelajaran Q lebih baik kunjungi tautan ini:https://towardsdatascience.com/a-beginners-guide-to-q-learning-c3e2a30a653c
///////////////////Implementasi Rumus Q_Learning//////////////////// ////
Q_OLD =Q_TABLE[S][A];
Q_MAX =MAX(Q_TABLE, NEXT_S);
Q_NEW =(1-LEARNING_RATE)*Q_OLD + LEARNING_RATE*(R + DISCOUNT_FACTOR*Q_MAX);
Serial.print("Q VALUE :");
Serial.println(Q_NEW);
Q_TABLE[S][A] =Q_NEW;
Video Kerja:Jangan lupa cek video kerja Robot AI :)
Kode
- Robot Penghindar Rintangan menggunakan Q-LEARNING
Robot Penghindar Rintangan menggunakan Q-LEARNINGC/C++
INI ADALAH KODE UTAMA ROBOT OBSTACLE AVOIDANCE BERBASIS KECERDASAN BUATAN./* Ini adalah Robot Penghindar Hambatan menggunakan Reinforcement Learning/AI Penulis Proyek ini :Varun Walimbe Algoritma yang digunakan dalam proyek ini:Q learningHow Obstacle Avoiding Works?1.Ultrasonic sensor digunakan mengukur jarak dari rintangan menggunakan Echo dan Trig Pins.2.Ketika jarak diukur dan jika kurang dari 20cm maka ada rintangan di dekatnya jika tidak robot aman dan terus Maju.3.Jika rintangan terdeteksi maka robot mengambil belok kiri atau kanan tergantung situasi. Bagaimana Penghindaran Rintangan berbasis AI Bekerja? (P belajar) 1. Di sini langkah 1 dari artikel atas tetap sama. Namun Langkah ke-2 berbeda. 2. Daftar tindakan robot adalah diinisialisasi terlebih dahulu. Misalnya dalam hal ini tindakan Robot adalah:Kiri, Maju, Mundur, Berhenti.3. Ketika Robot mendekati rintangan maka diperlukan untuk melakukan suatu tindakan. Namun perhatikan bahwa dalam hal ini Robot tidak tahu tindakan mana yang harus diambil karena tidak diprogram sebelumnya dan akan belajar sendiri untuk menghindari rintangan.4.Ketika Robot berhenti ketika ada rintangan di depannya maka ia mendapat hadiah sebagai 0 Ketika Robot berhenti dan mundur ia menerima hadiah -5 Ketika Robot terus bergerak maju mengabaikan rintangan, ia menerima hadiah -10 Ketika Robot hanya bergerak ke kiri segera setelah rintangan terdeteksi, ia mendapat hadiah +105. Dengan cara ini Robot belajar sendiri untuk menghindari rintangan dengan Mekanisme Penghargaan.*///////////PARAMETER PERANGKAT KERAS ROBOT///////////////////int TRIG_PIN =7;int ECHO_PIN =8;int durasi;float distance;int M1 =13;int M2 =12;int M3 =11;int M4 =10;bool Hambatan =false;int FLAG;////////// ///////////////AKHIR////////////////////////////////// ///////////////////////////////Q PARAMETER PEMBELAJARAN/////////////// ///////////////////////////float ALPHA =0.1; //LEARNING RATEfloat GAMMA =0,5; //FAKTOR DISKON mengambang EPSILON =0.90; //PARAMETER EKSPLORASIint HADIAH; //HADIAH UNTUK MELAKUKAN EPISODE TINDAKANint =100;int NEGARA; // NEGARA SAAT INI TINDAKAN ROBOTint =0; //TINDAKAN YANG DILAKUKAN OLEH ROBOT(0:FORWARD,1:BACKWARD ,2;STOP,3:LEFT)float PROB; // DIGUNAKAN UNTUK EPSILON DECAY bool ACTION_TAKEN =false; //VARIABEL INI MEMBERITAHU KITA APAKAH TINDAKAN DIAMBIL ATAU TIDAK NEXT_STATE; // NEGARA BERIKUTNYA DARI ROBOTconst int NEGARA =10; //JUMLAH NEGARA DALAM LINGKUNGAN int TINDAKAN[4] ={1,2,3,4};const int NUMBER_OF_ACTIONS =4; //TOTAL KITA MEMILIKI 4 AKSI MAJU, Mundur, KIRI DAN BERHENTI/*INI ADALAH MATRIKS Q ATAU TABEL Q. INI DASARNYA DIARY YANG AKAN DILIHAT ROBOT SEBELUM MELAKUKAN TINDAKAN. BERDASARKAN TINDAKAN, ROBOT AKAN MENDAPATKAN HADIAH DAN NILAI Q AKAN DIPERBARUI DI TABEL Q INI. DI SINI SAYA TELAH MEMPERTIMBANGKAN 10 NEGARA. SAYA TELAH MENANGGUNG SEMUA NEGARA BERBEDA MESKIPUN MEREKA SAMA. PADA DASARNYA PENGHINDARI ROBOT MENGHINDARI ROBOT HANYA MENGANDUNG DUA NEGARA Yaitu:1:KETIKA JAUH DARI Hambatan 2:KETIKA ITU DEKAT DENGAN OBSTACLEBUT DI SINI MENYELESAIKAN ILUSTRASI 10 NEGARA BERBEDA DI SINI MENGHARAPKAN TINDAKAN YANG SAMA/BERBEDA.*/float Q[STATES][NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0}, //PALING PENTING DARI SEMUA ADALAH Q TABLE. {0.0,0.0,0.0,0.0}, //DIBENTUK OLEH NEGARA-NEGARA SEBAGAI BARISNYA {0.0,0.0,0.0,0.0}, //DAN KOLOM SEBAGAI JUMLAH TINDAKANNYA {0.0,0.0,0.0,0.0}, / / DIINTIALISASI KE NOL DI MULAI {0.0,0.0,0.0,0.0}, // INI AKAN DIPERBARUI DI MASA DEPAN. {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}};/*INI ADALAH MATRIKS HADIAH ATAU TABEL HADIAH. INI BERTANGGUNG JAWAB UNTUK MEMBERIKAN REWARD KEPADA ROBOT UNTUK MELAKUKAN TINDAKAN TERTENTU. TI MENYIMPAN HADIAH UNTUK SETIAP TINDAKAN YANG DIAMBIL DI NEGARA. HADIAH AKAN POSITIF JIKA TINDAKAN YANG DILAKUKAN BAIK DAN NEGATIF JIKA TINDAKAN MEMBERI HASIL YANG BURUK.*/int REWARDS[STATES][NUMBER_OF_ACTIONS] ={{-10,-2,-1,10}, {-10,-2 ,-1,10}, {-10,-2,-1,10}, {-10,-2,-1,10}, {-10,-2,-1,10}, {-10, -2,-1,10}, {-10,-2,-1,10}, {-10,-2,-1,10}, {-10,-2,-1,10}, {- 10,-2,-1,10}}; ////////////////////////////////////////////AKHIR///// ////////////////////////////////////////////////////////////////// ////////////Q PARAMETER PEMBARUAN PEMBELAJARAN////////////float Q_OLD;float Q_NEW;float Q_MAX;//////////// /////////////END////////////////////////void setup() { Serial.begin (9600 ); pinMode(TRIG_PIN,OUTPUT); pinMode(ECHO_PIN,INPUT); pinMode(M1, OUTPUT); pinMode(M2,OUTPUT); pinMode(M3,OUTPUT); pinMode(M4,OUTPUT); randomSeed(analogRead(A0)); NEGARA =0; Serial.println("PELATIHAN AKAN DIMULAI DALAM 5 DETIK:"); delay(5000);} ///////////////////////////FUNGSI ROBOT////////////// ///////////////////void Forward(){ digitalWrite(M1,LOW); digitalWrite(M2,TINGGI); digitalWrite(M3,RENDAH); digitalWrite(M4,TINGGI); }kosong Mundur(){ digitalWrite(M1,HIGH); digitalWrite(M2,RENDAH); digitalWrite(M3,TINGGI); digitalWrite(M4,LOW);}kosong Kiri(){ digitalWrite(M1,HIGH); digitalWrite(M2,RENDAH); digitalWrite(M3,RENDAH); digitalWrite(M4,HIGH);}kosong Kanan(){ digitalWrite(M1,LOW); digitalWrite(M2,TINGGI); digitalWrite(M3,TINGGI); digitalWrite(M4,LOW);}void Stop(){ digitalWrite(M1,LOW); digitalWrite(M2,RENDAH); digitalWrite(M3,RENDAH); digitalWrite(M4,LOW);}bool Obstacle_Avoider(){ digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10); digitalWrite(TRIG_PIN, RENDAH); durasi =pulseIn(ECHO_PIN ,HIGH); jarak =(durasi/2)/29.1; if(jarak<15) { Hambatan =benar; } if(jarak>15) { Hambatan =salah; } penundaan (10); kembali Rintangan;}////////////////////////////////////////////////////////////END/ ////////////////////////////////////////////////////////////////// ///////////////////////////FUNGSI PEMBELAJARAN Q ROBOT ////////////////// //////////////////float RANDOM(float EXPLORATION_PARAMETER){ /*FUNGSI INI MENEMUKAN NOMOR RANDOM YANG MEMUTUSKAN APAKAH TINDAKAN YANG DILAKUKAN RANDOM ATAU DARI Q_TABLE*/ float RANDOM_VARIABLE; PROBABILITAS mengambang; RANDOM_VARIABLE =acak(0,100); PROBABILITAS =RANDOM_VARIABEL/100; return PROBABILITY;}float DECAY(float PARAMETER){ /*FUNGSI INI DIGUNAKAN UNTUK MENGURANGI EPSILON(EXPLORATION PARAMETER) DENGAN WAKTU.AKHIRNYA PADA AKHIRNYA ANDA MENDAPATKAN EPSILON DAN ROBOT BELAJAR UNTUK MENGHINDARI Hambatan PARAMETER SENDIRI =*/ PARAMETER SENDIRI *0,98; //PARAMETER DI SINI ADALAH EPSILON return PARAMETER;}int GET_STATE(){ int STATE_NUMBER; STATE_NUMBER =acak(0,10); return STATE_NUMBER;}float MAX(float Q_Table[][4],int NEXT_S){ /*FUNGSI INI MENCARI NOMOR TERBESAR DI Q_TABLE[NEXT_STATE]. PERAN UTAMA FUNGSI INI ADALAH UNTUK MENCARI PARAMETER Q_MAX*/ DAFTAR float[4]; mengapung N1; mengapung N2; mengapung MAX_VALUE=0,0; mengambang DIFF; for(int b =0; b<=3; b++) { LIST[b] =Q[NEXT_S][b]; } untuk(int j =0; j<=2; j++) { if(MAX_VALUE>LIST[j]) { N1 =MAX_VALUE; } else { N1 =DAFTAR[j]; } N2 =DAFTAR[j+1]; DIFF =N1- N2; if(DIFF> 0) { MAX_VALUE =N1; } else { MAX_VALUE =N2; } } return MAX_VALUE;}int ARGMAX(float Q_Table[][4],int S){ /*FUNGSI INI MENEMUKAN INDEKS NILAI Q TERBESAR DI Q TABLE[STATE]*/ float ARRAY[4]; mengapung N1; mengapung N2; mengapung MAX_VALUE =0,0; mengambang DIFF; mengapung NOMOR; int MAX_INDEX; for(int u=0; u<=3; u++) { ARRAY[u] =Q_Table[S][u]; } untuk(int p =0; p<=2; p++) { if(MAX_VALUE>ARRAY[p]) { N1 =MAX_VALUE; } else { N1 =ARRAY[p]; } N2 =ARRAY[p+1]; DIFF =N1- N2; if(DIFF> 0) { MAX_VALUE =N1; } else { MAX_VALUE =N2; } } untuk(int r =0; r<=3;r++) { NOMOR =ARRAY[r]; if(NUMBER ==MAX_VALUE) { MAX_INDEX =r; merusak; } } return MAX_INDEX;}void Update(float Q_TABLE[][4] , int S, int NEXT_S, int A, int ACTIONS[], int R, float LEARNING_RATE, float DISCOUNT_FACTOR){ /*FUNGSI INI MEMPERBARUI TABEL Q DAN NILAI Q. PEMBARUAN INI TERUS TERJADI SAMPAI LOOP UTAMA BERAKHIR. DI AKHIR EPISODE TABEL Q DIISI DENGAN BERBAGAI NILAI. LEBIH BESAR NILAI-NILAI LEBIH PENTINGNYA TINDAKAN DI NEGARA TERTENTU. "Q_OLD" ADALAH NILAI LAMA YANG DIMILIKI MATRIKS Q. INILAH NILAI YANG AKHIRNYA DIPERBARUI. Q_NEW ADALAH Q_VALUE BARU YANG DIHITUNG DENGAN FORMULA PEMBELAJARAN Q. FORMULA PEMBELAJARAN Q YANG DIGUNAKAN DI SINI BERDASARKAN PERSAMAAN BELLMAN MENGGUNAKAN PENDEKATAN PEMBELAJARAN TEMPORAL DIFFERENCE LEARNING.(PENDEKATAN MONTE CARLO TIDAK AKAN BEKERJA DALAM KASUS OBSTACLE MENGHINDARI ROBOT.*/ Q_OLD =Q_TABLE[S][A]; Q_MAX =MAX, NEXT_S); Q_NEW =(1-LEARNING_RATE)*Q_OLD + LEARNING_RATE*(R + DISCOUNT_FACTOR*Q_MAX); Serial.print("Q VALUE :"); Serial.println(Q_NEW); Q_TABLE[S][A] =Q_NEW; }//////////////////////////////////////////////////////////////// ///////////AKHIR////////////////////////////////////// ////////////////////////////////////////////////////////////////// ////////////////MULAI LOOP UTAMA///////////////////////////// ///////////////////void loop() { ////////////////////////////////////////////// ///////////////PELATIHAN////////////////////////////////// ////////// for(int I =0; I Schematics
obstacle_avoiding_robot_using_ai_DcoMCWIOFm.fzz
