Избегание препятствий с помощью искусственного интеллекта

Необходимые инструменты и машины

	Паяльник (общий)
	Проволока для припоя, без свинца
	Флюс для припоя, пайка
	Насос для удаления припоя, Deluxe SOLDAPULLT®
	Инструмент для зачистки и резки проводов, 18–10 AWG / 0,75–4 мм² Емкость проводов
	Пистолет для горячего клея (общий)
	Лента, двусторонняя

Приложения и онлайн-сервисы

IDE Arduino

Об этом проекте

РОБОТ ИЗБЕГАЮЩИХ ПРЕПЯТСТВИЙ, ИСПОЛЬЗУЯ ИИ / ОБУЧЕНИЕ ПО УСИЛЕНИЮ

Постановка проблемы: Основная цель - научиться избегать препятствий в «N» эпизодах и научиться оптимальному действию. В этом случае предположим, что нам нужно, чтобы наш робот научился оптимальному действию как «Правильно».

Используемый алгоритм усиления: Q обучение

Как L298N приводит в действие два двигателя постоянного тока:

Как датчик HC-SR04 рассчитывает расстояние:

Важные термины в обучении с подкреплением:

1. СОСТОЯНИЕ: Это та ситуация, в которой находится робот. Здесь для базового робота, уклоняющегося от препятствий, всего 2 состояния ... 1-е состояние - это когда рядом нет препятствия, а 2-е состояние, при котором есть препятствие перед ним. (Когда я писал код, я предполагал 10 различных могут быть состояния, в которых ожидается одно и то же действие. Причина, по которой я сделал это, чтобы проиллюстрировать более сложную среду.)

2. ДЕЙСТВИЕ: В определенном состоянии робот выполняет определенное действие. Во втором состоянии робот может выполнять 4 действия: «ВПЕРЕД», «НАЗАД», «ВЛЕВО», «СТОП». В 1-м состоянии робот может выполнять 4 действия, но, чтобы упростить задачу, я предположил, что робот может выполнять только одно действие, а именно «ВПЕРЕД» ( Это потому, что неуместно рассматривать такие действия, как ВЛЕВО или НАЗАД когда поблизости нет препятствий.

  int ACTIONS =[0,1,2,3] 
 
 / * ЗДЕСЬ:
 0 =ВПЕРЕД 
 1 =НАЗАД 
 2 =СТОП 
 3 =ВПРАВО * /  

3. СЛЕДУЮЩЕЕ СОСТОЯНИЕ: Это состояние, в которое попадает робот, когда он выполняет определенное ДЕЙСТВИЕ . в его текущем «СОСТОЯНИИ». Если робот объезжает препятствие, отображается СЛЕДУЮЩЕЕ СОСТОЯНИЕ может быть либо «АВАРИЙНЫЙ» состояние или «ВЫЖИЛИ» Состояние. (Здесь состояние ВЫЖИВАНИЯ такое же, как начальное состояние, в котором находится робот, когда начинается его эпизод.)

  / * ПОСЛЕ ВЫПОЛНЕНИЯ ДЕЙСТВИЯ РОБОТ ПЕРЕХОДИТ В СЛЕДУЮЩЕЕ СОСТОЯНИЕ В ЭТОМ СЛУЧАЕ ПРЕПЯТСТВИЯ 
 ИЗБЕЖАНИЕ РОБОТА * / 
 
 int NEXT_STATE; 
 int STATE =0; 
 NEXT_STATE =STATE + 1;  

4. Q ТАБЛИЦА / Q МАТРИЦА: Эта таблица состоит из количества «СОСТОЯНИЙ» и количества «ДЕЙСТВИЙ». В случае робота для уклонения от препятствий эта таблица представлена:

  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 }};  

Здесь N_STATES =10 И N_ACTIONS =4. здесь «0.0» означает, что любое действие может быть выполнено из любого из 4 возможных действий. если вы, однако, хотите удалить твердые частицы действие в состоянии просто замените «0,0» на «-1,0» в матрице. «-1.0» указывает, что действие не может быть выполнено в этом состоянии. здесь предполагается, что у нас есть 10 различных состояний, каждое из которых ожидает одного и того же действия. если вы хотите, чтобы ваш робот обучался действиям, которые различаются в каждом состоянии, измените вознаграждение из матрицы вознаграждений в коде

5. СОСТОЯНИЕ ТЕРМИНАЛА: Это последнее состояние, в котором может находиться робот. Для робота, избегающего препятствий, этого состояния не существует, поскольку у нас нет конечного состояния и мы хотим, чтобы наш робот учился вечно.

6. МАТРИЦА НАГРАД: Эта таблица или матрица используется для вознаграждения робота за определенные действия. Награда бывает положительной или отрицательной в зависимости от качества действия.

  int НАГРАДЫ [СОСТОЯНИЯ] [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. ОКРУЖАЮЩАЯ СРЕДА: Это также можно считать миром для роботов. Например, мы, люди, живем на Земле, поэтому в основном Земля - ​​это наша среда.

Гиперпараметры в обучении с подкреплением:

1. СТАВКА ОБУЧЕНИЯ (АЛЬФА): Скорость обучения или размер шага определяют, в какой степени вновь полученная информация перекрывает старую. Фактор 0 заставляет агента ничего не узнавать (исключительно используя предыдущие знания), в то время как коэффициент 1 заставляет агента рассматривать только самую последнюю информацию (игнорируя предыдущие знания для изучения возможностей). В полностью детерминированных средах скорость обучения ALPHA =1.0 является оптимальной. Когда проблема является стохастической, алгоритм сходится при некоторых технических условиях по скорости обучения, которые требуют ее уменьшения до нуля. На практике часто используется постоянная скорость обучения, например ALPHA =0,1 для всех сценариев.

  float ALPHA =0,2;  

2. КОЭФФИЦИЕНТ СКИДКИ (ГАММА): Коэффициент дисконтирования, равный 0, определяет важность будущих вознаграждений. Коэффициент, равный 0, сделает агента «близоруким» (или близоруким), учитывая только текущие вознаграждения, в то время как коэффициент, приближающийся к 1, заставит его стремиться к долгосрочному высокому вознаграждению. Если коэффициент скидки равен или превышает 1, значения действий могут отличаться. Для ГАММА =1.0, без конечного состояния или если агент никогда не достигает его, все истории среды становятся бесконечно длинными, а полезности с дополнительными недисконтированными вознаграждениями обычно становятся бесконечными. Даже если коэффициент дисконтирования немного меньше 1, Q обучение функции приводит к распространению ошибок и нестабильности при аппроксимации функции цены с помощью искусственной нейронной сети. В этом случае, если начать с более низкого коэффициента дисконтирования и увеличить его до конечного значения, обучение будет ускоряться.

  float GAMMA =0.9;  

3. ИССЛЕДОВАНИЕ (ЭПСИЛОН): Этот параметр определяет, в какой степени робот должен исследовать окружающую среду. Изучение окружающей среды означает выполнение случайных действий и анализ результатов с помощью значений Q. Обычно в Q Learning (в отличие от SARSA) мы в конце концов избавляемся от этого параметра, поскольку робот продолжает учиться все больше и больше. Но в этом проекте мы не собираемся избавляться от Epsilon, так как у нас нет конечного состояния. В этом случае Epsilon в некоторой степени снизится, а затем снова сбросится, когда оно опустится ниже порогового значения. Это гарантирует, что робот будет продолжать исследовать до конца своей жизни, как и мы, люди.

  float EPSILON =0,75;  

АЛГОРИТМ Q-ОБУЧЕНИЯ:

• Инициализировать таблицу значений Q, Q (s, a) . Я установил эти значения равными 0,0.
• Обратите внимание на текущее состояние, s .
• Выберите действие, a для этого состояния на основе одной из политик выбора действий, описанных здесь на предыдущей странице (📷-soft, 📷-greedy или softmax).

  ////////////////////////// Жадная политика Epsilon /////////////// /////////////// 
 
 PROB =RANDOM (EPSILON); 
 if (PROB <=EPSILON) // ИЗУЧИТЕ ДЕЙСТВИЯ 
 {
 ACTION =random (0,4); 
 FLAG =2; 
} 
 else // ИСПОЛЬЗУЙТЕ ДЕЙСТВИЯ ИЗ ТАБЛИЦЫ Q 
 {
 ДЕЙСТВИЕ =ARGMAX (Q, СОСТОЯНИЕ); 
 ФЛАГ =2; 
}  

• Действуйте и получайте награду, r , а также новое состояние s ' .
• Обновите Q-значение для состояния, используя наблюдаемое вознаграждение и максимально возможное вознаграждение для следующего состояния. Обновление производится в соответствии с формулой и параметрами, описанными выше.
• Установите новое состояние и повторяйте процесс, пока не будет достигнуто конечное состояние.
• Чтобы понять Q-обучение лучше посетить эту ссылку:https://towardsdatascience.com/a-beginners-guide-to-q-learning-c3e2a30a653c

  ///////////////////// Реализация формулы 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;  

Рабочее видео:не забудьте посмотреть рабочее видео AI Robot :)

Код

• Робот для предотвращения препятствий, использующий Q-LEARNING

Робот для предотвращения препятствий, использующий Q-LEARNING C / C ++

 / * Это робот для избегания препятствий, использующий обучение с подкреплением / искусственный интеллект Автор этого проекта:Варун Валимбэ Алгоритм, использованный в этом проекте:Q LearningКак работает предотвращение препятствий? 1.Ultrasonic датчик используется для измерения расстояния от препятствия с помощью его эхо-сигналов и триггеров. 2. когда расстояние измеряется и если оно меньше 20 см, значит поблизости есть препятствие, в противном случае робот находится в безопасности и продолжает движение вперед. 3. при обнаружении препятствия робот берет повернуть налево или направо в зависимости от ситуации. Как работает AI, основанный на предотвращении препятствий? (Q-обучение) 1. Здесь 1-й шаг из верхней статьи остается прежним. Однако 2-й шаг отличается. 2. Список действий робота инициализирован первым. Например, в этом случае действия робота следующие:влево, вперед, назад, стоп. 3. Когда робот приближается к препятствию, необходимо выполнить действие. Однако обратите внимание, что в этом случае робот не знает, какое действие следует предпринять, поскольку он не запрограммирован заранее и будет учиться самостоятельно, чтобы избегать препятствий. 4. Когда робот останавливается, когда перед ним есть препятствие, он получает вознаграждение в виде 0 Когда робот останавливается и движется назад, он получает награду -5. Когда робот продолжает двигаться вперед, игнорируя препятствия, он получает награду -10. Когда робот просто перемещается влево, как только обнаруживается препятствие, он получает награду +105. самостоятельно учится избегать препятствий с помощью механизма вознаграждения. * /////////// ОБОРУДОВАНИЕ РОБОТА; int ECHO_PIN =8; int duration; float distance; int M1 =13; int M2 =12; int M3 =11; int M4 =10; bool Obstacle =false; int FLAG; ////////// ///////////////КОНЕЦ////////////////////////////////// //////////////////////////////// Q ПАРАМЕТРЫ ОБУЧЕНИЯ /////////////// //////////////////////////// float ALPHA =0.1; // СКОРОСТЬ ОБУЧЕНИЯfloat GAMMA =0.5; // КОЭФФИЦИЕНТ СКИДКИ float EPSILON =0.90; // ПАРАМЕТРЫ ИССЛЕДОВАНИЙint REWARD; // НАГРАДА ЗА ВЫПОЛНЕНИЕ ДЕЙСТВИЯ int EPISODES =100; int STATE; // ТЕКУЩЕЕ СОСТОЯНИЕ ДЕЙСТВИЯ ROBOTINT =0; // ДЕЙСТВИЕ, ВЫПОЛНЯЕМЫЕ РОБОТОМ (0:ВПЕРЕД, 1:НАЗАД, 2; СТОП, 3:ВЛЕВО) float PROB; // ИСПОЛЬЗУЕТСЯ ДЛЯ EPSILON DECAY bool ACTION_TAKEN =false; // ЭТИ ПЕРЕМЕННЫЕ СООБЩАЮТ НАМ, ПРИНИМАЕТСЯ ЛИ ДЕЙСТВИЕ ИЛИ НЕ ИНТЕРНЕТ NEXT_STATE; // СЛЕДУЮЩЕЕ СОСТОЯНИЕ РОБОТАconst int STATES =10; // КОЛИЧЕСТВО СОСТОЯНИЙ В СРЕДЕ int ACTIONS [4] ={1,2,3,4}; const int NUMBER_OF_ACTIONS =4; // ВСЕГО У НАС ЕСТЬ 4 ДЕЙСТВИЯ ВПЕРЕД, НАЗАД, ВЛЕВО И СТОП / * ЭТО МАТРИЦА Q ИЛИ ТАБЛИЦА Q. ЭТО БАЗОВЫЙ ДНЕВНИК, В КОТОРЫЙ РОБОТ БУДЕТ ЗАСЛУЖИВАТЬСЯ ПЕРЕД ВЫПОЛНЕНИЕМ ДЕЙСТВИЯ, НА ОСНОВЕ ДЕЙСТВИЯ, КОТОРЫЙ РОБОТ ПОЛУЧАЕТ НАГРАДУ, И В ЭТОЙ ТАБЛИЦЕ Q БУДЕТ ОБНОВЛЕНО ЗНАЧЕНИЕ Q. ЗДЕСЬ Я СОСТАВИЛ 10 ГОСУДАРСТВ. Я ПРИНЯЛ, ВСЕ СОСТОЯНИЯ РАЗЛИЧНЫ, ДАЖЕ ХОТЯ ОНИ ОНИ ОДИНАКОВЫ. В основном робот, избегающий препятствий, содержит только два состояния, например:1:КОГДА ЕГО ВНЕШНИЙ ПРЕПЯТСТВИЕ 2:КОГДА ЕГО ВБЛИЗИ ПРЕПЯТСТВИЯ, Я НАСТРАИВАЮСЬ, ЧТОБЫ ЕЕ СОЗДАТЬ 10 РАЗЛИЧНЫХ СОСТОЯНИЙ ЗДЕСЬ, ОЖИДАЮЩИЕ ОДИНАКОВЫЕ / РАЗНЫЕ ДЕЙСТВИЯ. * / Float Q [СОСТОЯНИЯ] [NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0}, // САМОЕ ВАЖНОЕ ИЗ ВСЕГО - ТАБЛИЦА Q. {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}}; / * ЭТО МАТРИЦА НАГРАД ИЛИ ТАБЛИЦА НАГРАД. ЭТО ОТВЕТСТВЕННОСТЬ ЗА ПРЕДОСТАВЛЕНИЕ РОБОТА ЗА ВЫПОЛНЕНИЕ ОПРЕДЕЛЕННЫХ ДЕЙСТВИЙ. НАГРАДА ЗА КАЖДОЕ ДЕЙСТВИЕ, ПРИНЯТОЕ НА ГОСУДАРСТВЕ. НАГРАДА БУДЕТ ПОЛОЖИТЕЛЬНОЙ, ЕСЛИ ВЫПОЛНЕННОЕ ДЕЙСТВИЕ ХОРОШО И ОТРИЦАТЕЛЬНО, ЕСЛИ ДЕЙСТВИЕ ДАЕТ ПЛОХОЙ РЕЗУЛЬТАТ. * / 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}}; ////////////////////////////////////////////КОНЕЦ///// ////////////////////////////////////////////////// //////////// ПАРАМЕТРЫ ОБНОВЛЕНИЯ ОБУЧЕНИЯ Q //////////// float Q_OLD; float Q_NEW; float Q_MAX; ///////////// ///////////// END ////////////////////////// void setup () {Serial.begin (9600 ); pinMode (TRIG_PIN, ВЫХОД); pinMode (ECHO_PIN, ВХОД); pinMode (M1, ВЫХОД); pinMode (M2, ВЫХОД); pinMode (M3, ВЫХОД); pinMode (M4, ВЫХОД); randomSeed (analogRead (A0)); СОСТОЯНИЕ =0; Serial.println («ОБУЧЕНИЕ НАЧНЕТСЯ ЧЕРЕЗ 5 СЕКУНД:»); delay (5000);} //////////////////////////// ФУНКЦИИ РОБОТА ////////////// /////////////////// void Forward () {digitalWrite (M1, LOW); digitalWrite (M2, ВЫСОКИЙ); digitalWrite (M3, LOW); digitalWrite (M4, ВЫСОКИЙ); } void Backward () {digitalWrite (M1, HIGH); digitalWrite (M2, LOW); digitalWrite (M3, HIGH); digitalWrite (M4, LOW);} void Left () {digitalWrite (M1, HIGH); digitalWrite (M2, LOW); digitalWrite (M3, LOW); digitalWrite (M4, HIGH);} void Right () {digitalWrite (M1, LOW); digitalWrite (M2, ВЫСОКИЙ); digitalWrite (M3, HIGH); digitalWrite (M4, LOW);} void Stop () {digitalWrite (M1, LOW); digitalWrite (M2, LOW); digitalWrite (M3, LOW); digitalWrite (M4, LOW);} bool Obstacle_Avoider () {digitalWrite (TRIG_PIN, HIGH); delayMicroseconds (10); digitalWrite (TRIG_PIN, LOW); duration =pulseIn (ECHO_PIN, HIGH); расстояние =(длительность / 2) / 29,1; if (distance <15) {Препятствие =true; } if (distance> 15) {Препятствие =false; } задержка (10); вернуть препятствие;} //////////////////////////////////////////// END / ////////////////////////////////////////////////// //////////////////////////// ФУНКЦИИ ОБУЧЕНИЯ Q РОБОТА ////////////////// ////////////////// float RANDOM (float EXPLORATION_PARAMETER) {/ * ЭТА ФУНКЦИЯ НАХОДИТ СЛУЧАЙНОЕ НОМЕР, КОТОРЫЙ РЕШАЕТ, БУДЕТ ЛИ ДЕЙСТВИЕ СЛУЧАЙНЫМ ИЛИ ИЗ Q_TABLE * / float RANDOM_VARIABLE; float ВЕРОЯТНОСТЬ; СЛУЧАЙНАЯ_ПЕРЕМЕННАЯ =случайная (0,100); ВЕРОЯТНОСТЬ =СЛУЧАЙНАЯ_ПЕРЕМЕННАЯ / 100; return PROBABILITY;} float DECAY (float PARAMETER) {/ * ЭТА ФУНКЦИЯ ИСПОЛЬЗУЕТСЯ ДЛЯ УМЕНЬШЕНИЯ ЭПСИЛОНА (ИССЛЕДОВАТЕЛЬСКИЙ ПАРАМЕТР) ПО ВРЕМЕНИ. НАКОНЕЦ В КОНЦЕ ВЫ ПОЛУЧАЕТЕ ЭПСИЛОН, И РОБОТ НАУЧАЕТСЯ ИЗБЕГАТЬ ПРЕПЯТСТВИЙ НА СВОЕЙ ЧАСТИ * / * 0,98; // ПАРАМЕТР ЗДЕСЬ ПАРАМЕТР возврата EPSILON;} int GET_STATE () {int STATE_NUMBER; СОСТОЯНИЕ ЧИСЛО =случайное (0,10); return STATE_NUMBER;} float MAX (float Q_Table [] [4], int NEXT_S) {/ * ЭТА ФУНКЦИЯ НАХОДИТ САМЫЙ БОЛЬШОЙ НОМЕР В Q_TABLE [NEXT_STATE]. ОСНОВНАЯ РОЛЬ ЭТОЙ ФУНКЦИИ - НАЙТИ ПАРАМЕТР Q_MAX * / float LIST [4]; float N1; поплавок N2; float MAX_VALUE =0,0; float DIFF; для (int b =0; b <=3; b ++) {СПИСОК [b] =Q [NEXT_S] [b]; } for (int j =0; j <=2; j ++) {if (MAX_VALUE> LIST [j]) {N1 =MAX_VALUE; } иначе {N1 =СПИСОК [j]; } N2 =СПИСОК [j + 1]; ДИФФ =N1-N2; если (DIFF> 0) {MAX_VALUE =N1; } иначе {MAX_VALUE =N2; }} return MAX_VALUE;} int ARGMAX (float Q_Table [] [4], int S) {/ * ЭТА ФУНКЦИЯ НАХОДИТ ИНДЕКС НАИБОЛЬШЕГО ЗНАЧЕНИЯ Q В ТАБЛИЦЕ Q [СОСТОЯНИЕ] * / float ARRAY [4]; float N1; поплавок N2; float MAX_VALUE =0,0; float DIFF; число с плавающей запятой; int MAX_INDEX; для (int u =0; u <=3; u ++) {ARRAY [u] =Q_Table [S] [u]; } for (int p =0; p <=2; p ++) {if (MAX_VALUE> ARRAY [p]) {N1 =MAX_VALUE; } иначе {N1 =МАССИВ [p]; } N2 =МАССИВ [p + 1]; ДИФФ =N1-N2; если (DIFF> 0) {MAX_VALUE =N1; } иначе {MAX_VALUE =N2; }} для (int r =0; r <=3; r ++) {ЧИСЛО =ARRAY [r]; если (ЧИСЛО ==MAX_VALUE) {MAX_INDEX =r; ломать; }} 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) {/ * ЭТА ФУНКЦИЯ ОБНОВЛЯЕТ ТАБЛИЦУ Q И Q ЗНАЧЕНИЯ. ЭТО ОБНОВЛЕНИЕ ПРОДОЛЖАЕТСЯ, ПОКА НЕ ЗАКОНЧИТСЯ ГЛАВНЫЙ ЦИКЛ. В КОНЦЕ ЭПИЗОДОВ Q-ТАБЛИЦА ЗАПОЛНЯЕТСЯ РАЗЛИЧНЫМИ ЗНАЧЕНИЯМИ. Чем больше ценности, тем большее значение имеет действие в данном конкретном состоянии. "Q_OLD" - СТАРОЕ ЗНАЧЕНИЕ, КОТОРОЕ ИМЕЕТ МАТРИЦА Q. ЭТО ЗНАЧЕНИЕ, КОТОРОЕ ОБНОВЛЯЕТСЯ ВСЕГДА. Q_NEW - НОВОЕ Q_VALUE, КОТОРОЕ РАСЧЕТАЕТСЯ ФОРМУЛОЙ Q LEARNING FORMULA. ФОРМУЛА ОБУЧЕНИЯ Q, ИСПОЛЬЗУЕМЫЕ ЗДЕСЬ, ОСНОВАНА НА УРАВНЕНИИ БЕЛЛМЕНА ИСПОЛЬЗУЕТ ПОДХОД ОБУЧЕНИЯ ВРЕМЕННОЙ РАЗНИЦЫ. (ПОДХОД MONTE CARLO НЕ БУДЕТ РАБОТАТЬ В ЭТОМ СЛУЧАЕ РОБОТА ИЗБЕГАЮЩИЙ ПРЕПЯТСТВИЙ. * / Q_OLD =Q_TABLE [Q_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;} ////////////////////////////////////////////// ///////////КОНЕЦ////////////////////////////////////// ////////////////////////////////////////////////// ////////////////// НАЧАЛО ГЛАВНОГО ПЕТЛИ ////////////////////////////// /////////////////// void loop () {////////////////////////// ///////////////ОБУЧЕНИЕ////////////////////////////////// ////////// for (int I =0; I  

Schematics