Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Лабораторна 5
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
О
Факультет:
СІ
Кафедра:
Кафедра ЕОМ
Інформація про роботу
Рік:
2018
Тип роботи:
Звіт до лабораторної роботи
Предмет:
теорія інтелектуальних систем
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки України
Національний університет “Львівська політехніка”
Кафедра ЕОМ
Звіт
до лабораторної роботи №5
з дисципліни: «Теорія інтелектуальних систем»
на тему: «Дослідження методів та алгоритмів навчання з підкріпленням (Reinforcement Learning) у середовищі MDP»
Львів 2017
Мета: Дослідити роботу методів та алгоритмів навчання з підкріпленням у середовищі MDP, набути навички їх реалізації.
Порядок виконання роботи
1. Реалізувати модель взаємодії агента з середовищем у вигляді марківського процесу прийняття рішень (кількість станів середовища та кількість доступних агенту дій обрати згідно варіанту). Модель оптимальної поведінки (цільова функція): сумарний виграш з відступаючим горизонтом (receding-horizon model).
2. Реалізувати обраний згідно варіанту метод навчання з підкріпленням у вигляді програми.
3. Реалізувати програму обчислювального експерименту по дослідженню моделі взаємодії агента, що виконує метод навчання з підкріпленням, з середовищем у вигляді марківського процесу прийняття рішень.
4. Провести обчислювальний експеримент. Отримати усереднені залежності значень цільової функції від часу для 1) випадкового агента та 2) агента, що виконує метод навчання з підкріпленням.
5. Порівняти отримані залежності та зробити висновки.
Варіант
Q-learning -> Q-навчання
N
Метод навчання з підкріпленням
Кількість станів MDP
Кількість доступних агенту дій
6
Q-learning
3
4
Текст програми обчислювального експерименту
void mdpInit(void)
{
int i, j, v;
int maxReward = REWARD;
float _sum1, _sum2;
// probabilities of rewards
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
mdpR[i][j] = uRand(maxReward);
// probabilities of state transition
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
{
_sum1 = 0;
_sum2 = 0;
for (v = 0; v < nS; v++)
{
mdpT[i][j][v] = (float)rand() / (float)RAND_MAX;
_sum1 += mdpT[i][j][v];
}
for (v = 0; v < nS - 1; v++)
{
mdpT[i][j][v] = mdpT[i][j][v] / _sum1;
_sum2 += mdpT[i][j][v];
}
mdpT[i][j][nS - 1] = 1.0f - _sum2;
}
// initial state
mdpState = uRand(nS);
}
// ----------------------------------------------------------------------------
// response of mdp & state transition
int mdpResponse(void)
{
int _r;
// get response in current state
_r = mdpR[mdpState][action];
// commutate states
mdpState = dRand(mdpT[ceState][action], nS);
return _r;
}
// ----------------------------------------------------------------------------
// environment
int environment(int _en)
{
int _r = 0;
switch (_en)
{
case 0: _r = seResponse(); break;
case 1: _r = mdpResponse(); break;
default: printf("lab3 error: wrong env code specified\n");
}
return _r;
}
// ----------------------------------------------------------------------------
// save parameters in file
void saveParameters(void)
{
int i, j, v;
if ((par_file = fopen(par_file_name, "w")) == NULL) {
fprintf(stderr, "Cannot open file <%s> for parameters of experiment.\n", par_file_name);
}
fprintf(par_file, "T = %d\n", T);
fprintf(par_file, "n = %d\n", n);
fprintf(par_file, "env = %d\n", env);
fprintf(par_file, "nA = %d\n", nA);
if (env) fprintf(par_file, "nS = %d\n", nS);
fprintf(par_file, "RL-agent type = %d\n", RLTYPE);
if (agt == 3) fprintf(par_file, "epsilon = %f\n", e);
if (agt == 4) fprintf(par_file, "tau = %f\n", tau);
fprintf(par_file, "====================\n");
switch (env)
{
case 0: // se (stationary environment)
for (i = 0; i < nA; i++)
fprintf(par_file, "p(a%d) = %f\n", i, sePa[i]);
break;
case 1: // mdp
// values of reward function
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
fprintf(par_file, "R(s%d,a%d) = %d\n", i, j, mdpR[i][j]);
if (i < nS - 1) fprintf(par_file, "--------------------\n");
}
fprintf(par_file, "\n====================\n");
// probabilities of state transition (values of the state transition function)
for (i = 0; i < nS; i++)
{
for (j = 0; j < nA; j++)
{
for (v = 0; v < nS; v++)
fprintf(par_file, "T(s%d,a%d,s%d) = %f\n", i, j, v, mdpT[i][j][v]);
fprintf(par_file, "--------------------\n");
}
}
break;
default: printf("lab3 error: wrong env model code specified\n");
}
fclose(par_file);
}
// ----------------------------------------------------------------------------
// save results of random agent
void saveResultsRA(void)
{
int i;
if ((RA_res_file = fopen(RA_res_file_name, "w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", RA_res_file_name);
for (i = 0; i < T; i++)
fprintf(RA_res_file, "%f \t %f\n", avrRm[i], avrRv[i]);
fclose(RA_res_file);
}
// ----------------------------------------------------------------------------
// save results of perfect agent
void saveResultsPA(void)
{
int i;
if ((PA_res_file = fopen(PA_res_file_name, "w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", PA_res_file_name);
for (i = 0; i < T; i++)
fprintf(PA_res_file, "%f \t %f\n", sumRm[i], sumRv[i], avrRm[i], avrRv[i]);
fclose(PA_res_file);
}
// ----------------------------------------------------------------------------
// save results of RL-agent
void saveResultsRL(void)
{
int i;
if ((RL_res_file = fopen(RL_res_file_name, "w")) == NULL)
fprintf(stderr, "Cannot open file <%s> for experimental results.\n", RL_res_file_name);
for (i = 0; i < T; i++)
fprintf(RL_res_file, "%f \t %f\n", avrRm[i], avrRv[i]);
fclose(RL_res_file);
}
// ----------------------------------------------------------------------------
// return maximum value from <_array> of <size> elements
float max(float* _array, int size)
{
int _arg = uRand(size);
float _max = _array[_arg];
for (int i = 0; i < size; i++)
if (_array[i] > _max) _max = _array[i];
return _max;
}
// ----------------------------------------------------------------------------
// return index of maximum value in <_array> of <size> elements
int argmax(float* _array, int size)
{
int _arg = uRand(size);
float _max = _array[_arg];
for (int i = 0; i < size; i++)
if (_array[i] > _max) { _max = _array[i]; _arg = i; }
return _arg;
}
// ----------------------------------------------------------------------------
// init RL agent
void initRLAgent(void)
{
int i, j, z;
float sum = 0.0f;
// set initial values of estimated values of state (TD(0)))
for (z = 0; z < nS; z++) V[z] = 5.0f;
// init parameters of RL sub-agent for TD(0)
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
{
k[i][j] = 0.0f; r[i][j] = 0.0f; Q[i][j] = 5.0f; p[i] = 0.0f;
}
// set initial values of expected discounted reinforcements (Q-learning)
for (i = 0; i < nS; i++)
for (j = 0; j < nA; j++)
Qsa[i][j] = 5.0f;
}
// ----------------------------------------------------------------------------
// init agent
void initAgent(int _ag)
{
// int i;
switch (_ag)
{
case 0: break;
case 1: initPerfectAgent(); break;
// case 2: for(i=0;i<nA;i++){k[i]=0; r[i]=0; Q[i]=1.0f;}; action = uRand(nA); break;
// case 3: for(i=0;i<nA;i++){k[i]=0; r[i]=0; Q[i]=1.0f;}; action = uRand(nA); break;
// case 4: for(i=0;i<nA;i++){k[i]=0; r[i]=0; Q[i]=0.0f; p[i]=0.0f;}; action = uRand(nA); break;
case 5: initRLAgent(); break;
case 6: initRLAgent(); break;
default: printf("lab5 error: wrong agent code specified\n");
}
}
// ----------------------------------------------------------------------------
// random agent
int randomAgent(void)
{
return uRand(nA);
}
// ----------------------------------------------------------------------------
// perfect agent (for MDP)
int perfectAgent(void)
{
return paction[mdpState];
}
// ----------------------------------------------------------------------------
// Adaptive Heuristic Critic -> AHC
int AHC(void)
{
int ps, cs;
int _action;
// select first action randomly
if (t == 0) { mdpPrevState = mdpState; return uRand(nA); }
// adaptive heuristic critic
ps = mdpPrevState; // previous state of MDP
cs = mdpState; // current state of MDP
V[ps] = V[ps] + alfaAHC * (((float)response + (gammaAHC * V[cs])) - V[ps]);
AHCresponse = V[ps];
// call RL sub-agent
_action = greedy();
//_action = epsilonGreedy();
//_action = softmax();
mdpPrevState = mdpState;
return _action;
}
// ----------------------------------------------------------------------------
// Q-learning
int qLearning(void)
{
int ps, cs;
int a = action;
int _action;
float maxQ;
// select first action randomly
if (t == 0) { mdpPrevState = mdpState; return uRand(nA); }
// modify estimated action value Q(s,a) (= expected discounted reinforcement)
ps = mdpPrevState; // previous state of MDP
cs = mdpState; // current state of MDP
maxQ = max(Qsa[cs], nA);
Qsa[ps][a] = Qsa[ps][a] + alfaQL * (((float)response + (gammaQL * maxQ)) - Qsa[ps][a]);
// select next action
_action = argmax(Qsa[cs], nA);
mdpPrevState = mdpState;
return _action;
}
Графічні залежності отриманих результатів
/
Результати обчислення :
R(s0,a0) = 4 R(s1,a0) = 8 R(s2,a0) = 7
R(s0,a1) = 9 R(s1,a1) = 8 R(s2,a1) = 3
R(s0,a2) = 6 R(s1,a2) = 6 R(s2,a2) = 8
R(s0,a3) = 5 R(s1,a3) = 1 R(s2,a3) = 2
====================
T(s0,a0,s0) = 0.550505
T(s0,a0,s1) = 0.276937
T(s0,a0,s2) = 0.172559
--------------------
T(s0,a1,s0) = 0.296538
T(s0,a1,s1) = 0.701319
T(s0,a1,s2) = 0.002143
--------------------
T(s0,a2,s0) = 0.204620
T(s0,a2,s1) = 0.324740
T(s0,a2,s2) = 0.470640
--------------------
T(s0,a3,s0) = 0.155753
T(s0,a3,s1) = 0.308593
T(s0,a3,s2) = 0.535654
--------------------
T(s1,a0,s0) = 0.322156
T(s1,a0,s1) = 0.334819
T(s1,a0,s2) = 0.343025
--------------------
T(s1,a1,s0) = 0.408446
T(s1,a1,s1) = 0.158078
T(s1,a1,s2) = 0.433476
--------------------
T(s1,a2,s0) = 0.788103
T(s1,a2,s1) = 0.126013
T(s1,a2,s2) = 0.085884
--------------------
T(s1,a3,s0) = 0.570505
T(s1,a3,s1) = 0.254582
T(s1,a3,s2) = 0.174913
--------------------
T(s2,a0,s0) = 0.332783
T(s2,a0,s1) = 0.359146
T(s2,a0,s2) = 0.308072
--------------------
T(s2,a1,s0) = 0.370489
T(s2,a1,s1) = 0.559358
T(s2,a1,s2) = 0.070154
--------------------
T(s2,a2,s0) = 0.228875
T(s2,a2,s1) = 0.265790
T(s2,a2,s2) = 0.505335
--------------------
T(s2,a3,s0) = 0.682438
T(s2,a3,s1) = 0.010148
T(s2,a3,s2) = 0.307414
Висновок: на цій лабораторній роботі було досліджено методи та алгоритми навчання з підкріпленням у середовищі MDP і набуто навички їх реалізації.
02.05.2018 21:36
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора