Нека да се потопим дълбоко в обучението за подсилване. В тази статия ще се справим с конкретен проблем със съвременните библиотеки като TensorFlow, TensorBoard, Keras и фитнес за OpenAI. Ще видите как да приложите един от основните алгоритми, наречен дълбоко $ Q $ -учение, за да научите неговата вътрешна работа. Що се отнася до хардуера, целият код ще работи на типичен компютър и ще използва всички намерени ядра на процесора (това се обработва извън кутията от TensorFlow).

Проблемът се нарича Mountain Car: Колата е на едноизмерна писта, разположена между две планини. Целта е да се качите нагоре по планината вдясно (достигайки знамето). Двигателят на колата обаче не е достатъчно силен, за да се изкачи в планината за един проход. Следователно, единственият начин за успех е да карате напред-назад, за да натрупате инерция.

Този проблем беше избран, тъй като е достатъчно просто да се намери решение с обучение за подсилване за минути на едно ядро ​​на процесора. Той обаче е достатъчно сложен, за да бъде добър представител.

Първо, ще дам кратко обобщение на това, което ученето за подсилване прави като цяло. След това ще разгледаме основните термини и ще изразим проблема си с тях. След това ще опиша дълбокия $ Q $ -научен алгоритъм и ще го приложим за решаване на проблема.

Основи на обучението за подсилване

Подсилващото обучение с най-прости думи е ученето чрез проби и грешки. Главният герой се нарича „агент“, което би било кола в нашия проблем. Агентът извършва действие в среда и му се връща ново наблюдение и награда за това действие. Действията, водещи до по-големи награди, се подсилват, откъдето идва и името. Както при много други неща в компютърните науки, и този е вдъхновен от наблюдението на живи същества.

Взаимодействията на агента с околната среда са обобщени в следната графика:

Агентът получава наблюдение и награда за извършеното действие. След това прави ново действие и прави стъпка две. Сега средата връща (вероятно) малко по-различно наблюдение и награда. Това продължава до достигане на състоянието на терминала, сигнализирано чрез изпращане на „готово“ до агент. Цялата последователност от наблюдения> действия> следващи_ наблюдения> награди се нарича епизод (или траектория).

Връщайки се към нашата планинска кола: нашата кола е агент. Околната среда е черна кутия свят на едноизмерни планини. Действието на автомобила се свежда само до едно число: ако е положително, двигателят избутва колата надясно. Ако е отрицателно, то бута колата наляво. Агентът възприема околната среда чрез наблюдение: X позиция и скорост на автомобила. Ако искаме колата ни да кара на върха на планината, ние определяме наградата по удобен начин: Агентът получава -1 до наградата си за всяка стъпка, в която не е достигнал целта. Когато достигне целта, епизодът приключва. Така че всъщност агентът е наказан за това, че не е в положение, което ние искаме. Колкото по-бързо го достигне, толкова по-добре за него. Целта на агента е да максимизира общата награда, която е сумата от награди от един епизод. Така че, ако достигне желаната точка след, например, 110 стъпки, той получава обща възвръщаемост от -110, което би било чудесен резултат за Mountain Car, защото ако не достигне целта, тогава се наказва за 200 стъпки (следователно възвръщаемост от -200).

Това е цялата формулировка на проблема. Сега можем да го дадем на алгоритмите, които вече са достатъчно мощни, за да разрешат подобни проблеми за броени минути (ако са добре настроени). Струва си да се отбележи, че не казваме на агента как да постигне целта. Дори не предоставяме никакви подсказки (евристика). Агентът сам ще намери начин (политика) да спечели.

Настройване на околната среда

Първо, копирайте целия урок на вашия диск:

git clone https://github.com/AdamStelmaszczyk/rl-tutorial cd rl-tutorial

Сега трябва да инсталираме Python пакети, които ще използваме. За да не ги инсталираме във вашето потребителско пространство (и да рискуваме сблъсъци), ние ще го направим чист и ще ги инсталираме в конда среда. Ако нямате инсталирана конда, моля следвайте https://conda.io/docs/user-guide/install/index.html .

За да създадем нашата конда среда:

conda create -n tutorial python=3.6.5 -y

За да го активирате:

source activate tutorial

Трябва да видите (tutorial) близо до вашия ред в черупката. Това означава, че е активна конда среда с името „tutorial”. Отсега нататък всички команди трябва да се изпълняват в тази конда среда.

Сега можем да инсталираме всички зависимости в нашата херметична конда среда:

pip install -r requirements.txt

Приключихме с инсталацията, така че нека пуснем малко код. Не е нужно сами да прилагаме средата на Mountain Car; библиотеката OpenAI Gym осигурява това изпълнение. Нека видим случаен агент (агент, който предприема произволни действия) в нашата среда:

import gym env = gym.make('MountainCar-v0') done = True episode = 0 episode_return = 0.0 for episode in range(5): for step in range(200): if done: if episode > 0: print('Episode return: ', episode_return) obs = env.reset() episode += 1 episode_return = 0.0 env.render() else: obs = next_obs action = env.action_space.sample() next_obs, reward, done, _ = env.step(action) episode_return += reward env.render()

Това е see.py файл; за да го стартирате, изпълнете:

python see.py

Трябва да видите кола, която се движи произволно напред-назад. Всеки епизод ще се състои от 200 стъпки; общата възвръщаемост ще бъде -200.

Сега трябва да заменим случайните действия с нещо по-добро. Има много алгоритми, които човек може да използва. За уводен урок мисля, че подходът, наречен задълбочено $ Q $ -учене, е подходящ. Разбирането на този метод дава стабилна основа за изучаване на други подходи.

Дълбоко $ Q $ -учение

Алгоритъмът, който ще използваме, е описан за първи път през 2013 г. от Mnih et al. в Игра на Atari с обучение за дълбоко усилване и полиран две години по-късно през Контрол на човешко ниво чрез задълбочено обучение за подсилване . Много други произведения се надграждат върху тези резултати, включително текущия най-съвременен алгоритъм дъга (2017):

Rainbow постига свръхчовешко представяне в много игри на Atari 2600. Ще се съсредоточим върху основната версия на DQN, с възможно най-малък брой допълнителни подобрения, за да поддържаме този урок до разумен размер.

Политиката, обикновено обозначена с $ π (s) $, е функция, връщаща вероятностите за предприемане на отделни действия в дадено състояние $ s $. Така например, случайна политика на Mountain Car се връща за всяка държава: 50% вляво, 50% вдясно. По време на геймплея вземаме проби от тази политика (дистрибуция), за да получим реални действия.

$ Q $ -учене (Q е за качество) се отнася до функцията стойност-действие, обозначена с $ Q_π (s, a) $. Той връща общата възвръщаемост от дадено състояние $ s $, като избира действие $ a $, следвайки конкретна политика $ π $. Общата възвръщаемост е сумата от всички награди в един епизод (траектория).

Ако знаехме оптималната $ Q $ -функция, обозначена с $ Q ^ * $, бихме могли лесно да решим играта. Ние просто ще следваме действията с най-високата стойност $ Q ^ * $, т.е. най-високата очаквана възвръщаемост. Това гарантира, че ще достигнем възможно най-високата възвръщаемост.

Често обаче не знаем $ Q ^ * $. В такива случаи можем да приближим - или да „научим“ - това от взаимодействията с околната среда. Това е частта '$ Q $ -учение' в името. В него има и думата „дълбоко“, защото, за да апроксимираме тази функция, ще използваме дълбоки невронни мрежи, които са универсални апроксиматори на функции. Дълбоките невронни мрежи, които се доближават до $ Q $ -стойности, бяха наречени Deep Q-Networks (DQN). В прости среди (с броя на състоянията, които се вписват в паметта), човек може просто да използва таблица вместо невронна мрежа, за да представи $ Q $ -функцията, в този случай тя ще бъде наречена „таблична $ Q $ -учение“.

Така че нашата цел сега е да приближим функцията $ Q ^ * $. Ще използваме уравнението на Белман:

[Q (s, a) = r + γ интервал textrm {max} _ {a '} Q (s', a ') ]

$ s ’$ е състоянието след $ s $. $ γ $ (гама), обикновено 0,99, е фактор за отстъпка (това е хиперпараметър). Той поставя по-малка тежест върху бъдещите награди (защото те са по-несигурни от незабавните награди с нашите несъвършени $ Q $). Уравнението на Белман е от основно значение за дълбокото $ Q $ -учение. Той казва, че стойността $ Q $ за дадено състояние и действие е награда $ r $, получена след предприемане на действие $ a $ Повече ▼ най-високата $ Q $ -стойност за държавата, в която кацаме в $ s ’$. Най-високата е в смисъл, че избираме действие $ a ’$, което води до най-високата обща възвръщаемост от $ s’ $.

С уравнението на Белман можем да използваме контролирано обучение за приблизително $ Q ^ * $. Функцията $ Q $ ще бъде представена (параметризирана) от невронни мрежови тегла, обозначени като $ θ $ (theta). Еднолинейното внедряване би взело състояние и действие като мрежов вход и извеждане на Q-стойността. Неефективността е, че ако искаме да знаем $ Q $ -стойности за всички действия в дадено състояние, трябва да извикаме $ Q $ толкова пъти, колкото са действията. Има много по-добър начин: да се вземе само състоянието като вход и изход $ Q $ -стойности за всички възможни действия. Благодарение на това, можем да получим $ Q $ -ценности за всички действия само с един проход напред.

Започваме да обучаваме мрежата $ Q $ с произволни тегла. От околната среда получаваме много преходи (или „преживявания“). Това са набори от (състояние, действие, следващо състояние, награда) или накратко ($ s $, $ a $, $ s ’$, $ r $). Съхраняваме хиляди от тях в ринг буфер, наречен „преиграване на опит“. След това вземаме опит от този буфер с желанието, което уравнението на Белман ще има за тях. Можехме да пропуснем буфера и да приложим опит един по един (това се нарича „онлайн“ или „on-policy“); проблемът е, че последващите преживявания са силно свързани помежду си и DQN тренира лошо, когато това се случи. Ето защо беше въведено повторното преживяване (подход „офлайн“, „извън политиката“), за да се получи тази корелация на данните. Кодът на нашата най-проста реализация на буфер за пръстен може да бъде намерен в replay_buffer.py файл, препоръчвам ви да го прочетете.

В началото, тъй като теглото на нашата невронна мрежа беше произволно, лявата стойност на уравнението на Белман ще бъде далеч от дясната страна. Разликата на квадрат ще бъде нашата функция за загуби. Ще намалим функцията на загубите чрез промяна на тежестите на невронната мрежа $ θ $. Нека запишем нашата функция за загуби:

[L (θ) = [Q (s, a) - r - γ пространство textrm {max} _ {a '} Q (s', a ')] ^ 2 ]

Това е пренаписано уравнение на Белман. Да приемем, че взехме проба от опит ($ s $, вляво, $ s ’$, -1) от повторното преживяване на Mountain Car. Правим пряко преминаване през нашата $ Q $ мрежа със състояние $ s $ и за оставено действие ни дава -120, например. И така, $ Q (s, textrm {вляво}) = -120 $. След това подаваме $ s ’$ към мрежата, което ни дава напр. -130 за ляво и -122 за дясно. Така че явно най-доброто действие за $ s ’$ е правилно, като по този начин $ textrm {max} _ {a’} Q (s ’, a’) = -122 $. Знаем $ r $, това е истинската награда, която беше -1. Така че нашата прогноза за $ Q $-мрежа беше леко погрешна, защото $ L (θ) = [-120 - 1 + 0.99 .99 122] ^ 2 = (-0.22 ^ 2) = 0.0484 $. Така че ние разпространяваме грешката назад и коригираме тежестите $ θ $ леко. Ако трябваше отново да изчислим загубата за същото преживяване, сега тя щеше да бъде по-ниска.

Едно важно наблюдение, преди да преминем към кода. Нека забележим, че за да актуализираме нашия DQN, ще направим две предавания напред на самия DQN ... Това често води до нестабилно обучение. За да смекчим това, за следващото състояние $ Q $ прогноза не използваме същия DQN. Използваме по-стара версия от него, която в кода се нарича target_model (вместо model, който е основният DQN). Благодарение на това имаме стабилна цел. Актуализираме target_model като го зададете на model тежести на всеки 1000 стъпки. Но model актуализира всяка стъпка.

Нека разгледаме кода, създаващ модела DQN:

def create_model(env): n_actions = env.action_space.n obs_shape = env.observation_space.shape observations_input = keras.layers.Input(obs_shape, name='observations_input') action_mask = keras.layers.Input((n_actions,), name='action_mask') hidden = keras.layers.Dense(32, activation='relu')(observations_input) hidden_2 = keras.layers.Dense(32, activation='relu')(hidden) output = keras.layers.Dense(n_actions)(hidden_2) filtered_output = keras.layers.multiply([output, action_mask]) model = keras.models.Model([observations_input, action_mask], filtered_output) optimizer = keras.optimizers.Adam(lr=LEARNING_RATE, clipnorm=1.0) model.compile(optimizer, loss='mean_squared_error') return model

Първо, функцията взема размерите на пространството за действие и наблюдение от дадената среда на OpenAI Gym. Необходимо е например да се знае колко изхода ще има нашата мрежа. Тя трябва да е равна на броя на действията. Действията са едно горещо кодирано:

def one_hot_encode(n, action): one_hot = np.zeros(n) one_hot[int(action)] = 1 return one_hot

Така че (напр.) Ляво ще бъде [1, 0], а дясно ще бъде [0, 1].

Можем да видим, че наблюденията се предават като вход. Минаваме и action_mask като втори вход. Защо? Когато изчисляваме $ Q (s, a) $, трябва да знаем стойността на $ Q $ само за едно дадено действие, а не всички. action_mask съдържа 1 за действията, които искаме да предадем на изхода DQN. Ако action_mask има 0 за някакво действие, тогава съответната $ Q $ -стойност ще бъде нулирана на изхода. filtered_output слой прави това. Ако искаме всички $ Q $ -стойности (за максимално изчисление), можем просто да предадем всички.

Кодът използва keras.layers.Dense за да дефинирате напълно свързан слой. Keras е библиотека на Python за абстракция на по-високо ниво върху TensorFlow. Под капака Keras създава графика TensorFlow, с пристрастия, правилна инициализация на теглото и други неща от ниско ниво. Можехме просто да използваме суров TensorFlow, за да дефинираме графиката, но тя няма да бъде еднолинейна.

Така наблюденията се предават на първия скрит слой, с активиране на ReLU (коригирана линейна единица). ReLU(x) е просто функция $ textrm {max} (0, x) $. Този слой е напълно свързан с втори идентичен, hidden_2. Изходният слой намалява броя на невроните до броя на действията. В крайна сметка имаме filtered_output, което просто умножава изхода с action_mask.

За да намерим тежести от $ θ $, ще използваме оптимизатор на име „Адам“ със средна квадратна загуба на грешка.

Като имаме модел, можем да го използваме, за да предскажем стойности на $ Q $ за дадени наблюдения на състоянието:

def predict(env, model, observations): action_mask = np.ones((len(observations), env.action_space.n)) return model.predict(x=[observations, action_mask])

Искаме $ Q $ -стойности за всички действия, като по този начин action_mask е вектор на единици.

За да направим действителното обучение, ще използваме fit_batch():

def fit_batch(env, model, target_model, batch): observations, actions, rewards, next_observations, dones = batch # Predict the Q values of the next states. Passing ones as the action mask. next_q_values = predict(env, target_model, next_observations) # The Q values of terminal states is 0 by definition. next_q_values[dones] = 0.0 # The Q values of each start state is the reward + gamma * the max next state Q value q_values = rewards + DISCOUNT_FACTOR_GAMMA * np.max(next_q_values, axis=1) one_hot_actions = np.array([one_hot_encode(env.action_space.n, action) for action in actions]) history = model.fit( x=[observations, one_hot_actions], y=one_hot_actions * q_values[:, None], batch_size=BATCH_SIZE, verbose=0, ) return history.history['loss'][0]

Партидата съдържа BATCH_SIZE преживявания. next_q_values е $ Q (s, a) $. q_values е $ r + γ space textrm {max} _ {a ’} Q (s’, a ’) $ от уравнението на Белман. Действията, които предприехме, са едно горещо кодирани и предадени като action_mask към входа при извикване model.fit(). $ y $ е често срещана буква за „цел“ в контролираното обучение. Тук предаваме q_values. Аз го правя q_values[:. None] за да се увеличи размерът на масива, защото той трябва да съответства на измерението на one_hot_actions масив. Това се нарича slice notation, ако искате да прочетете повече за него.

Връщаме загубата, за да я запазим в регистрационния файл на TensorBoard и по-късно визуализираме. Има много други неща, които ще наблюдаваме: колко стъпки в секунда правим, общо използване на RAM, каква е средната възвръщаемост на епизода и т.н. Нека видим тези графики.

Бягане

За да визуализираме регистрационния файл на TensorBoard, първо трябва да имаме такъв. Така че нека просто стартираме обучението:

python run.py

Това първо ще отпечата резюмето на нашия модел. След това ще създаде дневник директория с текущата дата и ще започне обучението. На всеки 2000 стъпки ще се отпечатва логина, подобна на тази:

episode 10 steps 200/2001 loss 0.3346639 return -200.0 in 1.02s 195.7 steps/s 9.0/15.6 GB RAM

На всеки 20 000 ще оценяваме нашия модел на 10 000 стъпки:

Evaluation 100%|█████████████████████████████████████████████████████████████████████████████████| 10000/10000 [00:07<00:00, 1254.40it/s] episode 677 step 120000 episode_return_avg -136.750 avg_max_q_value -56.004

След 677 епизода и 120 000 стъпки, средната възвръщаемост на епизода се подобри от -200 на -136,75! Определено се учи. Какво avg_max_q_value оставям като добро упражнение на читателя. Но това е много полезна статистика, която да разгледате по време на обучение.

След 200 000 стъпки нашето обучение е готово. На моя четириядрен процесор това отнема около 20 минути. Можем да погледнем вътре в date-log директория, напр. 06-07-18-39-log. Ще има четири файла с модели с .h5 удължаване. Това е моментна снимка на графика на теглата TensorFlow, ние ги запазваме на всеки 50 000 стъпки, за да разгледаме по-късно политиката, която научихме. За да го видите:

python run.py --model 06-08-18-42-log/06-08-18-42-200000.h5 --view

За да видите другите възможни флагове: python run.py --help.

Сега колата върши много по-добра работа за постигане на желаната цел. В date-log директория, има и events.out.* файл. Това е файлът, в който TensorBoard съхранява данните си. Пишем му, използвайки най-простите TensorBoardLogger определено в loggers.py. За да прегледаме файла със събитията, трябва да стартираме локалния сървър TensorBoard:

tensorboard --logdir=.

--logdir просто сочи към директорията, в която има директории с дневник, в нашия случай това ще бъде текущата директория, така че .. TensorBoard отпечатва URL адреса, на който слуша. Ако отворите http://127.0.0.1:6006 , трябва да видите осем парцела, подобни на тези:

Обобщавайки

train() прави цялото обучение. Първо създаваме модела и преиграваме буфера. След това в цикъл, много подобен на този от see.py, ние взаимодействаме с околната среда и съхраняваме опит в буфера. Това, което е важно, е да следваме алчна политика на епсилон. Винаги бихме могли да изберем най-доброто действие според $ Q $ -функцията; това обаче обезкуражава проучванията, което вреди на цялостното представяне. Така че, за да наложим изследването с епсилонова вероятност, ние извършваме произволни действия:

def greedy_action(env, model, observation): next_q_values = predict(env, model, observations=[observation]) return np.argmax(next_q_values) def epsilon_greedy_action(env, model, observation, epsilon): if random.random()

Epsilon беше настроен на 1%. След 2000 опит, повторението се запълва достатъчно, за да започне обучението. Ние го правим, като извикаме fit_batch() с произволна партида преживявания, извадени от буфера за повторение:

batch = replay.sample(BATCH_SIZE) loss = fit_batch(env, model, target_model, batch)

На всеки 20 000 стъпки оценяваме и регистрираме резултатите (оценката е с epsilon = 0, напълно алчна политика):

if step >= TRAIN_START and step % EVAL_EVERY == 0: episode_return_avg = evaluate(env, model) q_values = predict(env, model, q_validation_observations) max_q_values = np.max(q_values, axis=1) avg_max_q_value = np.mean(max_q_values) print( 'episode {} ' 'step {} ' 'episode_return_avg {:.3f} ' 'avg_max_q_value {:.3f}'.format( episode, step, episode_return_avg, avg_max_q_value, )) logger.log_scalar('episode_return_avg', episode_return_avg, step) logger.log_scalar('avg_max_q_value', avg_max_q_value, step)

Целият код е около 300 реда и run.py съдържа около 250 от най-важните.

Може да се забележи, че има много хиперпараметри:

DISCOUNT_FACTOR_GAMMA = 0.99 LEARNING_RATE = 0.001 BATCH_SIZE = 64 TARGET_UPDATE_EVERY = 1000 TRAIN_START = 2000 REPLAY_BUFFER_SIZE = 50000 MAX_STEPS = 200000 LOG_EVERY = 2000 SNAPSHOT_EVERY = 50000 EVAL_EVERY = 20000 EVAL_STEPS = 10000 EVAL_EPSILON = 0 TRAIN_EPSILON = 0.01 Q_VALIDATION_SIZE = 10000

И това дори не са всички. Съществува и мрежова архитектура - използвахме два скрити слоя с 32 неврона, ReLU активации и оптимизатор на Adam, но има много други опции. Дори малките промени могат да окажат огромно влияние върху обучението. Много време може да се отдели за настройка на хиперпараметри. В скорошно състезание на OpenAI, състезател на второ място открих възможно е почти двойно Резултат на Rainbow след настройка на хиперпараметри. Естествено, трябва да се помни, че е лесно да се преоборудва. В момента алгоритмите за подсилване се борят с трансфера на знания в подобни среди. Нашата планинска кола в момента не обобщава всички видове планини. Всъщност можете да модифицирате средата на OpenAI Gym и да видите до каква степен агентът може да обобщи.

Друго упражнение ще бъде намирането на по-добър набор от хиперпараметри от моя. Определено е възможно. Въпреки това, една тренировка няма да е достатъчна, за да прецените дали промяната ви е подобрение. Обикновено има голяма разлика между тренировъчните писти; вариацията е голяма. Ще ви трябват много писти, за да определите, че нещо е по-добро. Ако искате да прочетете повече за такава важна тема като възпроизводимостта, препоръчвам ви да прочетете Дълбоко укрепващо обучение, което има значение . Вместо да се настройваме на ръка, можем донякъде да автоматизираме този процес - ако сме готови да похарчим повече изчислителна мощ за проблема. Един прост подход е да се подготви обещаващ диапазон от стойности за някои хиперпараметри и след това да се извърши търсене в мрежа (проверка на техните комбинации), като паралелно се провеждат обучения. Самата паралелизация сама по себе си е голяма тема, тъй като е от решаващо значение за висока производителност.

Дълбоко $ Q $ -учене представлява голямо семейство от алгоритми за засилване на обучение, които използват итерация на стойност. Опитахме се да приближим $ Q $ -функцията и просто я използвахме по алчен начин през повечето време. Има друго семейство, което използва повторение на политиката. Те не се фокусират върху сближаване на $ Q $ -функцията, а върху директно намиране на оптималната политика $ π ^ * $. За да видите къде итерацията на стойността се вписва в пейзажа на алгоритмите за засилване на обучението:

Вашите мисли биха могли да бъдат, че дълбокото укрепващо обучение изглежда крехко. Ще бъдеш прав; има много проблеми. Можете да се обърнете към Ученето за дълбоко усилване все още не работи и Усилващото обучение никога не е работило и „дълбокото“ само помогна малко .

Това завършва урока. Внедрихме собствения си основен DQN за целите на обучението. Много подобен код може да се използва за постигане на добро представяне в някои от игрите на Atari. В практическите приложения човек често взема тествани, високоефективни внедрения, например, от Базови линии на OpenAI . Ако искате да видите с какви предизвикателства човек може да се сблъска, когато се опитва да приложи дълбоко укрепващо обучение в по-сложна среда, можете да прочетете Нашият NIPS 2017: Подход за учене на бягане . Ако искате да научите повече в забавна състезателна среда, погледнете Състезания NIPS 2018 или crowdai.org .

Ако сте на път да станете машинно обучение експерт и бихте искали да задълбочите знанията си в контролирано обучение, вижте Видео анализ на машинно обучение: Идентифициране на риби за забавен експеримент за идентифициране на риби.

Свързани: Училище Flappy Bird: Учебен урок за подсилване

Разбиране на основите

Какво е засилване на обучението?

Подсилващото обучение е биологично вдъхновен метод на проба и грешка за обучение на агент. Ние възнаграждаваме агента за добри действия за засилване на желаното поведение. Също така наказвахме лоши действия, така че те да се случват по-рядко.

Какво е Q в Q-обучението?

Q е за „качество“. Той се отнася до функцията за стойност на действие, обозначена Qπ (s, a). Той връща общата възвръщаемост от дадено състояние s, като избира действие a, следвайки конкретна политика π. Общата възвръщаемост е сумата от всички награди в един епизод.

Какво е уравнението на Белман?

Q (s, a) = r + γ maxa'Q (s ', a'). Устно: Q-стойност за дадено състояние и действие е награда r, получена след предприемане на действие a + най-високата Q-стойност за държавата, в която се приземяваме. Най-високата в смисъл, че избираме действие „което води до най-висока обща възвръщаемост от s“.

Какъв е принципът на Белман за оптималност?

Принцип на оптималност: Оптималната политика има свойството, че каквито и да са първоначалното състояние и действия, останалите действия трябва да представляват оптимална политика по отношение на състоянието, произтичащо от първоначалното действие. Използва се в Q-обучението, но като цяло във всяка техника на динамично програмиране.

Какво представляват параметрите и хиперпараметрите?

Параметрите се отнасят до параметрите на модела, така че ако се използват невронни мрежи, това се отнася до техните тегла. Обикновено имаме хиляди или милиони параметри. Хиперпараметрите се използват за настройка на учебния процес - напр. Скорост на обучение, брой слоеве, неврони и др. Обикновено имаме по-малко от сто хиперпараметри.